Add files using upload-large-folder tool

Code/Baselines/experiment_baseline.ipynb

@@ -0,0 +1,1628 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "430e89a1",
+   "metadata": {},
+   "source": [
+    "## GeoAware-SC"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81eedb10",
+   "metadata": {},
+   "source": [
+    "## Pre-extract features for GeoAware-SC SD-UNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98e4fcda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/preprocess_map.py '../../Datasets/PF-dataset-PASCAL/JPEGImages'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eaca3cf4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/preprocess_map.py '../../Datasets/SPair-71k/JPEGImages' '1'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "190072b5",
+   "metadata": {},
+   "source": [
+    "## Extract the masks for unsupervised pose alignment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6009104d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/preprocess_mask_sam.py '../../Datasets/PF-dataset-PASCAL/JPEGImages'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e20911a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/preprocess_mask_sam.py '../../Datasets/SPair-71k/JPEGImages'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77589ff4",
+   "metadata": {},
+   "source": [
+    "## Supervised Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac36a283",
+   "metadata": {},
+   "source": [
+    "original"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "541a8f08",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/train_pascal.yaml --GPU_ID 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5cdc136c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/train_spair.yaml --GPU_ID 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5bc45556",
+   "metadata": {},
+   "source": [
+    "w/ dit feats"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5838586",
+   "metadata": {},
+   "source": [
+    "layer15+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0acc142",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/train_pascal.yaml --GPU_ID 4 --NOTE 'dit_t0.5_l15'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0657a0cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/train_spair.yaml --GPU_ID 5  --NOTE 'dit_t0.5_l15'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0975529",
+   "metadata": {},
+   "source": [
+    "layer20+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "615a4d60",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/train_pascal.yaml --GPU_ID 5 --NOTE 'dit_t0.5_l20' --SD_FEATURE_KEYS t_0.5_layer_20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9fad2454",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/train_spair.yaml --GPU_ID 4  --NOTE 'dit_t0.5_l20' --SD_FEATURE_KEYS t_0.5_layer_20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "741a46a1",
+   "metadata": {},
+   "source": [
+    "LBFGS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fded66dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_lbfgs.py --config ./GeoAware-SC/configs/train_pascal_lbfgs.yaml --GPU_ID 1 --OPTIMIZER 'LBFGS'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c5c70c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/train_spair_lbfgs.yaml --GPU_ID 2 --OPTIMIZER 'LBFGS'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a20f5133",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/train_pascal_lbfgs_bs8.yaml --GPU_ID 3 --OPTIMIZER 'LBFGS'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88b9cf88",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/train_spair_lbfgs_bs8.yaml --GPU_ID 4 --OPTIMIZER 'LBFGS'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1314a0a",
+   "metadata": {},
+   "source": [
+    "## Testing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98dea849",
+   "metadata": {},
+   "source": [
+    "baseline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b30673c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_pascal.yaml --GPU_ID 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "242e066c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_pascal.yaml --GPU_ID 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1776d25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_spair.yaml --GPU_ID 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82270929",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_pascal_reprod.yaml --GPU_ID 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe685287",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_spair.yaml --GPU_ID 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "127c7dd3",
+   "metadata": {},
+   "source": [
+    "visibility check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "388a3669",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_pascal.yaml --GPU_ID 1 --VISIBILITY 'single' --NOTE 'pascal_sup_single_vis'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "949022a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_spair.yaml --GPU_ID 2 --VISIBILITY 'single' --NOTE 'spair_sup_single_vis'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76c982b5",
+   "metadata": {},
+   "source": [
+    "w/ dit feats"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c9249d1",
+   "metadata": {},
+   "source": [
+    "layer15+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ea2531f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_pascal_dit.yaml --GPU_ID 6 --NOTE 'pascal_dit_t0.5_l15' --LOAD './results_pascal/pck_train_dit_t0.5_l15_sample_100_None_lr_0.00125/best.pth'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7d1852a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_spair_dit.yaml --GPU_ID 6 --NOTE 'spair_dit_t0.5_l15' --LOAD './results_spair/pck_train_dit_t0.5_l15_sample_2_None_lr_0.00125/best.pth'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29c3967e",
+   "metadata": {},
+   "source": [
+    "layer20+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d23bfea8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad11ce7a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "420965d8",
+   "metadata": {},
+   "source": [
+    "## Unsupervised"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "140c3c9f",
+   "metadata": {},
+   "source": [
+    "baseline w/o post-alignment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c42e018",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE \"pascal_zs_baseline\" "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8a2964e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 7 --NOTE \"spair_zs_baseline\" # ADAPT_FLIP: False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b6e03e8",
+   "metadata": {},
+   "source": [
+    "baseline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b116a806",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE \"pascal_zs_baseline_adp_flip\" --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7aab9b75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 3 --NOTE \"spair_zs_baseline_adp_flip_debug\" --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eebdb962",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"pascal_zs_baseline_adp_flip_subsample\" --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0edd33f9",
+   "metadata": {},
+   "source": [
+    "w/ dit feats"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8f5215d",
+   "metadata": {},
+   "source": [
+    "layer 10+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29415abe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_dino' --SD_FEATURE_KEYS t_0.5_layer_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ca39f461",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "947d4c1f",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 11+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e10352e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l11_dino' --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f81af184",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l10_l11_dino' --SD_FEATURE_KEYS t_0.7_layer_10 t_0.7_layer_11"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a63f92a",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 12+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bef31bad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l12_dino' --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63a3b010",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l10_l12_dino' --SD_FEATURE_KEYS t_0.7_layer_10 t_0.7_layer_12"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "27778af7",
+   "metadata": {},
+   "source": [
+    "layer 11+layer 12+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "197d55c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l11_l12_dino' --SD_FEATURE_KEYS t_0.5_layer_11 t_0.5_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4cb59c2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l11_l12_dino' --SD_FEATURE_KEYS t_0.7_layer_11 t_0.7_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4bc4147b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l11_t0.7_l12_dino' --SD_FEATURE_KEYS t_0.5_layer_11 t_0.7_layer_12"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2e4853b",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 15+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13272e3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l15_dino' --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_15"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2465766e",
+   "metadata": {},
+   "source": [
+    "efficient version but seems to have some performance issue"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18685f6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit_efficient.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l15_dino' --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_15"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee068f48",
+   "metadata": {},
+   "source": [
+    "layer 9+layer10+layer12+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f47e47e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l9_l10_l12_dino' --SD_FEATURE_KEYS t_0.5_layer_9 t_0.5_layer_10 t_0.5_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5002dfa",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61339328",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 15+layer20+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed91bba4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l15_l20_dino' --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_15 t_0.5_layer_20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "58176fe3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0992ef37",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 12+layer 15+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed5dabb4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l12_l15_dino' --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_12 t_0.5_layer_15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32f12c74",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a7e6b0c",
+   "metadata": {},
+   "source": [
+    "layer 15+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3861e38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l15' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae8fca37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 7 --NOTE 'spair_zs_dit_t0.5_l15_adp_flip' --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5cee3e3d",
+   "metadata": {},
+   "source": [
+    "layer20+dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0a41727",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l20' --SD_FEATURE_KEYS t_0.5_layer_20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6d7a983",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 7 --NOTE 'spair_zs_dit_t0.5_l20_adp_flip' --ADAPT_FLIP --SD_FEATURE_KEYS t_0.5_layer_20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8df228c5",
+   "metadata": {},
+   "source": [
+    "dino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b182bac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_dino' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "549d03ed",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8668cfe0",
+   "metadata": {},
+   "source": [
+    "layer 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ca35cd3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.3_l5_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.3_layer_5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f0a6986",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l5_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b33ef61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.6_l5_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0844e42",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l5_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "41aad527",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 7 --NOTE 'pascal_zs_dit_t0.8_l5_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e13179c",
+   "metadata": {},
+   "source": [
+    "layer 9"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8087d390",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l9_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_9"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ba2b184",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 7 --NOTE 'pascal_zs_dit_t0.6_l9_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_9"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29360749",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l9_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_9"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48c5d36e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.8_l9_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_9"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9dc34b1",
+   "metadata": {},
+   "source": [
+    "layer 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1eaf176a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.3_l10_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.3_layer_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7fd7166",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce558c62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 5 --NOTE 'pascal_zs_dit_t0.6_l10_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43ae6919",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l10_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08ab4aee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 4 --NOTE 'pascal_zs_dit_t0.8_l10_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f7d361ec",
+   "metadata": {},
+   "source": [
+    "layer 11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23bdc37d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6499ffe5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l11_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e77e4e36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 5 --NOTE 'pascal_zs_dit_t0.6_l11_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0916dde",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l11_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a65a0ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 4 --NOTE 'pascal_zs_dit_t0.8_l11_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_11"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be062473",
+   "metadata": {},
+   "source": [
+    "layer 12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0747f27d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68442baa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9334c986",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 3 --NOTE 'pascal_zs_dit_t0.6_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "334c9bda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04d23da9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 2 --NOTE 'pascal_zs_dit_t0.8_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_12"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2881e9d",
+   "metadata": {},
+   "source": [
+    "layer 13"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ccfed22",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "029bff11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l13_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_13"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ba7ba944",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.6_l13_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_13"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e4a191f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l13_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_13"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9531ba5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 7 --NOTE 'pascal_zs_dit_t0.8_l13_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_13"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8f8ea39",
+   "metadata": {},
+   "source": [
+    "layer 15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c691a72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.3_l15_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.3_layer_15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b09dc3d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l15_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9bcbdb33",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 3 --NOTE 'pascal_zs_dit_t0.6_l15_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.6_layer_15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1a0561b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l15_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_15"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e329675",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 2 --NOTE 'pascal_zs_dit_t0.8_l15_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.8_layer_15"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "447f4004",
+   "metadata": {},
+   "source": [
+    "layer 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "569c940c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.3_l20_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.3_layer_20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08d451ef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l20_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8231d012",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l20_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "954f1e0f",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d97002be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1cb6bb96",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l10_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_10 t_0.7_layer_12"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46ff2c36",
+   "metadata": {},
+   "source": [
+    "layer 10+layer 11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddc2c1cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l10_l11_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_10 t_0.5_layer_11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00d84b97",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l10_l11_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_10 t_0.7_layer_11"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1382199b",
+   "metadata": {},
+   "source": [
+    "layer 11+layer 12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4da4587d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.5_l11_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.5_layer_11 t_0.5_layer_12"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "369becde",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE 'pascal_zs_dit_t0.7_l11_l12_no_dino' --NO_DINO --SD_FEATURE_KEYS t_0.7_layer_11 t_0.7_layer_12"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "428ee089",
+   "metadata": {},
+   "source": [
+    "## Current best Pascal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7eb7a455",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 3 --NOTE 'pascal_zs_dit_t0.5_0.7_l11' --SD_FEATURE_KEYS t_0.5_layer_11 t_0.7_layer_11"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e000e16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "print(os.listdir('../Baselines/results_clean_pascal/pck_train_pascal_zs_dit_t0.5_0.7_l11_sample_1_None_lr_0.00125'))\n",
+    "\n",
+    "path_result = '../Baselines/results_clean_pascal/pck_train_pascal_zs_dit_t0.5_0.7_l11_sample_1_None_lr_0.00125'\n",
+    "\n",
+    "# load the result.pkl file\n",
+    "import pickle\n",
+    "\n",
+    "pkl_file = os.path.join(path_result, 'result.pkl')\n",
+    "with open(pkl_file, 'rb') as f:\n",
+    "    data = pickle.load(f)\n",
+    "\n",
+    "print(data)\n",
+    "\n",
+    "print(len(data))\n",
+    "\n",
+    "\n",
+    "print(os.listdir(path_result))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc3498b8",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "06d9c559",
+   "metadata": {},
+   "source": [
+    "## Baseline spair zeroshot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ebd98c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"pascal_zs_baseline_subsample_nosoft\" --TEST_SAMPLE 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce3f42eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"pascal_zs_baseline_subsample_nosoft_single\" --TEST_SAMPLE 10 --VISIBILITY 'single'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a715d30e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_single_no_adap_flip\" --TEST_SAMPLE 0 --VISIBILITY 'single'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e60c8bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 7 --NOTE \"spair_zs_baseline_single\" --TEST_SAMPLE 0 --VISIBILITY 'single' --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5183b94c",
+   "metadata": {},
+   "source": [
+    "## Best Spair Attempt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c75fb69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train.py --config ./GeoAware-SC/configs/eval_zero_shot_pascal.yaml --GPU_ID 6 --NOTE \"pascal_zs_baseline_adp_flip\" --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e573bbf5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_spair.yaml --GPU_ID 3 --ADAPT_FLIP --NOTE 'spair_zs_dit_t0.5_0.7_l11' --SD_FEATURE_KEYS t_0.5_layer_11 t_0.7_layer_11 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd13089f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_dit.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE 'spair_zs_dit_t0.5_l12_0.7_l10_sub_10' --SD_FEATURE_KEYS t_0.5_layer_12 t_0.7_layer_10 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f531af3",
+   "metadata": {},
+   "source": [
+    "## SPair + VLM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a5a9ef38",
+   "metadata": {},
+   "source": [
+    "## mutual visibility (traditional)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "189bf30f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d85a0750",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b' --VISIBILITY 'mutual'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53221795",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10_gpt4.1_mini_judge_dilation_0\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_gpt4.1_mini_judge_dilation_0/' --VISIBILITY 'mutual'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "598d8c65",
+   "metadata": {},
+   "source": [
+    "compute all"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "012f6a2e",
+   "metadata": {},
+   "source": [
+    "unsupervised"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1482c1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm_compute_all.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 1 --NOTE \"spair_zs_mutual_vlm_qwen_vl_32b\" --TEST_SAMPLE 0 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b/' --VISIBILITY 'mutual' --SOFT_EVAL --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1bed77bf",
+   "metadata": {},
+   "source": [
+    "supervised"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a94fe78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm_compute_all.py --config ./GeoAware-SC/configs/eval_spair_subsample_vlm.yaml --GPU_ID 2 --NOTE 'spair_sup_mutual_vlm_qwen_vl_32b_mutual_vis' --TEST_SAMPLE 0 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b' --VISIBILITY 'mutual' --SOFT_EVAL"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "975fa542",
+   "metadata": {},
+   "source": [
+    "## single visibility (in the wild)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "568213a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10_vis_single\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_dilation_0' --VISIBILITY 'single'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89b855c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10_vis_single_gpt4.1_mini_judge_dilation_28\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_gpt4.1_mini_judge_dilation_28/' --VISIBILITY 'single'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5815da7f",
+   "metadata": {},
+   "source": [
+    "compute all"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed0ba7cc",
+   "metadata": {},
+   "source": [
+    "unsupervised"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8eb712e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm_compute_all.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 3 --NOTE \"spair_zs_single_vlm_qwen_vl_32b\" --TEST_SAMPLE 0 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b/' --VISIBILITY 'single' --SOFT_EVAL --ADAPT_FLIP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d7b0ed7",
+   "metadata": {},
+   "source": [
+    "supervised"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8bda291",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm_compute_all.py --config ./GeoAware-SC/configs/eval_spair_subsample_vlm.yaml --GPU_ID 4 --NOTE 'spair_sup_single_vlm_qwen_vl_32b' --TEST_SAMPLE 0 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b' --VISIBILITY 'single' --SOFT_EVAL"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbfc9eca",
+   "metadata": {},
+   "source": [
+    "sanity check if no judge"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59aa9d92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10_vis_single_no_judge_dilation_28\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_no_judge_dilation_28/' --VISIBILITY 'single'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b7b949a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python ./GeoAware-SC/pck_train_vlm.py --config ./GeoAware-SC/configs/eval_zero_shot_spair_subsample.yaml --GPU_ID 6 --NOTE \"spair_zs_baseline_vlm_subsample_10_vis_mutual_no_judge_dilation_28\" --TEST_SAMPLE 10 --BBOX_PATH '../sc_dit/results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_no_judge_dilation_28/' --VISIBILITY 'mutual'"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "sc_env_torch_113",
+   "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.9.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Code/Baselines/run_dit_geoaware.sh

@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+#
+# Improved script to run all combinations of DiT features.
+#
+# Key Improvements:
+# - Corrected key formatting for multiple features (space-separated).
+# - Corrected GPU array handling for true parallel execution.
+# - Enhanced Logging: Each job now writes its output to a dedicated log file
+#   in a timestamped `logs/` directory, making it easy to debug failed runs.
+# - More Descriptive Output: Real-time logs now show which job is on which GPU slot.
+# - Robustness: The script will no longer exit if a single Python job fails.
+# - Better Process Management: The script saves its process ID (PID) to a file.
+
+# Exit on unset variables and pipeline errors, but not on a single command error.
+set -uo pipefail
+
+# ---------------------------------------------------------------------------
+# Section 0: Configuration
+# ---------------------------------------------------------------------------
+
+# --- File Paths ---
+CONFIG=./GeoAware-SC/configs/eval_zero_shot_pascal.yaml
+SCRIPT=./GeoAware-SC/pck_train_dit.py
+
+# --- Feature Parameters ---
+TIMESTEPS=(0.3 0.5 0.6 0.7 0.8)
+LAYERS=(5 9 10 11 12 13 15 18 20)
+
+# --- GPU Configuration ---
+# IMPORTANT: Use spaces to separate GPU IDs. DO NOT use commas.
+GPUS=(4 5 6 7)
+
+# --- Job Configuration ---
+COMBINATION_SIZES=(2 3)
+
+
+# ---------------------------------------------------------------------------
+# Section 1: Setup
+# ---------------------------------------------------------------------------
+MAX_PARALLEL=${#GPUS[@]}
+LOG_DIR="logs_pascal_zs_dit_$(date +%F_%H-%M-%S)"
+PID_FILE="run_dit_geoaware.pid"
+
+# Check if required files exist
+if [[ ! -f "$CONFIG" || ! -f "$SCRIPT" ]]; then
+  echo "Error: Config file ($CONFIG) or script file ($SCRIPT) not found."
+  exit 1
+fi
+
+# Create a directory for log files
+mkdir -p "$LOG_DIR"
+echo "✅ Log files will be saved in: $LOG_DIR"
+
+# Store the script's Process ID (PID) for easy termination
+echo $$ > "$PID_FILE"
+echo "🚀 Script started with PID: $$. To stop this script, run: kill \$(cat $PID_FILE)"
+
+# On exit, clean up the PID file
+trap 'rm -f "$PID_FILE"' EXIT
+
+
+# ---------------------------------------------------------------------------
+# Section 2: Key Generation
+# ---------------------------------------------------------------------------
+keys=()
+for t in "${TIMESTEPS[@]}"; do
+  for l in "${LAYERS[@]}"; do
+    keys+=("t_${t}_layer_${l}")
+  done
+done
+N=${#keys[@]}
+echo "💡 Generated $N unique feature keys. Will run with and without DINO."
+echo "🖥️  Will run jobs in parallel across $MAX_PARALLEL GPUs."
+
+
+# ---------------------------------------------------------------------------
+# Section 3: Job Execution
+# ---------------------------------------------------------------------------
+job_idx=0
+
+# Throttles the job launch rate to match the number of available GPUs.
+throttle() {
+  while (( $(jobs -r | wc -l) >= MAX_PARALLEL )); do
+    wait -n
+  done
+}
+
+# Launches a Python training job in the background with proper logging.
+run_job() {
+  local keystr="$1"     # Space-separated list of keys
+  local use_dino="$2"   # "true" or "false"
+  
+  throttle
+  
+  local gpu_idx=$(( job_idx % MAX_PARALLEL ))
+  local gpu="${GPUS[$gpu_idx]}"
+  
+  local dino_flag=""
+  local dino_tag=""
+  if [[ "$use_dino" == "false" ]]; then
+    dino_flag="--NO_DINO"
+    dino_tag="_no_dino"
+  fi
+  
+  # Create a descriptive name for logs, replacing spaces in keys with underscores.
+  local note_stub="${keystr// /__}"
+  local run_name="pascal_zs_dit_${note_stub}${dino_tag}"
+  
+  echo "  (Job $((job_idx+1))) [Slot $((gpu_idx+1))/${MAX_PARALLEL}] Launching on GPU ${gpu}: ${keystr}${dino_tag}"
+
+  # Launch the Python script in the background.
+  # IMPORTANT: $keystr is NOT quoted, allowing the shell to split it into multiple arguments.
+  CUDA_VISIBLE_DEVICES="$gpu" \
+    python "$SCRIPT" \
+      --config "$CONFIG" \
+      --GPU_ID "$gpu" \
+      --NOTE "$run_name" \
+      $dino_flag \
+      --SD_FEATURE_KEYS $keystr > "${LOG_DIR}/${run_name}.log" 2>&1 &
+      
+  ((job_idx++))
+}
+
+
+# ---------------------------------------------------------------------------
+# Section 4: Main Loop
+# ---------------------------------------------------------------------------
+echo "⏳ Starting job enumeration for combination sizes: ${COMBINATION_SIZES[*]}"
+
+for r in "${COMBINATION_SIZES[@]}"; do
+  echo "--- Generating combinations of size $r ---"
+  
+  if (( r == 1 )); then
+    for ((i=0; i<N; i++)); do
+      run_job "${keys[i]}" "true"
+      run_job "${keys[i]}" "false"
+    done
+    
+  elif (( r == 2 )); then
+    for ((i=0; i<N; i++)); do
+      for ((j=i+1; j<N; j++)); do
+        # FIXED: Keys are now separated by spaces, not commas.
+        combo="${keys[i]} ${keys[j]}"
+        run_job "$combo" "true"
+        run_job "$combo" "false"
+      done
+    done
+    
+  elif (( r == 3 )); then
+    for ((i=0; i<N; i++)); do
+      for ((j=i+1; j<N; j++)); do
+        for ((k=j+1; k<N; k++)); do
+          # FIXED: Keys are now separated by spaces, not commas.
+          combo="${keys[i]} ${keys[j]} ${keys[k]}"
+          run_job "$combo" "true"
+          run_job "$combo" "false"
+        done
+      done
+    done
+  fi
+done
+
+
+# ---------------------------------------------------------------------------
+# Section 5: Finalization
+# ---------------------------------------------------------------------------
+echo "All jobs have been launched. Waiting for the remaining jobs to finish..."
+wait
+echo "✅ All ${job_idx} jobs completed."
+echo "Check the '${LOG_DIR}/' directory for individual output logs."

Code/Data_preprocess/extract_3D_mesh.py

@@ -0,0 +1,86 @@
+import sys
+from pathlib import Path
+import torch
+import os
+import glob
+
+# print(project_root)
+project_root = Path(__file__).resolve().parents[1]
+print(os.listdir(project_root))
+project_path = os.path.join(str(project_root), 'Baselines', 'CraftsMan3D')
+print(os.listdir(project_path))
+
+# print("Project root:", project_root)
+# print("Project path:", project_path)
+
+# # Add the project root to Python's path to allow for absolute imports
+if str(project_path) not in sys.path:
+    sys.path.append(str(project_path))
+
+# print("Current sys.path:", sys.path)
+from craftsman import CraftsManPipeline
+
+def main():
+
+    print(os.listdir('../Baselines/sd3.5'))
+
+    path_data = '../Baselines/sd3.5/spair_71k_test_examples'
+    categories = os.listdir(path_data)
+    print("Categories:", categories)
+
+    path_images = glob.glob(os.path.join(path_data, '*', '*_bgd_rmv.png'))
+    print("Number of images found:", len(path_images))
+
+    path_output = './example_data/spair'
+
+    device = "cuda:7"
+
+    # print(os.listdir(path_data))
+
+    # path_image = os.path.join(path_data, 'motorbike', '2009_004845_bgd_rmv.png')
+
+    pipeline = CraftsManPipeline.from_pretrained("../Baselines/CraftsMan3D/ckpts/craftsman-DoraVAE", device=device, torch_dtype=torch.bfloat16)
+
+    for path_image in path_images:
+        # print("Processing image:", path_image)
+        # Extract the category and file ID from the image path
+        category = os.path.basename(os.path.dirname(path_image))
+        file_id = os.path.splitext(os.path.basename(path_image))[0].replace('_bgd_rmv', '')
+
+        path_obj_output = os.path.join(path_output, category, f"{file_id}.obj")
+        if not os.path.exists(os.path.dirname(path_obj_output)):
+            os.makedirs(os.path.dirname(path_obj_output))
+        # print("Output path for mesh:", path_obj_output)
+
+        mesh = pipeline(path_image).meshes[0]
+        mesh.export(path_obj_output)
+        print(f"Exported mesh for {file_id} to {path_obj_output}")
+
+        # copy the image to the ouput directory
+        path_image_output = os.path.join(path_output, category, f"{file_id}_bgd_rmv.png")
+        if not os.path.exists(os.path.dirname(path_image_output)):
+            os.makedirs(os.path.dirname(path_image_output))
+        os.system(f"cp {path_image} {path_image_output}")
+        os.system(f"cp {path_image.replace('_bgd_rmv.png', '.jpg')} {path_image_output.replace('_bgd_rmv.png', '.jpg')}")
+
+        # break
+
+        # # Run the pipeline
+        # try:
+        #     result = pipeline(path_image, category=category, file_id=file_id)
+        #     meshes = result.meshes
+        #     if meshes:
+        #         mesh = meshes[0]
+        #         mesh.export(f"{file_id}.obj")
+        #         print(f"Exported mesh for {file_id} to {file_id}.obj")
+        #     else:
+        #         print(f"No meshes found for {file_id}")
+        # except Exception as e:
+        #     print(f"Error processing {path_image}: {e}")
+    # mesh = pipeline(path_image).meshes[0]
+    # mesh.export("motorbike_1.obj")
+
+
+
+if __name__ == "__main__":
+    main()

Code/Data_preprocess/extract_kps_example_data.ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7a5614cf",
+   "metadata": {},
+   "source": [
+    "## Find the corresponding annotation for each pair"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ff48e0c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['extract_3D_mesh.py', '2010_001614_loss.png', 'all_comb_dp_pck_results.csv', 'example_results', 'utils.py', 'wandb', 'single_dp_pck_results.csv', 'analyze_acc.ipynb', 'example_data', '__pycache__', 'scripts', 'optimize_camera_pose_clean.py', 'demo_2D_to_3D_correspondence.ipynb']\n",
+      "['spair', 'pf_pascal']\n",
+      "['SPair-71k', 'PF-dataset-PASCAL']\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(os.listdir('../sc_dit'))\n",
+    "\n",
+    "path_example_data = '../sc_dit/example_data'\n",
+    "print(os.listdir(path_example_data))\n",
+    "\n",
+    "\n",
+    "path_annotation = '../../Datasets'\n",
+    "print(os.listdir(path_annotation))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "792ac8bc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "sc_env_torch_113",
+   "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.9.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Code/Data_preprocess/process_feats_sd35.py

@@ -0,0 +1,282 @@
+import torch
+import os
+from tqdm import tqdm
+import numpy as np
+from PIL import Image
+from utils.utils_correspondence import resize
+from diffusers import StableDiffusion3Pipeline
+import sys
+from typing import List, Dict, Tuple
+import glob
+
+
+class FeatureExtractor:
+    """
+    A class to register hooks and extract features from specified layers of a model.
+    This version is redesigned to capture both the image and text branches from the
+    JointTransformerBlock.
+    """
+    def __init__(self, model, layers_to_extract: List[int]):
+        self.model = model
+        self.layers_to_extract = layers_to_extract
+        self.features: Dict[int, List[Tuple[torch.Tensor, torch.Tensor]]] = {}
+        self.hooks = []
+
+    def _get_hook(self, layer_idx: int):
+        def hook(model, input, output):
+            # The output of a JointTransformerBlock is a tuple: (hidden_states, encoder_hidden_states)
+            # 0: image branch, 1: text branch
+            image_branch_features = output[1].detach().cpu()
+            text_branch_features = output[0].detach().cpu()
+            
+            if layer_idx not in self.features:
+                self.features[layer_idx] = []
+            self.features[layer_idx].append((image_branch_features, text_branch_features))
+        return hook
+
+    def register_hooks(self):
+        if not hasattr(self.model, 'transformer_blocks'):
+            raise AttributeError("The provided model does not have 'transformer_blocks'. Make sure you pass `pipe.transformer`.")
+
+        for layer_idx in self.layers_to_extract:
+            if layer_idx < 0 or layer_idx >= len(self.model.transformer_blocks):
+                print(f"Warning: Layer index {layer_idx} is out of bounds. Skipping.")
+                continue
+            
+            layer = self.model.transformer_blocks[layer_idx]
+            hook_handle = layer.register_forward_hook(self._get_hook(layer_idx))
+            self.hooks.append(hook_handle)
+
+    def remove_hooks(self):
+        for hook in self.hooks:
+            hook.remove()
+        self.hooks = []
+        self.features = {}
+
+    def __enter__(self):
+        self.register_hooks()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.remove_hooks()
+
+
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+
+
+
+def extract_feats_sd35(pipe, transformer, img_pil, category):
+    image_tensor = torch.from_numpy(np.array(img_pil)).float() / 127.5 - 1.0
+    image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0).to(DEVICE, dtype=pipe.vae.dtype)
+
+    with torch.no_grad():
+        vae_output = pipe.vae.encode(image_tensor)
+        clean_latent = vae_output.latent_dist.sample() * pipe.vae.config.scaling_factor
+
+    print("Preparing text conditioning embeddings...")
+
+   
+    prompt = "A photo of {}".format(category)
+    print(f"Prompt: {prompt}")
+    prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds = pipe.encode_prompt(
+            prompt=prompt, prompt_2=prompt, prompt_3=None,
+            negative_prompt="", negative_prompt_2="", negative_prompt_3=None, device=DEVICE
+        )
+    
+    batched_prompt_embeds = torch.cat([prompt_embeds, negative_prompt_embeds], dim=0).to(pipe.transformer.dtype)
+    batched_pooled_embeds = torch.cat([pooled_prompt_embeds, negative_pooled_prompt_embeds], dim=0).to(pipe.transformer.dtype)
+
+    # --- 2. DATA COLLECTION LOOP ---
+    # cond_feats = [[None for _ in LAYERS_TO_EXTRACT] for _ in TIMESTEPS]
+    # name_list = [[None for _ in LAYERS_TO_EXTRACT] for _ in TIMESTEPS]
+    cond_feats = []
+    name_list = []
+    # uncond_figs = [[None for _ in LAYERS_TO_EXTRACT] for _ in TIMESTEPS]
+
+    for i, ts_val in enumerate(TIMESTEPS):
+        print(f"\n===== Processing Timestep: {ts_val} =====\n")
+            
+        # Apply noise for the current timestep
+        noise = torch.randn_like(clean_latent)
+        t = torch.tensor([ts_val], device=DEVICE, dtype=clean_latent.dtype)
+        t_reshaped = t.reshape(-1, *([1] * (clean_latent.dim() - 1)))
+        noised_latent = (1 - t_reshaped) * clean_latent + t_reshaped * noise
+            
+        # Prepare inputs for the transformer (batch for CFG)
+        noised_latent_for_model = torch.cat([noised_latent] * 2).to(pipe.transformer.dtype)
+        timestep_for_model = torch.cat([t] * 2).to(pipe.transformer.dtype) * 1000
+
+        with FeatureExtractor(transformer, LAYERS_TO_EXTRACT) as extractor:
+            with torch.no_grad():
+                transformer(
+                        hidden_states=noised_latent_for_model,
+                        timestep=timestep_for_model,
+                        encoder_hidden_states=batched_prompt_embeds,
+                        pooled_projections=batched_pooled_embeds,
+                        return_dict=False
+                    )
+
+            # Process features for each requested layer at this timestep
+            for j, layer_idx in enumerate(LAYERS_TO_EXTRACT):
+                print(f"--- Analyzing Layer {layer_idx} ---")
+                if layer_idx in extractor.features:
+                    # The hook returns a list with one item (from the single forward pass)
+                    # which is a tuple of (image_batch_features, text_batch_features)
+                    img_features_batch, _ = extractor.features[layer_idx][0]
+                        
+                    # Separate cond and uncond features
+                    cond_img_features = img_features_batch[0] # 3600 x 1536
+
+                    num_patch = np.sqrt(cond_img_features.shape[0])
+                    print(f"Number of patches: {num_patch}")
+                    cond_img_features = cond_img_features.reshape(1, int(num_patch), int(num_patch), -1).permute(0, 3, 1, 2)  # Reshape to [1, 1536, num_patch, num_patch] # be super careful in the order of the dimensions
+                    # uncond_img_features = img_features_batch[1]
+
+                    # print(cond_img_features.shape)
+                    # cond_feats[i][j] = cond_img_features
+                    cond_feats.append(cond_img_features)
+
+                    name = "t_{}_layer_{}".format(ts_val, layer_idx)
+                    # name_list[i][j] = name
+                    name_list.append(name)
+
+                    # normalize 
+                    # print(cond_img_features.shape, uncond_img_features.shape)
+                        
+                    # # Run PCA and store the resulting image arrays
+                    # cond_figs[i][j] = get_pca_image(cond_img_features)
+                    # uncond_figs[i][j] = get_pca_image(uncond_img_features)
+                    # print(f"Stored PCA images for Layer {layer_idx}")
+            
+    return cond_feats, name_list
+
+
+def process_and_save_features(file_paths, real_size, pipe, transformer, flip=False, angle=0, device=None, PF_pascal=False):
+    for file_path in tqdm(file_paths, desc="Processing images (Flip: {})".format(flip)):
+        img1 = Image.open(file_path).convert('RGB')
+        if flip:
+            img1 = img1.transpose(Image.FLIP_LEFT_RIGHT)
+        # img1 = edge_pad_rotate_and_crop(img1, angle=angle) # Uncomment this line to enable different rotation
+        img1_input = resize(img1, real_size, resize=True, to_pil=True)
+        # img1 = resize(img1, img_size, resize=True, to_pil=True)
+
+        if PF_pascal:
+
+            base_annotation_path = file_path.replace('JPEGImages', 'Annotations')
+            # base_annotation_path will be 'path/to/your/Datasets/PF-dataset-PASCAL/Annotations/2009_002457.jpg'
+
+            # 2. Extract the directory part of the annotation path
+            #    This will give 'path/to/your/Datasets/PF-dataset-PASCAL/Annotations'
+            directory_part = os.path.dirname(base_annotation_path)
+
+            # 3. Extract the filename part (including .mat extension)
+            #    This will give '2009_002457.mat'
+            filename_part = os.path.basename(file_path).replace('.jpg', '.mat')
+
+            # # 4. Construct the desired path with the wildcard
+            # file_path_annot_wildcard = os.path.join(directory_part, '*', filename_part)
+            # # category = 
+            # # file_path = file_path.replace('JPEGImages', 'Annotations').replace('.jpg', '.mat')
+            # file_name = os.path.basename(file_path)
+
+            # # print(file_path.replace('JPEGImages', 'Annotations').replace('.jpg', '.mat'))
+
+            # parts = file_path.replace('JPEGImages', 'Annotations').replace('.jpg', '.mat')
+            # annotations_idx = parts.index('Annotations')
+            # # Insert '*' after 'Annotations'
+            # parts.insert(annotations_idx + 1, '*')
+            
+            file_path_annot = glob.glob(os.path.join(directory_part, '*', filename_part))  # Assuming annotations are in .mat files
+            
+            # print(file_name)
+            # print(file_path_annot)
+
+            category = file_path_annot[0].split('/')[-2] #if file_path_annot else 'unknown_category'
+            # print(category)
+        else:
+            print(file_path)
+            category = file_path.split('/')[-2]  # Assuming category is the parent directory name
+
+        # break
+
+        accumulated_features = {}
+        for _ in range(NUM_ENSEMBLE): 
+            # print('model device:', model.device)
+            # features1 = process_features_and_mask(model, aug, img1_input, mask=False, raw=True, device=device)
+            features1, name_list = extract_feats_sd35(pipe, transformer, img1_input, category=category)  # Example category
+
+            for name, features in zip(name_list, features1):
+                accumulated_features[name] = accumulated_features.get(name, 0) + features
+
+
+            # del features1['s2']
+            # for k in features1:
+            #     accumulated_features[k] = accumulated_features.get(k, 0) + features1[k]
+
+        for k in accumulated_features:
+            accumulated_features[k] /= NUM_ENSEMBLE
+
+        subdir_name = 'features' if NUM_ENSEMBLE == 1 else f'features_ensemble{NUM_ENSEMBLE}'
+        output_subdir = file_path.replace('JPEGImages', subdir_name).rsplit('/', 1)[0]
+        os.makedirs(output_subdir, exist_ok=True)
+        
+        suffix = '_flip' if flip else ''
+        output_path = os.path.join(output_subdir, os.path.splitext(os.path.basename(file_path))[0] + f'_sd35{suffix}.pt')
+        torch.save(accumulated_features, output_path)
+
+        # clear memory
+        torch.cuda.empty_cache()
+
+        # print(output_path)
+        # break
+
+        # img1_batch = extractor_vit.preprocess_pil(img1)
+        # img1_desc_dino = extractor_vit.extract_descriptors(img1_batch.to(device), layer, facet).permute(0, 1, 3, 2).reshape(1, -1, 60, 60) # img1_batch.cuda()
+        # output_path_dino = os.path.join(output_subdir, os.path.splitext(os.path.basename(file_path))[0] + f'_dino{suffix}.pt')
+        # torch.save(img1_desc_dino, output_path_dino)
+
+
+
+if __name__ == '__main__':
+    set_seed()
+
+    NUM_ENSEMBLE = 1
+    # TIMESTEPS = [0.3, 0.5, 0.6, 0.7, 0.8]
+    TIMESTEPS = [0.5, 0.7]
+    # LAYERS_TO_EXTRACT = [5, 9, 10, 11, 12, 13, 15, 18, 20]  # Example layer indices to extract features from
+    LAYERS_TO_EXTRACT = [10, 11, 12]  # Example layer indices to extract features from
+
+    real_size = 960
+
+    MODEL_ID = "stabilityai/stable-diffusion-3-medium-diffusers"
+    # DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+    base_dir = sys.argv[1] if len(sys.argv) > 1 else 'data/SPair-71k/JPEGImages'
+    # set the device using the second argument if provided, otherwise use 'cuda'
+    device_str = sys.argv[2] if len(sys.argv) > 2 else 'cuda'
+    PF_pascal = sys.argv[3] if len(sys.argv) > 3 else False
+    print(f"Using device: {device_str}")
+    DEVICE = torch.device(device_str if torch.cuda.is_available() else "cpu")
+
+    print(f"Using device: {DEVICE}")
+    print(f"Loading pipeline: {MODEL_ID}...")
+
+    pipe = StableDiffusion3Pipeline.from_pretrained(MODEL_ID, torch_dtype=torch.float16)
+    pipe = pipe.to(DEVICE)
+    transformer = pipe.transformer
+
+    print("Pipeline loaded successfully.")
+
+    all_files = [os.path.join(subdir, file) for subdir, dirs, files in os.walk(base_dir) for file in files if file.endswith('.jpg')]
+
+    angles = [0] # angles for rotation
+    for angle in angles:
+        # Process and save features
+        process_and_save_features(all_files, real_size, pipe, transformer, flip=False, angle=angle, device=DEVICE, PF_pascal=PF_pascal)
+        process_and_save_features(all_files, real_size, pipe, transformer, flip=True, angle=angle, device=DEVICE, PF_pascal=PF_pascal)

Code/qwen-vl-flash-attn.yml

@@ -0,0 +1,282 @@
+name: qwen-vl-flash-attn
+channels:
+  - conda-forge
+  - nvidia
+  - pytorch
+dependencies:
+  - _libgcc_mutex=0.1=conda_forge
+  - _openmp_mutex=4.5=3_kmp_llvm
+  - aom=3.6.1=h59595ed_0
+  - asttokens=3.0.0=pyhd8ed1ab_1
+  - blas=2.116=mkl
+  - blas-devel=3.9.0=16_linux64_mkl
+  - brotli-python=1.1.0=py311hfdbb021_3
+  - bzip2=1.0.8=h4bc722e_7
+  - ca-certificates=2025.7.9=hbd8a1cb_0
+  - certifi=2025.7.9=pyhd8ed1ab_0
+  - cffi=1.17.1=py311hf29c0ef_0
+  - charset-normalizer=3.4.2=pyhd8ed1ab_0
+  - comm=0.2.2=pyhd8ed1ab_1
+  - cpython=3.11.13=py311hd8ed1ab_0
+  - cuda-cudart=12.1.105=0
+  - cuda-cupti=12.1.105=0
+  - cuda-libraries=12.1.0=0
+  - cuda-nvrtc=12.1.105=0
+  - cuda-nvtx=12.1.105=0
+  - cuda-opencl=12.9.19=0
+  - cuda-runtime=12.1.0=0
+  - cuda-version=12.9=3
+  - debugpy=1.8.14=py311hfdbb021_0
+  - decorator=5.2.1=pyhd8ed1ab_0
+  - exceptiongroup=1.3.0=pyhd8ed1ab_0
+  - executing=2.2.0=pyhd8ed1ab_0
+  - ffmpeg=4.4.2=gpl_hdf48244_113
+  - filelock=3.18.0=pyhd8ed1ab_0
+  - font-ttf-dejavu-sans-mono=2.37=hab24e00_0
+  - font-ttf-inconsolata=3.000=h77eed37_0
+  - font-ttf-source-code-pro=2.038=h77eed37_0
+  - font-ttf-ubuntu=0.83=h77eed37_3
+  - fontconfig=2.15.0=h7e30c49_1
+  - fonts-conda-ecosystem=1=0
+  - fonts-conda-forge=1=0
+  - freetype=2.13.3=ha770c72_1
+  - giflib=5.2.2=hd590300_0
+  - gmp=6.3.0=hac33072_2
+  - gmpy2=2.2.1=py311h0f6cedb_0
+  - gnutls=3.7.9=hb077bed_0
+  - h2=4.2.0=pyhd8ed1ab_0
+  - hpack=4.1.0=pyhd8ed1ab_0
+  - hyperframe=6.1.0=pyhd8ed1ab_0
+  - icu=75.1=he02047a_0
+  - idna=3.10=pyhd8ed1ab_1
+  - importlib-metadata=8.7.0=pyhe01879c_1
+  - ipykernel=6.29.5=pyh3099207_0
+  - ipython=9.4.0=pyhfa0c392_0
+  - ipython_pygments_lexers=1.1.1=pyhd8ed1ab_0
+  - jedi=0.19.2=pyhd8ed1ab_1
+  - jinja2=3.1.6=pyhd8ed1ab_0
+  - jupyter_client=8.6.3=pyhd8ed1ab_1
+  - jupyter_core=5.8.1=pyh31011fe_0
+  - keyutils=1.6.1=h166bdaf_0
+  - krb5=1.21.3=h659f571_0
+  - lame=3.100=h166bdaf_1003
+  - lcms2=2.17=h717163a_0
+  - ld_impl_linux-64=2.44=h1423503_1
+  - lerc=4.0.0=h0aef613_1
+  - libasprintf=0.25.1=h8e693c7_0
+  - libblas=3.9.0=16_linux64_mkl
+  - libcblas=3.9.0=16_linux64_mkl
+  - libcublas=12.1.0.26=0
+  - libcufft=11.0.2.4=0
+  - libcufile=1.14.1.1=4
+  - libcurand=10.3.10.19=0
+  - libcusolver=11.4.4.55=0
+  - libcusparse=12.0.2.55=0
+  - libdeflate=1.24=h86f0d12_0
+  - libdrm=2.4.125=hb9d3cd8_0
+  - libedit=3.1.20250104=pl5321h7949ede_0
+  - libegl=1.7.0=ha4b6fd6_2
+  - libexpat=2.7.0=h5888daf_0
+  - libffi=3.4.6=h2dba641_1
+  - libfreetype=2.13.3=ha770c72_1
+  - libfreetype6=2.13.3=h48d6fc4_1
+  - libgcc=15.1.0=h767d61c_3
+  - libgcc-ng=15.1.0=h69a702a_3
+  - libgettextpo=0.25.1=h5888daf_0
+  - libgfortran=15.1.0=h69a702a_3
+  - libgfortran-ng=15.1.0=h69a702a_3
+  - libgfortran5=15.1.0=hcea5267_3
+  - libgl=1.7.0=ha4b6fd6_2
+  - libglvnd=1.7.0=ha4b6fd6_2
+  - libglx=1.7.0=ha4b6fd6_2
+  - libgomp=15.1.0=h767d61c_3
+  - libhwloc=2.11.2=default_h0d58e46_1001
+  - libiconv=1.18=h4ce23a2_1
+  - libidn2=2.3.8=ha4ef2c3_0
+  - libjpeg-turbo=3.1.0=hb9d3cd8_0
+  - liblapack=3.9.0=16_linux64_mkl
+  - liblapacke=3.9.0=16_linux64_mkl
+  - liblzma=5.8.1=hb9d3cd8_2
+  - libnpp=12.0.2.50=0
+  - libnsl=2.0.1=hb9d3cd8_1
+  - libnvjitlink=12.1.105=0
+  - libnvjpeg=12.1.1.14=0
+  - libpciaccess=0.18=hb9d3cd8_0
+  - libpng=1.6.50=h943b412_0
+  - libsodium=1.0.20=h4ab18f5_0
+  - libsqlite=3.50.2=hee844dc_2
+  - libstdcxx=15.1.0=h8f9b012_3
+  - libstdcxx-ng=15.1.0=h4852527_3
+  - libtasn1=4.20.0=hb9d3cd8_0
+  - libtiff=4.7.0=hf01ce69_5
+  - libunistring=0.9.10=h7f98852_0
+  - libuuid=2.38.1=h0b41bf4_0
+  - libva=2.22.0=h4f16b4b_2
+  - libvpx=1.13.1=h59595ed_0
+  - libwebp=1.6.0=h9635ea4_0
+  - libwebp-base=1.6.0=hd42ef1d_0
+  - libxcb=1.17.0=h8a09558_0
+  - libxcrypt=4.4.36=hd590300_1
+  - libxml2=2.13.8=h4bc477f_0
+  - libzlib=1.3.1=hb9d3cd8_2
+  - llvm-openmp=15.0.7=h0cdce71_0
+  - markupsafe=3.0.2=py311h2dc5d0c_1
+  - matplotlib-inline=0.1.7=pyhd8ed1ab_1
+  - mkl=2022.1.0=h84fe81f_915
+  - mkl-devel=2022.1.0=ha770c72_916
+  - mkl-include=2022.1.0=h84fe81f_915
+  - mpc=1.3.1=h24ddda3_1
+  - mpfr=4.2.1=h90cbb55_3
+  - mpmath=1.3.0=pyhd8ed1ab_1
+  - ncurses=6.5=h2d0b736_3
+  - nest-asyncio=1.6.0=pyhd8ed1ab_1
+  - nettle=3.9.1=h7ab15ed_0
+  - networkx=3.5=pyhe01879c_0
+  - ocl-icd=2.3.3=hb9d3cd8_0
+  - opencl-headers=2025.06.13=h5888daf_0
+  - openh264=2.3.1=hcb278e6_2
+  - openjpeg=2.5.3=h5fbd93e_0
+  - openssl=3.5.1=h7b32b05_0
+  - p11-kit=0.24.1=hc5aa10d_0
+  - packaging=25.0=pyh29332c3_1
+  - parso=0.8.4=pyhd8ed1ab_1
+  - pexpect=4.9.0=pyhd8ed1ab_1
+  - pickleshare=0.7.5=pyhd8ed1ab_1004
+  - pillow=11.3.0=py311h1322bbf_0
+  - pip=25.1.1=pyh8b19718_0
+  - platformdirs=4.3.8=pyhe01879c_0
+  - prompt-toolkit=3.0.51=pyha770c72_0
+  - psutil=7.0.0=py311h9ecbd09_0
+  - pthread-stubs=0.4=hb9d3cd8_1002
+  - ptyprocess=0.7.0=pyhd8ed1ab_1
+  - pure_eval=0.2.3=pyhd8ed1ab_1
+  - pycparser=2.22=pyh29332c3_1
+  - pygments=2.19.2=pyhd8ed1ab_0
+  - pysocks=1.7.1=pyha55dd90_7
+  - python=3.11.13=h9e4cc4f_0_cpython
+  - python-dateutil=2.9.0.post0=pyhe01879c_2
+  - python_abi=3.11=7_cp311
+  - pytorch-cuda=12.1=ha16c6d3_6
+  - pytorch-mutex=1.0=cuda
+  - pyyaml=6.0.2=py311h2dc5d0c_2
+  - pyzmq=27.0.0=py311h7deb3e3_0
+  - readline=8.2=h8c095d6_2
+  - requests=2.32.4=pyhd8ed1ab_0
+  - setuptools=80.9.0=pyhff2d567_0
+  - six=1.17.0=pyhd8ed1ab_0
+  - stack_data=0.6.3=pyhd8ed1ab_1
+  - svt-av1=1.4.1=hcb278e6_0
+  - tbb=2021.13.0=hceb3a55_1
+  - tk=8.6.13=noxft_hd72426e_102
+  - tornado=6.5.1=py311h9ecbd09_0
+  - traitlets=5.14.3=pyhd8ed1ab_1
+  - typing_extensions=4.14.1=pyhe01879c_0
+  - urllib3=2.5.0=pyhd8ed1ab_0
+  - wayland=1.24.0=h3e06ad9_0
+  - wayland-protocols=1.45=hd8ed1ab_0
+  - wcwidth=0.2.13=pyhd8ed1ab_1
+  - wheel=0.45.1=pyhd8ed1ab_1
+  - x264=1!164.3095=h166bdaf_2
+  - x265=3.5=h924138e_3
+  - xorg-libx11=1.8.12=h4f16b4b_0
+  - xorg-libxau=1.0.12=hb9d3cd8_0
+  - xorg-libxdmcp=1.1.5=hb9d3cd8_0
+  - xorg-libxext=1.3.6=hb9d3cd8_0
+  - xorg-libxfixes=6.0.1=hb9d3cd8_0
+  - yaml=0.2.5=h7f98852_2
+  - zeromq=4.3.5=h3b0a872_7
+  - zipp=3.23.0=pyhd8ed1ab_0
+  - zstandard=0.23.0=py311h9ecbd09_2
+  - zstd=1.5.7=hb8e6e7a_2
+  - pip:
+      - accelerate==1.8.1
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.12.14
+      - aiosignal==1.4.0
+      - annotated-types==0.7.0
+      - anyio==4.9.0
+      - attrs==25.3.0
+      - av==15.0.0
+      - click==8.2.1
+      - contourpy==1.3.2
+      - cycler==0.12.1
+      - decord==0.6.0
+      - diskcache==5.6.3
+      - distro==1.9.0
+      - docstring-parser==0.17.0
+      - einops==0.8.1
+      - flash-attn==2.8.1
+      - fonttools==4.58.5
+      - frozenlist==1.7.0
+      - fsspec==2025.5.1
+      - gitdb==4.0.12
+      - gitpython==3.1.44
+      - h11==0.16.0
+      - hf-xet==1.1.5
+      - httpcore==1.0.9
+      - httpx==0.28.1
+      - huggingface-hub==0.33.4
+      - imageio==2.37.0
+      - instructor==1.10.0
+      - jiter==0.10.0
+      - joblib==1.5.1
+      - kiwisolver==1.4.8
+      - lazy-loader==0.4
+      - loguru==0.7.3
+      - markdown-it-py==3.0.0
+      - matplotlib==3.10.3
+      - mdurl==0.1.2
+      - multidict==6.6.3
+      - ninja==1.11.1.4
+      - numpy==2.2.6
+      - nvidia-cublas-cu12==12.4.5.8
+      - nvidia-cuda-cupti-cu12==12.4.127
+      - nvidia-cuda-nvrtc-cu12==12.4.127
+      - nvidia-cuda-runtime-cu12==12.4.127
+      - nvidia-cudnn-cu12==9.1.0.70
+      - nvidia-cufft-cu12==11.2.1.3
+      - nvidia-curand-cu12==10.3.5.147
+      - nvidia-cusolver-cu12==11.6.1.9
+      - nvidia-cusparse-cu12==12.3.1.170
+      - nvidia-cusparselt-cu12==0.6.2
+      - nvidia-nccl-cu12==2.21.5
+      - nvidia-nvjitlink-cu12==12.4.127
+      - nvidia-nvtx-cu12==12.4.127
+      - openai==1.97.1
+      - opencv-python==4.12.0.88
+      - pandas==2.3.1
+      - propcache==0.3.2
+      - protobuf==6.31.1
+      - pydantic==2.11.7
+      - pydantic-core==2.33.2
+      - pyparsing==3.2.3
+      - pytz==2025.2
+      - qwen-vl-utils==0.0.11
+      - regex==2024.11.6
+      - rich==14.1.0
+      - safetensors==0.5.3
+      - scikit-image==0.25.2
+      - scikit-learn==1.7.0
+      - scipy==1.16.0
+      - sentry-sdk==2.33.0
+      - shellingham==1.5.4
+      - smmap==5.0.2
+      - sniffio==1.3.1
+      - sympy==1.13.1
+      - tenacity==9.1.2
+      - threadpoolctl==3.6.0
+      - tifffile==2025.6.11
+      - timm==1.0.17
+      - tokenizers==0.21.2
+      - torch==2.6.0+cu124
+      - torchaudio==2.6.0+cu124
+      - torchvision==0.21.0+cu124
+      - tqdm==4.67.1
+      - transformers==4.51.3
+      - triton==3.2.0
+      - typer==0.16.0
+      - typing-inspection==0.4.1
+      - tzdata==2025.2
+      - wandb==0.21.0
+      - yarl==1.20.1
+prefix: /opt/conda/envs/qwen-vl-flash-attn

Code/qwen_inference/dataset.py

@@ -0,0 +1,64 @@
+import os
+
+def get_dataset_info(args, split):
+    if args.EVAL_DATASET == 'pascal':
+        # data_dir = 'data/PF-dataset-PASCAL'
+        data_dir = '../../Datasets/PF-dataset-PASCAL'
+        categories = sorted(os.listdir(os.path.join(data_dir, 'Annotations')))
+    # elif args.EVAL_DATASET == 'ap10k':
+    #     data_dir = 'data/ap-10k'
+    #     categories = []
+    #     subfolders = os.listdir(os.path.join(data_dir, 'ImageAnnotation'))
+    #     # Handle AP10K_EVAL test settings
+    #     if args.AP10K_EVAL_SUBSET == 'intra-species':
+    #         categories = [folder for subfolder in subfolders for folder in os.listdir(os.path.join(data_dir, 'ImageAnnotation', subfolder))]
+    #     elif args.AP10K_EVAL_SUBSET == 'cross-species':
+    #         categories = [subfolder for subfolder in subfolders if len(os.listdir(os.path.join(data_dir, 'ImageAnnotation', subfolder))) > 1]
+    #         split += '_cross_species'
+    #     elif args.AP10K_EVAL_SUBSET == 'cross-family':
+    #         categories = ['all']
+    #         split += '_cross_family'
+    #     categories = sorted(categories)
+    #     if split == 'val':
+    #         # remove category "king cheetah" from categories, since it is not present in the validation set
+    #         categories.remove('king cheetah')
+    elif args.EVAL_DATASET == 'spair': # SPair
+        # data_dir = 'data/SPair-71k'
+        data_dir = '../../Datasets/SPair-71k'
+        categories = sorted(os.listdir(os.path.join(data_dir, 'ImageAnnotation')))
+
+    return data_dir, categories, split
+
+
+
+# SPair-71k dataset for batch processing
+from PIL import Image
+from torch.utils.data import Dataset
+
+class VLDataset(Dataset):
+    """A simple dataset to wrap a list of images and prompts for the DataLoader."""
+    def __init__(self, images, prompts):
+        self.images = images
+        self.prompts = prompts
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        # The DataLoader will call this for each item
+        return self.images[idx], self.prompts[idx]
+    
+
+class VLDatasetPaired(Dataset):
+    """A simple dataset to wrap a list of images and prompts for the DataLoader."""
+    def __init__(self, source_imgs, target_imgs, prompts):
+        self.source_imgs = source_imgs
+        self.target_imgs = target_imgs
+        self.prompts = prompts
+
+    def __len__(self):
+        return len(self.source_imgs)
+
+    def __getitem__(self, idx):
+        # The DataLoader will call this for each item
+        return self.source_imgs[idx], self.target_imgs[idx], self.prompts[idx]

Code/qwen_inference/inference_batched.py

@@ -0,0 +1,367 @@
+import os
+import wandb
+import matplotlib.pyplot as plt
+from torch.utils.data import DataLoader
+import argparse
+import torch
+from tqdm import tqdm
+from PIL import ImageDraw, ImageFont
+import numpy as np
+import json
+
+# mutliprocessing for parallel job preparation
+import concurrent.futures
+
+# custom imports
+from dataset import get_dataset_info, VLDataset
+from utils import load_eval_data, load_img_and_kps
+from qwen_utils import QwenVLDetector
+# from predict_correspondence_vlm import create_image_with_one_kp
+
+# Place the new, fast drawing function here
+# def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, **kwargs):
+#     img_with_kp = img.copy()
+#     draw = ImageDraw.Draw(img_with_kp)
+#     cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+#     radius = circ_size / 10 
+#     bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+#     draw.ellipse(bbox, outline="red", width=4)
+#     return img_with_kp
+
+def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, add_text=True, **kwargs):
+    img_with_kp = img.copy()
+    draw = ImageDraw.Draw(img_with_kp)
+    cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+    radius = circ_size / 10 
+    bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+    draw.ellipse(bbox, outline="red", width=4)
+
+    if add_text:
+        text = "Ref"
+        # Try to use a better font, or fall back to the default if not found
+        # try:
+        font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+        # except IOError:
+        #     print('test')
+        #     font = ImageFont.load_default()
+
+        # Get text bounding box for centering
+        # print(font)
+        bbox_text = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox_text[2] - bbox_text[0]
+        text_height = bbox_text[3] - bbox_text[1]
+
+        text_x = cx - text_width // 2
+        text_y = cy - text_height // 2
+        draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+    return img_with_kp
+
+# Helper function to process a single keypoint (needed for parallelization)
+def prepare_single_job(task_args):
+    img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, category_prompt_sem = task_args
+
+    if img1_kps[kps_idx, 2] == 1:
+        # Use the fast, new function
+        img1_kp = create_image_with_one_kp_pil(img1, img1_kps, kps_idx=kps_idx)
+        
+        return {
+            "img1": img1,
+            "img1_kp": img1_kp,
+            "img2": img2,
+            "prompt_sem": category_prompt_sem,
+            "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+        }
+    return None
+
+def run_batched_evaluation(args, model, system_prompt_sem, system_prompt_bbox, task_prompt_sem, task_prompt_bbox):
+    """
+    Runs the entire evaluation using a batched approach for maximum efficiency.
+    """
+    # --- Create save directories if provided ---
+    if args.SAVE_DIR:
+        stage2_dir = os.path.join(args.SAVE_DIR, "stage2_semantics", args.EVAL_DATASET, args.EXP_NOTE)
+        stage3_dir = os.path.join(args.SAVE_DIR, "stage3_bboxes", args.EVAL_DATASET, args.EXP_NOTE)
+        os.makedirs(stage2_dir, exist_ok=True)
+        os.makedirs(stage3_dir, exist_ok=True)
+        print(f"Intermediate results will be saved to: {args.SAVE_DIR}")
+
+
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    results_table = wandb.Table(columns=["category", "src_id", "tgt_id", "kpt_id", "plot", "extracted_semantics", "src_response", "src_bbox", "src_input_size", "tgt_response", "tgt_bbox", "target_input_size"])
+
+    # --- STAGE 1: PREPARE ALL INFERENCE JOBS FIRST ---
+    print("--- Stage 1: Preparing all inference jobs... ---")
+    # inference_jobs = []
+    # for category in categories:
+    #     # print(f"Preparing jobs for category: {category}")
+    #     category_prompt_sem = task_prompt_sem.format(class_name=category)
+    #     files, kps, _, _ = load_eval_data(args, data_dir, category, split)
+    #     N = len(files) // 2
+
+    #     # for pair_idx in range(N):
+    #     for pair_idx in tqdm(range(N), desc=f"Processing {category} pairs"):
+    #         img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+    #         img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+    #         src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+    #         tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+    #         for kps_idx in range(img1_kps.shape[0]):
+    #             if img1_kps[kps_idx, 2] == 1:
+    #                 # CPU-bound image creation
+    #                 img1_kp = create_image_with_one_kp(img1, img1_kps, kps_idx=kps_idx, add_text=False, add_circle=True)
+                    
+    #                 job = {
+    #                     "img1_kp": img1_kp,
+    #                     "img2": img2,
+    #                     "prompt_sem": category_prompt_sem,
+    #                     "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+    #                 }
+    #                 inference_jobs.append(job)
+    # print(f"Prepared {len(inference_jobs)} total jobs.")
+
+    # First, create a flat list of all tasks to be done
+    tasks = []
+    for category in categories:
+        # category_prompt_sem = task_prompt_sem.format(class_name=category)
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split)
+        N = len(files) // 2
+
+        # for pair_idx in range(N):
+        for pair_idx in tqdm(range(N), desc=f"Adding {category} pairs"):
+            img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+            tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+            for kps_idx in range(img1_kps.shape[0]):
+                # point_x = int(img1_kps[kps_idx, 0])
+                # point_y = int(img1_kps[kps_idx, 1])
+                # get two decimal places
+                point_x = f"{img1_kps[kps_idx, 0]:.2f}"
+                point_y = f"{img1_kps[kps_idx, 1]:.2f}"
+                category_prompt_sem = task_prompt_sem.format(class_name=category, point_x=point_x, point_y=point_y)
+                tasks.append((img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, category_prompt_sem))
+
+    # Now, process the flat list of tasks in parallel
+    inference_jobs = []
+    # Use max_workers=None to use all available CPU cores
+    with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
+        # `map` will apply `prepare_single_job` to each item in `tasks` across multiple processes
+        # `tqdm` provides a progress bar
+        results = list(tqdm(executor.map(prepare_single_job, tasks), total=len(tasks), desc="Preparing Jobs"))
+
+    # Filter out None results (from invisible keypoints)
+    inference_jobs = [job for job in results if job is not None]
+
+    print(f"Prepared {len(inference_jobs)} total jobs.")
+
+
+    # --- STAGE 2: BATCHED SEMANTIC EXTRACTION (1st Model Call) ---
+    print("\n--- Stage 2: Running batched semantic extraction... ---")
+    src_images = [job["img1_kp"] for job in inference_jobs]
+    src_prompts = [job["prompt_sem"] for job in inference_jobs]
+
+    dataset_sem = VLDataset(src_images, src_prompts)
+    loader_sem = DataLoader(dataset_sem, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x, pin_memory=True)
+    
+    all_src_results = []
+    # for batch in loader_sem:
+    for batch in tqdm(loader_sem, desc="Processing semantic extraction batches"):
+        images_pil, text_prompts = zip(*batch)
+        # Use the base `chat` method as it seems you want raw text back
+        # NOTE: You might need a batched version of `chat` if it doesn't support lists
+        results = model.chat_batch(list(images_pil), list(text_prompts), system_prompt_sem, 'self-handled') # Assuming model.chat is updated for batching
+        all_src_results.extend(results)
+
+    # Extract semantics and prepare for the next stage
+    for i, job in enumerate(inference_jobs):
+        response_text = all_src_results[i]['response']
+        job["metadata"]["src_input_size"] = all_src_results[i]['input_size']
+        job["src_response"] = response_text
+        job["extracted_semantics"] = response_text.split("Keypoint component:")[-1].strip()
+        job["src_bbox"] = model._get_bounding_boxes(response_text, all_src_results[i]['input_size'], job['img1_kp'].size)
+
+
+    # --- SAVE STAGE 2 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 2 results to {stage2_dir}...")
+        for job in tqdm(inference_jobs, desc="Saving Stage 2 results"):
+            meta = job["metadata"]
+            if args.DEBUG:
+                filename = f"DEBUG:{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            else:
+                filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage2_dir, filename)
+            src_bbox = list(job["src_bbox"].values())[0]['bbox'] if job["src_bbox"] and job["src_bbox"].values() else None
+            output_data = {
+                "metadata": meta,
+                "full_response": job["src_response"],
+                "extracted_semantics": job["extracted_semantics"],
+                "source_bbox": src_bbox,
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+    # --- STAGE 3: BATCHED BOUNDING BOX PREDICTION (2nd Model Call) ---
+    print("\n--- Stage 3: Running batched bounding box prediction... ---")
+    if args.DEBUG:
+        # print("Debug mode enabled: Saving intermediate results to disk.")
+        print("Debug mode enabled: Using img1 for bounding box prediction.")
+        tgt_images = [job["img1"] for job in inference_jobs]
+    else:
+        tgt_images = [job["img2"] for job in inference_jobs]
+    tgt_prompts = [task_prompt_bbox.format(class_name=job["metadata"]["category"], extracted_semantics=job["extracted_semantics"]) for job in inference_jobs]
+
+    dataset_bbox = VLDataset(tgt_images, tgt_prompts)
+    loader_bbox = DataLoader(dataset_bbox, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x)
+
+    all_tgt_results = []
+    # for batch in loader_bbox:
+    for batch in tqdm(loader_bbox, desc="Processing bounding box prediction batches"):
+        images_pil, text_prompts = zip(*batch)
+        # Assuming model.predict is updated for batching
+        results = model.predict_batch(list(images_pil), list(text_prompts), system_prompt_bbox, 'object') 
+        all_tgt_results.extend(results)
+
+    # --- SAVE STAGE 3 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 3 results to {stage3_dir}...")
+        for i, job in enumerate(tqdm(inference_jobs, desc="Saving Stage 3 results")):
+            meta = job["metadata"]
+            tgt_result = all_tgt_results[i]
+            if args.DEBUG:
+                tgt_bbox = model.predict_bounding_boxes(job["img1"], tgt_result['response'], tgt_result['input_size'])
+            else:
+                tgt_bbox = model.predict_bounding_boxes(job["img2"], tgt_result['response'], tgt_result['input_size'])
+            
+            filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage3_dir, filename)
+            output_data = {
+                "metadata": meta,
+                "full_response": tgt_result['response'],
+                "target_bbox": tgt_bbox,
+                "target_input_size": tgt_result['input_size'],
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+
+
+    # --- STAGE 4: LOGGING ---
+    print("\n--- Stage 4: Plotting and logging results to WandB... ---")
+    # for i, job in enumerate(inference_jobs):
+    for i, job in tqdm(enumerate(inference_jobs), total=len(inference_jobs), desc="Logging results"):
+        meta = job["metadata"]
+        src_bbox_dict = job["src_bbox"]
+        tgt_result = all_tgt_results[i]
+
+        src_bbox = list(src_bbox_dict.values())[0]['bbox'] if src_bbox_dict else None
+        tgt_bbox = model.predict_bounding_boxes(job["img2"], tgt_result['response'], tgt_result['input_size'])
+
+        # Create plot
+        # --- COMPLETED PLOTTING LOGIC ---
+        # Get the source and target images for plotting
+        img1_kp = job["img1_kp"]
+        if args.DEBUG:
+            img2 = job["img1"]  # Use img1 for bbox prediction in debug mode
+        else:
+            img2 = job["img2"]
+
+        fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+        axes[0].imshow(np.array(img1_kp))
+        axes[0].axis('off')
+        axes[0].set_title('Source Image with Keypoint')
+        axes[1].imshow(np.array(img2))
+        axes[1].axis('off')
+        axes[1].set_title('Target Image with Bounding Box')
+        if src_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = src_bbox
+            axes[0].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        
+        if tgt_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = tgt_bbox
+            axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        else:
+            axes[1].text(img2.width / 2, img2.height / 2, "No bounding box found", color='red', fontsize=12, ha='center', va='center')
+        
+        fig.tight_layout()
+
+        wandb_img = wandb.Image(fig)
+        plt.close(fig) 
+
+
+        results_table.add_data(
+            meta["category"], 
+            meta["src_id"], 
+            meta["tgt_id"], 
+            meta["kps_idx"],
+            wandb_img, 
+            job["extracted_semantics"], 
+            job["src_response"],
+            str(src_bbox),
+            job["metadata"]["src_input_size"],
+            tgt_result['response'], 
+            str(tgt_bbox),
+            tgt_result['input_size']
+        )
+    
+    wandb.log({"evaluation_results": results_table})
+
+
+# ===================================================================
+# 4. YOUR ORIGINAL `main` FUNCTION, NOW SIMPLIFIED TO CALL THE BATCHED RUNNER
+# ===================================================================
+def main(args):
+    with open(args.SYSTEM_PROMPT_SEM, 'r') as f:
+        system_prompt_sem = f.read()
+    with open(args.SYSTEM_PROMPT_BBOX, 'r') as f:
+        system_prompt_bbox = f.read()
+    with open(args.TASK_PROMPT_SEM, 'r') as f:
+        task_prompt_sem = f.read()
+    with open(args.TASK_PROMPT_BBOX, 'r') as f:
+        task_prompt_bbox = f.read()
+
+    # Initialize the Qwen VLM model
+    print("Initializing Qwen model...")
+    model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name=args.MODEL_NAME, device="auto", flash_attn=True)
+    # model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name="Qwen/Qwen2.5-VL-7B-Instruct", device="auto", flash_attn=True)
+
+    # Initialize WandB
+    print("Initializing WandB...")
+    wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    # Run the optimized evaluation
+    run_batched_evaluation(args, model, system_prompt_sem, system_prompt_bbox, task_prompt_sem, task_prompt_bbox)
+
+    print('Finished processing all categories and logging results.')
+    wandb.finish()
+    print('WandB run finished.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # ... (all your existing arguments) ...
+    parser.add_argument('--SYSTEM_PROMPT_SEM', type=str, required=True)
+    parser.add_argument('--SYSTEM_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_SEM', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    parser.add_argument('--DEBUG', action='store_true', help='Enable debug mode for verbose output.') # decouple the prediction
+    parser.add_argument('--MODEL_NAME', type=str, default='Qwen/Qwen2.5-VL-32B-Instruct', help='Model name for Qwen VLM.')
+    
+    # --- ADD THESE NEW ARGUMENTS for controlling batching ---
+    parser.add_argument('--BATCH_SIZE', type=int, default=4, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+
+    
+    args = parser.parse_args()
+    main(args)

Code/qwen_inference/prompts/sys_bbox.txt

@@ -0,0 +1,39 @@
+You are a helpful assistant.
+
+# Task
+1. Analyze the image of a {class_name} and locate the most prominent instance of the component described by: "{extracted_semantics}".
+2. Interpret the semantics carefully — including spatial orientation (e.g., left/right from object's perspective), attachment, and visibility.
+3. If the component is clearly visible and matches the description, draw a tight 2-D bounding box around it in absolute pixel coordinates: [x1, y1, x2, y2].
+4. If the component is:
+   - not present,
+   - fully occluded,
+   - ambiguous, or
+   - does not match the semantics (e.g., wrong side, wrong part),
+   return an empty list: [].
+
+# Output Rules
+- On a **new line**, output the result in **exactly** this JSON format:
+```json
+   [
+      {"bbox_2d": [x1, y1, x2, y2], "label": "<component-label>"}
+   ]
+```
+- OR, if not found
+```json
+   []
+```
+- All coordinates are in absolute pixels; assume image size is 840×840 with (0,0) at top-left.
+- No extra text, explanations, or formatting outside the JSON.
+
+# Examples:
+Thought: The semantics "left engine (mounted under left wing, pilot's perspective)" refer to the engine on the pilot’s left. In this image, the left engine is visible and matches the description.
+```json
+    [
+      {"bbox_2d": [x1, y1, x2, y2], "label": "left engine"}
+   ]
+```
+
+Thought: The semantics "right ear (upright, located on the top-right side of the head from the object's perspective)" describe the right ear. However, the dog’s head is partially cropped, and the right ear is not visible.
+```json
+    []
+```

Code/qwen_inference/prompts/tsk_bbox.txt

@@ -0,0 +1,4 @@
+Locate the most prominent instance of the component described by "{extracted_semantics}" in the image of a {class_name}. The component should match the described location, orientation, and attachment from the object’s perspective. Assume the image is 840×840 pixels with (0,0) at the top-left. If the component is clearly visible and matches the semantics, return a single tight bounding box in absolute pixel coordinates [x1, y1, x2, y2]. Otherwise, return an empty list.
+
+
+

Code/qwen_inference/prompts/tsk_vlm_judge.txt

@@ -0,0 +1,22 @@
+You are given two images:
+
+- **First image (source)**: includes a green bounding box marking a specific semantic part of an object.
+- **Second image (target)**: contains a **predicted bounding box**, which may or may not be present.
+
+Your task is to **judge the correctness of the prediction** in the second image.
+
+Instructions:
+
+1. If the **second image contains a green bounding box**, determine whether it refers to the **same semantic part** as highlighted in the first image. Consider:
+   - Object orientation and viewpoint
+   - Symmetry and part alignment
+   - Whether the semantic part is visible and appropriately localized
+
+2. If the **second image does NOT contain a bounding box**, determine whether this is correct:
+   - If the semantic part from the first image is **absent, occluded, or cropped** in the second image, then **no bounding box is a correct prediction**.
+   - If the part is still visible or partially visible, then **a bounding box should have been predicted**, and the absence is incorrect.
+
+**Output your response in the following format:**
+
+<reasoning>  
+<final_answer>  (only output "yes" or "no")

Code/qwen_inference/qwen_utils.py

@@ -0,0 +1,1289 @@
+# class PromptManager():
+#     def __init__(self):
+#         pass
+
+#     def construct_prompt(self, text_prompt, prompt_type):
+#         if prompt_type.lower() == 'object':
+#             prompt = f"""Outline the position of each {text_prompt} and output all bounding box coordinates in JSON format"""
+#         elif prompt_type.lower() == 'self-handled':
+#             prompt = text_prompt
+#         else:
+#             raise NotImplementedError
+
+#         return prompt
+
+import os
+from os import path
+from PIL import Image, ImageDraw, ImageFont
+from PIL import ImageColor
+import json
+import requests
+from io import BytesIO
+from urllib.parse import urlparse
+import pathlib
+import torch
+from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+from qwen_vl_utils import process_vision_info
+
+class PromptManager:
+    """
+    Builds a prompt that forces the LLM to return
+    a *pure* JSON list of bounding-box dictionaries:
+
+        [
+          {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"},
+          ...
+        ]
+    """
+
+    @staticmethod
+    def construct_prompt(text_prompt: str, prompt_type: str = "object") -> str:
+        if prompt_type.lower() == "object":
+            prompt = text_prompt+"""
+                Required format (copy this structure exactly):
+                ```json
+                [
+                {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"},
+                ]
+                ```
+            """
+            return prompt
+        elif prompt_type.lower() == "self-handled":
+            return text_prompt
+        else:
+            raise NotImplementedError("prompt_type must be 'object' or 'self-handled'")
+
+
+def load_image(source, image_path=None):
+    try:
+        parsed = urlparse(source)
+        is_url = bool(parsed.scheme and parsed.netloc)
+        
+        if is_url:
+            response = requests.get(source, stream=True)
+            response.raise_for_status()
+            img = Image.open(BytesIO(response.content))
+        else:
+            if path.exists(source):
+                img = Image.open(source)
+            else:
+                print(f"Error: Local file not found at {source}")
+                return None
+        
+        if image_path is not None:
+            directory = path.dirname(image_path)
+            if directory and not path.exists(directory):
+                pathlib.Path(directory).mkdir(parents=True, exist_ok=True)
+            img.save(image_path)
+            print(f"Image saved to {image_path}")
+                
+        return img
+                
+    except Exception as e:
+        print(f"Error loading image: {e}")
+        return None
+
+
+class QwenVLDetector():
+    def __init__(self, model_dir=None, torch_dtype=torch.bfloat16, device="cuda:0", model_name="Qwen/Qwen2.5-VL-7B-Instruct", flash_attn=False):
+        if model_dir is not None:
+            self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_dir, torch_dtype=torch_dtype, device_map=device, local_files_only=True)
+            self.processor = AutoProcessor.from_pretrained(model_dir)
+        else:
+            attn_impl = "flash_attention_2" if flash_attn else "sdpa"
+            self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch_dtype, device_map=device, attn_implementation=attn_impl)
+            self.processor = AutoProcessor.from_pretrained(model_name)
+        
+
+        self.processor.tokenizer.padding_side = "left"
+        self.prompt_manager = PromptManager()
+        self._init_parameters()
+
+    def _init_parameters(self):
+        self.max_size = 1024
+        self.max_new_tokens = 1024
+        self.min_pixels = 512 * 512
+        self.max_pixels = self.max_size * self.max_size 
+
+    def resize_image(self, img, max_size):
+        width, height = img.size
+        if max(width, height) <= max_size:
+            return img
+        scaling_factor = max_size / max(width, height)
+        new_width = int(width * scaling_factor)
+        new_height = int(height * scaling_factor)
+        return img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+    def _parse_json(self, response_text):
+        """
+        Parses a JSON object from a model's response text.
+        Prioritizes extracting from a ```json markdown fence.
+        """
+        try:
+            # Priority 1: Look for a JSON markdown fence. This is the most reliable.
+            if "```json" in response_text:
+                # Isolate the string between the fences
+                json_str = response_text.split("```json")[1].split("```")[0]
+                return json_str.strip()
+
+            # Priority 2: If no fence, find the first '[' and last ']'
+            # This is less reliable and can cause the error you saw.
+            start_idx = response_text.find('[')
+            end_idx = response_text.rfind(']')
+            
+            if start_idx != -1 and end_idx != -1 and end_idx > start_idx:
+                return response_text[start_idx : end_idx + 1]
+
+        except (IndexError, json.JSONDecodeError):
+            # This will catch errors from malformed markdown or other slicing issues.
+            pass
+
+        # Return None if no valid JSON is found
+        return None
+
+    def calculate_iou(self, box1, box2):
+        x1_1, y1_1, x2_1, y2_1 = box1
+        x1_2, y1_2, x2_2, y2_2 = box2
+        area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+        area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+        x1_i, y1_i = max(x1_1, x1_2), max(y1_1, y1_2)
+        x2_i, y2_i = min(x2_1, x2_2), min(y2_1, y2_2)
+        if x2_i <= x1_i or y2_i <= y1_i:
+            return 0.0
+        intersection_area = (x2_i - x1_i) * (y2_i - y1_i)
+        union_area = area1 + area2 - intersection_area
+        return intersection_area / union_area if union_area > 0 else 0.0
+
+    def _check_bbox(self, bbox_with_label, bbox_coor, size, threshold=0.7):
+        x1, y1, x2, y2 = bbox_coor
+        width, height = size
+        if (x2 - x1) * (y2 - y1) / (width * height) >= threshold:
+            return False
+        for bbox_label in bbox_with_label.values():
+            if self.calculate_iou(bbox_label['bbox'], bbox_coor) >= threshold:
+                return False
+        return True
+
+    def _get_bounding_boxes(self, response, input_size, size):
+        bounding_boxes_str = self._parse_json(response)
+        print(f"Bounding boxes string: {bounding_boxes_str}")
+        if not bounding_boxes_str:
+            return {}
+            
+        input_width, input_height = input_size
+        width, height = size
+    
+        try:
+            # Use robust, standard JSON parsing
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not decode JSON from model output: {bounding_boxes_str}")
+            return {}
+    
+        bbox_with_label = {}
+        if isinstance(json_output, list) and len(json_output) > 0:
+            for i, bounding_box in enumerate(json_output):   
+                try:           
+                    coords = bounding_box["bbox_2d"]
+                    abs_x1 = int(coords[0] / input_width * width)            
+                    abs_y1 = int(coords[1] / input_height * height)
+                    abs_x2 = int(coords[2] / input_width * width)
+                    abs_y2 = int(coords[3] / input_height * height)            
+            
+                    if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                    if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+
+                    if self._check_bbox(bbox_with_label, [abs_x1, abs_y1, abs_x2, abs_y2], size):                        
+                        bbox_with_label[i] = {'bbox': [abs_x1, abs_y1, abs_x2, abs_y2], 'label': bounding_box.get('label')}
+                    
+                except (KeyError, IndexError, TypeError) as e:
+                    print(f"Error processing bounding box {bounding_box}: {e}")                
+
+        return bbox_with_label
+    
+    # Other methods like chat, predict, plot_bounding_boxes etc. remain the same,
+    # but I've included a corrected plot_bounding_boxes method for robustness.
+    def chat(self, image, text_prompt, system_prompt, prompt_type):
+        curr_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+        # Handle the image input: either load from URL or use the PIL Image directly
+        if isinstance(image, str):
+            # It's a URL or path, load the image
+            image_type = 'str'
+            image_pil = load_image(image)
+            size = image_pil.size
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image,
+                            "min_pixels": self.min_pixels,
+                            "max_pixels": self.max_pixels
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            image_inputs, video_inputs = process_vision_info(messages)
+            inputs = self.processor(text=[text], 
+                                    images=image_inputs, 
+                                    videos=video_inputs, 
+                                    padding=True, 
+                                    return_tensors="pt"
+                                   ).to(self.model.device)
+            
+        else:
+            image_type = 'pil'
+            # Assume it's already a PIL Image
+            image_pil = image
+            # For the message content, we need to use the image directly
+
+            size = image_pil.size
+            image_for_message = self.resize_image(image_pil, self.max_size)
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image_for_message
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+        output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+        response = output_text[0]
+
+        input_height = inputs['image_grid_thw'][0][1] * 14
+        input_width = inputs['image_grid_thw'][0][2] * 14
+        input_size = (input_width.item(), input_height.item())
+
+        del text, inputs, output_ids, generated_ids, output_text
+        torch.cuda.empty_cache()
+
+        return {'response': response, 'input_size': input_size}
+
+    # def predict(self, image, text_prompt, system_prompt, prompt_type='object', bbox_refine=False):
+    #     # This method's internal logic remains the same, as it calls _get_bounding_boxes
+    #     # which has been corrected.
+    #     curr_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+    #     print('this is my curr prompt:', curr_prompt)
+
+    #     if isinstance(image, str):
+    #         image_pil = load_image(image)
+    #         image_for_message = image
+    #     else:
+    #         image_pil = image
+    #         image_for_message = self.resize_image(image_pil, self.max_size)
+
+    #     size = image_pil.size
+    #     messages = [
+    #         {"role": "system", "content": system_prompt},
+    #         {"role": "user", "content": [{"type": "text", "text": curr_prompt}, {"type": "image", "image": image_for_message}]}
+    #     ]
+        
+    #     text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    #     inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+    #     output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+    #     generated_ids = output_ids[:, inputs.input_ids.shape[1]:]
+    #     response = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)[0]
+    
+    #     input_height = inputs['image_grid_thw'][0][1] * 14
+    #     input_width = inputs['image_grid_thw'][0][2] * 14
+    #     input_size = (input_width.item(), input_height.item())
+
+    #     # Cleanup
+    #     del text, inputs, output_ids, generated_ids
+    #     torch.cuda.empty_cache()
+        
+    #     # Bbox refine logic can be kept if needed
+    #     # if bbox_refine: ...
+
+    #     bbox_with_label = self._get_bounding_boxes(response, input_size, size)
+    #     results = {'bbox_with_label': bbox_with_label, 'response': response, 'input_size': input_size}
+
+    #     return results
+
+    def predict(self, image, text_prompt, system_prompt, prompt_type='object', bbox_refine=False):
+        curr_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+        print('this is my curr prompt:', curr_prompt)
+
+        # Handle the image input: either load from URL or use the PIL Image directly
+        if isinstance(image, str):
+            # It's a URL or path, load the image
+            image_type = 'str'
+            image_pil = load_image(image)
+            size = image_pil.size
+            image_for_message = image
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image,
+                            "min_pixels": self.min_pixels,
+                            "max_pixels": self.max_pixels
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            image_inputs, video_inputs = process_vision_info(messages)
+            inputs = self.processor(text=[text], 
+                                    images=image_inputs, 
+                                    videos=video_inputs, 
+                                    padding=True, 
+                                    return_tensors="pt"
+                                   ).to(self.model.device)
+            
+        else:
+            image_type = 'pil'
+            # Assume it's already a PIL Image
+            image_pil = image
+            # For the message content, we need to use the image directly
+
+            size = image_pil.size
+            image_for_message = self.resize_image(image_pil, self.max_size)
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image_for_message
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+        output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+    
+        input_height = inputs['image_grid_thw'][0][1]*14
+        input_width = inputs['image_grid_thw'][0][2]*14
+        
+        response_org = output_text[0]
+        input_size = (input_width.item(), input_height.item())
+
+        del text, inputs, output_ids, generated_ids, output_text
+        torch.cuda.empty_cache()
+
+        if bbox_refine:
+            response = self._bbox_refine(response_org, messages, image_type, image_for_message)
+        else:
+            response = response_org
+
+        results = dict()
+        bbox_with_label = self._get_bounding_boxes(response, input_size, size)
+        results = {'bbox_with_label': bbox_with_label, 'response': response, 'input_size': input_size}
+
+        return results
+
+    def plot_bounding_boxes(self, image, response, input_size, output_path='./temp.png'):
+        img = image.copy()
+        width, height = img.size
+        input_width, input_height = input_size
+    
+        draw = ImageDraw.Draw(img)
+        colors = list(ImageColor.colormap.keys())
+        font = ImageFont.load_default()
+
+        bounding_boxes_str = self._parse_json(response)
+        if not bounding_boxes_str:
+            print("No bounding boxes found in the response.")
+            img.save(output_path)
+            return
+
+        try:
+            # Use robust, standard JSON parsing
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not decode JSON for plotting: {bounding_boxes_str}")
+            img.save(output_path)
+            return
+
+        if isinstance(json_output, list) and len(json_output) > 0:
+            for i, bounding_box in enumerate(json_output):
+                try:                
+                    color = colors[i % len(colors)]
+                    coords = bounding_box["bbox_2d"]
+                    abs_x1 = int(coords[0] / input_width * width)
+                    abs_y1 = int(coords[1] / input_height * height)
+                    abs_x2 = int(coords[2] / input_width * width)
+                    abs_y2 = int(coords[3] / input_height * height) 
+            
+                    if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                    if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+            
+                    draw.rectangle(((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4)
+            
+                    if "label" in bounding_box:
+                        draw.text((abs_x1 + 8, abs_y1 + 6), str(bounding_box["label"]), fill=color, font=font)
+                except (KeyError, IndexError, TypeError) as e:
+                    print(f"Error processing bounding box for plotting {bounding_box}: {e}")                
+    
+        img.save(output_path)
+        print(f"Image with bounding boxes saved to: {output_path}")
+
+    def predict_bounding_boxes(self, image, response, input_size):
+        # This method is for extracting coordinates, so it also benefits from robust parsing
+        width, height = image.size
+        input_width, input_height = input_size
+        
+        bounding_boxes_str = self._parse_json(response)
+        if not bounding_boxes_str:
+            return None
+
+        try:
+            # Use robust, standard JSON parsing
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            return None
+
+        if isinstance(json_output, list) and len(json_output) > 0:
+            try:
+                bounding_box = json_output[0] # Assuming we only want the first one
+                coords = bounding_box["bbox_2d"]
+                abs_x1 = int(coords[0] / input_width * width)
+                abs_y1 = int(coords[1] / input_height * height)
+                abs_x2 = int(coords[2] / input_width * width)
+                abs_y2 = int(coords[3] / input_height * height)
+                if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+                return [abs_x1, abs_y1, abs_x2, abs_y2]
+            except (KeyError, IndexError, TypeError):
+                return None
+        return None
+
+    # ===================================================================
+    # NEW BATCHED INFERENCE FUNCTIONS
+    # ===================================================================
+    def chat_batch(self, images, text_prompts, system_prompt, prompt_type):
+        """Processes a batch of images and prompts for chat-style interaction."""
+        if not images:
+            return []
+
+        # 1. Prepare all inputs for the batch
+        prompts = [self.prompt_manager.construct_prompt(tp, prompt_type) for tp in text_prompts]
+        images_for_message = [self.resize_image(img, self.max_size) for img in images]
+
+        print(f"Batch size: {len(images)}")
+        print(f"Prompts: {prompts}")
+        
+        # 2. Create message structures for the entire batch
+        batch_messages = []
+        for i in range(len(images)):
+            batch_messages.append([
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": [{"type": "text", "text": prompts[i]}, {"type": "image"}]}
+            ])
+            
+        # 3. Use the processor on the entire batch at once
+        text_for_processor = [self.processor.apply_chat_template(m, tokenize=False, add_generation_prompt=True) for m in batch_messages]
+        inputs = self.processor(
+            text=text_for_processor, 
+            images=images_for_message, 
+            padding=True, 
+            return_tensors="pt"
+        ).to(self.model.device)
+
+        # 4. Generate outputs for the entire batch
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [out[len(inp):] for inp, out in zip(inputs.input_ids, output_ids)]
+        responses = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+
+        # 5. Format results
+        input_height = inputs['image_grid_thw'][0][1] * 14
+        input_width = inputs['image_grid_thw'][0][2] * 14
+        input_size = (input_width.item(), input_height.item())
+
+        batch_results = []
+        for response in responses:
+            batch_results.append({'response': response, 'input_size': input_size})
+            
+        del inputs, output_ids, generated_ids
+        # torch.cuda.empty_cache()
+            
+        return batch_results
+
+    def predict_batch(self, images, text_prompts, system_prompt, prompt_type='object'):
+        """Processes a batch of images and prompts to predict bounding boxes."""
+        if not images:
+            return []
+
+        # 1. Prepare all inputs for the batch
+        prompts = [self.prompt_manager.construct_prompt(tp, prompt_type) for tp in text_prompts]
+        images_for_message = [self.resize_image(img, self.max_size) for img in images]
+        original_sizes = [img.size for img in images]
+
+        # 2. Create message structures for the entire batch
+        batch_messages = []
+        for i in range(len(images)):
+            batch_messages.append([
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": [{"type": "text", "text": prompts[i]}, {"type": "image"}]}
+            ])
+
+        # 3. Use the processor on the entire batch at once
+        text_for_processor = [self.processor.apply_chat_template(m, tokenize=False, add_generation_prompt=True) for m in batch_messages]
+        inputs = self.processor(
+            text=text_for_processor, 
+            images=images_for_message, 
+            padding=True, 
+            return_tensors="pt"
+        ).to(self.model.device)
+
+        # 4. Generate outputs for the entire batch
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [out[len(inp):] for inp, out in zip(inputs.input_ids, output_ids)]
+        responses = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+
+        # 5. Format results
+        input_height = inputs['image_grid_thw'][0][1] * 14
+        input_width = inputs['image_grid_thw'][0][2] * 14
+        input_size = (input_width.item(), input_height.item())
+
+        batch_results = []
+        for i, response in enumerate(responses):
+            bbox_with_label = self._get_bounding_boxes(response, input_size, original_sizes[i])
+            batch_results.append({
+                'bbox_with_label': bbox_with_label, 
+                'response': response, 
+                'input_size': input_size
+            })
+
+        del inputs, output_ids, generated_ids
+        # torch.cuda.empty_cache()
+            
+        return batch_results
+
+
+
+# class PromptManager:
+#     """
+#     Builds a prompt that forces the LLM to return
+#     a *pure* JSON list of bounding-box dictionaries:
+
+#         [
+#           {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"},
+#           ...
+#         ]
+#     """
+
+#     @staticmethod
+#     def construct_prompt(text_prompt: str, prompt_type: str = "object") -> str:
+#         """
+#         Parameters
+#         ----------
+#         target_desc : str
+#             Human-readable name of what you want boxed, e.g. "rear wheel of the motorbike".
+#         prompt_type : str
+#             Supported: "object" (build full bounding-box prompt)
+#                         "self-handled" (return target_desc unchanged)
+#         """
+#         if prompt_type.lower() == "object":
+#             # ░░░ Prompt template ░░░
+#             prompt = f"""{text_prompt}
+#                 Required format (copy this structure exactly):
+#                 ```json
+#                 [
+#                 {{"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"}},
+#                 ]
+#                 ```
+#             """
+#             # Strip leading spaces so the first char is '[' once the model starts its answer
+#             return prompt
+
+#         elif prompt_type.lower() == "self-handled":
+#             return text_prompt
+#         else:
+#             raise NotImplementedError("prompt_type must be 'object' or 'self-handled'")
+
+
+# import os
+# from os import path
+# from PIL import Image, ImageDraw, ImageFont
+# from PIL import ImageColor
+# import json
+# import requests
+# from io import BytesIO
+# from urllib.parse import urlparse
+# import pathlib
+
+# import ast
+# import torch
+# from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+# from qwen_vl_utils import process_vision_info
+
+# # from .prompt_manager import PromptManager
+
+
+# def load_image(source, image_path=None):
+#     """
+#     Load an image from a URL or local file path and return a PIL Image object.
+#     Optionally save the loaded image to a specified path.
+    
+#     Args:
+#         source (str): URL or local file path to the image
+#         image_path (str, optional): Path where to save the loaded image
+        
+#     Returns:
+#         PIL.Image: The loaded image or None if loading fails
+#     """
+#     try:
+#         # Check if the source is a URL or local path
+#         parsed = urlparse(source)
+#         is_url = bool(parsed.scheme and parsed.netloc)
+        
+#         if is_url:
+#             # Handle URL
+#             response = requests.get(source, stream=True)
+#             response.raise_for_status()
+#             img = Image.open(BytesIO(response.content))
+#         else:
+#             # Handle local file path
+#             if path.exists(source):
+#                 img = Image.open(source)
+#             else:
+#                 print(f"Error: Local file not found at {source}")
+#                 return None
+        
+#         # Save the image if image_path is provided
+#         if image_path is not None:
+#             # Make sure the directory exists
+#             directory = path.dirname(image_path)
+#             if directory and not path.exists(directory):
+#                 pathlib.Path(directory).mkdir(parents=True, exist_ok=True)
+            
+#             # Save the image in the appropriate format based on file extension
+#             img.save(image_path)
+#             print(f"Image saved to {image_path}")
+                
+#         return img
+                
+#     except Exception as e:
+#         print(f"Error loading image: {e}")
+#         return None
+
+
+# class QwenVLDetector():
+#     # Qwen 2.5 VL
+    
+#     def __init__(self, model_dir=None, torch_dtype=torch.bfloat16, device="cuda:0", model_name="Qwen/Qwen2.5-VL-7B-Instruct", flash_attn=False):
+#         if model_dir is not None:
+#             # Load model and processor from local directory
+#             self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+#                 model_dir,
+#                 torch_dtype=torch_dtype,
+#                 device_map=device,  # Explicitly use first GPU
+#                 local_files_only=True  # Ensures it only looks for local files
+#             )
+#             self.processor = AutoProcessor.from_pretrained(model_dir)
+#         else:
+#             if flash_attn:
+#                 self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch_dtype, device_map=device, attn_implementation="flash_attention_2")
+#             else:
+#                 self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch_dtype, device_map=device)
+#             self.processor = AutoProcessor.from_pretrained(model_name)
+            
+#         # self.system_prompt = system_prompt
+#         self.prompt_manager = PromptManager()
+#         self._init_parameters()
+
+#     def _init_parameters(self):
+#         self.max_size = 1024
+#         self.max_new_tokens = 1024
+#         self.min_pixels = 512 * 512
+#         self.max_pixels = self.max_size * self.max_size 
+
+#     def resize_image(self, img, max_size):
+#         # Get original dimensions                                                                                                               
+#         width, height = img.size
+#             # If image already satisfies the size limit, return original                                                                                           
+#         if max(width, height) <= max_size:
+#             return img
+    
+#         # Calculate scaling factor                                                                                                                             
+#         if width >= height:
+#             # Width is the long edge                                                                                                                           
+#             scaling_factor = max_size / width
+#             new_width = max_size
+#             new_height = int(height * scaling_factor)
+#         else:
+#             # Height is the long edge                                                                                                                          
+#             scaling_factor = max_size / height
+#             new_height = max_size
+#             new_width = int(width * scaling_factor)
+    
+#         # Resize image                                                
+#         resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+#         return resized_img
+
+#     # @title Parsing JSON output
+#     def _parse_json(self, json_output):
+#         # Parsing out the markdown fencing
+#         lines = json_output.splitlines()
+#         for i, line in enumerate(lines):
+#             if line == "```json":
+#                 json_output = "\n".join(lines[i+1:])  # Remove everything before "```json"
+#                 json_output = json_output.split("```")[0]  # Remove everything after the closing "```"
+#                 return json_output
+#         return None   # Bounding box not found
+
+#     def calculate_iou(self, box1, box2):
+#         """
+#         Calculate the Intersection over Union (IoU) between two bounding boxes.
+        
+#         Args:
+#             box1 (list): First bounding box in format [x1, y1, x2, y2]
+#                          where (x1, y1) is the top-left corner and (x2, y2) is the bottom-right corner
+#             box2 (list): Second bounding box in same format
+        
+#         Returns:
+#             float: IoU value between 0 and 1
+#         """
+#         # Extract coordinates
+#         x1_1, y1_1, x2_1, y2_1 = box1
+#         x1_2, y1_2, x2_2, y2_2 = box2
+        
+#         # Calculate area of each bounding box
+#         area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+#         area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+        
+#         # Calculate coordinates of intersection
+#         x1_i = max(x1_1, x1_2)
+#         y1_i = max(y1_1, y1_2)
+#         x2_i = min(x2_1, x2_2)
+#         y2_i = min(y2_1, y2_2)
+        
+#         # Check if there is an intersection
+#         if x2_i <= x1_i or y2_i <= y1_i:
+#             return 0.0
+        
+#         # Calculate intersection area
+#         intersection_area = (x2_i - x1_i) * (y2_i - y1_i)
+        
+#         # Calculate union area (sum of areas - intersection)
+#         union_area = area1 + area2 - intersection_area
+        
+#         # Calculate IoU
+#         iou = intersection_area / union_area
+        
+#         return iou
+
+#     def _check_bbox(self, bbox_with_label, bbox_coor, size, threshold=0.7):
+#         x1, y1, x2, y2 = bbox_coor
+#         width, height = size
+#         if (x2 - x1) * (y2 - y1) / width / height >= threshold:
+#             return False
+
+#         for idx, bbox_label in bbox_with_label.items():
+#             iou = self.calculate_iou(bbox_label['bbox'], bbox_coor)
+#             if iou >= threshold:
+#                 return False
+
+#         return True
+
+#     def _get_bounding_boxes(self, response, input_size, size):
+#         # Parsing out the markdown fencing
+#         bounding_boxes = self._parse_json(response)
+#         if bounding_boxes is None:
+#             return dict()
+            
+#         input_width, input_height = input_size
+#         width, height = size
+    
+#         try:
+#             json_output = ast.literal_eval(bounding_boxes)
+#         except Exception as e:
+#             end_idx = bounding_boxes.rfind('"}') + len('"}')
+#             truncated_text = bounding_boxes[:end_idx] + "]"
+#             json_output = ast.literal_eval(truncated_text)
+    
+#         # Iterate over the bounding boxes
+#         bbox_with_label = dict()
+
+#         if len(json_output) > 0:        
+#             for i, bounding_box in enumerate(json_output):   
+#                 try:           
+                    
+#                     # Convert normalized coordinates to absolute coordinates
+#                     abs_x1 = int(bounding_box["bbox_2d"][0] / input_width * width)            
+#                     abs_y1 = int(bounding_box["bbox_2d"][1] / input_height * height)
+#                     abs_x2 = int(bounding_box["bbox_2d"][2] / input_width * width)
+#                     abs_y2 = int(bounding_box["bbox_2d"][3] / input_height * height)            
+            
+#                     if abs_x1 > abs_x2:
+#                         abs_x1, abs_x2 = abs_x2, abs_x1
+            
+#                     if abs_y1 > abs_y2:
+#                         abs_y1, abs_y2 = abs_y2, abs_y1     
+
+#                     if self._check_bbox(bbox_with_label, [abs_x1, abs_y1, abs_x2, abs_y2], size):                        
+#                         bbox_with_label[i] = {'bbox': [abs_x1, abs_y1, abs_x2, abs_y2], 'label': bounding_box.get('label')}
+                    
+#                 except Exception as e:
+#                     print(f"Error {str(e)} for bounding box {bounding_box}")                
+
+#         return bbox_with_label
+
+#     def _bbox_refine(self, response_org, messages, image_type, image_for_message):
+#         bbox_text = self._parse_json(response_org)
+#         if bbox_text is None:
+#             return response_org
+
+#         prompt_type = 'bbox_refine'
+#         text_prompt = self.prompt_manager.construct_prompt(bbox_text, prompt_type)
+#         messages[1]['content'][0]['text'] = text_prompt
+        
+#         if image_type == 'str':
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             image_inputs, video_inputs = process_vision_info(messages)
+#             inputs = self.processor(text=[text], 
+#                                     images=image_inputs, 
+#                                     videos=video_inputs, 
+#                                     padding=True, 
+#                                     return_tensors="pt"
+#                                    ).to(self.model.device)            
+#         elif image_type == 'pil':            
+#             # Assume it's already a PIL Image
+#             messages[1]['content'][1]['image'] = image_for_message
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+#         else:
+#             raise NotImplementedError
+            
+#         output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+#         generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+#         output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+#         response = output_text[0]
+
+#         del text, inputs, output_ids, generated_ids, output_text
+#         torch.cuda.empty_cache()
+
+#         return response
+
+#     def chat(self, image, text_prompt, system_prompt, prompt_type):
+#         self.text_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+#         # Handle the image input: either load from URL or use the PIL Image directly
+#         if isinstance(image, str):
+#             # It's a URL or path, load the image
+#             image_type = 'str'
+#             image_pil = load_image(image)
+#             size = image_pil.size
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image,
+#                             "min_pixels": self.min_pixels,
+#                             "max_pixels": self.max_pixels
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             image_inputs, video_inputs = process_vision_info(messages)
+#             inputs = self.processor(text=[text], 
+#                                     images=image_inputs, 
+#                                     videos=video_inputs, 
+#                                     padding=True, 
+#                                     return_tensors="pt"
+#                                    ).to(self.model.device)
+            
+#         else:
+#             image_type = 'pil'
+#             # Assume it's already a PIL Image
+#             image_pil = image
+#             # For the message content, we need to use the image directly
+
+#             size = image_pil.size
+#             image_for_message = self.resize_image(image_pil, self.max_size)
+            
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image_for_message
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+#         output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+#         generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+#         output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+#         response = output_text[0]
+
+#         input_height = inputs['image_grid_thw'][0][1] * 14
+#         input_width = inputs['image_grid_thw'][0][2] * 14
+#         input_size = (input_width.item(), input_height.item())
+
+#         del text, inputs, output_ids, generated_ids, output_text
+#         torch.cuda.empty_cache()
+
+#         return {'response': response, 'input_size': input_size}
+                
+#     def predict(self, image, text_prompt, system_prompt, prompt_type='object', bbox_refine=False):
+#         self.text_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+#         # Handle the image input: either load from URL or use the PIL Image directly
+#         if isinstance(image, str):
+#             # It's a URL or path, load the image
+#             image_type = 'str'
+#             image_pil = load_image(image)
+#             size = image_pil.size
+#             image_for_message = image
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image,
+#                             "min_pixels": self.min_pixels,
+#                             "max_pixels": self.max_pixels
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             image_inputs, video_inputs = process_vision_info(messages)
+#             inputs = self.processor(text=[text], 
+#                                     images=image_inputs, 
+#                                     videos=video_inputs, 
+#                                     padding=True, 
+#                                     return_tensors="pt"
+#                                    ).to(self.model.device)
+            
+#         else:
+#             image_type = 'pil'
+#             # Assume it's already a PIL Image
+#             image_pil = image
+#             # For the message content, we need to use the image directly
+
+#             size = image_pil.size
+#             image_for_message = self.resize_image(image_pil, self.max_size)
+            
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image_for_message
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+#         output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+#         generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+#         output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+    
+#         input_height = inputs['image_grid_thw'][0][1]*14
+#         input_width = inputs['image_grid_thw'][0][2]*14
+        
+#         response_org = output_text[0]
+#         input_size = (input_width.item(), input_height.item())
+
+#         del text, inputs, output_ids, generated_ids, output_text
+#         torch.cuda.empty_cache()
+
+#         if bbox_refine:
+#             response = self._bbox_refine(response_org, messages, image_type, image_for_message)
+#         else:
+#             response = response_org
+
+#         results = dict()
+#         bbox_with_label = self._get_bounding_boxes(response, input_size, size)
+#         results = {'bbox_with_label': bbox_with_label, 'response': response, 'input_size': input_size}
+
+#         return results
+
+#     def plot_bounding_boxes(self, image, response, input_size, output_path='./temp.png'):
+    
+#         # Load the image
+#         img = image.copy()
+#         width, height = img.size
+#         input_width, input_height = input_size
+    
+#         # Create a drawing object
+#         draw = ImageDraw.Draw(img)
+
+#         additional_colors = [colorname for (colorname, colorcode) in ImageColor.colormap.items()]
+        
+#         # Define a list of colors
+#         colors = [
+#         'red',
+#         'green',
+#         'blue',
+#         'yellow',
+#         'orange',
+#         'pink',
+#         'purple',
+#         'brown',
+#         'gray',
+#         'beige',
+#         'turquoise',
+#         'cyan',
+#         'magenta',
+#         'lime',
+#         'navy',
+#         'maroon',
+#         'teal',
+#         'olive',
+#         'coral',
+#         'lavender',
+#         'violet',
+#         'gold',
+#         'silver',
+#         ] + additional_colors
+
+#         # Parsing out the markdown fencing
+#         bounding_boxes = self._parse_json(response)
+
+#         # font = ImageFont.truetype("NotoSansCJK-Regular.ttc", size=14)
+#         font = ImageFont.load_default()
+
+#         # print(f"Bounding boxes: {bounding_boxes}")
+    
+#         try:
+#             # print(f"Bounding boxes: {bounding_boxes}")
+#             if bounding_boxes is None:
+#                 print("No bounding boxes found in the response.")
+#                 return
+#             json_output = ast.literal_eval(bounding_boxes)
+#         except Exception as e:
+#             end_idx = bounding_boxes.rfind('"}') + len('"}')
+#             truncated_text = bounding_boxes[:end_idx] + "]"
+#             json_output = ast.literal_eval(truncated_text)
+
+#         print(f"Parsed JSON output: {json_output}")
+        
+#         if len(json_output) > 0:
+            
+#             # Iterate over the bounding boxes
+#             for i, bounding_box in enumerate(json_output):
+#                 try:                
+#                     # Select a color from the list
+#                     color = colors[i % len(colors)]
+#                     # Convert normalized coordinates to absolute coordinates
+#                     abs_x1 = int(bounding_box["bbox_2d"][0] / input_width * width)
+#                     abs_y1 = int(bounding_box["bbox_2d"][1] / input_height * height)
+#                     abs_x2 = int(bounding_box["bbox_2d"][2] / input_width * width)
+#                     abs_y2 = int(bounding_box["bbox_2d"][3] / input_height * height) 
+            
+#                     if abs_x1 > abs_x2:
+#                         abs_x1, abs_x2 = abs_x2, abs_x1
+            
+#                     if abs_y1 > abs_y2:
+#                         abs_y1, abs_y2 = abs_y2, abs_y1
+            
+#                     # Draw the bounding box
+#                     draw.rectangle(
+#                         ((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4
+#                     )
+            
+#                     # Draw the text
+#                     if "label" in bounding_box:
+#                         draw.text((abs_x1 + 8, abs_y1 + 6), bounding_box["label"], fill=color, font=font)
+#                 except Exception as e:
+#                     print(f"Error {str(e)} for bounding box {bounding_box}")                
+    
+#         img.save(output_path)
+#         print(f"Image with bounding boxes saved to: {output_path}")
+        
+
+#     def predict_bounding_boxes(self, image, response, input_size):
+    
+#         # Load the image
+#         img = image.copy()
+#         width, height = img.size
+#         input_width, input_height = input_size
+        
+#         # Create a drawing object
+#         # draw = ImageDraw.Draw(img)
+
+#         additional_colors = [colorname for (colorname, colorcode) in ImageColor.colormap.items()]
+            
+#         # # Define a list of colors
+#         # colors = [
+#         #     'red',
+#         #     'green',
+#         #     'blue',
+#         #     'yellow',
+#         #     'orange',
+#         #     'pink',
+#         #     'purple',
+#         #     'brown',
+#         #     'gray',
+#         #     'beige',
+#         #     'turquoise',
+#         #     'cyan',
+#         #     'magenta',
+#         #     'lime',
+#         #     'navy',
+#         #     'maroon',
+#         #     'teal',
+#         #     'olive',
+#         #     'coral',
+#         #     'lavender',
+#         #     'violet',
+#         #     'gold',
+#         #     'silver',
+#         #     ] + additional_colors
+
+#         # Parsing out the markdown fencing
+#         bounding_boxes = self._parse_json(response)
+
+#             # # font = ImageFont.truetype("NotoSansCJK-Regular.ttc", size=14)
+#             # font = ImageFont.load_default()
+
+#             # print(f"Bounding boxes: {bounding_boxes}")
+        
+#         try:
+#             # print(f"Bounding boxes: {bounding_boxes}")
+#             if bounding_boxes is None:
+#                 print("No bounding boxes found in the response.")
+#                 return
+#             json_output = ast.literal_eval(bounding_boxes)
+#         except Exception as e:
+#             end_idx = bounding_boxes.rfind('"}') + len('"}')
+#             truncated_text = bounding_boxes[:end_idx] + "]"
+#             json_output = ast.literal_eval(truncated_text)
+
+#         print(f"Parsed JSON output: {json_output}")
+            
+#         if len(json_output) > 0:
+                
+#             # Iterate over the bounding boxes
+#             for i, bounding_box in enumerate(json_output):
+#                 try:                
+#                     # # Select a color from the list
+#                     # color = colors[i % len(colors)]
+#                     # Convert normalized coordinates to absolute coordinates
+#                     abs_x1 = int(bounding_box["bbox_2d"][0] / input_width * width)
+#                     abs_y1 = int(bounding_box["bbox_2d"][1] / input_height * height)
+#                     abs_x2 = int(bounding_box["bbox_2d"][2] / input_width * width)
+#                     abs_y2 = int(bounding_box["bbox_2d"][3] / input_height * height) 
+                
+#                     if abs_x1 > abs_x2:
+#                         abs_x1, abs_x2 = abs_x2, abs_x1
+                
+#                     if abs_y1 > abs_y2:
+#                         abs_y1, abs_y2 = abs_y2, abs_y1
+                
+#                         # # Draw the bounding box
+#                         # draw.rectangle(
+#                         #     ((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4
+#                         # )
+                
+#                         # # Draw the text
+#                         # if "label" in bounding_box:
+#                         #     draw.text((abs_x1 + 8, abs_y1 + 6), bounding_box["label"], fill=color, font=font)
+                    
+#                     return [abs_x1, abs_y1, abs_x2, abs_y2]
+#                 except Exception as e:
+#                     print(f"Error {str(e)} for bounding box {bounding_box}")                
+        
+#             # img.save(output_path)
+#             # print(f"Image with bounding boxes saved to: {output_path}")
+        

Code/qwen_inference/utils.py

@@ -0,0 +1,829 @@
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+import numpy as np
+
+def resize_and_pad(image_tensor, output_size):
+    """
+    Resizes an image tensor to a square shape by scaling and padding.
+    
+    Args:
+        image_tensor (torch.Tensor): Input image tensor of shape (H, W).
+        output_size (int): The desired square output size.
+        
+    Returns:
+        torch.Tensor: The resized and padded image tensor of shape (output_size, output_size).
+    """
+    original_h, original_w = image_tensor.shape
+    
+    # 1. Calculate the scale factor to fit the longest side to output_size
+    scale = output_size / max(original_h, original_w)
+    new_h, new_w = int(original_h * scale), int(original_w * scale)
+
+    # Add batch and channel dimensions for F.interpolate
+    image_tensor = image_tensor.unsqueeze(0).unsqueeze(0)
+    
+    # 2. Resize the image, preserving aspect ratio
+    resized_image = F.interpolate(image_tensor, size=(new_h, new_w), mode='bilinear', align_corners=False)
+    
+    # 3. Calculate padding for the shorter side
+    pad_h = output_size - new_h
+    pad_w = output_size - new_w
+    
+    # Padding format is (left, right, top, bottom)
+    padding = (pad_w // 2, pad_w - (pad_w // 2), pad_h // 2, pad_h - (pad_h // 2))
+    
+    # 4. Pad the image with a constant value (0 for black)
+    padded_image = F.pad(resized_image, padding, "constant", 0)
+    
+    return padded_image.squeeze()
+
+
+def resize(img, target_res=224, resize=True, to_pil=True, edge=False):
+    original_width, original_height = img.size
+    original_channels = len(img.getbands())
+    if not edge:
+        canvas = np.zeros([target_res, target_res, 3], dtype=np.uint8)
+        if original_channels == 1:
+            canvas = np.zeros([target_res, target_res], dtype=np.uint8)
+        if original_height <= original_width:
+            if resize:
+                img = img.resize((target_res, int(np.around(target_res * original_height / original_width))), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            canvas[(width - height) // 2: (width + height) // 2] = img
+        else:
+            if resize:
+                img = img.resize((int(np.around(target_res * original_width / original_height)), target_res), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            canvas[:, (height - width) // 2: (height + width) // 2] = img
+    else:
+        if original_height <= original_width:
+            if resize:
+                img = img.resize((target_res, int(np.around(target_res * original_height / original_width))), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            top_pad = (target_res - height) // 2
+            bottom_pad = target_res - height - top_pad
+            img = np.pad(img, pad_width=[(top_pad, bottom_pad), (0, 0), (0, 0)], mode='edge')
+        else:
+            if resize:
+                img = img.resize((int(np.around(target_res * original_width / original_height)), target_res), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            left_pad = (target_res - width) // 2
+            right_pad = target_res - width - left_pad
+            img = np.pad(img, pad_width=[(0, 0), (left_pad, right_pad), (0, 0)], mode='edge')
+        canvas = img
+    if to_pil:
+        canvas = Image.fromarray(canvas)
+    return canvas
+
+def scaled_shifted_sigmoid(
+    x: Tensor,
+    a: float = 1.0,   # vertical scale
+    b: float = 1.0,   # slope (steepness)
+    c: float = 0.0,   # horizontal shift (bias)
+    d: float = 0.0,   # vertical shift (baseline)
+) -> Tensor:
+    """
+    Compute a scaled-and-shifted sigmoid: y = a * sigmoid(b * x + c) + d.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Input tensor.
+    a : float, default 1.0
+        Output scale (amplitude).
+    b : float, default 1.0
+        Input scale (controls slope).
+    c : float, default 0.0
+        Input shift (horizontal translation).
+    d : float, default 0.0
+        Output shift (vertical translation).
+
+    Returns
+    -------
+    torch.Tensor
+        Tensor with the same shape as `x` after applying the transformation.
+    """
+    return a * torch.sigmoid(b * x + c) + d
+
+
+############
+# for 2D to 3D correspondence with cropping
+
+from scipy.ndimage import distance_transform_edt as edt
+from scipy.ndimage import gaussian_filter
+# from skimage import img_as_ubyte
+from PIL import Image
+from pathlib import Path
+import numpy as np
+from typing import Tuple
+
+# ✨ New helper to find the object's bounding box from transparency
+def get_bbox_from_alpha(image_path: Path) -> Tuple[int, int, int, int]:
+    """Calculates a bounding box from the alpha channel of a PNG."""
+    with Image.open(image_path).convert("RGBA") as img:
+        alpha = np.array(img)[:, :, 3]
+        non_transparent_pixels = np.argwhere(alpha > 0)
+        y_min, x_min = non_transparent_pixels.min(axis=0)
+        y_max, x_max = non_transparent_pixels.max(axis=0)
+        return x_min, y_min, x_max, y_max
+
+# ... (rest of your imports and functions)
+
+
+
+#####################
+# dataset utils loading functions
+#####################
+import os
+import json
+import numpy as np
+import pandas as pd
+import torch
+from glob import glob
+# from scipy.io import loadmat as read_mat
+import scipy.io as sio
+
+
+def read_mat(path, obj_name):
+    r"""Reads specified objects from Matlab data file, (.mat)"""
+    mat_contents = sio.loadmat(path)
+    mat_obj = mat_contents[obj_name]
+
+    return mat_obj
+
+def process_kps_pascal(kps):
+    # Step 1: Reshape the array to (20, 2) by adding nan values
+    num_pad_rows = 20 - kps.shape[0]
+    if num_pad_rows > 0:
+        pad_values = np.full((num_pad_rows, 2), np.nan)
+        kps = np.vstack((kps, pad_values))
+        
+    # Step 2: Reshape the array to (20, 3) 
+    # Add an extra column: set to 1 if the row does not contain nan, 0 otherwise
+    last_col = np.isnan(kps).any(axis=1)
+    last_col = np.where(last_col, 0, 1)
+    kps = np.column_stack((kps, last_col))
+
+    # Step 3: Replace rows with nan values to all 0's
+    mask = np.isnan(kps).any(axis=1)
+    kps[mask] = 0
+
+    return torch.tensor(kps).float()
+
+def preprocess_kps_pad(kps, img_width, img_height, size):
+    # Once an image has been pre-processed via border (or zero) padding,
+    # the location of key points needs to be updated. This function applies
+    # that pre-processing to the key points so they are correctly located
+    # in the border-padded (or zero-padded) image.
+    kps = kps.clone()
+    scale = size / max(img_width, img_height)
+    kps[:, [0, 1]] *= scale
+    if img_height < img_width:
+        new_h = int(np.around(size * img_height / img_width))
+        offset_y = int((size - new_h) / 2)
+        offset_x = 0
+        kps[:, 1] += offset_y
+    elif img_width < img_height:
+        new_w = int(np.around(size * img_width / img_height))
+        offset_x = int((size - new_w) / 2)
+        offset_y = 0
+        kps[:, 0] += offset_x
+    else:
+        offset_x = 0
+        offset_y = 0
+    kps *= kps[:, 2:3].clone()  # zero-out any non-visible key points
+    return kps, offset_x, offset_y, scale
+
+
+def load_pascal_data(path="data/PF-dataset-PASCAL", size=256, category='cat', split='test', subsample=None):
+    
+    def get_points(point_coords_list, idx):
+        X = np.fromstring(point_coords_list.iloc[idx, 0], sep=";")
+        Y = np.fromstring(point_coords_list.iloc[idx, 1], sep=";")
+        Xpad = -np.ones(20)
+        Xpad[: len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[: len(X)] = Y
+        Zmask = np.zeros(20)
+        Zmask[: len(X)] = 1
+        point_coords = np.concatenate(
+            (Xpad.reshape(1, 20), Ypad.reshape(1, 20), Zmask.reshape(1,20)), axis=0
+        )
+        # make arrays float tensor for subsequent processing
+        point_coords = torch.Tensor(point_coords.astype(np.float32))
+        return point_coords
+    
+    np.random.seed(42)
+    files = []
+    kps = []
+    test_data = pd.read_csv(f'{path}/{split}_pairs_pf_pascal.csv')
+    cls = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
+                    'bus', 'car', 'cat', 'chair', 'cow',
+                    'diningtable', 'dog', 'horse', 'motorbike', 'person',
+                    'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+    cls_ids = test_data.iloc[:,2].values.astype("int") - 1
+    cat_id = cls.index(category)
+    subset_id = np.where(cls_ids == cat_id)[0]
+    # logger.info(f'Number of Pairs for {category} = {len(subset_id)}')
+    subset_pairs = test_data.iloc[subset_id,:]
+    src_img_names = np.array(subset_pairs.iloc[:,0])
+    trg_img_names = np.array(subset_pairs.iloc[:,1])
+    # print(src_img_names.shape, trg_img_names.shape)
+    if not split.startswith('train'):
+        point_A_coords = subset_pairs.iloc[:,3:5]
+        point_B_coords = subset_pairs.iloc[:,5:]
+    # print(point_A_coords.shape, point_B_coords.shape)
+    for i in range(len(src_img_names)):
+        src_fn= f'{path}/../{src_img_names[i]}'
+        trg_fn= f'{path}/../{trg_img_names[i]}'
+        src_size=Image.open(src_fn).size
+        trg_size=Image.open(trg_fn).size
+
+        if not split.startswith('train'):
+            point_coords_src = get_points(point_A_coords, i).transpose(1,0)
+            point_coords_trg = get_points(point_B_coords, i).transpose(1,0)
+        else:
+            src_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(src_fn))[:-4] + '.mat'
+            trg_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(trg_fn))[:-4] + '.mat'
+            point_coords_src = process_kps_pascal(read_mat(src_anns, 'kps'))
+            point_coords_trg = process_kps_pascal(read_mat(trg_anns, 'kps'))
+
+        # print(src_size)
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(src_fn)
+        files.append(trg_fn)
+    
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+    # logger.info(f'Final number of used key points: {kps.size(1)}')
+    return files, kps, None, used_kps
+
+
+def load_spair_data(path="data/SPair-71k", size=256, category='cat', split='test', subsample=None):
+    np.random.seed(42)
+    pairs = sorted(glob(f'{path}/PairAnnotation/{split}/*:{category}.json'))
+    if subsample is not None and subsample > 0:
+        pairs = [pairs[ix] for ix in np.random.choice(len(pairs), subsample)]
+    files = []
+    thresholds = []
+    kps = []
+    category_anno = list(glob(f'{path}/ImageAnnotation/{category}/*.json'))[0]
+    with open(category_anno) as f:
+        num_kps = len(json.load(f)['kps'])
+    for pair in pairs:
+        source_kps = torch.zeros(num_kps, 3)
+        target_kps = torch.zeros(num_kps, 3)
+        with open(pair) as f:
+            data = json.load(f)
+        assert category == data["category"]
+        source_fn = f'{path}/JPEGImages/{category}/{data["src_imname"]}'
+        target_fn = f'{path}/JPEGImages/{category}/{data["trg_imname"]}'
+        source_json_name = source_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        target_json_name = target_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        source_bbox = np.asarray(data["src_bndbox"])    # (x1, y1, x2, y2)
+        target_bbox = np.asarray(data["trg_bndbox"])
+        with open(source_json_name) as f:
+            file = json.load(f)
+            kpts_src = file['kps']
+        with open(target_json_name) as f:
+            file = json.load(f)
+            kpts_trg = file['kps']
+
+        source_size = data["src_imsize"][:2]  # (W, H)
+        target_size = data["trg_imsize"][:2]  # (W, H)
+
+        for i in range(30):
+            point = kpts_src[str(i)]
+            if point is None:
+                source_kps[i, :3] = 0
+            else:
+                source_kps[i, :2] = torch.Tensor(point).float()  # set x and y
+                source_kps[i, 2] = 1
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps, source_size[0], source_size[1], size)
+        
+        for i in range(30):
+            point = kpts_trg[str(i)]
+            if point is None:
+                target_kps[i, :3] = 0
+            else:
+                target_kps[i, :2] = torch.Tensor(point).float()
+                target_kps[i, 2] = 1
+        # target_raw_kps = torch.cat([torch.tensor(data["trg_kps"], dtype=torch.float), torch.ones(kp_ixs.size(0), 1)], 1)
+        # target_kps = blank_kps.scatter(dim=0, index=kp_ixs, src=target_raw_kps)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps, target_size[0], target_size[1], size)
+        if split == 'test' or split == 'val':
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+        elif split == 'trn':
+            thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0])*src_scale)
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(source_fn)
+        files.append(target_fn)
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+
+    return files, kps, thresholds, used_kps
+
+
+def load_specific_pascal_pair(
+    source_image_id: str,
+    target_image_id: str,
+    path: str = "data/PF-dataset-PASCAL",
+    size: int = 256,
+    split: str = 'test'
+):
+    """
+    Loads and processes a specific pair of source and target images from the PASCAL dataset.
+
+    Args:
+        source_image_id: The identifier of the source image (e.g., '2011_001407').
+        target_image_id: The identifier of the target image (e.g., '2010_004184').
+        path: The base path to the PF-PASCAL dataset directory.
+        size: The target size for preprocessing images.
+        split: The dataset split to use ('test', 'train', etc.).
+
+    Returns:
+        A tuple containing:
+        - files (list): A list with the full paths to the source and target images.
+        - kps (torch.Tensor): A tensor of processed keypoints for the image pair.
+        - None: A placeholder to match the original function's return format.
+        - used_kps_indices (torch.Tensor): A tensor of indices for keypoints present in either image.
+    """
+    
+    def get_points_from_strings(x_str: str, y_str: str) -> torch.Tensor:
+        """Parses coordinate strings, pads them, and returns a tensor."""
+        X = np.fromstring(x_str, sep=";")
+        Y = np.fromstring(y_str, sep=";")
+        
+        # Pad arrays to a fixed size of 20 (as in the original function)
+        Xpad = -np.ones(20)
+        Xpad[:len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[:len(Y)] = Y
+        
+        # Create a mask for valid keypoints
+        Zmask = np.zeros(20)
+        Zmask[:len(X)] = 1
+        
+        point_coords = np.stack((Xpad, Ypad, Zmask), axis=0)
+        return torch.from_numpy(point_coords.astype(np.float32))
+
+    # Construct the path to the CSV file and load it
+    csv_path = os.path.join(path, f'{split}_pairs_pf_pascal.csv')
+    try:
+        pairs_df = pd.read_csv(csv_path)
+    except FileNotFoundError:
+        print(f"Error: CSV file not found at '{csv_path}'")
+        return None, None, None, None
+
+    # Find the specific row matching the source and target image IDs
+    pair_row = pairs_df[
+        pairs_df['source_image'].str.contains(source_image_id) &
+        pairs_df['target_image'].str.contains(target_image_id)
+    ]
+
+    if pair_row.empty:
+        print(f"Error: Pair for source '{source_image_id}' and target '{target_image_id}' not found.")
+        return None, None, None, None
+    
+    # Select the first match
+    pair_data = pair_row.iloc[0]
+
+    # Get full image paths and dimensions
+    src_fn = os.path.join(path, '..', pair_data['source_image'])
+    trg_fn = os.path.join(path, '..', pair_data['target_image'])
+    
+    try:
+        src_size = Image.open(src_fn).size
+        trg_size = Image.open(trg_fn).size
+    except FileNotFoundError as e:
+        print(f"Error: Image file not found: {e.filename}")
+        return None, None, None, None
+
+    # Process keypoints based on the split type
+    if not split.startswith('train'):
+        point_coords_src = get_points_from_strings(pair_data['XA'], pair_data['YA']).T
+        point_coords_trg = get_points_from_strings(pair_data['XB'], pair_data['YB']).T
+    else:
+        # This logic for the 'train' split is preserved from the original function
+        cls_list = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 
+                    'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 
+                    'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+        category = cls_list[pair_data['class'] - 1]
+        
+        src_anns_path = os.path.join(path, 'Annotations', category, os.path.basename(src_fn).replace('.jpg', '.mat'))
+        trg_anns_path = os.path.join(path, 'Annotations', category, os.path.basename(trg_fn).replace('.jpg', '.mat'))
+        
+        point_coords_src = process_kps_pascal(read_mat(src_anns_path, 'kps'))
+        point_coords_trg = process_kps_pascal(read_mat(trg_anns_path, 'kps'))
+
+    # Preprocess keypoints (e.g., padding and scaling)
+    source_kps, _, _, _ = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+    target_kps, _, _, _ = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+
+    # Stack keypoints and find the indices of keypoints present in at least one image
+    kps = torch.stack([source_kps, target_kps])
+    used_kps_indices, = torch.where(kps[:, :, 2].any(dim=0))
+    
+    # Filter the keypoints tensor to include only the used keypoints
+    kps_final = kps[:, used_kps_indices, :]
+
+    return [src_fn, trg_fn], kps_final, None, used_kps_indices
+
+import matplotlib.pyplot as plt
+def load_img_and_kps(idx, files, kps, img_size=224, edge=False, load_masked=False):
+    if load_masked:
+        img_rgba = Image.open(files[idx].replace('JPEGImages', 'JPEGImages_bgd_rmv').replace('.jpg', '_bgd_rmv.png')).convert('RGBA')
+        
+        # img_rgba = Image.open(path_image).convert("RGBA")
+
+        # 2. create a white background and composite
+        img = Image.new("RGB", img_rgba.size, (0, 0, 0))  # choose any colour here
+        img.paste(img_rgba, mask=img_rgba.split()[3])               # mask = alpha channel
+        plt.imsave("img2_masked_before_resize.png", np.array(img))
+        # print(np.array(img).shape)
+    else:
+        img = Image.open(files[idx]).convert('RGB')
+    img = resize(img, img_size, resize=True, to_pil=True, edge=edge)
+    if load_masked:
+        plt.imsave("img2_masked_after_resize.png", np.array(img))
+    img_kps = kps[idx]
+
+    return img, img_kps
+
+
+import os
+import json
+from glob import glob
+import numpy as np
+import torch
+
+# NOTE: The helper function preprocess_kps_pad(kps, width, height, size) 
+# is assumed to be defined elsewhere, as in your original code.
+
+def load_specific_spair_pair(
+    source_image_name: str,
+    target_image_name: str,
+    category: str,
+    path: str = "data/SPair-71k",
+    size: int = 256,
+    split: str = 'test',
+    unfiltered: bool = False
+    
+):
+    """
+    Loads and processes a specific pair of images from the SPair-71k dataset.
+
+    Args:
+        source_image_name (str): Filename of the source image (e.g., '2008_002719.jpg').
+        target_image_name (str): Filename of the target image (e.g., '2008_004100.jpg').
+        category (str): The object category (e.g., 'aeroplane').
+        path (str): The base path to the SPair-71k dataset directory.
+        size (int): The target size for preprocessing images.
+        split (str): The dataset split to use ('test', 'trn', 'val').
+
+    Returns:
+        A tuple containing:
+        - files (list): Full paths to the source and target images.
+        - kps (torch.Tensor): Processed keypoints for the pair.
+        - thresholds (list): Bounding-box based thresholds for the pair.
+        - used_kps_indices (torch.Tensor): Indices of keypoints present in either image.
+    """
+    
+    # Helper to create a keypoint tensor from the annotation dictionary
+    def _get_kps_tensor(kps_dict, num_kps):
+        kps_tensor = torch.zeros(num_kps, 3)
+        for i in range(num_kps):
+            point = kps_dict.get(str(i)) # Use .get() for safety
+            if point is not None:
+                kps_tensor[i, :2] = torch.tensor(point, dtype=torch.float)
+                kps_tensor[i, 2] = 1.0 # Mark as visible
+        return kps_tensor
+
+    # --- 1. Find the correct pair annotation file ---
+    pair_annotation_path = os.path.join(path, 'PairAnnotation', split)
+    candidate_files = glob(os.path.join(pair_annotation_path, f'*:{category}.json'))
+    
+    pair_data = None
+    for file_path in candidate_files:
+        with open(file_path) as f:
+            data = json.load(f)
+            if data['src_imname'] == source_image_name and data['trg_imname'] == target_image_name:
+                pair_data = data
+                break
+    
+    if pair_data is None:
+        print(f"Error: Pair for '{source_image_name}' and '{target_image_name}' not found.")
+        return None, None, None, None
+
+    # --- 2. Process the found pair ---
+    source_fn = os.path.join(path, 'JPEGImages', category, pair_data['src_imname'])
+    target_fn = os.path.join(path, 'JPEGImages', category, pair_data['trg_imname'])
+    files = [source_fn, target_fn]
+
+    # Get total number of keypoints for the category
+    try:
+        category_anno_path = glob(os.path.join(path, 'ImageAnnotation', category, '*.json'))[0]
+        with open(category_anno_path) as f:
+            num_kps = len(json.load(f)['kps'])
+    except IndexError:
+        print(f"Error: No image annotations found for category '{category}'.")
+        return None, None, None, None
+
+    # Get keypoints from individual image annotation files
+    source_json_path = source_fn.replace('JPEGImages', 'ImageAnnotation').replace('.jpg', '.json')
+    target_json_path = target_fn.replace('JPEGImages', 'ImageAnnotation').replace('.jpg', '.json')
+
+    with open(source_json_path) as f:
+        kpts_src_dict = json.load(f)['kps']
+    with open(target_json_path) as f:
+        kpts_trg_dict = json.load(f)['kps']
+        
+    source_kps_raw = _get_kps_tensor(kpts_src_dict, num_kps)
+    target_kps_raw = _get_kps_tensor(kpts_trg_dict, num_kps)
+
+    # print(f"Source keypoints raw: {source_kps_raw.shape}, Target keypoints raw: {target_kps_raw.shape}")
+
+    # Preprocess keypoints (padding, scaling, etc.)
+    w_src, h_src = pair_data["src_imsize"][:2]
+    w_trg, h_trg = pair_data["trg_imsize"][:2]
+    
+    source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps_raw, w_src, h_src, size)
+    target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps_raw, w_trg, h_trg, size)
+    
+    # Calculate thresholds from bounding boxes
+    source_bbox = np.asarray(pair_data["src_bndbox"])
+    target_bbox = np.asarray(pair_data["trg_bndbox"])
+    thresholds = []
+    if split == 'test' or split == 'val':
+        thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0]) * trg_scale)
+    elif split == 'trn':
+        thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0]) * src_scale)
+        thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0]) * trg_scale)
+
+    # --- 3. Format output ---
+    kps = torch.stack([source_kps, target_kps])
+    used_kps_indices, = torch.where(kps[:, :, 2].any(dim=0))
+    kps_final = kps[:, used_kps_indices, :]
+
+    if unfiltered:
+        return files, kps, thresholds, used_kps_indices
+    else:
+        return files, kps_final, thresholds, used_kps_indices
+
+
+
+
+######################################
+# original loading function
+######################################
+
+def load_spair_data(path="data/SPair-71k", size=256, category='cat', split='test', subsample=None):
+    np.random.seed(42)
+    pairs = sorted(glob(f'{path}/PairAnnotation/{split}/*:{category}.json'))
+    if subsample is not None and subsample > 0:
+        pairs = [pairs[ix] for ix in np.random.choice(len(pairs), subsample)]
+    files = []
+    thresholds = []
+    kps = []
+    category_anno = list(glob(f'{path}/ImageAnnotation/{category}/*.json'))[0]
+    with open(category_anno) as f:
+        num_kps = len(json.load(f)['kps'])
+    for pair in pairs:
+        source_kps = torch.zeros(num_kps, 3)
+        target_kps = torch.zeros(num_kps, 3)
+        with open(pair) as f:
+            data = json.load(f)
+        assert category == data["category"]
+        source_fn = f'{path}/JPEGImages/{category}/{data["src_imname"]}'
+        target_fn = f'{path}/JPEGImages/{category}/{data["trg_imname"]}'
+        source_json_name = source_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        target_json_name = target_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        source_bbox = np.asarray(data["src_bndbox"])    # (x1, y1, x2, y2)
+        target_bbox = np.asarray(data["trg_bndbox"])
+        with open(source_json_name) as f:
+            file = json.load(f)
+            kpts_src = file['kps']
+        with open(target_json_name) as f:
+            file = json.load(f)
+            kpts_trg = file['kps']
+
+        source_size = data["src_imsize"][:2]  # (W, H)
+        target_size = data["trg_imsize"][:2]  # (W, H)
+
+        for i in range(30):
+            point = kpts_src[str(i)]
+            if point is None:
+                source_kps[i, :3] = 0
+            else:
+                source_kps[i, :2] = torch.Tensor(point).float()  # set x and y
+                source_kps[i, 2] = 1
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps, source_size[0], source_size[1], size)
+        
+        for i in range(30):
+            point = kpts_trg[str(i)]
+            if point is None:
+                target_kps[i, :3] = 0
+            else:
+                target_kps[i, :2] = torch.Tensor(point).float()
+                target_kps[i, 2] = 1
+        # target_raw_kps = torch.cat([torch.tensor(data["trg_kps"], dtype=torch.float), torch.ones(kp_ixs.size(0), 1)], 1)
+        # target_kps = blank_kps.scatter(dim=0, index=kp_ixs, src=target_raw_kps)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps, target_size[0], target_size[1], size)
+        if split == 'test' or split == 'val':
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+        elif split == 'trn':
+            thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0])*src_scale)
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(source_fn)
+        files.append(target_fn)
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+
+    return files, kps, thresholds, used_kps
+
+
+def load_pascal_data(path="data/PF-dataset-PASCAL", size=256, category='cat', split='test', subsample=None):
+    
+    def get_points(point_coords_list, idx):
+        X = np.fromstring(point_coords_list.iloc[idx, 0], sep=";")
+        Y = np.fromstring(point_coords_list.iloc[idx, 1], sep=";")
+        Xpad = -np.ones(20)
+        Xpad[: len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[: len(X)] = Y
+        Zmask = np.zeros(20)
+        Zmask[: len(X)] = 1
+        point_coords = np.concatenate(
+            (Xpad.reshape(1, 20), Ypad.reshape(1, 20), Zmask.reshape(1,20)), axis=0
+        )
+        # make arrays float tensor for subsequent processing
+        point_coords = torch.Tensor(point_coords.astype(np.float32))
+        return point_coords
+    
+    np.random.seed(42)
+    files = []
+    kps = []
+    test_data = pd.read_csv(f'{path}/{split}_pairs_pf_pascal.csv')
+    cls = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
+                    'bus', 'car', 'cat', 'chair', 'cow',
+                    'diningtable', 'dog', 'horse', 'motorbike', 'person',
+                    'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+    cls_ids = test_data.iloc[:,2].values.astype("int") - 1
+    cat_id = cls.index(category)
+    subset_id = np.where(cls_ids == cat_id)[0]
+    # logger.info(f'Number of Pairs for {category} = {len(subset_id)}')
+    subset_pairs = test_data.iloc[subset_id,:]
+    src_img_names = np.array(subset_pairs.iloc[:,0])
+    trg_img_names = np.array(subset_pairs.iloc[:,1])
+    # print(src_img_names.shape, trg_img_names.shape)
+    if not split.startswith('train'):
+        point_A_coords = subset_pairs.iloc[:,3:5]
+        point_B_coords = subset_pairs.iloc[:,5:]
+    # print(point_A_coords.shape, point_B_coords.shape)
+    for i in range(len(src_img_names)):
+        src_fn= f'{path}/../{src_img_names[i]}'
+        trg_fn= f'{path}/../{trg_img_names[i]}'
+        src_size=Image.open(src_fn).size
+        trg_size=Image.open(trg_fn).size
+
+        if not split.startswith('train'):
+            point_coords_src = get_points(point_A_coords, i).transpose(1,0)
+            point_coords_trg = get_points(point_B_coords, i).transpose(1,0)
+        else:
+            src_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(src_fn))[:-4] + '.mat'
+            trg_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(trg_fn))[:-4] + '.mat'
+            point_coords_src = process_kps_pascal(read_mat(src_anns, 'kps'))
+            point_coords_trg = process_kps_pascal(read_mat(trg_anns, 'kps'))
+
+        # print(src_size)
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(src_fn)
+        files.append(trg_fn)
+    
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+    # logger.info(f'Final number of used key points: {kps.size(1)}')
+    return files, kps, None, used_kps
+
+
+def load_eval_data(args, path, category, split):
+    # if args.EVAL_DATASET == 'ap10k':
+    #     files, kps, thresholds, used_kps = load_ap10k_data(path, args.ANNO_SIZE, category, split, args.TEST_SAMPLE)
+    print(f"Loading evaluation data for dataset: {args.EVAL_DATASET}, category: {category}, split: {split}, test sample: {args.TEST_SAMPLE}")
+    if args.EVAL_DATASET == 'pascal':
+        files, kps, thresholds, used_kps = load_pascal_data(path, args.ANNO_SIZE, category, split, args.TEST_SAMPLE)
+    elif args.EVAL_DATASET == 'spair':
+        files, kps, thresholds, used_kps = load_spair_data(path, args.ANNO_SIZE, category, split, args.TEST_SAMPLE)
+
+    return files, kps, thresholds, used_kps
+
+
+###### plot helper
+from PIL import Image, ImageDraw, ImageFont
+
+def draw_bbox_point_grid(
+    image,
+    bbox=None,
+    point=None,
+    box_color=(0, 255, 0),
+    pt_color=(255, 0, 0),
+    width=5,
+    draw_grid=False,
+    step=50,                # pixels between grid lines
+    grid_color=(255, 255, 255),
+    grid_width=1,
+    add_text=True,
+    dilation=28
+):
+    """Draw bbox, point, and optional grid on a PIL image.
+
+    Args
+    ----
+    image (PIL.Image): target image (modified in place if not copied).
+    bbox  (list | tuple): [x1, y1, x2, y2] or None.
+    point (tuple): (x, y) or None.
+    color (tuple): RGB for bbox / point.
+    width (int): line width for bbox.
+    draw_grid (bool): enable/disable grid.
+    step (int): grid spacing in pixels.
+    grid_color (tuple): RGB for grid.
+    grid_width (int): line width for grid.
+    """
+    draw = ImageDraw.Draw(image)
+
+    if dilation > 0 and bbox is not None:
+        # Dilation logic: expand bbox by dilation pixels
+        x1, y1, x2, y2 = bbox
+        bbox = (x1 - dilation, y1 - dilation, x2 + dilation, y2 + dilation)
+
+    # ── draw grid ───────────────────────────────────────────
+    if draw_grid and step > 0:
+        w, h = image.size
+        # vertical lines
+        for x in range(0, w, step):
+            draw.line([(x, 0), (x, h)], fill=grid_color, width=grid_width)
+        # horizontal lines
+        for y in range(0, h, step):
+            draw.line([(0, y), (w, y)], fill=grid_color, width=grid_width)
+
+    # ── draw bbox ──────────────────────────────────────────
+    if bbox is not None:
+        draw.rectangle(bbox, outline=box_color, width=width)
+
+    # ── draw point ─────────────────────────────────────────
+    if point is not None:
+        radius = 20
+        x, y = point
+        draw.ellipse(
+            (x - radius, y - radius, x + radius, y + radius),
+            fill=pt_color
+        )
+        # add a white text at the center of the point
+        # add a white text at the center of the point
+        if add_text:
+            text = "Ref"
+            # Try to use a better font, or fall back to the default if not found
+            # try:
+            font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+            # except IOError:
+            #     print('test')
+            #     font = ImageFont.load_default()
+
+            # Get text bounding box for centering
+            print(font)
+            bbox_text = draw.textbbox((0, 0), text, font=font)
+            text_width = bbox_text[2] - bbox_text[0]
+            text_height = bbox_text[3] - bbox_text[1]
+
+            text_x = x - text_width // 2
+            text_y = y - text_height // 2
+            draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+
+
+    return image

Code/sc_dit/dataset.py

@@ -0,0 +1,64 @@
+import os
+
+def get_dataset_info(args, split):
+    if args.EVAL_DATASET == 'pascal':
+        # data_dir = 'data/PF-dataset-PASCAL'
+        data_dir = '../../Datasets/PF-dataset-PASCAL'
+        categories = sorted(os.listdir(os.path.join(data_dir, 'Annotations')))
+    # elif args.EVAL_DATASET == 'ap10k':
+    #     data_dir = 'data/ap-10k'
+    #     categories = []
+    #     subfolders = os.listdir(os.path.join(data_dir, 'ImageAnnotation'))
+    #     # Handle AP10K_EVAL test settings
+    #     if args.AP10K_EVAL_SUBSET == 'intra-species':
+    #         categories = [folder for subfolder in subfolders for folder in os.listdir(os.path.join(data_dir, 'ImageAnnotation', subfolder))]
+    #     elif args.AP10K_EVAL_SUBSET == 'cross-species':
+    #         categories = [subfolder for subfolder in subfolders if len(os.listdir(os.path.join(data_dir, 'ImageAnnotation', subfolder))) > 1]
+    #         split += '_cross_species'
+    #     elif args.AP10K_EVAL_SUBSET == 'cross-family':
+    #         categories = ['all']
+    #         split += '_cross_family'
+    #     categories = sorted(categories)
+    #     if split == 'val':
+    #         # remove category "king cheetah" from categories, since it is not present in the validation set
+    #         categories.remove('king cheetah')
+    elif args.EVAL_DATASET == 'spair': # SPair
+        # data_dir = 'data/SPair-71k'
+        data_dir = '../../Datasets/SPair-71k'
+        categories = sorted(os.listdir(os.path.join(data_dir, 'ImageAnnotation')))
+
+    return data_dir, categories, split
+
+
+
+# SPair-71k dataset for batch processing
+from PIL import Image
+from torch.utils.data import Dataset
+
+class VLDataset(Dataset):
+    """A simple dataset to wrap a list of images and prompts for the DataLoader."""
+    def __init__(self, images, prompts):
+        self.images = images
+        self.prompts = prompts
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        # The DataLoader will call this for each item
+        return self.images[idx], self.prompts[idx]
+    
+
+class VLDatasetPaired(Dataset):
+    """A simple dataset to wrap a list of images and prompts for the DataLoader."""
+    def __init__(self, source_imgs, target_imgs, prompts):
+        self.source_imgs = source_imgs
+        self.target_imgs = target_imgs
+        self.prompts = prompts
+
+    def __len__(self):
+        return len(self.source_imgs)
+
+    def __getitem__(self, idx):
+        # The DataLoader will call this for each item
+        return self.source_imgs[idx], self.target_imgs[idx], self.prompts[idx]

Code/sc_dit/eval_bbox_acc.py

@@ -0,0 +1,202 @@
+import numpy as np
+import os
+import argparse
+import pandas as pd
+import ast
+from tqdm import tqdm
+import json
+
+# custom imports
+from dataset import get_dataset_info
+from utils import load_eval_data
+
+
+# def compute_bbox_accuracy(pred_bbox, gt_point, dilation=0):
+#     x1, y1, x2, y2 = pred_bbox
+#     if dilation > 0:
+#         # Dilate the bounding box
+#         x1 -= dilation
+#         y1 -= dilation
+#         x2 += dilation
+#         y2 += dilation
+#     x_gt, y_gt = gt_point
+
+#     # Check if the ground truth point is inside the predicted bounding box
+#     if x1 <= x_gt <= x2 and y1 <= y_gt <= y2:
+#         return 1.0
+#     else:
+#         return 0.0
+
+
+import numpy as np
+import os
+import argparse
+import pandas as pd
+import ast
+from tqdm import tqdm
+
+# custom imports
+from dataset import get_dataset_info
+from utils import load_eval_data
+
+def get_evaluation_outcome(pred_bbox, gt_point, dilation=0):
+    """Evaluates a single prediction and returns the outcome (TP, FP, FN, or TN)."""
+    is_gt_visible = not np.array_equal(gt_point, [0, 0])
+    is_pred_valid = pred_bbox is not None and pred_bbox != [0, 0, 0, 0]
+
+    if is_gt_visible:
+        if is_pred_valid:
+            x1, y1, x2, y2 = pred_bbox
+            if dilation > 0:
+                x1, y1, x2, y2 = x1 - dilation, y1 - dilation, x2 + dilation, y2 + dilation
+            x_gt, y_gt = gt_point
+            is_hit = (x1 <= x_gt <= x2) and (y1 <= y_gt <= y2)
+            return 'tp' if is_hit else 'fp'
+        else:
+            return 'fn'
+    else: # GT is not visible
+        return 'fp' if is_pred_valid else 'tn'
+
+def calculate_metrics(tp, fp, fn, tn):
+    """Calculates all metrics from the confusion matrix components."""
+    total = tp + fp + fn + tn
+    accuracy = (tp + tn) / total if total > 0 else 0.0
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+    f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0
+    return {"Accuracy": accuracy, "Precision": precision, "Recall": recall, "F1-Score": f1}
+
+def main(args):
+    results_df = pd.read_csv(args.RESULT_DIR)
+    data_dir, categories, split = get_dataset_info(args, split='test')
+
+
+    # --- Prepare directory for saving wrong predictions ---
+    wrong_pred_dir = args.OUTPUT_WRONG_PRED
+    if wrong_pred_dir:
+        # Ensure the directory exists
+        os.makedirs(wrong_pred_dir, exist_ok=True)
+        print(f"Wrong predictions will be saved in: {wrong_pred_dir}")
+    # if args.OUTPUT_CSV:
+    #     base_dir = os.path.dirname(args.OUTPUT_CSV)
+    #     if base_dir: # Ensure base_dir is not empty if path is just a filename
+    #          wrong_pred_dir = os.path.join(base_dir, "wrong_predictions")
+    #          os.makedirs(wrong_pred_dir, exist_ok=True)
+
+    print("Pre-loading ground truth data into a lookup table...")
+    gt_data = {}
+    for category in categories:
+        gt_data[category] = {}
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split=split)
+        for i, file_path in enumerate(files):
+            file_id = file_path.split('/')[-1].split('.')[0]
+            gt_data[category][file_id] = kps[i]
+
+    # Expanded stats dictionary to track source and target separately
+    stats = {cat: {'tp_src': 0, 'fp_src': 0, 'fn_src': 0, 'tn_src': 0, 
+                   'tp_tgt': 0, 'fp_tgt': 0, 'fn_tgt': 0, 'tn_tgt': 0} for cat in categories}
+    
+    matched_rows = 0
+
+    print("Evaluating predictions...")
+    for _, row in tqdm(results_df.iterrows(), total=len(results_df)):
+        category, src_id, tgt_id, kpt_id = row['category'], row['src_id'], row['tgt_id'], row['kpt_id']
+
+        if src_id not in gt_data.get(category, {}) or tgt_id not in gt_data.get(category, {}):
+            continue
+        
+        matched_rows += 1
+        
+        # --- Process Source Image ---
+        kps_src_img = gt_data[category][src_id][kpt_id]
+        is_src_visible = kps_src_img.numpy()[2] == 1
+        src_kp_gt = kps_src_img.numpy()[:2] if is_src_visible else np.array([0, 0])
+        src_bbox = ast.literal_eval(row['src_bbox']) if pd.notna(row['src_bbox']) else None
+        src_outcome = get_evaluation_outcome(src_bbox, src_kp_gt, args.DILATION)
+        stats[category][f"{src_outcome.lower()}_src"] += 1
+        
+        # --- Process Target Image ---
+        kps_tgt_img = gt_data[category][tgt_id][kpt_id]
+        is_tgt_visible = kps_tgt_img.numpy()[2] == 1
+        tgt_kp_gt = kps_tgt_img.numpy()[:2] if is_tgt_visible else np.array([0, 0])
+        tgt_bbox = ast.literal_eval(row['tgt_bbox']) if pd.notna(row['tgt_bbox']) else None
+        tgt_outcome = get_evaluation_outcome(tgt_bbox, tgt_kp_gt, args.DILATION)
+        stats[category][f"{tgt_outcome.lower()}_tgt"] += 1
+    
+        # --- NEW: Log wrong predictions if a save path is provided ---
+        if wrong_pred_dir:
+            if src_outcome in ['fp', 'fn'] or tgt_outcome in ['fp', 'fn']:
+                filename = f"{category}_{src_id}_{tgt_id}_kps:{kpt_id}_src:{src_outcome}_tgt:{tgt_outcome}.json"
+                data_to_save = {'src_name': src_id, 
+                                'src_pred_bbox': src_bbox, 
+                                'src_gt_point': src_kp_gt.tolist(),
+                                'tgt_name': tgt_id,
+                                'tgt_pred_bbox': tgt_bbox,
+                                'tgt_gt_point': tgt_kp_gt.tolist()
+                                }
+                with open(os.path.join(wrong_pred_dir, filename), 'w') as f:
+                    json.dump(data_to_save, f, indent=4)
+            
+            
+            
+
+
+    # print(stats)
+
+    print(f"\nSuccessfully matched and evaluated {matched_rows} rows.")
+    if matched_rows == 0:
+        print("WARNING: No rows were matched. Check IDs in your CSV.")
+        return
+
+    # --- Step 4: Aggregate results for reporting and saving ---
+    reports = {'source': {}, 'target': {}}
+    src_totals = {'tp': 0, 'fp': 0, 'fn': 0, 'tn': 0}
+    tgt_totals = {'tp': 0, 'fp': 0, 'fn': 0, 'tn': 0}
+
+    # Calculate metrics for each category and accumulate totals
+    for category, s in stats.items():
+        # Correctly assign metrics to 'source' and 'target' reports
+        reports['source'][category] = calculate_metrics(s['tp_src'], s['fp_src'], s['fn_src'], s['tn_src'])
+        reports['target'][category] = calculate_metrics(s['tp_tgt'], s['fp_tgt'], s['fn_tgt'], s['tn_tgt'])
+
+        # Accumulate totals for the 'Average' column
+        for key in src_totals.keys():
+            src_totals[key] += s[f'{key}_src']
+            tgt_totals[key] += s[f'{key}_tgt']
+
+    # Calculate overall average metrics
+    reports['source']['Average'] = calculate_metrics(src_totals['tp'], src_totals['fp'], src_totals['fn'], src_totals['tn'])
+    reports['target']['Average'] = calculate_metrics(tgt_totals['tp'], tgt_totals['fp'], tgt_totals['fn'], tgt_totals['tn'])
+    
+    # --- Step 5: Print reports and save to CSV ---
+    for report_type in ['source', 'target']:
+        df = pd.DataFrame(reports[report_type])
+        
+        print(f"\n--- Evaluation Summary ({report_type.capitalize()} Images) ---")
+        print(df.round(4).to_string())
+
+        # Check if the user provided an output path
+        if args.OUTPUT_CSV:
+            # Create a specific filename for each report
+            base, ext = os.path.splitext(args.OUTPUT_CSV)
+            save_path = f"{base}_{report_type}{ext}"
+            try:
+                df.to_csv(save_path)
+                print(f"Results successfully saved to: {save_path}")
+            except Exception as e:
+                print(f"\nError saving CSV file to {save_path}: {e}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate bounding box accuracy")
+    # ... (all your arguments are the same) ...
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--RESULT_DIR', type=str, required=True)
+    parser.add_argument('--DILATION', type=int, default=0)
+    parser.add_argument('--OUTPUT_CSV', type=str, default=None, help='Optional path to save the final report. Will create _src.csv and _tgt.csv.')
+    parser.add_argument('--OUTPUT_WRONG_PRED', type=str, default=None, help='Optional path to save wrong predictions. Will create a directory named "wrong_predictions" in the same location as OUTPUT_CSV.')
+    
+    args = parser.parse_args()
+    main(args)
+

Code/sc_dit/evaluate_vlm_judge.py

@@ -0,0 +1,300 @@
+import pandas as pd
+import numpy as np
+import ast
+import argparse
+import os
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+from tqdm import tqdm
+import json
+from collections import defaultdict
+
+# --- Utility Functions & Imports from your original script ---
+# NOTE: This script assumes you have 'utils.py' and 'dataset.py' files
+# with the necessary functions. I've included placeholders if you don't.
+
+from utils import load_eval_data
+from dataset import get_dataset_info
+
+# --- Re-used function from your script ---
+def get_evaluation_outcome(pred_bbox, gt_point, dilation=0):
+    """
+    Evaluates a single prediction and returns the outcome (TP, FP, FN, or TN).
+    """
+    is_gt_visible = not np.array_equal(gt_point, [0, 0])
+    is_pred_valid = pred_bbox is not None and pred_bbox != [0, 0, 0, 0]
+
+    if is_gt_visible:
+        if is_pred_valid:
+            x1, y1, x2, y2 = pred_bbox
+            if dilation > 0:
+                x1, y1, x2, y2 = x1 - dilation, y1 - dilation, x2 + dilation, y2 + dilation
+            x_gt, y_gt = gt_point
+            is_hit = (x1 <= x_gt <= x2) and (y1 <= y_gt <= y2)
+            return 'tp' if is_hit else 'fp'
+        else:
+            return 'fn'
+    else:
+        return 'fp' if is_pred_valid else 'tn'
+
+# --- Main Analysis Function ---
+def analyze_accuracy(args):
+    """
+    Analyzes the accuracy of the 'final_answer' column against programmatic evaluation.
+    """
+    # --- 1. Load and Merge Data ---
+    print("Loading and merging data files...")
+    try:
+        # Load the file with human-provided "yes"/"no" answers
+        answers_df = pd.read_csv(args.ANSWER_FILE)
+        # Load the original prediction results which contain the bounding boxes
+        results_df = pd.read_csv(args.RESULT_DIR)
+    except FileNotFoundError as e:
+        print(f"Error: {e}. Please check your file paths.")
+        return
+
+    # Merge the two dataframes to have bounding boxes and final_answer in one place
+    # The key identifies a unique prediction for a specific keypoint in a specific image pair
+    merge_keys = ['category', 'src_id', 'tgt_id', 'kpt_id']
+    merged_df = pd.merge(answers_df, results_df, on=merge_keys, how='left')
+    
+    if merged_df['src_bbox'].isnull().any():
+        print("Warning: Some rows in the answer file could not be matched with results. They will be skipped.")
+        merged_df.dropna(subset=['src_bbox', 'tgt_bbox'], inplace=True)
+    
+    print(f"Successfully merged data. Total rows to analyze: {len(merged_df)}")
+
+    # --- 2. Load Ground Truth Data ---
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    print("Pre-loading ground truth data into a lookup table...")
+    gt_data = {}
+    for category in tqdm(categories, desc="Loading GT"):
+        gt_data[category] = {}
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split=split)
+        for i, file_path in enumerate(files):
+            file_id = os.path.basename(file_path).split('.')[0]
+            print('loading gt file path:', file_path)
+            gt_data[category][file_id] = kps[i]
+
+    # --- 3. Evaluate and Compare ---
+    y_true_script = [] # What the script determines (Correct/Incorrect)
+    y_pred_answer = [] # What the 'final_answer' column says (yes/no)
+
+    # create a dictionary to hold the results for each pair
+    results_columns = ['src_id', 'tgt_id', 'kpt_id', 'gt_judge', 'pred_judge']
+    results_data = defaultdict(list)
+
+    print("Comparing 'final_answer' against script evaluation...")
+    for _, row in tqdm(merged_df.iterrows(), total=len(merged_df), desc="Analyzing rows"):
+        category = row['category']
+        src_id = str(row['src_id'])
+        tgt_id = str(row['tgt_id'])
+        kpt_id = int(row['kpt_id'])
+        
+        # Skip if ground truth is missing for some reason
+        if src_id not in gt_data.get(category, {}) or tgt_id not in gt_data.get(category, {}):
+            continue
+
+        # # Evaluate Source Image
+        # kps_src_img = gt_data[category][src_id][kpt_id]
+        # src_kp_gt = kps_src_img.numpy()[:2] if kps_src_img.numpy()[2] == 1 else np.array([0, 0])
+        # src_bbox_pred = ast.literal_eval(row['src_bbox']) if pd.notna(row['src_bbox']) else None
+        # src_outcome = get_evaluation_outcome(src_bbox_pred, src_kp_gt, args.DILATION)
+
+        # Evaluate Target Image
+        kps_tgt_img = gt_data[category][tgt_id][kpt_id]
+        tgt_kp_gt = kps_tgt_img.numpy()[:2] if kps_tgt_img.numpy()[2] == 1 else np.array([0, 0])
+        tgt_bbox_pred = ast.literal_eval(row['tgt_bbox']) if pd.notna(row['tgt_bbox']) else None
+        tgt_outcome = get_evaluation_outcome(tgt_bbox_pred, tgt_kp_gt, args.DILATION)
+
+        # --- Determine the "ground truth" based on script logic ---
+        # A prediction is considered correct if BOTH source and target are 'tp' or 'tn'.
+        # is_script_correct = (src_outcome in ['tp', 'tn']) and (tgt_outcome in ['tp', 'tn'])
+        is_script_correct = (tgt_outcome in ['tp', 'tn'])
+        script_label = 'yes' if is_script_correct else 'no'
+        
+        y_true_script.append(script_label)
+        y_pred_answer.append(row['final_answer'].lower()) # Use lower() for consistency
+
+        # --- Store results for this pair ---
+        results_data['src_id'].append(src_id)
+        results_data['tgt_id'].append(tgt_id)
+        results_data['kpt_id'].append(kpt_id)
+        results_data['gt_judge'].append(script_label)
+        results_data['pred_judge'].append(row['final_answer'].lower())
+
+
+    # --- 4. Report Metrics ---
+    if not y_true_script:
+        print("\nNo data was processed. Cannot generate a report. Check your file paths and content.")
+        return
+        
+    print("\n--- Evaluation Report ---")
+
+    print(f"Total pairs evaluated: {len(y_true_script)}")
+    print(f"Total pair predictions: {len(y_pred_answer)}")
+    # print(f"Correctly identified pairs (script): {y_true_script.count('yes')
+    
+    # Accuracy
+    accuracy = accuracy_score(y_true_script, y_pred_answer)
+    print(f"Overall Accuracy: {accuracy:.4f}\n")
+
+    # Confusion Matrix
+    labels = sorted(list(set(y_true_script) | set(y_pred_answer)))
+    cm = confusion_matrix(y_true_script, y_pred_answer, labels=labels)
+    cm_df = pd.DataFrame(cm, index=[f'Actual: {l}' for l in labels], columns=[f'Predicted: {l}' for l in labels])
+    
+    print("Confusion Matrix:")
+    print(cm_df)
+    print("\n(Rows are the actual values from the script, Columns are the 'final_answer' predictions)")
+
+    # Classification Report (Precision, Recall, F1-Score)
+    print("\nClassification Report:")
+    report = classification_report(y_true_script, y_pred_answer, labels=labels, zero_division=0)
+    print(report)
+
+    # Save results to a DataFrame and then to a CSV
+    results_df = pd.DataFrame(results_data)
+    output_csv = os.path.join(args.OUTPUT_DIR, 'evaluation_results.csv')
+    os.makedirs(args.OUTPUT_DIR, exist_ok=True)
+    results_df.to_csv(output_csv, index=False)
+    print(f"\nResults saved to '{output_csv}'")
+
+def filter_with_answers(args):
+    """
+    Filters predictions based on a 'final_answer' file and saves them to JSON.
+    """
+    # --- 1. Load and Merge Data ---
+    print("Loading and merging data files...")
+    try:
+        # Load the file with "yes"/"no" answers
+        answers_df = pd.read_csv(args.ANSWER_FILE)
+        # Load the original prediction results which contain the bounding boxes
+        results_df = pd.read_csv(args.RESULT_DIR)
+    except FileNotFoundError as e:
+        print(f"Error: {e}. Please check your file paths.")
+        return
+
+    # Merge dataframes to align bounding boxes with their corresponding "yes"/"no" answer
+    merge_keys = ['category', 'src_id', 'tgt_id', 'kpt_id']
+    merged_df = pd.merge(answers_df, results_df, on=merge_keys, how='left')
+
+    # Warn user if some answers don't have a matching prediction
+    if merged_df['src_bbox'].isnull().any():
+        print("Warning: Some rows in the answer file could not be matched with results. Their bboxes will be null.")
+    
+    print(f"Successfully merged data. Total rows to process: {len(merged_df)}")
+
+    # --- 2. Load Ground Truth Data (for output file consistency) ---
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    print("Pre-loading ground truth keypoint data...")
+    gt_data = {}
+    for category in tqdm(categories, desc="Loading GT"):
+        gt_data[category] = {}
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split=split)
+        for i, file_path in enumerate(files):
+            file_id = os.path.basename(file_path).split('.')[0]
+            gt_data[category][file_id] = kps[i]
+
+    # --- 3. Prepare Data Structure for Final Output ---
+    pairs_data = defaultdict(lambda: {
+        'src_bbox': [None] * 30,
+        'tgt_bbox': [None] * 30,
+        'src_kp_gt': [None] * 30,
+        'tgt_kp_gt': [None] * 30
+    })
+
+    # --- 4. Process and Filter Each Row Based on 'final_answer' ---
+    print("Applying filtering logic based on 'final_answer' column...")
+    for _, row in tqdm(merged_df.iterrows(), total=len(merged_df)):
+        category = row['category']
+        src_id = str(row['src_id'])
+        tgt_id = str(row['tgt_id'])
+        kpt_id = int(row['kpt_id'])
+        
+        final_answer = str(row['final_answer']).lower()
+        
+        # Initialize final bboxes as None (to be discarded)
+        final_src_bbox = None
+        final_tgt_bbox = None
+
+        # If the answer is 'yes', we keep the bounding box
+        if final_answer == 'yes':
+        # if True:
+            # Safely evaluate the bounding box string from the CSV
+            src_bbox_pred = ast.literal_eval(row['src_bbox']) if pd.notna(row['src_bbox']) else [0, 0, 0, 0]
+            tgt_bbox_pred = ast.literal_eval(row['tgt_bbox']) if pd.notna(row['tgt_bbox']) else [0, 0, 0, 0]
+
+            # Apply dilation if specified and the box exists
+            if args.DILATION > 0:
+                if src_bbox_pred:
+                    src_bbox_pred = [max(0, coord - args.DILATION) for coord in src_bbox_pred[:2]] + \
+                                    [coord + args.DILATION for coord in src_bbox_pred[2:]]
+                if tgt_bbox_pred:
+                    tgt_bbox_pred = [max(0, coord - args.DILATION) for coord in tgt_bbox_pred[:2]] + \
+                                    [coord + args.DILATION for coord in tgt_bbox_pred[2:]]
+            
+            final_src_bbox = src_bbox_pred
+            final_tgt_bbox = tgt_bbox_pred
+
+        # --- Store Filtered Data ---
+        pair_key = (src_id, tgt_id)
+        if 'src_name' not in pairs_data[pair_key]:
+            pairs_data[pair_key]['category'] = category
+            pairs_data[pair_key]['src_name'] = src_id
+            pairs_data[pair_key]['tgt_name'] = tgt_id
+
+        if 0 <= kpt_id < 30:
+            # Get GT keypoints for the output file
+            src_kp_gt, tgt_kp_gt = np.array([0,0]), np.array([0,0]) # Default
+            if src_id in gt_data.get(category, {}) and kpt_id < len(gt_data[category][src_id]):
+                kps_src_img = gt_data[category][src_id][kpt_id]
+                if kps_src_img.numpy()[2] == 1:
+                    src_kp_gt = kps_src_img.numpy()[:2]
+            
+            if tgt_id in gt_data.get(category, {}) and kpt_id < len(gt_data[category][tgt_id]):
+                kps_tgt_img = gt_data[category][tgt_id][kpt_id]
+                if kps_tgt_img.numpy()[2] == 1:
+                    tgt_kp_gt = kps_tgt_img.numpy()[:2]
+
+            pairs_data[pair_key]['src_bbox'][kpt_id] = final_src_bbox
+            pairs_data[pair_key]['tgt_bbox'][kpt_id] = final_tgt_bbox
+            pairs_data[pair_key]['src_kp_gt'][kpt_id] = src_kp_gt.tolist()
+            pairs_data[pair_key]['tgt_kp_gt'][kpt_id] = tgt_kp_gt.tolist()
+
+    # --- 5. Save Filtered Data to JSON Files ---
+    output_dir = args.OUTPUT_DIR
+    os.makedirs(output_dir, exist_ok=True)
+    print(f"\nSaving {len(pairs_data)} filtered JSON files to '{output_dir}'...")
+
+    for pair_key, data in tqdm(pairs_data.items(), desc="Saving JSON"):
+        src_id, tgt_id = pair_key
+        output_filename = f"{src_id}-{tgt_id}.json"
+        output_filepath = os.path.join(output_dir, output_filename)
+        try:
+            with open(output_filepath, mode='w', encoding='utf-8') as jsonfile:
+                json.dump(data, jsonfile, indent=4)
+        except IOError as e:
+            print(f"Error writing to file '{output_filepath}': {e}")
+    
+    print("Processing complete.")
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description="Evaluate the accuracy of a 'final_answer' column in a CSV file."
+    )
+    # Args from your original script needed for evaluation
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'], help="Dataset to use for evaluation.")
+    parser.add_argument('--DILATION', type=int, default=0, help="Dilation for bounding box evaluation.")
+
+    # Args for the two files we need to compare
+    parser.add_argument('--RESULT_DIR', type=str, required=True, help="Path to the original CSV file with prediction bounding boxes.")
+    parser.add_argument('--ANSWER_FILE', type=str, required=True, help="Path to the new CSV file with the 'final_answer' column.")
+    parser.add_argument('--OUTPUT_DIR', type=str, required=True, help="Path to the directory for the final filtered JSON files.")
+    
+    # Dummy args to satisfy your utility functions if needed
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+
+    args = parser.parse_args()
+    analyze_accuracy(args)
+    # filter_with_answers(args)

Code/sc_dit/experiment_vlm.ipynb

@@ -0,0 +1,594 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "99fe7a9b",
+   "metadata": {},
+   "source": [
+    "## VLM coarse correspondence evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a91edc6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python predict_correspondence_vlm.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 0 --EXP_NOTE 'Qwen Demo Debug'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6837f94",
+   "metadata": {},
+   "source": [
+    "## VLM batch inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "196013ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --EXP_NOTE 'Qwen-VL-7B batch Sub 1 test'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5933b997",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --EXP_NOTE 'Qwen-VL-32B batch Sub 10'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ee0ae2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --EXP_NOTE 'Qwen-VL-7B batch Sub 1 DEBUG' --MODEL_NAME 'Qwen/Qwen2.5-VL-7B-Instruct' --DEBUG"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45cd5cde",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --EXP_NOTE 'Qwen-VL-32B batch Sub 1' --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76290aaf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --EXP_NOTE 'Qwen-VL-32B batch Sub 10' --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5eb4df5",
+   "metadata": {},
+   "source": [
+    "with confidence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84647c37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched_with_conf.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics_enhanced.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox_with_conf.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --EXP_NOTE 'Qwen-VL-32B batch Sub 1' --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb629e68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched_with_conf.py --SYSTEM_PROMPT_SEM './prompts/sys_semantics_enhanced.txt' --SYSTEM_PROMPT_BBOX './prompts/sys_bbox_with_conf.txt' --TASK_PROMPT_SEM './prompts/tsk_semantics.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --EXP_NOTE 'Qwen-VL-32B Sub 1 with conf and eh sem' --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0e750be",
+   "metadata": {},
+   "source": [
+    "gpt batched"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d42d796f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_batched.py --SYSTEM_PROMPT './prompts/sys_paired.txt' --TASK_PROMPT './prompts/tsk_paired.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --MODEL_NAME='gpt-4.1-mini' --EXP_NOTE 'GPT 4.1 mini batch Sub 1'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "562e12ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_batched.py --SYSTEM_PROMPT './prompts/sys_paired.txt' --TASK_PROMPT './prompts/tsk_paired.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --MODEL_NAME='gpt-4.1-mini' --EXP_NOTE 'GPT 4.1 mini batch Sub 10'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6ea9073",
+   "metadata": {},
+   "source": [
+    "## VLM evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "267db584",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --RESULT_DIR './results_vlm/csv/test_sample_1_qwen_vl_7b.csv' --DILATION 14 --OUTPUT_CSV './results_vlm/csv/test_sample_1_qwen_vl_7b_acc.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b914ee05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 20 --RESULT_DIR './results_vlm/csv/test_sample_20_qwen_vl_32b.csv' --DILATION 28 --OUTPUT_CSV './results_vlm/csv/test_sample_20_qwen_vl_32b_acc.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb4e3aa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --DILATION 28 --OUTPUT_CSV './results_vlm/csv/test_sample_10_qwen_vl_32b_acc.csv' --OUTPUT_WRONG_PRED './results_vlm/wrong_predictions/test_sample_10_qwen_vl_32b'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a926a5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --DILATION 84 --OUTPUT_CSV './results_vlm/csv/test_sample_10_qwen_vl_32b_acc_dilation_84.csv' --OUTPUT_WRONG_PRED './results_vlm/wrong_predictions/test_sample_10_qwen_vl_32b_dilation_84'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a926c0a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 1 --RESULT_DIR './results_vlm/csv/test_sample_1_qwen_vl_32b.csv' --DILATION 28 --OUTPUT_CSV './results_vlm/csv/test_sample_1_qwen_vl_32b_acc.csv' --OUTPUT_WRONG_PRED './results_vlm/wrong_predictions/test_sample_1_qwen_vl_32b'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9217a832",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b_conf_improved_sem.csv' --DILATION 28 --OUTPUT_CSV './results_vlm/csv/test_sample_10_qwen_vl_32b_conf_improved_sem_acc.csv' --OUTPUT_WRONG_PRED './results_vlm/wrong_predictions/test_sample_10_qwen_vl_32b_conf_improved_sem'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7dcf1b50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b_with_crop.csv' --DILATION 28 --OUTPUT_CSV './results_vlm/csv/test_sample_10_qwen_vl_32b_with_crop_acc.csv' --OUTPUT_WRONG_PRED './results_vlm/wrong_predictions/test_sample_10_qwen_vl_32b_with_crop'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e5978e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python eval_bbox_acc.py --EVAL_DATASET 'spair' --ANNO_SIZE 840 --TEST_SAMPLE 10 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b_with_crop.csv' --DILATION 84 --OUTPUT_CSV './results_vlm/csv/test_sample_10_qwen_vl_32b_with_crop_acc_dilation_84.csv' --OUTPUT_WRONG_PRED './results_vlm/wrong_predictions/test_sample_10_qwen_vl_32b_with_crop_dilation_84'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b628dc5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c062f2cd",
+   "metadata": {},
+   "source": [
+    "## VLM prediction extraction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b525eee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python extract_vlm_prediction.py --EVAL_DATASET 'spair' --TEST_SAMPLE 10 --DILATION 28 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --OUTPUT_DIR './results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0f498bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python extract_vlm_prediction.py --EVAL_DATASET 'spair' --TEST_SAMPLE 10 --DILATION 0 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --OUTPUT_DIR './results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_dilation_0'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c73d5f93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python extract_vlm_prediction.py --EVAL_DATASET 'spair' --TEST_SAMPLE 10 --DILATION 28 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --OUTPUT_DIR './results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_dilation_28'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c518febb",
+   "metadata": {},
+   "source": [
+    "## VLM judge"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6d8b0ef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python vlm_judge_bbox_pred.py --SYSTEM_PROMPT './prompts/sys_vlm_judge.txt' --TASK_PROMPT './prompts/tsk_vlm_judge.txt' --EVAL_DATASET 'spair' --BBOX_FILE './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --EXP_NOTE 'GPT-4o Judge Test 10' --MODEL_NAME 'gpt-4o'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f308c5d5",
+   "metadata": {},
+   "source": [
+    "batch version has some issues"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e48aa4df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python vlm_judge_bbox_pred_batched.py --SYSTEM_PROMPT './prompts/sys_vlm_judge.txt' --TASK_PROMPT './prompts/tsk_vlm_judge.txt' --EVAL_DATASET 'spair' --BBOX_FILE './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --EXP_NOTE 'GPT-4.1-mini Test 10 Batched Judge Debug' --MODEL_NAME 'gpt-4.1-mini'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "729dc349",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['devkit', 'Layout', 'PairAnnotation', 'Segmentation', 'ImageAnnotation', 'features', 'JPEGImages_bgd_rmv', 'README', 'JPEGImages']\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(os.listdir('../../Datasets/SPair-71k'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "393b36c4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f65b9cc",
+   "metadata": {},
+   "source": [
+    "## VLM judge evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "934c7b45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python evaluate_vlm_judge.py --EVAL_DATASET 'spair' --TEST_SAMPLE 10 --DILATION 28 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --ANSWER_FILE './results_vlm/csv/vlm_judge_test_sample_10_gpt4.1_mini.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ca2d41d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python evaluate_vlm_judge.py --EVAL_DATASET 'spair' --TEST_SAMPLE 10 --DILATION 28 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --ANSWER_FILE './results_vlm/csv/vlm_judge_test_sample_10_gpt4.1_mini.csv' --OUTPUT_DIR './results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_gpt4.1_mini_judge_dilation_28'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f45536f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python evaluate_vlm_judge.py --EVAL_DATASET 'spair' --TEST_SAMPLE 10 --DILATION 28 --RESULT_DIR './results_vlm/csv/test_sample_10_qwen_vl_32b.csv' --ANSWER_FILE './results_vlm/csv/vlm_judge_test_sample_10_gpt4.1_mini.csv' --OUTPUT_DIR './results_vlm/filtered_predictions/test_sample_10_qwen_vl_32b_gpt4.1mini_dilation_28_debug'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "196dfab7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25ba6a0c",
+   "metadata": {},
+   "source": [
+    "## GPT semantic extraction actor critic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56e660a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_actor_critic.py --MODEL_NAME 'gpt-4.1' --TEST_SAMPLE 10 --EXP_NOTE 'GPT-4.1 Actor Critic Test 10' --ANNO_SIZE 840 --EVAL_DATASET 'spair' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94c95ff3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_actor_critic_ort_with_instruction.py --MODEL_NAME 'gpt-5' --TEST_SAMPLE 1 --EXP_NOTE 'GPT-5 Low Actor Critic Test 1' --ANNO_SIZE 840 --EVAL_DATASET 'spair' --ORIENTATION_PATH '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --REASONING_EFFORT 'low'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4442548f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_actor_critic_ort_with_instruction.py --MODEL_NAME 'gpt-5' --TEST_SAMPLE 1 --EXP_NOTE 'GPT-5 minimal Actor Critic Test 1' --ANNO_SIZE 840 --EVAL_DATASET 'spair' --ORIENTATION_PATH '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --REASONING_EFFORT 'minimal'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62147027",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_actor_critic_ort_with_instruction.py --MODEL_NAME 'gpt-5' --TEST_SAMPLE 10 --EXP_NOTE 'GPT-5 Low Actor Critic Test 10 Ort Corrected' --ANNO_SIZE 840 --EVAL_DATASET 'spair' --ORIENTATION_PATH '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --REASONING_EFFORT 'low'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "adc21c50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_gpt_actor_critic_ort_with_instruction.py --MODEL_NAME 'gpt-5' --TEST_SAMPLE 10 --EXP_NOTE 'GPT-5 Low Actor Critic Test 10 Ort Real Corrected' --ANNO_SIZE 840 --EVAL_DATASET 'spair' --ORIENTATION_PATH '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --REASONING_EFFORT 'low'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e542fe92",
+   "metadata": {},
+   "source": [
+    "## Crop Qwen inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ce5f07c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched_with_crop.py --SYSTEM_PROMPT_BBOX './prompts/sys_bbox_crop.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox_crop.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct' --SEM_DIR './results_vlm/spair/GPT-4.1_Actor_Critic_Test_10/' --TEST_SAMPLE 10 --EXP_NOTE 'Qwen-VL-32B batch Sub 10 Crop'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32f15b6a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched_with_crop_ort.py --SYSTEM_PROMPT_BBOX './prompts/sys_bbox_crop_with_ort.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox_crop_with_ort.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct' --SEM_DIR './results_vlm/spair/GPT-5 Low Actor Critic Test 10 Near Side Corrected/' --TEST_SAMPLE 1 --EXP_NOTE 'Qwen-VL-32B batch Sub 1 Crop GPT-5' --ORIENTATION_DIR '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3003cff6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python inference_batched_with_crop_ort.py --SYSTEM_PROMPT_BBOX './prompts/sys_bbox_crop_with_ort.txt' --TASK_PROMPT_BBOX './prompts/tsk_bbox_crop_with_ort.txt' --EVAL_DATASET 'spair' --ANNO_SIZE 840 --MODEL_NAME 'Qwen/Qwen2.5-VL-32B-Instruct' --SEM_DIR './results_vlm/spair/GPT-5 Low Actor Critic Test 10 Near Side Corrected/' --TEST_SAMPLE 10 --EXP_NOTE 'Qwen-VL-32B batch Sub 10 Crop GPT-5' --ORIENTATION_DIR '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db178765",
+   "metadata": {},
+   "source": [
+    "# Orient-Anything (Assume we are inside the Baselines/Orient-Anything)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2a0c1fae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python extract_orientation.py --EVAL_DATASET 'spair' --SAVE_PATH '../../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --DEVICE 'cuda:1' --EXP_NOTE 'Orientation Extraction bgd rmv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "55556f11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python extract_orientation.py --EVAL_DATASET 'spair' --SAVE_PATH '../../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --DEVICE 'cuda:1' --EXP_NOTE 'Orientation Extraction org img'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3737ff3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python extract_orientation.py --EVAL_DATASET 'spair' --SAVE_PATH '../../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/' --DEVICE 'cuda:1' --EXP_NOTE 'Orientation Extraction org img demo'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c24345b2",
+   "metadata": {},
+   "source": [
+    "evaluate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef956e0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python evaluate_orientation.py --EVAL_DATASET 'spair' "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8df8228",
+   "metadata": {},
+   "source": [
+    "## Super resolution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f17d8d71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python realesrgan_sr.py --EVAL_DATASET 'spair' --SAVE_PATH '../../../Datasets/SPair-71k/JPEGImages_4x/' --GPU_ID 2 --OUT_SCALE 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fc2c7b5",
+   "metadata": {},
+   "source": [
+    "## Orientation correction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f6c2c53",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python near_side_correction.py"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17c098a5",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qwen-vl-flash-attn",
+   "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.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Code/sc_dit/extract_3D_mesh.py

@@ -0,0 +1,86 @@
+import sys
+from pathlib import Path
+import torch
+import os
+import glob
+
+# print(project_root)
+project_root = Path(__file__).resolve().parents[1]
+print(os.listdir(project_root))
+project_path = os.path.join(str(project_root), 'Baselines', 'CraftsMan3D')
+print(os.listdir(project_path))
+
+# print("Project root:", project_root)
+# print("Project path:", project_path)
+
+# # Add the project root to Python's path to allow for absolute imports
+if str(project_path) not in sys.path:
+    sys.path.append(str(project_path))
+
+# print("Current sys.path:", sys.path)
+from craftsman import CraftsManPipeline
+
+def main():
+
+    print(os.listdir('../Baselines/sd3.5'))
+
+    path_data = '../Baselines/sd3.5/spair_71k_test_examples'
+    categories = os.listdir(path_data)
+    print("Categories:", categories)
+
+    path_images = glob.glob(os.path.join(path_data, '*', '*_bgd_rmv.png'))
+    print("Number of images found:", len(path_images))
+
+    path_output = './example_data/spair'
+
+    device = "cuda:7"
+
+    # print(os.listdir(path_data))
+
+    # path_image = os.path.join(path_data, 'motorbike', '2009_004845_bgd_rmv.png')
+
+    pipeline = CraftsManPipeline.from_pretrained("../Baselines/CraftsMan3D/ckpts/craftsman-DoraVAE", device=device, torch_dtype=torch.bfloat16)
+
+    for path_image in path_images:
+        # print("Processing image:", path_image)
+        # Extract the category and file ID from the image path
+        category = os.path.basename(os.path.dirname(path_image))
+        file_id = os.path.splitext(os.path.basename(path_image))[0].replace('_bgd_rmv', '')
+
+        path_obj_output = os.path.join(path_output, category, f"{file_id}.obj")
+        if not os.path.exists(os.path.dirname(path_obj_output)):
+            os.makedirs(os.path.dirname(path_obj_output))
+        # print("Output path for mesh:", path_obj_output)
+
+        mesh = pipeline(path_image).meshes[0]
+        mesh.export(path_obj_output)
+        print(f"Exported mesh for {file_id} to {path_obj_output}")
+
+        # copy the image to the ouput directory
+        path_image_output = os.path.join(path_output, category, f"{file_id}_bgd_rmv.png")
+        if not os.path.exists(os.path.dirname(path_image_output)):
+            os.makedirs(os.path.dirname(path_image_output))
+        os.system(f"cp {path_image} {path_image_output}")
+        os.system(f"cp {path_image.replace('_bgd_rmv.png', '.jpg')} {path_image_output.replace('_bgd_rmv.png', '.jpg')}")
+
+        # break
+
+        # # Run the pipeline
+        # try:
+        #     result = pipeline(path_image, category=category, file_id=file_id)
+        #     meshes = result.meshes
+        #     if meshes:
+        #         mesh = meshes[0]
+        #         mesh.export(f"{file_id}.obj")
+        #         print(f"Exported mesh for {file_id} to {file_id}.obj")
+        #     else:
+        #         print(f"No meshes found for {file_id}")
+        # except Exception as e:
+        #     print(f"Error processing {path_image}: {e}")
+    # mesh = pipeline(path_image).meshes[0]
+    # mesh.export("motorbike_1.obj")
+
+
+
+if __name__ == "__main__":
+    main()

Code/sc_dit/extract_vlm_prediction.py

@@ -0,0 +1,158 @@
+import csv
+import json
+import argparse
+import os
+import pandas as pd
+import ast
+from collections import defaultdict
+from tqdm import tqdm
+import numpy as np
+
+# --- Utility Functions & Imports ---
+# NOTE: This script assumes you have 'utils.py' and 'dataset.py' files
+# with the necessary functions as used in your original script.
+from utils import load_eval_data
+from dataset import get_dataset_info
+
+def get_evaluation_outcome(pred_bbox, gt_point, dilation=0):
+    """
+    Evaluates a single prediction and returns the outcome (TP, FP, FN, or TN).
+    
+    Args:
+        pred_bbox (list or None): The predicted bounding box [x1, y1, x2, y2].
+        gt_point (np.array): The ground truth keypoint [x, y].
+        dilation (int): Dilation pixels to expand the predicted bounding box.
+
+    Returns:
+        str: 'tp' (True Positive), 'fp' (False Positive), 
+             'fn' (False Negative), or 'tn' (True Negative).
+    """
+    # GT is visible if the point is not [0, 0]
+    is_gt_visible = not np.array_equal(gt_point, [0, 0])
+    # Prediction is valid if it's not None and not an empty placeholder
+    is_pred_valid = pred_bbox is not None and pred_bbox != [0, 0, 0, 0]
+
+    if is_gt_visible:
+        if is_pred_valid:
+            # GT is visible, and we made a prediction. Check if it's a hit.
+            x1, y1, x2, y2 = pred_bbox
+            if dilation > 0:
+                x1, y1, x2, y2 = x1 - dilation, y1 - dilation, x2 + dilation, y2 + dilation
+            x_gt, y_gt = gt_point
+            is_hit = (x1 <= x_gt <= x2) and (y1 <= y_gt <= y2)
+            return 'tp' if is_hit else 'fp'
+        else:
+            # GT is visible, but we did not make a prediction.
+            return 'fn'
+    else:  # GT is not visible
+        return 'fp' if is_pred_valid else 'tn'
+
+def process_and_filter_data(args):
+    """
+    Main function to read, evaluate, filter, and save data.
+    """
+    # --- 1. Load Data & Ground Truth ---
+    results_df = pd.read_csv(args.RESULT_DIR)
+    data_dir, categories, split = get_dataset_info(args, split='test')
+
+    print("Pre-loading ground truth data into a lookup table...")
+    gt_data = {}
+    for category in categories:
+        gt_data[category] = {}
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split=split)
+        for i, file_path in enumerate(files):
+            file_id = os.path.basename(file_path).split('.')[0]
+            gt_data[category][file_id] = kps[i]
+
+    # --- 2. Prepare Data Structure for Final Output ---
+    # This structure will hold all the data for each pair before saving.
+    pairs_data = defaultdict(lambda: {
+        'src_bbox': [None] * 30,
+        'tgt_bbox': [None] * 30,
+        'src_kp_gt': [None] * 30, # New field for source keypoints
+        'tgt_kp_gt': [None] * 30  # New field for target keypoints
+    })
+
+    # --- 3. Process, Evaluate, and Filter Each Row ---
+    print("Evaluating predictions and applying filtering logic...")
+    for _, row in tqdm(results_df.iterrows(), total=len(results_df)):
+        category, src_id, tgt_id = row['category'], str(row['src_id']), str(row['tgt_id'])
+        kpt_id = int(row['kpt_id'])
+
+        if src_id not in gt_data.get(category, {}) or tgt_id not in gt_data.get(category, {}):
+            continue
+
+        # --- Process Source ---
+        kps_src_img = gt_data[category][src_id][kpt_id]
+        is_src_visible = kps_src_img.numpy()[2] == 1
+        src_kp_gt = kps_src_img.numpy()[:2] if is_src_visible else np.array([0, 0])
+        src_bbox_pred = ast.literal_eval(row['src_bbox']) if pd.notna(row['src_bbox']) else None
+        src_outcome = get_evaluation_outcome(src_bbox_pred, src_kp_gt, args.DILATION)
+
+        # --- Process Target ---
+        kps_tgt_img = gt_data[category][tgt_id][kpt_id]
+        is_tgt_visible = kps_tgt_img.numpy()[2] == 1
+        tgt_kp_gt = kps_tgt_img.numpy()[:2] if is_tgt_visible else np.array([0, 0])
+        tgt_bbox_pred = ast.literal_eval(row['tgt_bbox']) if pd.notna(row['tgt_bbox']) else None
+        tgt_outcome = get_evaluation_outcome(tgt_bbox_pred, tgt_kp_gt, args.DILATION)
+
+        # --- Apply Filtering Logic to Bounding Boxes ---
+        if src_outcome == 'tp' and src_bbox_pred is not None:
+            src_bbox_pred = [max(0, coord - args.DILATION) for coord in src_bbox_pred[:2]] + \
+                            [coord + args.DILATION for coord in src_bbox_pred[2:]]
+        if tgt_outcome == 'tp' and tgt_bbox_pred is not None:
+            tgt_bbox_pred = [max(0, coord - args.DILATION) for coord in tgt_bbox_pred[:2]] + \
+                            [coord + args.DILATION for coord in tgt_bbox_pred[2:]]
+        
+        final_src_bbox = src_bbox_pred if src_outcome == 'tp' else ([0, 0, 0, 0] if src_outcome == 'tn' else None)
+        final_tgt_bbox = tgt_bbox_pred if tgt_outcome == 'tp' else ([0, 0, 0, 0] if tgt_outcome == 'tn' else None)
+        
+        # --- Store Filtered Data ---
+        pair_key = (src_id, tgt_id)
+        if 'src_name' not in pairs_data[pair_key]:
+            pairs_data[pair_key]['category'] = category # Store category
+            pairs_data[pair_key]['src_name'] = src_id
+            pairs_data[pair_key]['tgt_name'] = tgt_id
+
+        if 0 <= kpt_id < 30:
+            pairs_data[pair_key]['src_bbox'][kpt_id] = final_src_bbox
+            pairs_data[pair_key]['tgt_bbox'][kpt_id] = final_tgt_bbox
+            # Store the ground truth keypoints (converted to list for JSON)
+            pairs_data[pair_key]['src_kp_gt'][kpt_id] = src_kp_gt.tolist()
+            pairs_data[pair_key]['tgt_kp_gt'][kpt_id] = tgt_kp_gt.tolist()
+
+    # --- 4. Save Filtered Data to JSON Files ---
+    output_dir = args.OUTPUT_DIR
+    os.makedirs(output_dir, exist_ok=True)
+    print(f"\nSaving {len(pairs_data)} filtered JSON files to '{output_dir}'...")
+
+    for pair_key, data in pairs_data.items():
+        src_id, tgt_id = pair_key
+        # Use hyphen in filename as per your provided code
+        output_filename = f"{src_id}-{tgt_id}.json"
+        output_filepath = os.path.join(output_dir, output_filename)
+        try:
+            with open(output_filepath, mode='w', encoding='utf-8') as jsonfile:
+                json.dump(data, jsonfile, indent=4)
+        except IOError as e:
+            print(f"Error writing to file '{output_filepath}': {e}")
+    
+    print("Processing complete.")
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description="Evaluate, filter, and convert keypoint CSV data to multiple JSON files."
+    )
+    # Arguments from your evaluation script
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'], help="Dataset to use for evaluation.")
+    parser.add_argument('--ANNO_SIZE', type=int, default=840, help="Annotation size.")
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0, help="Number of test samples to use (0 for all).")
+    parser.add_argument('--RESULT_DIR', type=str, required=True, help="Path to the input CSV file with predictions.")
+    parser.add_argument('--DILATION', type=int, default=0, help="Dilation for bounding box evaluation.")
+    
+    # Updated argument for the output directory
+    parser.add_argument('--OUTPUT_DIR', type=str, required=True, help="Path to the directory for the final filtered JSON files.")
+    
+    args = parser.parse_args()
+    process_and_filter_data(args)

Code/sc_dit/inference_batched.py

@@ -0,0 +1,367 @@
+import os
+import wandb
+import matplotlib.pyplot as plt
+from torch.utils.data import DataLoader
+import argparse
+import torch
+from tqdm import tqdm
+from PIL import ImageDraw, ImageFont
+import numpy as np
+import json
+
+# mutliprocessing for parallel job preparation
+import concurrent.futures
+
+# custom imports
+from dataset import get_dataset_info, VLDataset
+from utils import load_eval_data, load_img_and_kps
+from qwen_utils import QwenVLDetector
+# from predict_correspondence_vlm import create_image_with_one_kp
+
+# Place the new, fast drawing function here
+# def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, **kwargs):
+#     img_with_kp = img.copy()
+#     draw = ImageDraw.Draw(img_with_kp)
+#     cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+#     radius = circ_size / 10 
+#     bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+#     draw.ellipse(bbox, outline="red", width=4)
+#     return img_with_kp
+
+def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, add_text=True, **kwargs):
+    img_with_kp = img.copy()
+    draw = ImageDraw.Draw(img_with_kp)
+    cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+    radius = circ_size / 10 
+    bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+    draw.ellipse(bbox, outline="red", width=4)
+
+    if add_text:
+        text = "Ref"
+        # Try to use a better font, or fall back to the default if not found
+        # try:
+        font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+        # except IOError:
+        #     print('test')
+        #     font = ImageFont.load_default()
+
+        # Get text bounding box for centering
+        # print(font)
+        bbox_text = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox_text[2] - bbox_text[0]
+        text_height = bbox_text[3] - bbox_text[1]
+
+        text_x = cx - text_width // 2
+        text_y = cy - text_height // 2
+        draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+    return img_with_kp
+
+# Helper function to process a single keypoint (needed for parallelization)
+def prepare_single_job(task_args):
+    img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, category_prompt_sem = task_args
+
+    if img1_kps[kps_idx, 2] == 1:
+        # Use the fast, new function
+        img1_kp = create_image_with_one_kp_pil(img1, img1_kps, kps_idx=kps_idx)
+        
+        return {
+            "img1": img1,
+            "img1_kp": img1_kp,
+            "img2": img2,
+            "prompt_sem": category_prompt_sem,
+            "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+        }
+    return None
+
+def run_batched_evaluation(args, model, system_prompt_sem, system_prompt_bbox, task_prompt_sem, task_prompt_bbox):
+    """
+    Runs the entire evaluation using a batched approach for maximum efficiency.
+    """
+    # --- Create save directories if provided ---
+    if args.SAVE_DIR:
+        stage2_dir = os.path.join(args.SAVE_DIR, "stage2_semantics", args.EVAL_DATASET, args.EXP_NOTE)
+        stage3_dir = os.path.join(args.SAVE_DIR, "stage3_bboxes", args.EVAL_DATASET, args.EXP_NOTE)
+        os.makedirs(stage2_dir, exist_ok=True)
+        os.makedirs(stage3_dir, exist_ok=True)
+        print(f"Intermediate results will be saved to: {args.SAVE_DIR}")
+
+
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    results_table = wandb.Table(columns=["category", "src_id", "tgt_id", "kpt_id", "plot", "extracted_semantics", "src_response", "src_bbox", "src_input_size", "tgt_response", "tgt_bbox", "target_input_size"])
+
+    # --- STAGE 1: PREPARE ALL INFERENCE JOBS FIRST ---
+    print("--- Stage 1: Preparing all inference jobs... ---")
+    # inference_jobs = []
+    # for category in categories:
+    #     # print(f"Preparing jobs for category: {category}")
+    #     category_prompt_sem = task_prompt_sem.format(class_name=category)
+    #     files, kps, _, _ = load_eval_data(args, data_dir, category, split)
+    #     N = len(files) // 2
+
+    #     # for pair_idx in range(N):
+    #     for pair_idx in tqdm(range(N), desc=f"Processing {category} pairs"):
+    #         img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+    #         img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+    #         src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+    #         tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+    #         for kps_idx in range(img1_kps.shape[0]):
+    #             if img1_kps[kps_idx, 2] == 1:
+    #                 # CPU-bound image creation
+    #                 img1_kp = create_image_with_one_kp(img1, img1_kps, kps_idx=kps_idx, add_text=False, add_circle=True)
+                    
+    #                 job = {
+    #                     "img1_kp": img1_kp,
+    #                     "img2": img2,
+    #                     "prompt_sem": category_prompt_sem,
+    #                     "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+    #                 }
+    #                 inference_jobs.append(job)
+    # print(f"Prepared {len(inference_jobs)} total jobs.")
+
+    # First, create a flat list of all tasks to be done
+    tasks = []
+    for category in categories:
+        # category_prompt_sem = task_prompt_sem.format(class_name=category)
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split)
+        N = len(files) // 2
+
+        # for pair_idx in range(N):
+        for pair_idx in tqdm(range(N), desc=f"Adding {category} pairs"):
+            img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+            tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+            for kps_idx in range(img1_kps.shape[0]):
+                # point_x = int(img1_kps[kps_idx, 0])
+                # point_y = int(img1_kps[kps_idx, 1])
+                # get two decimal places
+                point_x = f"{img1_kps[kps_idx, 0]:.2f}"
+                point_y = f"{img1_kps[kps_idx, 1]:.2f}"
+                category_prompt_sem = task_prompt_sem.format(class_name=category, point_x=point_x, point_y=point_y)
+                tasks.append((img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, category_prompt_sem))
+
+    # Now, process the flat list of tasks in parallel
+    inference_jobs = []
+    # Use max_workers=None to use all available CPU cores
+    with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
+        # `map` will apply `prepare_single_job` to each item in `tasks` across multiple processes
+        # `tqdm` provides a progress bar
+        results = list(tqdm(executor.map(prepare_single_job, tasks), total=len(tasks), desc="Preparing Jobs"))
+
+    # Filter out None results (from invisible keypoints)
+    inference_jobs = [job for job in results if job is not None]
+
+    print(f"Prepared {len(inference_jobs)} total jobs.")
+
+
+    # --- STAGE 2: BATCHED SEMANTIC EXTRACTION (1st Model Call) ---
+    print("\n--- Stage 2: Running batched semantic extraction... ---")
+    src_images = [job["img1_kp"] for job in inference_jobs]
+    src_prompts = [job["prompt_sem"] for job in inference_jobs]
+
+    dataset_sem = VLDataset(src_images, src_prompts)
+    loader_sem = DataLoader(dataset_sem, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x, pin_memory=True)
+    
+    all_src_results = []
+    # for batch in loader_sem:
+    for batch in tqdm(loader_sem, desc="Processing semantic extraction batches"):
+        images_pil, text_prompts = zip(*batch)
+        # Use the base `chat` method as it seems you want raw text back
+        # NOTE: You might need a batched version of `chat` if it doesn't support lists
+        results = model.chat_batch(list(images_pil), list(text_prompts), system_prompt_sem, 'self-handled') # Assuming model.chat is updated for batching
+        all_src_results.extend(results)
+
+    # Extract semantics and prepare for the next stage
+    for i, job in enumerate(inference_jobs):
+        response_text = all_src_results[i]['response']
+        job["metadata"]["src_input_size"] = all_src_results[i]['input_size']
+        job["src_response"] = response_text
+        job["extracted_semantics"] = response_text.split("Keypoint component:")[-1].strip()
+        job["src_bbox"] = model._get_bounding_boxes(response_text, all_src_results[i]['input_size'], job['img1_kp'].size)
+
+
+    # --- SAVE STAGE 2 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 2 results to {stage2_dir}...")
+        for job in tqdm(inference_jobs, desc="Saving Stage 2 results"):
+            meta = job["metadata"]
+            if args.DEBUG:
+                filename = f"DEBUG:{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            else:
+                filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage2_dir, filename)
+            src_bbox = list(job["src_bbox"].values())[0]['bbox'] if job["src_bbox"] and job["src_bbox"].values() else None
+            output_data = {
+                "metadata": meta,
+                "full_response": job["src_response"],
+                "extracted_semantics": job["extracted_semantics"],
+                "source_bbox": src_bbox,
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+    # --- STAGE 3: BATCHED BOUNDING BOX PREDICTION (2nd Model Call) ---
+    print("\n--- Stage 3: Running batched bounding box prediction... ---")
+    if args.DEBUG:
+        # print("Debug mode enabled: Saving intermediate results to disk.")
+        print("Debug mode enabled: Using img1 for bounding box prediction.")
+        tgt_images = [job["img1"] for job in inference_jobs]
+    else:
+        tgt_images = [job["img2"] for job in inference_jobs]
+    tgt_prompts = [task_prompt_bbox.format(class_name=job["metadata"]["category"], extracted_semantics=job["extracted_semantics"]) for job in inference_jobs]
+
+    dataset_bbox = VLDataset(tgt_images, tgt_prompts)
+    loader_bbox = DataLoader(dataset_bbox, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x)
+
+    all_tgt_results = []
+    # for batch in loader_bbox:
+    for batch in tqdm(loader_bbox, desc="Processing bounding box prediction batches"):
+        images_pil, text_prompts = zip(*batch)
+        # Assuming model.predict is updated for batching
+        results = model.predict_batch(list(images_pil), list(text_prompts), system_prompt_bbox, 'object') 
+        all_tgt_results.extend(results)
+
+    # --- SAVE STAGE 3 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 3 results to {stage3_dir}...")
+        for i, job in enumerate(tqdm(inference_jobs, desc="Saving Stage 3 results")):
+            meta = job["metadata"]
+            tgt_result = all_tgt_results[i]
+            if args.DEBUG:
+                tgt_bbox = model.predict_bounding_boxes(job["img1"], tgt_result['response'], tgt_result['input_size'])
+            else:
+                tgt_bbox = model.predict_bounding_boxes(job["img2"], tgt_result['response'], tgt_result['input_size'])
+            
+            filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage3_dir, filename)
+            output_data = {
+                "metadata": meta,
+                "full_response": tgt_result['response'],
+                "target_bbox": tgt_bbox,
+                "target_input_size": tgt_result['input_size'],
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+
+
+    # --- STAGE 4: LOGGING ---
+    print("\n--- Stage 4: Plotting and logging results to WandB... ---")
+    # for i, job in enumerate(inference_jobs):
+    for i, job in tqdm(enumerate(inference_jobs), total=len(inference_jobs), desc="Logging results"):
+        meta = job["metadata"]
+        src_bbox_dict = job["src_bbox"]
+        tgt_result = all_tgt_results[i]
+
+        src_bbox = list(src_bbox_dict.values())[0]['bbox'] if src_bbox_dict else None
+        tgt_bbox = model.predict_bounding_boxes(job["img2"], tgt_result['response'], tgt_result['input_size'])
+
+        # Create plot
+        # --- COMPLETED PLOTTING LOGIC ---
+        # Get the source and target images for plotting
+        img1_kp = job["img1_kp"]
+        if args.DEBUG:
+            img2 = job["img1"]  # Use img1 for bbox prediction in debug mode
+        else:
+            img2 = job["img2"]
+
+        fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+        axes[0].imshow(np.array(img1_kp))
+        axes[0].axis('off')
+        axes[0].set_title('Source Image with Keypoint')
+        axes[1].imshow(np.array(img2))
+        axes[1].axis('off')
+        axes[1].set_title('Target Image with Bounding Box')
+        if src_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = src_bbox
+            axes[0].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        
+        if tgt_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = tgt_bbox
+            axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        else:
+            axes[1].text(img2.width / 2, img2.height / 2, "No bounding box found", color='red', fontsize=12, ha='center', va='center')
+        
+        fig.tight_layout()
+
+        wandb_img = wandb.Image(fig)
+        plt.close(fig) 
+
+
+        results_table.add_data(
+            meta["category"], 
+            meta["src_id"], 
+            meta["tgt_id"], 
+            meta["kps_idx"],
+            wandb_img, 
+            job["extracted_semantics"], 
+            job["src_response"],
+            str(src_bbox),
+            job["metadata"]["src_input_size"],
+            tgt_result['response'], 
+            str(tgt_bbox),
+            tgt_result['input_size']
+        )
+    
+    wandb.log({"evaluation_results": results_table})
+
+
+# ===================================================================
+# 4. YOUR ORIGINAL `main` FUNCTION, NOW SIMPLIFIED TO CALL THE BATCHED RUNNER
+# ===================================================================
+def main(args):
+    with open(args.SYSTEM_PROMPT_SEM, 'r') as f:
+        system_prompt_sem = f.read()
+    with open(args.SYSTEM_PROMPT_BBOX, 'r') as f:
+        system_prompt_bbox = f.read()
+    with open(args.TASK_PROMPT_SEM, 'r') as f:
+        task_prompt_sem = f.read()
+    with open(args.TASK_PROMPT_BBOX, 'r') as f:
+        task_prompt_bbox = f.read()
+
+    # Initialize the Qwen VLM model
+    print("Initializing Qwen model...")
+    model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name=args.MODEL_NAME, device="auto", flash_attn=True)
+    # model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name="Qwen/Qwen2.5-VL-7B-Instruct", device="auto", flash_attn=True)
+
+    # Initialize WandB
+    print("Initializing WandB...")
+    wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    # Run the optimized evaluation
+    run_batched_evaluation(args, model, system_prompt_sem, system_prompt_bbox, task_prompt_sem, task_prompt_bbox)
+
+    print('Finished processing all categories and logging results.')
+    wandb.finish()
+    print('WandB run finished.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # ... (all your existing arguments) ...
+    parser.add_argument('--SYSTEM_PROMPT_SEM', type=str, required=True)
+    parser.add_argument('--SYSTEM_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_SEM', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    parser.add_argument('--DEBUG', action='store_true', help='Enable debug mode for verbose output.') # decouple the prediction
+    parser.add_argument('--MODEL_NAME', type=str, default='Qwen/Qwen2.5-VL-32B-Instruct', help='Model name for Qwen VLM.')
+    
+    # --- ADD THESE NEW ARGUMENTS for controlling batching ---
+    parser.add_argument('--BATCH_SIZE', type=int, default=4, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+
+    
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/inference_batched_with_conf.py

@@ -0,0 +1,409 @@
+import os
+import wandb
+import matplotlib.pyplot as plt
+from torch.utils.data import DataLoader
+import argparse
+import torch
+from tqdm import tqdm
+from PIL import ImageDraw, ImageFont
+import numpy as np
+import json
+
+# mutliprocessing for parallel job preparation
+import concurrent.futures
+
+# custom imports
+from dataset import get_dataset_info, VLDataset
+from utils import load_eval_data, load_img_and_kps
+from qwen_utils import QwenVLDetector
+# from predict_correspondence_vlm import create_image_with_one_kp
+
+# Place the new, fast drawing function here
+# def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, **kwargs):
+#     img_with_kp = img.copy()
+#     draw = ImageDraw.Draw(img_with_kp)
+#     cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+#     radius = circ_size / 10 
+#     bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+#     draw.ellipse(bbox, outline="red", width=4)
+#     return img_with_kp
+
+def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, add_text=True, **kwargs):
+    img_with_kp = img.copy()
+    draw = ImageDraw.Draw(img_with_kp)
+    cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+    radius = circ_size / 10 
+    bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+    draw.ellipse(bbox, outline="red", width=4)
+
+    if add_text:
+        text = "Ref"
+        # Try to use a better font, or fall back to the default if not found
+        # try:
+        font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+        # except IOError:
+        #     print('test')
+        #     font = ImageFont.load_default()
+
+        # Get text bounding box for centering
+        # print(font)
+        bbox_text = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox_text[2] - bbox_text[0]
+        text_height = bbox_text[3] - bbox_text[1]
+
+        text_x = cx - text_width // 2
+        text_y = cy - text_height // 2
+        draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+    return img_with_kp
+
+# Helper function to process a single keypoint (needed for parallelization)
+def prepare_single_job(task_args):
+    img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, category_prompt_sem = task_args
+
+    if img1_kps[kps_idx, 2] == 1:
+        # Use the fast, new function
+        img1_kp = create_image_with_one_kp_pil(img1, img1_kps, kps_idx=kps_idx)
+        
+        return {
+            "img1": img1,
+            "img1_kp": img1_kp,
+            "img2": img2,
+            "prompt_sem": category_prompt_sem,
+            "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+        }
+    return None
+
+def run_batched_evaluation(args, model, system_prompt_sem, system_prompt_bbox, task_prompt_sem, task_prompt_bbox):
+    """
+    Runs the entire evaluation using a batched approach for maximum efficiency.
+    """
+    # --- Create save directories if provided ---
+    if args.SAVE_DIR:
+        stage2_dir = os.path.join(args.SAVE_DIR, "stage2_semantics", args.EVAL_DATASET, args.EXP_NOTE)
+        stage3_dir = os.path.join(args.SAVE_DIR, "stage3_bboxes", args.EVAL_DATASET, args.EXP_NOTE)
+        os.makedirs(stage2_dir, exist_ok=True)
+        os.makedirs(stage3_dir, exist_ok=True)
+        print(f"Intermediate results will be saved to: {args.SAVE_DIR}")
+
+
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    results_table = wandb.Table(columns=["category", "src_id", "tgt_id", "kpt_id", "plot", "extracted_semantics", "src_response", "src_bbox", "src_input_size", "tgt_response", "tgt_bbox", "target_input_size", "tgt_bbox_conf"])
+
+    # --- STAGE 1: PREPARE ALL INFERENCE JOBS FIRST ---
+    print("--- Stage 1: Preparing all inference jobs... ---")
+    # First, create a flat list of all tasks to be done
+    tasks = []
+    for category in categories:
+        # category_prompt_sem = task_prompt_sem.format(class_name=category)
+        files, kps, _, _ = load_eval_data(args, data_dir, category, split)
+        N = len(files) // 2
+
+        # for pair_idx in range(N):
+        for pair_idx in tqdm(range(N), desc=f"Adding {category} pairs"):
+            img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+            tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+            for kps_idx in range(img1_kps.shape[0]):
+                # point_x = int(img1_kps[kps_idx, 0])
+                # point_y = int(img1_kps[kps_idx, 1])
+                # get two decimal places
+                point_x = f"{img1_kps[kps_idx, 0]:.2f}"
+                point_y = f"{img1_kps[kps_idx, 1]:.2f}"
+                category_prompt_sem = task_prompt_sem.format(class_name=category, point_x=point_x, point_y=point_y)
+                tasks.append((img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, category_prompt_sem))
+
+    # Now, process the flat list of tasks in parallel
+    inference_jobs = []
+    # Use max_workers=None to use all available CPU cores
+    with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
+        # `map` will apply `prepare_single_job` to each item in `tasks` across multiple processes
+        # `tqdm` provides a progress bar
+        results = list(tqdm(executor.map(prepare_single_job, tasks), total=len(tasks), desc="Preparing Jobs"))
+
+    # Filter out None results (from invisible keypoints)
+    inference_jobs = [job for job in results if job is not None]
+
+    print(f"Prepared {len(inference_jobs)} total jobs.")
+
+
+    # --- STAGE 2: BATCHED SEMANTIC EXTRACTION (1st Model Call) ---
+    # print("\n--- Stage 2: Running batched semantic extraction... ---")
+    # src_images = [job["img1_kp"] for job in inference_jobs]
+    # src_prompts = [job["prompt_sem"] for job in inference_jobs]
+
+    # dataset_sem = VLDataset(src_images, src_prompts)
+    # loader_sem = DataLoader(dataset_sem, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x, pin_memory=True)
+    
+    # all_src_results = []
+    # # for batch in loader_sem:
+    # for batch in tqdm(loader_sem, desc="Processing semantic extraction batches"):
+    #     images_pil, text_prompts = zip(*batch)
+    #     # Use the base `chat` method as it seems you want raw text back
+    #     # NOTE: You might need a batched version of `chat` if it doesn't support lists
+    #     results = model.chat_batch(list(images_pil), list(text_prompts), system_prompt_sem, 'self-handled') # Assuming model.chat is updated for batching
+    #     all_src_results.extend(results)
+
+    # # Extract semantics and prepare for the next stage
+    # for i, job in enumerate(inference_jobs):
+    #     response_text = all_src_results[i]['response']
+    #     job["metadata"]["src_input_size"] = all_src_results[i]['input_size']
+    #     job["src_response"] = response_text
+    #     job["extracted_semantics"] = response_text.split("Keypoint component:")[-1].strip()
+    #     job["src_bbox"] = model._get_bounding_boxes(response_text, all_src_results[i]['input_size'], job['img1_kp'].size)
+
+
+    # --- SAVE STAGE 2 RESULTS IMMEDIATELY ---
+    # --- STAGE 2: BATCHED SEMANTIC EXTRACTION (OR LOAD FROM CACHE) ---
+    # NEW: Add a command-line argument `--skip-stage2` to your parser for this
+    if args.SKIP_STAGE2 and os.path.exists(stage2_dir):
+        print(f"--- Stage 2: SKIPPED. Loading results from {stage2_dir}... ---")
+        
+        # This requires a way to match jobs to files. We'll use a dictionary lookup.
+        # Create a mapping from a unique job ID to its index in inference_jobs
+        job_map = {
+            f"{job['metadata']['category']}_{job['metadata']['src_id']}_{job['metadata']['tgt_id']}_kps{job['metadata']['kps_idx']}": i
+            for i, job in enumerate(inference_jobs)
+        }
+
+        # Loop through the saved files
+        for filename in tqdm(os.listdir(stage2_dir), desc="Loading cached Stage 2 results"):
+            if filename.endswith(".json"):
+                # Reconstruct the job ID from the filename
+                job_id = filename.replace('.json', '')
+                if job_id in job_map:
+                    job_index = job_map[job_id]
+                    
+                    # Load the data and populate the job
+                    with open(os.path.join(stage2_dir, filename), 'r') as f:
+                        cached_data = json.load(f)
+                    
+                    inference_jobs[job_index]["extracted_semantics"] = cached_data["extracted_semantics"]
+                    # You can add other fields if needed later, e.g., src_response
+                    inference_jobs[job_index]["src_response"] = cached_data["full_response"]
+
+    else:
+        # This is your original Stage 2 code block
+        print("\n--- Stage 2: Running batched semantic extraction... ---")
+        src_images = [job["img1_kp"] for job in inference_jobs]
+        src_prompts = [job["prompt_sem"] for job in inference_jobs]
+
+        dataset_sem = VLDataset(src_images, src_prompts)
+        loader_sem = DataLoader(dataset_sem, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x, pin_memory=True)
+        
+        all_src_results = []
+        for batch in tqdm(loader_sem, desc="Processing semantic extraction batches"):
+            images_pil, text_prompts = zip(*batch)
+            results = model.chat_batch(list(images_pil), list(text_prompts), system_prompt_sem, 'self-handled')
+            all_src_results.extend(results)
+
+        for i, job in enumerate(inference_jobs):
+            response_text = all_src_results[i]['response']
+            job["metadata"]["src_input_size"] = all_src_results[i]['input_size']
+            job["src_response"] = response_text
+            job["extracted_semantics"] = response_text.split("Keypoint component:")[-1].strip()
+            job["src_bbox"] = model._get_bounding_boxes(response_text, all_src_results[i]['input_size'], job['img1_kp'].size)
+
+        # The 'SAVE STAGE 2 RESULTS' block can remain as is, it will just be skipped if you load from cache
+        if args.SAVE_DIR and not args.SKIP_STAGE2:
+            print(f"Saving Stage 2 results to {stage2_dir}...")
+            for job in tqdm(inference_jobs, desc="Saving Stage 2 results"):
+                meta = job["metadata"]
+                if args.DEBUG:
+                    filename = f"DEBUG:{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+                else:
+                    filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+                save_path = os.path.join(stage2_dir, filename)
+                src_bbox = list(job["src_bbox"].values())[0]['bbox'] if job["src_bbox"] and job["src_bbox"].values() else None
+                output_data = {
+                    "metadata": meta,
+                    "full_response": job["src_response"],
+                    "extracted_semantics": job["extracted_semantics"],
+                    "source_bbox": src_bbox,
+                }
+                with open(save_path, 'w') as f:
+                    json.dump(output_data, f, indent=4)
+
+    # --- STAGE 3: BATCHED BOUNDING BOX PREDICTION (2nd Model Call) ---
+    print("\n--- Stage 3: Running batched bounding box prediction... ---")
+    if args.DEBUG:
+        # print("Debug mode enabled: Saving intermediate results to disk.")
+        print("Debug mode enabled: Using img1 for bounding box prediction.")
+        tgt_images = [job["img1"] for job in inference_jobs]
+    else:
+        tgt_images = [job["img2"] for job in inference_jobs]
+    tgt_prompts = [task_prompt_bbox.format(class_name=job["metadata"]["category"], extracted_semantics=job["extracted_semantics"]) for job in inference_jobs]
+
+    dataset_bbox = VLDataset(tgt_images, tgt_prompts)
+    loader_bbox = DataLoader(dataset_bbox, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x)
+
+    all_tgt_results = []
+    # for batch in loader_bbox:
+    for batch in tqdm(loader_bbox, desc="Processing bounding box prediction batches"):
+        images_pil, text_prompts = zip(*batch)
+        # Assuming model.predict is updated for batching
+        results = model.predict_batch(list(images_pil), list(text_prompts), system_prompt_bbox, 'object_with_conf') 
+        all_tgt_results.extend(results)
+
+    # --- SAVE STAGE 3 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 3 results to {stage3_dir}...")
+        for i, job in enumerate(tqdm(inference_jobs, desc="Saving Stage 3 results")):
+            meta = job["metadata"]
+            tgt_result = all_tgt_results[i]
+            
+            # --- NEW: Use the structured output directly ---
+            tgt_bbox_dict = tgt_result.get('bbox_with_label', {})
+            # Safely get the first prediction object from the dictionary
+            prediction = list(tgt_bbox_dict.values())[0] if tgt_bbox_dict else None
+
+            # Extract bbox and confidence
+            tgt_bbox = prediction.get('bbox') if prediction else None
+            tgt_confidence = prediction.get('confidence') if prediction else None
+            # --- END NEW ---
+
+            filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage3_dir, filename)
+            
+            output_data = {
+                "metadata": meta,
+                "full_response": tgt_result['response'],
+                "target_bbox": tgt_bbox,
+                "target_input_size": tgt_result['input_size'],
+                "target_confidence": tgt_confidence  # NEW: Save confidence to the file
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+
+
+    # --- STAGE 4: LOGGING ---
+    print("\n--- Stage 4: Plotting and logging results to WandB... ---")
+    for i, job in tqdm(enumerate(inference_jobs), total=len(inference_jobs), desc="Logging results"):
+        meta = job["metadata"]
+        src_bbox_dict = job["src_bbox"]
+        tgt_result = all_tgt_results[i]
+
+        # --- NEW: Use the structured output directly for both src and tgt ---
+        src_prediction = list(src_bbox_dict.values())[0] if src_bbox_dict else None
+        src_bbox = src_prediction.get('bbox') if src_prediction else None
+
+        tgt_bbox_dict = tgt_result.get('bbox_with_label', {})
+        tgt_prediction = list(tgt_bbox_dict.values())[0] if tgt_bbox_dict else None
+        
+        tgt_bbox = tgt_prediction.get('bbox') if tgt_prediction else None
+        tgt_confidence = tgt_prediction.get('confidence') if tgt_prediction else None
+        # --- END NEW ---
+        
+        # Create plot
+        img1_kp = job["img1_kp"]
+        img2 = job["img1"] if args.DEBUG else job["img2"]
+
+        fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+        axes[0].imshow(np.array(img1_kp))
+        axes[0].axis('off')
+        axes[0].set_title('Source Image with Keypoint')
+        axes[1].imshow(np.array(img2))
+        axes[1].axis('off')
+        axes[1].set_title('Target Image with Bounding Box')
+        
+        if src_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = src_bbox
+            axes[0].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        
+        if tgt_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = tgt_bbox
+            axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+            
+            # RECOMMENDED: Add confidence to the title for quick debugging
+            axes[1].set_title(f'Target (Conf: {tgt_confidence:.2f})')
+
+        else:
+            # RECOMMENDED: Display confidence on the plot when no box is found
+            display_text = f"Not Found (Conf: {tgt_confidence:.2f})" if tgt_confidence is not None else "Not Found"
+            axes[1].text(img2.width / 2, img2.height / 2, display_text, color='red', fontsize=12, ha='center', va='center')
+        
+        fig.tight_layout()
+        wandb_img = wandb.Image(fig)
+        plt.close(fig) 
+
+        # The column names in your table init
+        # "category", "src_id", "tgt_id", "kpt_id", "plot", "extracted_semantics", "src_response", "src_bbox", "src_input_size", "tgt_response", "tgt_bbox", "target_input_size", "tgt_bbox_conf"
+        results_table.add_data(
+            meta["category"], 
+            meta["src_id"], 
+            meta["tgt_id"], 
+            meta["kps_idx"],
+            wandb_img, 
+            job["extracted_semantics"], 
+            job["src_response"],
+            str(src_bbox),
+            job["metadata"]["src_input_size"],
+            tgt_result['response'], 
+            str(tgt_bbox),
+            tgt_result['input_size'],
+            tgt_confidence # NEW: Add the confidence value here
+        )
+    
+    wandb.log({"evaluation_results": results_table})
+
+
+# ===================================================================
+# 4. YOUR ORIGINAL `main` FUNCTION, NOW SIMPLIFIED TO CALL THE BATCHED RUNNER
+# ===================================================================
+def main(args):
+    with open(args.SYSTEM_PROMPT_SEM, 'r') as f:
+        system_prompt_sem = f.read()
+    with open(args.SYSTEM_PROMPT_BBOX, 'r') as f:
+        system_prompt_bbox = f.read()
+    with open(args.TASK_PROMPT_SEM, 'r') as f:
+        task_prompt_sem = f.read()
+    with open(args.TASK_PROMPT_BBOX, 'r') as f:
+        task_prompt_bbox = f.read()
+
+    # Initialize the Qwen VLM model
+    print("Initializing Qwen model...")
+    model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name=args.MODEL_NAME, device="auto", flash_attn=True)
+    # model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name="Qwen/Qwen2.5-VL-7B-Instruct", device="auto", flash_attn=True)
+
+    # Initialize WandB
+    print("Initializing WandB...")
+    wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    # Run the optimized evaluation
+    run_batched_evaluation(args, model, system_prompt_sem, system_prompt_bbox, task_prompt_sem, task_prompt_bbox)
+
+    print('Finished processing all categories and logging results.')
+    wandb.finish()
+    print('WandB run finished.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # ... (all your existing arguments) ...
+    parser.add_argument('--SYSTEM_PROMPT_SEM', type=str, required=True)
+    parser.add_argument('--SYSTEM_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_SEM', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    parser.add_argument('--DEBUG', action='store_true', help='Enable debug mode for verbose output.') # decouple the prediction
+    parser.add_argument('--MODEL_NAME', type=str, default='Qwen/Qwen2.5-VL-32B-Instruct', help='Model name for Qwen VLM.')
+    parser.add_argument('--SKIP_STAGE2', action='store_true', help='Skip Stage 2 and load results from SAVE_DIR.')
+    
+    # --- ADD THESE NEW ARGUMENTS for controlling batching ---
+    parser.add_argument('--BATCH_SIZE', type=int, default=4, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+
+    
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/inference_batched_with_crop.py

@@ -0,0 +1,327 @@
+import os
+import wandb
+import matplotlib.pyplot as plt
+from torch.utils.data import DataLoader
+import argparse
+import torch
+from tqdm import tqdm
+from PIL import ImageDraw, ImageFont
+import numpy as np
+import json
+
+# mutliprocessing for parallel job preparation
+import concurrent.futures
+
+# custom imports
+from dataset import get_dataset_info, VLDatasetPaired
+from utils import load_eval_data, load_img_and_kps, square_bbox_to_multiple
+from qwen_utils import QwenVLDetector
+# from inference_batched import create_image_with_one_kp_pil
+
+def create_image_with_one_kp_pil(img, query_point, circ_size=200, add_text=True, **kwargs):
+    img_with_kp = img.copy()
+    draw = ImageDraw.Draw(img_with_kp)
+    # cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+    cx, cy = query_point[0], query_point[1]
+    radius = circ_size / 10 
+    bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+    draw.ellipse(bbox, outline="red", width=4)
+
+    if add_text:
+        text = "Ref"
+        font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+        bbox_text = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox_text[2] - bbox_text[0]
+        text_height = bbox_text[3] - bbox_text[1]
+
+        text_x = cx - text_width // 2
+        text_y = cy - text_height // 2
+        draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+    return img_with_kp
+
+
+# Helper function to process a single keypoint (needed for parallelization)
+def prepare_single_job(task_args):
+    img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, kp_semantics = task_args
+
+    if img1_kps[kps_idx, 2] == 1: # double check if the keypoint is visible
+        # Use the fast, new function
+        # img1_kp = create_image_with_one_kp_pil(img1, img1_kps, kps_idx=kps_idx)
+
+        img1_bbox = square_bbox_to_multiple(kp_semantics['proposed_bbox'], multiple=14)
+        img1_crop = img1.crop(img1_bbox)
+
+        qeury_point = (img1_kps[kps_idx, 0], img1_kps[kps_idx, 1])
+        
+        return {
+            "img1": img1,
+            "img1_bbox": img1_bbox,
+            "img1_crop": img1_crop,
+            "img1_kp_semantics": kp_semantics,
+            "qeury_point": qeury_point,
+            "img2": img2,
+            "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+        }
+    return None
+
+
+def prepare_inference_job(args):
+
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    
+    # --- STAGE 1: PREPARE ALL INFERENCE JOBS FIRST ---
+    print("--- Stage 1: Preparing all inference jobs... ---")
+    # First, create a flat list of all tasks to be done
+    tasks = []
+    for category in categories:
+        # category_prompt_sem = task_prompt_sem.format(class_name=category)
+        files, kps, _, used_kps = load_eval_data(args, data_dir, category, split)
+        N = len(files) // 2
+
+        # for pair_idx in range(N):
+        for pair_idx in tqdm(range(N), desc=f"Adding {category} pairs"):
+            img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+            tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+            # print('check folder', os.listdir('./results_vlm/spair/GPT-4.1_Actor_Critic_Test_10'))
+            # print('all files:', os.listdir(args.SEM_DIR))
+
+            file_json_path = os.path.join(args.SEM_DIR, category, f"{src_id}.json")
+            sem_json = json.load(open(file_json_path, 'r'))
+            print('keys:', sem_json.keys())
+
+            # break
+            assert img1_kps.shape[0] == used_kps.shape[0], "Keypoints mismatch"
+            n_kps = img1_kps.shape[0]
+
+            for kps_idx in range(n_kps):
+                # print('this is the src_id:', src_id)
+                # print('this is the kps_idx:', kps_idx)
+                # print('img1_kps:', img1_kps[kps_idx])
+                if img1_kps[kps_idx, 2] == 1: # check if the keypoint is visible
+                    used_kps_id = used_kps[kps_idx].item()
+                    # print('used_kps_id:', used_kps_id)
+                    kp_semantics = sem_json['keypoints'][str(used_kps_id)]['actor_output']
+                    # print('kp_semantics:', kp_semantics)    
+                    tasks.append((img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, kp_semantics))
+
+    # Now, process the flat list of tasks in parallel
+    inference_jobs = []
+    # Use max_workers=None to use all available CPU cores
+    with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
+        # `map` will apply `prepare_single_job` to each item in `tasks` across multiple processes
+        # `tqdm` provides a progress bar
+        results = list(tqdm(executor.map(prepare_single_job, tasks), total=len(tasks), desc="Preparing Jobs"))
+
+    # Filter out None results (from invisible keypoints)
+    inference_jobs = [job for job in results if job is not None]
+
+    return inference_jobs
+
+
+def run_batched_evaluation(args, model, system_prompt_bbox, task_prompt_bbox, inference_jobs):
+    """
+    Runs the entire evaluation using a batched approach for maximum efficiency.
+    """
+
+    # --- Create save directories if provided ---
+    if args.SAVE_DIR:
+        stage3_dir = os.path.join(args.SAVE_DIR, "stage3_bboxes", args.EVAL_DATASET, args.EXP_NOTE)
+        os.makedirs(stage3_dir, exist_ok=True)
+        print(f"Intermediate results will be saved to: {args.SAVE_DIR}")
+
+    
+
+    print(f"Total inference jobs prepared: {len(inference_jobs)}")
+   
+
+    # --- STAGE 3: BATCHED BOUNDING BOX PREDICTION (2nd Model Call) ---
+    print("\n--- Stage 3: Running batched bounding box prediction... ---")
+
+    src_crops = [job["img1_crop"] for job in inference_jobs]
+    tgt_images = [job["img2"] for job in inference_jobs]
+    tgt_prompts = [task_prompt_bbox.format(class_name=job["metadata"]["category"], 
+                                           part_name=job["img1_kp_semantics"]['part_name'],
+                                           orientation=job["img1_kp_semantics"]['orientation'], 
+                                           spatial_location=job["img1_kp_semantics"]['spatial_location'], 
+                                           object_facing_direction=job["img1_kp_semantics"]['object_facing_direction']) for job in inference_jobs]
+
+    dataset_bbox = VLDatasetPaired(src_crops, tgt_images, tgt_prompts)
+    loader_bbox = DataLoader(dataset_bbox, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x)
+
+    all_tgt_results = []
+    # for batch in loader_bbox:
+    for batch in tqdm(loader_bbox, desc="Processing bounding box prediction batches"):
+        images1_crop_pil, images2_pil, text_prompts = zip(*batch)
+        # Assuming model.predict is updated for batching
+        results = model.predict_paired_batch(list(images1_crop_pil), list(images2_pil), list(text_prompts), system_prompt_bbox, 'self-handled') 
+        # print('results:', results)
+
+        all_tgt_results.extend(results)
+
+        if args.DEBUG:
+            break
+
+    # --- SAVE STAGE 3 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 3 results to {stage3_dir}...")
+        for i, job in enumerate(tqdm(inference_jobs, desc="Saving Stage 3 results")):
+            meta = job["metadata"]
+            tgt_result = all_tgt_results[i]
+            
+            filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage3_dir, filename)
+            output_data = {
+                "metadata": meta,
+                "target_bbox": tgt_result['img2_bbox'],
+                "visible": tgt_result['visible'],
+                'label': tgt_result['label'],
+                "crop_size": tgt_result['crop_size'],
+                "img_size": tgt_result['img_size'],
+                "full_response": tgt_result['reasoning'],
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+            if args.DEBUG:
+                break
+
+    return all_tgt_results
+
+def dict_to_string(dict_data):
+    """
+    Converts a dictionary to a string representation.
+    """
+    return ', '.join(f"{key}: {value}" for key, value in dict_data.items() if value is not None)
+
+
+def wandb_logging(inference_jobs, all_tgt_results):
+    # initialize the wandb table
+    results_table = wandb.Table(columns=["category", "src_id", "tgt_id", "kpt_id", "plot", "extracted_semantics", "src_bbox", "tgt_img_size", "src_crop_size", "tgt_response", "tgt_bbox"])
+
+    print("\n--- Stage 4: Plotting and logging results to WandB... ---")
+    # for i, job in enumerate(inference_jobs):
+
+    for i, job in tqdm(enumerate(inference_jobs), total=len(inference_jobs), desc="Logging results"):
+        meta = job["metadata"]
+        src_bbox = job["img1_bbox"]
+        tgt_result = all_tgt_results[i]
+
+        # src_bbox = list(src_bbox_dict.values())[0]['bbox'] if src_bbox_dict else None
+        # src_bbox = src
+        tgt_bbox = tgt_result['img2_bbox'] if tgt_result['visible'] else None
+        # tgt_bbox = model.predict_bounding_boxes(job["img2"], tgt_result['response'], tgt_result['input_size'])
+
+        # Create plot
+        # --- COMPLETED PLOTTING LOGIC ---
+        # Get the source and target images for plotting
+
+        img1_kp = create_image_with_one_kp_pil(job["img1"], job["qeury_point"], circ_size=200, add_text=True)
+        img2 = job["img2"]
+
+        fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+        axes[0].imshow(np.array(img1_kp))
+        axes[0].axis('off')
+        axes[0].set_title('Source Image with Keypoint')
+        axes[1].imshow(np.array(img2))
+        axes[1].axis('off')
+        axes[1].set_title('Target Image with Bounding Box')
+        if src_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = src_bbox
+            axes[0].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        
+        if tgt_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = tgt_bbox
+            axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        else:
+            axes[1].text(img2.width / 2, img2.height / 2, "No bounding box found", color='red', fontsize=12, ha='center', va='center')
+        
+        fig.tight_layout()
+
+        wandb_img = wandb.Image(fig)
+        plt.close(fig) 
+
+
+        results_table.add_data(
+            meta["category"], 
+            meta["src_id"], 
+            meta["tgt_id"], 
+            meta["kps_idx"],
+            wandb_img, 
+            dict_to_string(job["img1_kp_semantics"]), 
+            str(src_bbox),
+            str(all_tgt_results[i]['img_size']),
+            str(all_tgt_results[i]['crop_size']),
+            tgt_result['raw_response_text'], 
+            str(tgt_bbox),
+        )
+
+        if args.DEBUG:
+            break
+    
+    wandb.log({"evaluation_results": results_table})
+
+
+
+# ===================================================================
+# 4. YOUR ORIGINAL `main` FUNCTION, NOW SIMPLIFIED TO CALL THE BATCHED RUNNER
+# ===================================================================
+def main(args):
+    with open(args.SYSTEM_PROMPT_BBOX, 'r') as f:
+        system_prompt_bbox = f.read()
+    with open(args.TASK_PROMPT_BBOX, 'r') as f:
+        task_prompt_bbox = f.read()
+
+    # Initialize the Qwen VLM model
+    print("Initializing Qwen model...")
+    model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name=args.MODEL_NAME, device="auto", flash_attn=True)
+    # model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name="Qwen/Qwen2.5-VL-7B-Instruct", device="auto", flash_attn=True)
+
+    # Initialize WandB
+    print("Initializing WandB...")
+    wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    # prepare inference jobs
+    inference_jobs = prepare_inference_job(args)
+
+    # Run the optimized evaluation
+    all_tgt_results = run_batched_evaluation(args, model, system_prompt_bbox, task_prompt_bbox, inference_jobs)
+
+    # Log results to WandB
+    wandb_logging(inference_jobs, all_tgt_results)
+
+
+    print('Finished processing all categories and logging results.')
+    wandb.finish()
+    print('WandB run finished.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # ... (all your existing arguments) ...
+    parser.add_argument('--SYSTEM_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--SEM_DIR', type=str, required=True, help='Directory containing semantic annotations.')
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    
+    parser.add_argument('--DEBUG', action='store_true', help='Enable debug mode for verbose output.') # decouple the prediction
+    parser.add_argument('--MODEL_NAME', type=str, default='Qwen/Qwen2.5-VL-32B-Instruct', help='Model name for Qwen VLM.')
+    
+    # --- ADD THESE NEW ARGUMENTS for controlling batching ---
+    parser.add_argument('--BATCH_SIZE', type=int, default=4, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+
+    
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/inference_batched_with_crop_ort.py

@@ -0,0 +1,355 @@
+import os
+import wandb
+import matplotlib.pyplot as plt
+from torch.utils.data import DataLoader
+import argparse
+import torch
+from tqdm import tqdm
+from PIL import ImageDraw, ImageFont
+import numpy as np
+import json
+
+# mutliprocessing for parallel job preparation
+import concurrent.futures
+
+# custom imports
+from dataset import get_dataset_info, VLDatasetPaired
+from utils import load_eval_data, load_img_and_kps, square_bbox_to_multiple
+from qwen_utils import QwenVLDetector
+# from inference_batched import create_image_with_one_kp_pil
+from inference_gpt_actor_critic_ort_with_instruction import describe_orientation
+
+def create_image_with_one_kp_pil(img, query_point, circ_size=200, add_text=True, **kwargs):
+    img_with_kp = img.copy()
+    draw = ImageDraw.Draw(img_with_kp)
+    # cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+    cx, cy = query_point[0], query_point[1]
+    radius = circ_size / 10 
+    bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+    draw.ellipse(bbox, outline="red", width=4)
+
+    if add_text:
+        text = "Ref"
+        font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+        bbox_text = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox_text[2] - bbox_text[0]
+        text_height = bbox_text[3] - bbox_text[1]
+
+        text_x = cx - text_width // 2
+        text_y = cy - text_height // 2
+        draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+    return img_with_kp
+
+
+# Helper function to process a single keypoint (needed for parallelization)
+def prepare_single_job(task_args):
+    img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, kp_semantics, src_ort_hint, tgt_ort_hint = task_args
+
+    if img1_kps[kps_idx, 2] == 1: # double check if the keypoint is visible
+        # Use the fast, new function
+        # img1_kp = create_image_with_one_kp_pil(img1, img1_kps, kps_idx=kps_idx)
+
+        img1_bbox = square_bbox_to_multiple(kp_semantics['proposed_bbox'], multiple=14)
+        img1_crop = img1.crop(img1_bbox)
+
+        qeury_point = (img1_kps[kps_idx, 0], img1_kps[kps_idx, 1])
+        
+        return {
+            "img1": img1,
+            "img1_bbox": img1_bbox,
+            "img1_crop": img1_crop,
+            "img1_kp_semantics": kp_semantics,
+            "src_ort_hint": src_ort_hint,
+            "tgt_ort_hint": tgt_ort_hint,
+            "qeury_point": qeury_point,
+            "img2": img2,
+            "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+        }
+    return None
+
+
+def prepare_inference_job(args):
+
+    data_dir, categories, split = get_dataset_info(args, split='test')
+    
+    # --- STAGE 1: PREPARE ALL INFERENCE JOBS FIRST ---
+    print("--- Stage 1: Preparing all inference jobs... ---")
+    # First, create a flat list of all tasks to be done
+    tasks = []
+    for category in categories:
+        # category_prompt_sem = task_prompt_sem.format(class_name=category)
+        files, kps, _, used_kps = load_eval_data(args, data_dir, category, split)
+        N = len(files) // 2
+
+        # for pair_idx in range(N):
+        for pair_idx in tqdm(range(N), desc=f"Adding {category} pairs"):
+            img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            img2, _ = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE)
+            src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+            tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+            # print('check folder', os.listdir('./results_vlm/spair/GPT-4.1_Actor_Critic_Test_10'))
+            # print('all files:', os.listdir(args.SEM_DIR))
+
+            file_json_path = os.path.join(args.SEM_DIR, category, f"{src_id}.json")
+            sem_json = json.load(open(file_json_path, 'r'))
+            print('keys:', sem_json.keys())
+
+            src_ort_hint_path = os.path.join(args.ORIENTATION_DIR, category, f"{src_id}.json")
+            tgt_ort_hint_path = os.path.join(args.ORIENTATION_DIR, category, f"{tgt_id}.json")
+
+            with open(src_ort_hint_path, 'r') as f:
+                src_orientation_json = json.load(f)
+            
+            with open(tgt_ort_hint_path, 'r') as f:
+                tgt_orientation_json = json.load(f)
+
+            src_ort_hint = str(describe_orientation(
+                azimuth=src_orientation_json.get("azimuth"),
+                polar=src_orientation_json.get("polar"),
+                confidence=src_orientation_json.get("confidence")
+            ))
+            tgt_ort_hint = str(describe_orientation(
+                azimuth=tgt_orientation_json.get("azimuth"),
+                polar=tgt_orientation_json.get("polar"),
+                confidence=tgt_orientation_json.get("confidence")
+            ))
+
+            # break
+            assert img1_kps.shape[0] == used_kps.shape[0], "Keypoints mismatch"
+            n_kps = img1_kps.shape[0]
+
+            for kps_idx in range(n_kps):
+                # print('this is the src_id:', src_id)
+                # print('this is the kps_idx:', kps_idx)
+                # print('img1_kps:', img1_kps[kps_idx])
+                if img1_kps[kps_idx, 2] == 1: # check if the keypoint is visible
+                    used_kps_id = used_kps[kps_idx].item()
+                    # print('used_kps_id:', used_kps_id)
+                    kp_semantics = sem_json['keypoints'][str(used_kps_id)]['actor_output']
+                    # print('kp_semantics:', kp_semantics)    
+                    tasks.append((img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, kp_semantics, src_ort_hint, tgt_ort_hint))
+
+    # Now, process the flat list of tasks in parallel
+    inference_jobs = []
+    # Use max_workers=None to use all available CPU cores
+    with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
+        # `map` will apply `prepare_single_job` to each item in `tasks` across multiple processes
+        # `tqdm` provides a progress bar
+        results = list(tqdm(executor.map(prepare_single_job, tasks), total=len(tasks), desc="Preparing Jobs"))
+
+    # Filter out None results (from invisible keypoints)
+    inference_jobs = [job for job in results if job is not None]
+
+    return inference_jobs
+
+
+def run_batched_evaluation(args, model, system_prompt_bbox, task_prompt_bbox, inference_jobs):
+    """
+    Runs the entire evaluation using a batched approach for maximum efficiency.
+    """
+
+    # --- Create save directories if provided ---
+    if args.SAVE_DIR:
+        stage3_dir = os.path.join(args.SAVE_DIR, "stage3_bboxes", args.EVAL_DATASET, args.EXP_NOTE)
+        os.makedirs(stage3_dir, exist_ok=True)
+        print(f"Intermediate results will be saved to: {args.SAVE_DIR}")
+
+    
+
+    print(f"Total inference jobs prepared: {len(inference_jobs)}")
+   
+
+    # --- STAGE 3: BATCHED BOUNDING BOX PREDICTION (2nd Model Call) ---
+    print("\n--- Stage 3: Running batched bounding box prediction... ---")
+
+    src_crops = [job["img1_crop"] for job in inference_jobs]
+    tgt_images = [job["img2"] for job in inference_jobs]
+    tgt_prompts = [task_prompt_bbox.format(class_name=job["metadata"]["category"], 
+                                           part_name=job["img1_kp_semantics"]['part_name'],
+                                           part_location=job["img1_kp_semantics"]['part_location'], 
+                                           spatial_location=job["img1_kp_semantics"]['spatial_location'], 
+                                           object_facing_direction=job["img1_kp_semantics"]['object_facing_direction'],
+                                           orientation_hint_src=job["src_ort_hint"],orientation_hint_tgt=job["tgt_ort_hint"])
+                                        for job in inference_jobs]
+
+    dataset_bbox = VLDatasetPaired(src_crops, tgt_images, tgt_prompts)
+    loader_bbox = DataLoader(dataset_bbox, batch_size=args.BATCH_SIZE, num_workers=args.NUM_WORKERS, collate_fn=lambda x: x)
+
+    all_tgt_results = []
+    # for batch in loader_bbox:
+    for batch in tqdm(loader_bbox, desc="Processing bounding box prediction batches"):
+        images1_crop_pil, images2_pil, text_prompts = zip(*batch)
+        # Assuming model.predict is updated for batching
+        results = model.predict_paired_batch(list(images1_crop_pil), list(images2_pil), list(text_prompts), system_prompt_bbox, 'self-handled') 
+        # print('results:', results)
+
+        all_tgt_results.extend(results)
+
+        if args.DEBUG:
+            break
+
+    # --- SAVE STAGE 3 RESULTS IMMEDIATELY ---
+    if args.SAVE_DIR:
+        print(f"Saving Stage 3 results to {stage3_dir}...")
+        for i, job in enumerate(tqdm(inference_jobs, desc="Saving Stage 3 results")):
+            meta = job["metadata"]
+            tgt_result = all_tgt_results[i]
+            
+            filename = f"{meta['category']}_{meta['src_id']}_{meta['tgt_id']}_kps{meta['kps_idx']}.json"
+            save_path = os.path.join(stage3_dir, filename)
+            output_data = {
+                "metadata": meta,
+                "target_bbox": tgt_result['img2_bbox'],
+                "visible": tgt_result['visible'],
+                'label': tgt_result['label'],
+                "crop_size": tgt_result['crop_size'],
+                "img_size": tgt_result['img_size'],
+                "full_response": tgt_result['reasoning'],
+            }
+            with open(save_path, 'w') as f:
+                json.dump(output_data, f, indent=4)
+
+            if args.DEBUG:
+                break
+
+    return all_tgt_results
+
+def dict_to_string(dict_data):
+    """
+    Converts a dictionary to a string representation.
+    """
+    return ', '.join(f"{key}: {value}" for key, value in dict_data.items() if value is not None)
+
+
+def wandb_logging(inference_jobs, all_tgt_results):
+    # initialize the wandb table
+    results_table = wandb.Table(columns=["category", "src_id", "tgt_id", "kpt_id", "plot", "extracted_semantics", "src_bbox", "tgt_img_size", "src_crop_size", "tgt_response", "tgt_bbox", "src_ort_hint", "tgt_ort_hint"])
+
+    print("\n--- Stage 4: Plotting and logging results to WandB... ---")
+    # for i, job in enumerate(inference_jobs):
+
+    for i, job in tqdm(enumerate(inference_jobs), total=len(inference_jobs), desc="Logging results"):
+        meta = job["metadata"]
+        src_bbox = job["img1_bbox"]
+        tgt_result = all_tgt_results[i]
+
+        # src_bbox = list(src_bbox_dict.values())[0]['bbox'] if src_bbox_dict else None
+        # src_bbox = src
+        tgt_bbox = tgt_result['img2_bbox'] if tgt_result['visible'] else None
+        # tgt_bbox = model.predict_bounding_boxes(job["img2"], tgt_result['response'], tgt_result['input_size'])
+
+        # Create plot
+        # --- COMPLETED PLOTTING LOGIC ---
+        # Get the source and target images for plotting
+
+        img1_kp = create_image_with_one_kp_pil(job["img1"], job["qeury_point"], circ_size=200, add_text=True)
+        img2 = job["img2"]
+
+        fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+        axes[0].imshow(np.array(img1_kp))
+        axes[0].axis('off')
+        axes[0].set_title('Source Image with Keypoint')
+        axes[1].imshow(np.array(img2))
+        axes[1].axis('off')
+        axes[1].set_title('Target Image with Bounding Box')
+        if src_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = src_bbox
+            axes[0].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        
+        if tgt_bbox:
+            abs_x1, abs_y1, abs_x2, abs_y2 = tgt_bbox
+            axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+        else:
+            axes[1].text(img2.width / 2, img2.height / 2, "No bounding box found", color='red', fontsize=12, ha='center', va='center')
+        
+        fig.tight_layout()
+
+        wandb_img = wandb.Image(fig)
+        plt.close(fig) 
+
+
+        results_table.add_data(
+            meta["category"], 
+            meta["src_id"], 
+            meta["tgt_id"], 
+            meta["kps_idx"],
+            wandb_img, 
+            dict_to_string(job["img1_kp_semantics"]), 
+            str(src_bbox),
+            str(all_tgt_results[i]['img_size']),
+            str(all_tgt_results[i]['crop_size']),
+            tgt_result['raw_response_text'], 
+            str(tgt_bbox),
+            job["src_ort_hint"],
+            job["tgt_ort_hint"]
+        )
+
+        if args.DEBUG:
+            break
+    
+    wandb.log({"evaluation_results": results_table})
+
+
+
+# ===================================================================
+# 4. YOUR ORIGINAL `main` FUNCTION, NOW SIMPLIFIED TO CALL THE BATCHED RUNNER
+# ===================================================================
+def main(args):
+    with open(args.SYSTEM_PROMPT_BBOX, 'r') as f:
+        system_prompt_bbox = f.read()
+    with open(args.TASK_PROMPT_BBOX, 'r') as f:
+        task_prompt_bbox = f.read()
+
+    # Initialize the Qwen VLM model
+    print("Initializing Qwen model...")
+    model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name=args.MODEL_NAME, device="auto", flash_attn=True)
+    # model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name="Qwen/Qwen2.5-VL-7B-Instruct", device="auto", flash_attn=True)
+
+    # Initialize WandB
+    print("Initializing WandB...")
+    wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    # prepare inference jobs
+    inference_jobs = prepare_inference_job(args)
+
+    # Run the optimized evaluation
+    all_tgt_results = run_batched_evaluation(args, model, system_prompt_bbox, task_prompt_bbox, inference_jobs)
+
+    # Log results to WandB
+    wandb_logging(inference_jobs, all_tgt_results)
+
+
+    print('Finished processing all categories and logging results.')
+    wandb.finish()
+    print('WandB run finished.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # ... (all your existing arguments) ...
+    parser.add_argument('--SYSTEM_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT_BBOX', type=str, required=True)
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--SEM_DIR', type=str, required=True, help='Directory containing semantic annotations.')
+    parser.add_argument('--ORIENTATION_DIR', type=str, default=None, help='Directory containing orientation annotations.')
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    
+    parser.add_argument('--DEBUG', action='store_true', help='Enable debug mode for verbose output.') # decouple the prediction
+    parser.add_argument('--MODEL_NAME', type=str, default='Qwen/Qwen2.5-VL-32B-Instruct', help='Model name for Qwen VLM.')
+    
+    # --- ADD THESE NEW ARGUMENTS for controlling batching ---
+    parser.add_argument('--BATCH_SIZE', type=int, default=4, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+
+    
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/inference_gpt_actor_critic.py

@@ -0,0 +1,403 @@
+import argparse
+import wandb
+from PIL import Image
+from typing import Dict, Any, Tuple, Optional
+import openai
+import json
+import time
+from tqdm import tqdm
+import numpy as np
+import os
+import logging
+
+# custom imports
+from utils_actor_critic import _actor_prompt, _critic_prompt, _encode_image_to_data_url, _make_overlay, _extract_json, save_actor_critic_output, check_if_done, get_existing_result
+from dataset import get_dataset_info
+from utils import load_eval_data, resize, load_img_and_kps
+from openai_api_key import OPENAI_API_KEY
+
+
+PART_VOCAB = {
+    "boat": ["hull", "bow", "stern", "mast", "sail", "trampoline", "rudder"],
+    "car": ["hood", "trunk", "roof", "wheel", "door", "bumper", "windshield"],
+    "person": ["head", "face", "arm", "hand", "leg", "torso", "foot"],
+    "dog": ["head", "snout", "ear", "leg", "tail", "torso"],
+    "bicycle": ["wheel", "handlebar", "pedal", "seat", "frame", "chain"],
+    "aeroplane": ["wing", "fuselage", "cockpit", "engine", "tail", "nose", "landing gear"],
+    "bus": ["wheel", "door", "window", "roof", "headlight", "rear", "side panel"],
+    "motorbike": ["wheel", "seat", "handlebar", "exhaust", "headlight", "fuel tank"],
+    "chair": ["seat", "backrest", "leg", "armrest"],
+    "tvmonitor": ["screen", "bezel", "stand", "corner"],
+    "train": ["car", "cabin", "roof", "window", "door", "headlight", "wheel"],
+    "bird": ["head", "beak", "wing", "tail", "foot", "eye"],
+    "sheep": ["head", "leg", "torso", "tail", "ear"],
+    "horse": ["head", "mane", "leg", "tail", "torso"],
+    "cow": ["head", "horn", "leg", "torso", "tail", "ear"],
+    "bottle": ["cap", "neck", "body", "base", "shoulder"],
+    "pottedplant": ["pot", "stem", "leaf", "flower"],
+    "cat": ["head", "ear", "paw", "tail", "torso", "eye"],
+}
+
+def _call_gpt4o_vision(
+    image: Image.Image,
+    prompt: str,
+    model: str = "gpt-4o-mini",  # or "gpt-4o" / "gpt-4o-audio-video-preview"
+    max_tokens: int = 256,
+    timeout: int = 120,
+    temperature: float = 0.2,
+    reasoning_effort: str = "minimal",
+) -> str:
+    """
+    One-shot vision query. Returns raw assistant text.
+
+    OpenAI chat messages with images follow the documented format:
+    [{role:"user", content:[{type:"image_url",image_url:{url:data_url}}, {type:"text",text:prompt}]}] :contentReference[oaicite:0]{index=0}
+    """
+    client = openai.OpenAI(api_key=OPENAI_API_KEY)
+
+    data_url = _encode_image_to_data_url(image)
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": data_url}},
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+
+    if model == 'gpt-5':
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            # temperature=temperature,
+            reasoning_effort=reasoning_effort,
+        )
+    else:        
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+    
+    return response.choices[0].message.content
+
+
+def _call_gpt4o_critic(
+    crop_img: Image.Image,
+    overlay_img: Image.Image,
+    prompt_text: str,
+    model: str = "gpt-4o-mini",
+    max_tokens: int = 256,
+    temperature: float = 0.2,
+    reasoning_effort: str = "minimal",
+) -> str:
+    """Send crop + overlay + text prompt to GPT-4o and return raw text."""
+    client = openai.OpenAI(api_key=OPENAI_API_KEY)
+
+    crop_url     = _encode_image_to_data_url(crop_img)
+    overlay_url  = _encode_image_to_data_url(overlay_img)
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": crop_url}},
+                {"type": "image_url", "image_url": {"url": overlay_url}},
+                {"type": "text",      "text": prompt_text},
+            ],
+        }
+    ]
+    # resp = client.chat.completions.create(
+    #     model=model,
+    #     messages=messages,
+    #     max_tokens=max_tokens,
+    #     temperature=temperature,
+    # )
+
+    if model == 'gpt-5':
+        resp = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            reasoning_effort=reasoning_effort,
+            # temperature=temperature,
+        )
+    else:        
+        resp = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+    
+    return resp.choices[0].message.content
+
+
+def actor_describe(
+    image: Image.Image,
+    point: Tuple[int, int],
+    class_name: str,
+    feedback: Optional[str] = None,
+    previous_json: Optional[Dict[str, Any]] = None,
+    model: str = "gpt-4o-mini",
+    max_tokens: int = 1024,
+    reasoning_effort: str = "minimal",
+    orientation_hint: str | None = None,
+) -> Optional[Dict[str, Any]]:
+    """
+    Run GPT-4o Vision as the ‘actor’.
+
+    • `feedback` …… critic’s message, or None on first pass  
+    • `previous_json` …… actor’s last JSON (shown to model on revision)  
+    """
+    x, y = point
+    prompt = _actor_prompt(x, y, class_name, feedback, previous_json)  # ← NEW arg
+    if class_name.lower() in PART_VOCAB:
+        parts = PART_VOCAB[class_name.lower()]
+        part_list = ", ".join(f'"{p}"' for p in parts)
+        prompt += (
+            f"\n\nReference part vocabulary for '{class_name}':\n"
+            f"{part_list}\n"
+            "Try to choose the most specific valid part_name from this list."
+        )
+
+    raw = _call_gpt4o_vision(image, prompt, model=model, max_tokens=max_tokens, reasoning_effort=reasoning_effort)
+    return _extract_json(raw)
+
+
+def critic_check(
+    image: Image.Image,
+    point: Tuple[int, int],
+    description_json: Dict[str, Any],
+    class_name: str,
+    model: str = "gpt-4o-mini",
+    orientation_hint: str | None = None,
+    hypothesis: str | None = None,
+    reasoning_effort: str = "minimal",
+) -> Dict[str, Any]:
+    """Run the critic with crop + overlay."""
+    x, y = point
+    bbox = description_json.get("proposed_bbox", [0, 0, 0, 0])
+    crop  = image.crop(bbox)
+    overlay = _make_overlay(image, point, bbox)
+
+    prompt = _critic_prompt(
+        description_json, class_name, x, y,
+        orientation_hint=orientation_hint,
+        hypothesis=hypothesis,
+    )
+
+    if class_name.lower() in PART_VOCAB:
+        parts = PART_VOCAB[class_name.lower()]
+        prompt += f"\nReference part names for a '{class_name}': {', '.join(parts)}, choose the closest match. (e.g. front right of starboard hull should be bow)"
+
+    raw = _call_gpt4o_critic(crop, overlay, prompt, model=model, max_tokens=256, reasoning_effort=reasoning_effort)
+    parsed = _extract_json(raw)
+    if not parsed:
+        return {"is_consistent": False, "reason": "Critic returned invalid JSON."}
+    return parsed
+
+def actor_critic_refine(
+    # image_path: str,
+    img: Image.Image,
+    point: Tuple[int, int],
+    class_name: str,
+    max_iters: int = 3,
+    model: str = "gpt-4o-mini",
+    reasoning_effort: str = "minimal",
+) -> Optional[Dict[str, Any]]:
+    """
+    Repeatedly run actor → critic until agreement or max_iters reached.
+    Returns final accepted description (or last attempt on failure).
+    """
+    # img = Image.open(image_path).convert("RGB")
+    # img = resize(img, args.ANNO_SIZE)  # ensure consistent size
+    feedback = None
+    final_desc = None
+
+    print("\n=== Actor-Critic Self-Refine ===")
+    for i in range(max_iters):
+        print(f"\n--- Iteration {i+1}/{max_iters} ---")
+        # ---------- Python-side geometry check ---------- #
+        
+        desc = actor_describe(
+            img,
+            point,
+            class_name,
+            feedback=feedback,
+            previous_json=final_desc,   # ← pass last JSON back in
+            model=model,
+            reasoning_effort=reasoning_effort,
+        )
+
+        x, y = point
+        proposed_bbox = desc.get("proposed_bbox", [])
+        x1, y1, x2, y2 = proposed_bbox
+        inside = (x1 < x < x2) and (y1 < y < y2)
+
+        if not inside:
+            feedback = "Keypoint not inside proposed_bbox."
+            print("Geometry check failed:", feedback)
+            continue # skip critic check if geometry is wrong
+
+        # print('this is the proposed bbox', proposed_bbox)
+        # print('this is the type of the bbox', type(proposed_bbox))
+
+        if not desc:
+            print("Actor failed to return JSON; abort.")
+            break
+        print("Actor:", json.dumps(desc, indent=2, ensure_ascii=False))
+        final_desc = desc
+
+        # print('this is the desc', desc)
+
+        report = critic_check(img, point, desc, class_name, model, reasoning_effort=reasoning_effort)
+        print("Critic:", json.dumps(report, indent=2, ensure_ascii=False))
+
+        if report.get("is_consistent"):
+            print("Agreement reached.")
+            return final_desc, report
+
+        feedback = report.get("reason", "Description inconsistent.")
+        print("Revising…")
+        # time.sleep(1)  # avoid rapid-fire rate-limit hits
+
+    print("Max iterations exhausted.")
+    return final_desc, report
+
+def main(args):
+    run = wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    columns = [
+        "category", 
+        "img_id", 
+        "kpt_id",
+        "preview", 
+        "part_name",
+        "orientation",
+        "spatial_location",
+        "object_facing_direction",
+        "bbox",
+        "actor_desc",
+        "critic_report",
+    ]
+
+    results_tb = wandb.Table(columns=columns)
+
+    data_dir, categories, split = get_dataset_info(args, split="test")
+    for cat in categories:
+        files, kps, _, used_kps = load_eval_data(args, data_dir, cat, split)
+        N = len(files) // 2
+        for pair_idx in tqdm(range(N), desc=f"Processing {cat}"):
+            img1, img1_kps = load_img_and_kps(
+                idx=2 * pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE
+            )
+
+            assert img1_kps.shape[0] == used_kps.shape[0], "Keypoints mismatch"
+            n_kps = img1_kps.shape[0]
+
+            for kps_idx in range(n_kps):
+                # If the query point is zero, skip it entirely
+                if np.all(img1_kps[kps_idx, :2].numpy() == (0,0)):
+                    continue
+                
+                # --- CHANGED: Define all identifiers upfront ---
+                used_kps_id = used_kps[kps_idx].item()
+                img_id = files[2 * pair_idx].split("/")[-1]
+                save_directory = os.path.join(args.SAVE_DIR, args.EVAL_DATASET, args.EXP_NOTE)
+                query_kp = tuple(img1_kps[kps_idx, :2].numpy())
+                
+                # Initialize descriptors
+                actor_desc = None
+                critic_report = None
+
+                # --- CHANGED: Use the new getter function ---
+                existing_result = get_existing_result(
+                    save_dir=save_directory, category=cat, image_id=img_id, kpt_id=used_kps_id
+                )
+
+                if existing_result:
+                    print(f"Found existing result for kpt_id {used_kps_id} in {img_id}. Logging it.")
+                    # Load data from the file
+                    actor_desc = existing_result.get("actor_output")
+                    critic_report = existing_result.get("critic_output")
+                else:
+                    print(f"Processing new kpt_id {used_kps_id} for {img_id}.")
+                    # This expensive part now only runs if the result doesn't exist
+                    new_actor_desc, new_critic_report = actor_critic_refine(
+                        img=img1,
+                        point=query_kp,
+                        class_name=cat.lower(),
+                        max_iters=args.MAX_ITERS,
+                        model=args.MODEL_NAME,
+                    )
+
+                    # Handle cases where the actor/critic might fail
+                    if not new_actor_desc or not new_critic_report:
+                        print(f"Actor/Critic failed for kpt {used_kps_id} on {img_id}. Skipping.")
+                        continue
+                    
+                    # Assign to the main variables
+                    actor_desc = new_actor_desc
+                    critic_report = new_critic_report
+                    
+                    # Save the new result
+                    save_actor_critic_output(
+                        save_dir=save_directory,
+                        category=cat,
+                        image_id=img_id,
+                        kpt_id=used_kps_id,
+                        query_point=(int(query_kp[0]), int(query_kp[1])),
+                        actor_desc=actor_desc,
+                        critic_report=critic_report,
+                        model_name=args.MODEL_NAME
+                    )
+
+                # --- CHANGED: Unified logging for both new and existing results ---
+                if actor_desc and critic_report:
+                    bbox = actor_desc.get("proposed_bbox", [])
+                    img1_preview = wandb.Image(_make_overlay(img1, query_kp, bbox), caption=f"Keypoint {query_kp}")
+                    results_tb.add_data(
+                        cat,
+                        img_id,
+                        used_kps_id,
+                        img1_preview,
+                        actor_desc.get("part_name", ""),
+                        actor_desc.get("orientation", ""),
+                        actor_desc.get("spatial_location", ""),
+                        actor_desc.get("object_facing_direction", ""),
+                        actor_desc.get("proposed_bbox", []),
+                        json.dumps(actor_desc, ensure_ascii=False),
+                        json.dumps(critic_report, ensure_ascii=False),
+                    )
+            #         break
+            # break
+
+    # Save results to WandB
+    run.log({"results": results_tb})
+    wandb.finish()
+    # pass
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the Actor-Critic model for inference.")
+    parser.add_argument('--MODEL_NAME', type=str, default='gpt-4.1', help='Model name to use for inference.')
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    parser.add_argument('--EVAL_DATASET', type=str, default='spair', help='Dataset to evaluate on.')
+    parser.add_argument('--MAX_ITERS', type=int, default=5, help='Maximum iterations for actor-critic refinement.')
+
+    parser.add_argument('--BATCH_SIZE', type=int, default=16, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+    parser.add_argument('--CONCURRENCY', type=int, default=8, help='Number of concurrent requests to OpenAI API.')
+
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/inference_gpt_actor_critic_ort_with_instruction.py

@@ -0,0 +1,535 @@
+import argparse
+import wandb
+from PIL import Image
+from typing import Dict, Any, Tuple, Optional
+import openai
+import json
+import time
+from tqdm import tqdm
+import numpy as np
+import os
+import logging
+
+# custom imports
+from utils_actor_critic_with_ort import _actor_prompt, _critic_prompt, _encode_image_to_data_url, _make_overlay, _extract_json, save_actor_critic_output, check_if_done, get_existing_result, get_all_parts_from_schema
+from dataset import get_dataset_info
+from utils import load_eval_data, resize, load_img_and_kps
+from openai_api_key import OPENAI_API_KEY
+from part_dictionary import PART_SCHEMA
+
+
+def _call_gpt4o_vision(
+    image: Image.Image,
+    prompt: str,
+    model: str = "gpt-4o-mini",  # or "gpt-4o" / "gpt-4o-audio-video-preview"
+    max_tokens: int = 256,
+    timeout: int = 120,
+    temperature: float = 0.2,
+    reasoning_effort: str = "minimal",
+) -> str:
+    """
+    One-shot vision query. Returns raw assistant text.
+
+    OpenAI chat messages with images follow the documented format:
+    [{role:"user", content:[{type:"image_url",image_url:{url:data_url}}, {type:"text",text:prompt}]}] :contentReference[oaicite:0]{index=0}
+    """
+    client = openai.OpenAI(api_key=OPENAI_API_KEY)
+
+    data_url = _encode_image_to_data_url(image)
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": data_url}},
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+
+    if model == 'gpt-5':
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            # temperature=temperature,
+            reasoning_effort=reasoning_effort,
+        )
+    else:        
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+    
+    return response.choices[0].message.content
+
+
+def _call_gpt4o_critic(
+    crop_img: Image.Image,
+    overlay_img: Image.Image,
+    prompt_text: str,
+    model: str = "gpt-4o-mini",
+    max_tokens: int = 256,
+    temperature: float = 0.2,
+    reasoning_effort: str = "minimal",
+) -> str:
+    """Send crop + overlay + text prompt to GPT-4o and return raw text."""
+    client = openai.OpenAI(api_key=OPENAI_API_KEY)
+
+    crop_url     = _encode_image_to_data_url(crop_img)
+    overlay_url  = _encode_image_to_data_url(overlay_img)
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": crop_url}},
+                {"type": "image_url", "image_url": {"url": overlay_url}},
+                {"type": "text",      "text": prompt_text},
+            ],
+        }
+    ]
+    # resp = client.chat.completions.create(
+    #     model=model,
+    #     messages=messages,
+    #     max_tokens=max_tokens,
+    #     temperature=temperature,
+    # )
+
+    if model == 'gpt-5':
+        resp = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            reasoning_effort=reasoning_effort,
+            # temperature=temperature,
+        )
+    else:        
+        resp = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+    
+    return resp.choices[0].message.content
+
+
+def actor_describe(
+    image: Image.Image,
+    point: Tuple[int, int],
+    class_name: str,
+    feedback: Optional[str] = None,
+    previous_json: Optional[Dict[str, Any]] = None,
+    model: str = "gpt-4o-mini",
+    max_tokens: int = 1024,
+    reasoning_effort: str = "low",
+    orientation_hint: str | None = None,
+    part_schema: Dict[str, Any] = PART_SCHEMA,
+) -> Optional[Dict[str, Any]]:
+    """
+    Run GPT-4o Vision as the ‘actor’.
+
+    • `feedback` …… critic’s message, or None on first pass  
+    • `previous_json` …… actor’s last JSON (shown to model on revision)  
+    """
+    x, y = point
+    prompt = _actor_prompt(
+        x=x, 
+        y=y, 
+        class_name=class_name, 
+        feedback=feedback, 
+        previous_json=previous_json, 
+        orientation_hint=orientation_hint, 
+        part_schema=part_schema, 
+        )  # ← NEW arg
+    print(f"\nActor prompt:\n{prompt}\n")
+    # if class_name.lower() in PART_VOCAB:
+    #     parts = PART_VOCAB[class_name.lower()]
+    #     part_list = ", ".join(f'"{p}"' for p in parts)
+    #     prompt += (
+    #         f"\n\nReference part vocabulary for '{class_name}':\n"
+    #         f"{part_list}\n"
+    #         "Try to choose the most specific valid part_name from this list."
+    #     )
+    class_specific_schema = part_schema.get(class_name.lower())
+    if class_specific_schema:
+        # Generate a flat list of ALL valid parts using the helper function
+        all_parts = get_all_parts_from_schema(class_specific_schema)
+        
+        # Create a clean, sorted, unique list for the prompt
+        part_list_str = ", ".join(f'"{p}"' for p in sorted(list(set(all_parts))))
+
+        # Append the reference vocabulary to the prompt
+        prompt += (
+            f"\n\n---"
+            f"\n## Reference Vocabulary\n"
+            f"You are ENCOURAGED to choose the `part_name` from this official list for a '{class_name}':\n"
+            f"[{part_list_str}]"
+        )
+
+
+    raw = _call_gpt4o_vision(image, prompt, model=model, max_tokens=max_tokens, reasoning_effort=reasoning_effort)
+    return _extract_json(raw)
+
+
+def critic_check(
+    image: Image.Image,
+    point: Tuple[int, int],
+    description_json: Dict[str, Any],
+    class_name: str,
+    model: str = "gpt-4o-mini",
+    orientation_hint: str | None = None,
+    reasoning_effort: str = "minimal",
+    part_schema: Dict[str, Any] = PART_SCHEMA,
+) -> Dict[str, Any]:
+    """Run the critic with crop + overlay."""
+    x, y = point
+    bbox = description_json.get("proposed_bbox", [0, 0, 0, 0])
+    crop  = image.crop(bbox)
+    overlay = _make_overlay(image, point, bbox)
+
+    prompt = _critic_prompt(
+        description_json, class_name, x, y,
+        orientation_hint=orientation_hint,
+        part_schema=part_schema,  # pass the schema for dynamic instructions
+    )
+
+    print(f"\nCritic prompt:\n{prompt}\n")
+
+    raw = _call_gpt4o_critic(crop, overlay, prompt, model=model, max_tokens=256, reasoning_effort=reasoning_effort)
+    parsed = _extract_json(raw)
+    if not parsed:
+        return {"is_consistent": False, "reason": "Critic returned invalid JSON."}
+    return parsed
+
+
+def _score_feedback(feedback_type: str) -> int:
+    """Scores the quality of the critic's feedback type."""
+    score_map = {
+        "Approved": 4,              # Perfect: Correct and specific.
+        "Go Deeper": 3,             # Excellent: Correct part, just needs refinement.
+        "Check Other Children": 2,  # Good: Wrong guess, but the anchor is correct.
+        "Geometric Error": 2,       # Good: Correct part, but location is wrong.
+        "Go Back": 1,               # Bad: Fundamentally wrong part.
+    }
+    return score_map.get(feedback_type, 0) # Default to 0 for any unknown type
+
+
+def actor_critic_refine(
+    # image_path: str,
+    img: Image.Image,
+    point: Tuple[int, int],
+    class_name: str,
+    max_iters: int = 3,
+    model: str = "gpt-4o-mini",
+    orientation_hint: Optional[str] = None,
+    reasoning_effort: str = "low",  # NEW ARG
+    part_schema: Dict[str, Any] = PART_SCHEMA,  # pass the schema for dynamic instructions
+) -> Optional[Dict[str, Any]]:
+    """
+    Repeatedly run actor → critic until agreement or max_iters reached.
+    Returns final accepted description (or last attempt on failure).
+    """
+    # img = Image.open(image_path).convert("RGB")
+    # img = resize(img, args.ANNO_SIZE)  # ensure consistent size
+    feedback = None
+
+    # set tracking variables
+    best_desc = None
+    prev_desc = None
+    best_desc_score = 0 # Start with the lowest possible score
+
+    print("I am using the new function")
+
+    print("\n=== Actor-Critic Self-Refine ===")
+    for i in range(max_iters):
+        print(f"\n--- Iteration {i+1}/{max_iters} ---")
+        # ---------- Python-side geometry check ---------- #
+        
+        current_desc = actor_describe(
+            img,
+            point,
+            class_name,
+            feedback=feedback,
+            previous_json=prev_desc,   # ← pass last JSON back in
+            model=model,
+            orientation_hint=orientation_hint,  # NEW ARG
+            reasoning_effort=reasoning_effort,  # NEW ARG
+            part_schema=part_schema,  # pass the schema for dynamic instructions
+        )
+
+        if not current_desc:
+            print("Actor failed to return JSON; abort.")
+            break
+        prev_desc = current_desc  # Store the last description for the next iteration
+
+        print('current output from actor:', current_desc)
+
+        x, y = point
+        proposed_bbox = current_desc.get("proposed_bbox", [])
+        x1, y1, x2, y2 = proposed_bbox
+        inside = (x1 < x < x2) and (y1 < y < y2)
+
+        print('proposed bbox:', proposed_bbox)
+        print('point:', point)
+
+        if not inside:
+            feedback = f"Keypoint not inside proposed_bbox."
+            print("Geometry check failed:", feedback)
+            continue # skip critic check if geometry is wrong
+
+
+        report = critic_check(
+            img, 
+            point, 
+            current_desc, 
+            class_name, 
+            model, 
+            orientation_hint=orientation_hint, 
+            reasoning_effort=reasoning_effort, 
+            part_schema=part_schema,
+        )
+        print("Critic report:", json.dumps(report, indent=2, ensure_ascii=False))
+
+
+        # --- NEW: Score and State Management ---
+        feedback_type = report.get("feedback_type", "Go Back") # Default to worst case
+        current_score = _score_feedback(feedback_type)
+        print(f"Iteration Score: {current_score} (Feedback: {feedback_type})")
+
+        if current_score >= best_desc_score:
+            print(f"Found new best description (Score: {current_score} >= {best_desc_score}).")
+            best_desc = current_desc
+            best_desc_score = current_score
+
+        # Check for success
+        if feedback_type == "Approved":
+            print("Agreement reached.")
+            return best_desc, report
+
+        feedback = report.get("reason", "Description inconsistent.")
+        print("Revising…")
+        print(f"Feedback for next actor: {feedback}")
+        # time.sleep(1)  # avoid rapid-fire rate-limit hits
+
+    print("Max iterations exhausted.")
+    return best_desc, report
+
+
+def describe_orientation(azimuth: float, polar: float, *, confidence: float | None = None) -> Dict:
+    """
+    azimuth: yaw in degrees, 0 = toward viewer, 90 = facing left, 180 = away, 270 = facing right
+    polar  : elevation in degrees; + up (top view), - down (bottom view); 0 ≈ side
+    returns a structured viewer-centric hint
+    """
+    # az = _bucket_angle(azimuth)
+    assert azimuth >= 0 and azimuth < 360, "Azimuth must be in the range [0, 360)"
+    az = azimuth
+    po = polar
+
+    # ---- Facing & yaw_bias ---------------------------------------------------
+    # Main facing from octants; diagonals become a bias on the nearest cardinal
+    if 337.5 <= az or az <= 22.5:
+        facing, yaw_bias = "toward viewer", "none"
+    elif 22.5 < az <= 67.5:
+        facing, yaw_bias = "toward viewer", "left"
+    elif 67.5 < az <= 112.5:
+        facing, yaw_bias = "facing left", "none"
+    elif 112.5 < az <= 157.5:
+        facing, yaw_bias = "away from viewer", "left"
+    elif 157.5 < az <= 202.5:
+        facing, yaw_bias = "away from viewer", "none"
+    elif 202.5 < az <= 247.5:
+        facing, yaw_bias = "away from viewer", "right"
+    elif 247.5 < az <= 292.5:
+        facing, yaw_bias = "facing right", "none"
+    elif 292.5 < az <= 337.5:
+        facing, yaw_bias = "toward viewer", "right"
+    else:
+        facing, yaw_bias = "unknown", "none"
+
+    # ---- Elevation bucket ----------------------------------------------------
+    if -22.5 < po <= 22.5:
+        elevation = "side"
+    elif 22.5 < po <= 60:
+        elevation = "oblique-top"
+    elif po > 60:
+        elevation = "top-down"
+    elif -60 <= po <= -22.5:
+        elevation = "oblique-bottom"
+    else:  # po < -60
+        elevation = "bottom-up"
+
+    # ---- Near-side in object-centric terms ----------------------------------
+    if facing == "facing left":
+        near_side = "object-left"
+    elif facing == "facing right":
+        near_side = "object-right"
+    elif facing == "toward viewer" or facing == "away from viewer":
+        near_side = "object-right" if yaw_bias == "right" else ("object-left" if yaw_bias == "left" else "none")
+    # elif facing == "away from viewer":
+    #     # flipped: when looking at the back, the opposite side appears nearer
+    #     near_side = "object-left" if yaw_bias == "left" else ("object-right" if yaw_bias == "right" else "none")
+    else:
+        near_side = "none"
+
+    return {
+        "facing": facing,                 # enum (camera-relative)
+        "yaw_bias": yaw_bias,             # enum (camera-relative)
+        "elevation": elevation,           # enum (camera-relative) 
+        "near_side": near_side,           # enum (object-centric)
+        "confidence": confidence,
+    }
+
+
+def main(args):
+    run = wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    columns = [
+        "category", 
+        "img_id", 
+        "kpt_id",
+        "orientation_hint",
+        "preview", 
+        "part_name",
+        "part_location",
+        "spatial_location",
+        "object_facing_direction",
+        "bbox",
+        "actor_desc",
+        "critic_report",
+    ]
+
+    results_tb = wandb.Table(columns=columns)
+
+    data_dir, categories, split = get_dataset_info(args, split="test")
+    for cat in categories:
+        files, kps, _, used_kps = load_eval_data(args, data_dir, cat, split)
+        N = len(files) // 2
+        for pair_idx in tqdm(range(N), desc=f"Processing {cat}"):
+            img1, img1_kps = load_img_and_kps(
+                idx=2 * pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE
+            )
+
+            img_id = files[2 * pair_idx].split("/")[-1]
+            file_name = img_id.split(".")[0]
+            orient_path = os.path.join(args.ORIENTATION_PATH, cat, f"{file_name}.json")
+
+            with open(orient_path, 'r') as f:
+                orientation_raw_json = json.load(f)
+
+            assert img1_kps.shape[0] == used_kps.shape[0], "Keypoints mismatch"
+            n_kps = img1_kps.shape[0]
+
+            for kps_idx in range(n_kps):
+                # If the query point is zero, skip it entirely
+                if np.all(img1_kps[kps_idx, :2].numpy() == (0,0)):
+                    continue
+                
+                # --- CHANGED: Define all identifiers upfront ---
+                used_kps_id = used_kps[kps_idx].item()
+                save_directory = os.path.join(args.SAVE_DIR, args.EVAL_DATASET, args.EXP_NOTE)
+                query_kp = tuple(img1_kps[kps_idx, :2].numpy())
+
+                orientation_hint = describe_orientation(azimuth=orientation_raw_json.get('azimuth',''), 
+                                        polar=orientation_raw_json.get('polar',''), 
+                                        confidence=orientation_raw_json.get('confidence', ''))
+                
+                # Initialize descriptors
+                actor_desc = None
+                critic_report = None
+
+                # --- CHANGED: Use the new getter function ---
+                existing_result = get_existing_result(
+                    save_dir=save_directory, category=cat, image_id=img_id, kpt_id=used_kps_id
+                )
+
+                if existing_result:
+                    print(f"Found existing result for kpt_id {used_kps_id} in {img_id}. Logging it.")
+                    # Load data from the file
+                    actor_desc = existing_result.get("actor_output")
+                    critic_report = existing_result.get("critic_output")
+                else:
+                    print(f"Processing new kpt_id {used_kps_id} for {img_id}.")
+                    # This expensive part now only runs if the result doesn't exist
+                    new_actor_desc, new_critic_report = actor_critic_refine(
+                        img=img1,
+                        point=query_kp,
+                        class_name=cat.lower(),
+                        max_iters=args.MAX_ITERS,
+                        model=args.MODEL_NAME,
+                        orientation_hint=orientation_hint,
+                        reasoning_effort=args.REASONING_EFFORT,
+                    )
+
+                    # Handle cases where the actor/critic might fail
+                    if not new_actor_desc or not new_critic_report:
+                        print(f"Actor/Critic failed for kpt {used_kps_id} on {img_id}. Skipping.")
+                        continue
+                    
+                    # Assign to the main variables
+                    actor_desc = new_actor_desc
+                    critic_report = new_critic_report
+                    
+                    # Save the new result
+                    save_actor_critic_output(
+                        save_dir=save_directory,
+                        category=cat,
+                        image_id=img_id,
+                        kpt_id=used_kps_id,
+                        query_point=(int(query_kp[0]), int(query_kp[1])),
+                        actor_desc=actor_desc,
+                        critic_report=critic_report,
+                        model_name=args.MODEL_NAME
+                    )
+
+                # --- CHANGED: Unified logging for both new and existing results ---
+                if actor_desc and critic_report:
+                    bbox = actor_desc.get("proposed_bbox", [])
+                    img1_preview = wandb.Image(_make_overlay(img1, query_kp, bbox), caption=f"Keypoint {query_kp}")
+                    results_tb.add_data(
+                        cat,
+                        img_id,
+                        used_kps_id,
+                        str(orientation_hint),
+                        img1_preview,
+                        actor_desc.get("part_name", ""),
+                        actor_desc.get("part_location", ""),
+                        actor_desc.get("spatial_location", ""),
+                        actor_desc.get("object_facing_direction", ""),
+                        actor_desc.get("proposed_bbox", []),
+                        json.dumps(actor_desc, ensure_ascii=False),
+                        json.dumps(critic_report, ensure_ascii=False),
+                    )
+            #         break
+            # break
+
+    # Save results to WandB
+    run.log({"results": results_tb})
+    wandb.finish()
+    # pass
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the Actor-Critic model for inference.")
+    parser.add_argument('--MODEL_NAME', type=str, default='gpt-4.1', help='Model name to use for inference.')
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    parser.add_argument('--EVAL_DATASET', type=str, default='spair', help='Dataset to evaluate on.')
+    parser.add_argument('--MAX_ITERS', type=int, default=5, help='Maximum iterations for actor-critic refinement.')
+    parser.add_argument('--ORIENTATION_PATH', type=str, required=True, help='Path to orientation hint file.')
+
+    parser.add_argument('--BATCH_SIZE', type=int, default=16, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+    parser.add_argument('--CONCURRENCY', type=int, default=8, help='Number of concurrent requests to OpenAI API.')
+    parser.add_argument('--REASONING_EFFORT', type=str, default='low', choices=['minimal', 'low'], help='Reasoning effort level for the model.')
+
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/inference_gpt_batched.py

@@ -0,0 +1,325 @@
+import os
+import wandb
+import matplotlib.pyplot as plt
+from torch.utils.data import DataLoader
+import argparse
+import torch
+from tqdm import tqdm
+from PIL import ImageDraw, ImageFont
+import numpy as np
+import json
+import pathlib
+from io import BytesIO
+import base64
+from PIL import Image
+
+# openai imports
+# from openai import OpenAI
+from openai import AsyncClient
+# from throttle
+
+# mutliprocessing for parallel job preparation
+import concurrent.futures
+
+# custom imports
+from dataset import get_dataset_info, VLDatasetPaired
+from utils import load_eval_data, load_img_and_kps
+# from qwen_utils import QwenVLDetector
+from openai_utils import build_messages, CoarseSemCorrBBox, make_preview, img_to_data_url
+# from predict_correspondence_vlm import create_image_with_one_kp
+
+# Place the new, fast drawing function here
+def create_image_with_one_kp_pil(img, kps, kps_idx=0, circ_size=200, add_text=True, **kwargs):
+    img_with_kp = img.copy()
+    draw = ImageDraw.Draw(img_with_kp)
+    cx, cy = kps[kps_idx, 0], kps[kps_idx, 1]
+    radius = circ_size / 10 
+    bbox = [cx - radius, cy - radius, cx + radius, cy + radius]
+    draw.ellipse(bbox, outline="red", width=4)
+
+    if add_text:
+        text = "Ref"
+        # Try to use a better font, or fall back to the default if not found
+        # try:
+        font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+        # except IOError:
+        #     print('test')
+        #     font = ImageFont.load_default()
+
+        # Get text bounding box for centering
+        # print(font)
+        bbox_text = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox_text[2] - bbox_text[0]
+        text_height = bbox_text[3] - bbox_text[1]
+
+        text_x = cx - text_width // 2
+        text_y = cy - text_height // 2
+        draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+    return img_with_kp
+
+# Helper function to process a single keypoint (needed for parallelization)
+def prepare_single_job(task_args):
+    img1, img2, img1_kps, kps_idx, category, src_id, tgt_id, task_prompt = task_args
+
+    if img1_kps[kps_idx, 2] == 1:
+        # Use the fast, new function
+        img1_kp = create_image_with_one_kp_pil(img1, img1_kps, kps_idx=kps_idx)
+
+        # plt.imsave("img2_masked_loop.png", img2)
+        
+        return {
+            "img1_kp": img1_kp,
+            "img2": img2,
+            "task_prompt": task_prompt,
+            "metadata": { "category": category, "src_id": src_id, "tgt_id": tgt_id, "kps_idx": kps_idx }
+        }
+    return None
+
+
+def encode_image_to_base64(image: Image.Image) -> str:
+    """Encodes a PIL image to a base64 data URI."""
+    buffered = BytesIO()
+    image.save(buffered, format="JPEG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/jpeg;base64,{img_str}"
+
+import asyncio, itertools, json
+from tqdm import tqdm
+
+def run_batched_evaluation(args, model, system_prompt, task_prompt):
+    """
+    End‑to‑end evaluation: prepare jobs ➜ async GPT calls ➜ majority vote ➜
+    preview + W&B logging (streaming rows, no giant table in RAM).
+    """
+
+    # ────────── 0.  WandB  ───────────────────────────────────────────────────#
+    run = wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+    run.define_metric("step")
+
+    columns = [
+        "step", "category", "src_id", "tgt_id", "kpt_id",
+        "preview", "full_response",
+        "bbox_src", "bbox_tgt",
+        #"src_img_size", "tgt_img_size"
+    ]
+    results_tb = wandb.Table(columns=columns)
+
+    # ────────── 1.  Async GPT helper  ────────────────────────────────────────#
+    async def one_call(text_prompt, img1, img2):
+
+        # print(type(img1), type(img2))
+
+        # plt.imsave("img2_masked.png", img2)
+
+        img1_url = encode_image_to_base64(img1)
+        img2_url = encode_image_to_base64(img2)
+
+        msgs = build_messages(system_prompt, text_prompt, img1_url, img2_url)
+        resp = await model.chat.completions.create(
+            model=args.MODEL_NAME,
+            messages=msgs,
+            response_format={"type": "json_object"},
+            # parse_model=CoarseSemCorrBBox,
+        )
+        # return resp
+        raw_json = resp.choices[0].message.content
+
+            # Add this check!
+        if not raw_json:
+            print(f"Warning: Received an empty response for item: {text_prompt}. Skipping.")
+            return None # or return a default error object
+        
+        return CoarseSemCorrBBox.model_validate_json(raw_json)
+
+    CONCURRENCY = min(args.CONCURRENCY, 1)  # safety cap
+
+
+    async def batch_worker(batch):
+        src_urls, tgt_urls, txt_prompts = zip(*batch)
+        tasks = [one_call(tp, s, t) for tp, s, t in zip(txt_prompts, src_urls, tgt_urls)]
+
+        # throttle
+        out, i = [], 0
+        while i < len(tasks):
+            chunk = tasks[i:i + CONCURRENCY]
+            out.extend(await asyncio.gather(*chunk))
+            i += CONCURRENCY
+        return out
+
+    async def main_loop(data_loader):
+        all_preds = []
+        for batch in tqdm(data_loader, desc="semantic correspondence"):
+            all_preds.extend(await batch_worker(batch))
+        return all_preds
+
+    # ────────── 2.  Prepare jobs  ────────────────────────────────────────────#
+    data_dir, categories, split = get_dataset_info(args, split="test")
+    tasks_to_prepare = []
+    for cat in categories:
+        files, kps, _, _ = load_eval_data(args, data_dir, cat, split)
+        N = len(files) // 2
+        for pair_idx in tqdm(range(N), desc=f"prep {cat}"):
+            img1, img1_kps = load_img_and_kps(
+                idx=2 * pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE
+            )
+            img2, _ = load_img_and_kps(
+                idx=2 * pair_idx + 1, files=files, kps=kps,
+                img_size=args.ANNO_SIZE, load_masked=args.LOAD_MASKED
+            )
+            src_id = pathlib.Path(files[2 * pair_idx]).stem
+            tgt_id = pathlib.Path(files[2 * pair_idx + 1]).stem
+
+            # for k_idx, (x, y) in enumerate(img1_kps):
+            # print('img1_kps.shape', img1_kps.shape)
+            for k_idx in range(img1_kps.shape[0]):
+                kp_prompt = task_prompt.format(class_name=cat, point_x=img1_kps[k_idx, 0], point_y=img1_kps[k_idx, 1])
+                tasks_to_prepare.append(
+                    (img1, img2, img1_kps, k_idx, cat, src_id, tgt_id, kp_prompt)
+                )
+
+    # parallel preprocessing (e.g. resizing / base64 upload)
+    with concurrent.futures.ProcessPoolExecutor(max_workers=os.cpu_count()) as ex:
+        prepared = list(
+            tqdm(
+                ex.map(prepare_single_job, tasks_to_prepare),
+                total=len(tasks_to_prepare),
+                desc="prepare jobs",
+            )
+        )
+    inference_jobs = [j for j in prepared if j is not None]
+    print(f"Prepared {len(inference_jobs)} visible‑keypoint jobs.")
+
+    # ────────── 3.  Build DataLoader & run GPT  ──────────────────────────────#
+    src_urls = [j["img1_kp"] for j in inference_jobs]
+    tgt_urls = [j["img2"] for j in inference_jobs]
+    prompts  = [j["task_prompt"] for j in inference_jobs]
+
+    dataset_sem = VLDatasetPaired(src_urls, tgt_urls, prompts)
+    loader_sem = DataLoader(
+        dataset_sem,
+        batch_size=args.BATCH_SIZE,
+        num_workers=args.NUM_WORKERS,
+        collate_fn=lambda x: x,
+        pin_memory=True,
+    )
+
+    preds = asyncio.run(main_loop(loader_sem))  # list[CoarseSemCorrBBox]
+
+    # keep raw preds alongside run
+    # pred_file = pathlib.Path(run.dir) / "bboxes.jsonl"
+    # pred_file.write_text("\n".join(json.dumps(p.model_dump()) for p in preds))
+    # run.log_artifact(
+    #     wandb.Artifact(name=f"preds_{run.id}", type="predictions").add_file(pred_file)
+    # )
+
+    out_dir   = pathlib.Path(args.SAVE_DIR).expanduser()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    pred_file = out_dir / f"{args.EXP_NOTE}_bboxes_{run.id}.jsonl"
+    with pred_file.open("w") as f:
+        for p in preds:
+            f.write(json.dumps(p.model_dump()) + "\n")
+
+    # ────────── 4.  Streaming W&B logging  ──────────────────────────────────#
+    for step, (job, pred) in tqdm(
+        enumerate(zip(inference_jobs, preds), 1), total=len(inference_jobs),
+        desc="log wandb"
+    ):
+        # unpack
+        meta      = job["metadata"]
+        # semantics = job["extracted_semantics"]
+        full_response = pred.full_response
+        src_bbox  = pred.bbox_src
+        tgt_bbox  = pred.bbox_tgt #if pred.bbox_tgt else "none"
+
+        fig = make_preview(
+            np.array(job["img1_kp"]),
+            np.array(job["img2"]),
+            src_bbox,
+            tgt_bbox,
+        )
+
+        wandb_img = wandb.Image(fig)
+        plt.close(fig)
+
+        results_tb.add_data(
+            step,
+            meta["category"],
+            meta["src_id"],
+            meta["tgt_id"],
+            meta["kps_idx"],
+            wandb_img,
+            full_response,
+            src_bbox,
+            tgt_bbox,
+            # meta["src_input_size"],
+            # meta["tgt_input_size"],
+        )
+
+        if step % 100 == 0:
+            wandb.log({"evaluation_results": results_tb}, step=step)
+
+    # final flush
+    wandb.log({"evaluation_results": results_tb}, step=len(inference_jobs))
+    run.finish()
+
+
+# ===================================================================
+# 4. YOUR ORIGINAL `main` FUNCTION, NOW SIMPLIFIED TO CALL THE BATCHED RUNNER
+# ===================================================================
+def main(args):
+    with open(args.SYSTEM_PROMPT, 'r') as f:
+        system_prompt = f.read()
+    with open(args.TASK_PROMPT, 'r') as f:
+        task_prompt = f.read()
+
+        task_prompt = task_prompt.replace("{", "{{").replace("}", "}}")
+
+    # Initialize the OpenAI VLM model
+    print("Initializing OpenAI model...")
+    # model = OpenAI()
+    model = AsyncClient()
+
+    # Initialize WandB
+    # print("Initializing WandB...")
+    # wandb.init(
+    #     project=args.EVAL_DATASET,
+    #     entity="amazon_intern2025",
+    #     name=args.EXP_NOTE,
+    #     config=vars(args)
+    # )
+
+    # Run the optimized evaluation
+    run_batched_evaluation(args, model, system_prompt, task_prompt)
+
+    print('Finished processing all categories and logging results.')
+    wandb.finish()
+    print('WandB run finished.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # ... (all your existing arguments) ...
+    parser.add_argument('--SYSTEM_PROMPT', type=str, required=True)
+    parser.add_argument('--TASK_PROMPT', type=str, required=True)
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'])
+    parser.add_argument('--MODEL_NAME', type=str, default='gpt-4.1-mini', help='Model name to use for inference.')
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0)
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo')
+    parser.add_argument('--SAVE_DIR', type=str, default='./results_vlm/', help='Directory to save intermediate results.')
+    
+    
+    # --- ADD THESE NEW ARGUMENTS for controlling batching ---
+    parser.add_argument('--BATCH_SIZE', type=int, default=16, help='Batch size for GPU inference.')
+    parser.add_argument('--NUM_WORKERS', type=int, default=8, help='Number of CPU cores for data loading.')
+    parser.add_argument('--CONCURRENCY', type=int, default=8, help='Number of concurrent requests to OpenAI API.')
+    parser.add_argument('--LOAD_MASKED', action='store_true', help='Load masked images for inference.')
+    
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/near_side_correction.py

@@ -0,0 +1,224 @@
+import json
+import os
+import glob
+from typing import Dict, Any, Optional, Tuple
+
+# custom imports
+def previous_flipped_near_side_orientation(azimuth: float, polar: float, *, confidence: float | None = None) -> Dict:
+    """
+    azimuth: yaw in degrees, 0 = toward viewer, 90 = facing left, 180 = away, 270 = facing right
+    polar  : elevation in degrees; + up (top view), - down (bottom view); 0 ≈ side
+    returns a structured viewer-centric hint
+    """
+    # az = _bucket_angle(azimuth)
+    assert azimuth >= 0 and azimuth < 360, "Azimuth must be in the range [0, 360)"
+    az = azimuth
+    po = polar
+
+    # ---- Facing & yaw_bias ---------------------------------------------------
+    # Main facing from octants; diagonals become a bias on the nearest cardinal
+    if 337.5 <= az or az <= 22.5:
+        facing, yaw_bias = "toward viewer", "none"
+    elif 22.5 < az <= 67.5:
+        facing, yaw_bias = "toward viewer", "left"
+    elif 67.5 < az <= 112.5:
+        facing, yaw_bias = "facing left", "none"
+    elif 112.5 < az <= 157.5:
+        facing, yaw_bias = "away from viewer", "left"
+    elif 157.5 < az <= 202.5:
+        facing, yaw_bias = "away from viewer", "none"
+    elif 202.5 < az <= 247.5:
+        facing, yaw_bias = "away from viewer", "right"
+    elif 247.5 < az <= 292.5:
+        facing, yaw_bias = "facing right", "none"
+    elif 292.5 < az <= 337.5:
+        facing, yaw_bias = "toward viewer", "right"
+    else:
+        facing, yaw_bias = "unknown", "none"
+
+    # ---- Elevation bucket ----------------------------------------------------
+    if -22.5 < po <= 22.5:
+        elevation = "side"
+    elif 22.5 < po <= 60:
+        elevation = "oblique-top"
+    elif po > 60:
+        elevation = "top-down"
+    elif -60 <= po <= -22.5:
+        elevation = "oblique-bottom"
+    else:  # po < -60
+        elevation = "bottom-up"
+
+    # ---- Near-side in object-centric terms ----------------------------------
+    if facing == "facing left":
+        near_side = "object-left"
+    elif facing == "facing right":
+        near_side = "object-right"
+
+    ##### this is the flipped logic and needs to be corrected ######
+    elif facing == "toward viewer":
+        near_side = "object-left" if yaw_bias == "left" else ("object-right" if yaw_bias == "right" else "none")
+    elif facing == "away from viewer":
+        # flipped: when looking at the back, the opposite side appears nearer
+        near_side = "object-right" if yaw_bias == "left" else ("object-left" if yaw_bias == "right" else "none")
+    else:
+        near_side = "none"
+
+    return {
+        "facing": facing,                 # enum (camera-relative)
+        "yaw_bias": yaw_bias,             # enum (camera-relative)
+        "elevation": elevation,           # enum (camera-relative) 
+        "near_side": near_side,           # enum (object-centric)
+        "confidence": confidence,
+    }
+
+
+
+
+def get_correct_orientation(orientation_data: Dict[str, Any]) -> Optional[str]:
+    """
+    Determines the correct 'near_side' based on facing direction and yaw bias.
+    This follows the "Golden Rule" often used in computer vision annotation.
+    """
+    facing = orientation_data.get("facing")
+    yaw_bias = orientation_data.get("yaw_bias")
+
+    if facing == "away from viewer":
+        if yaw_bias == "right":
+            return "object-right"
+        if yaw_bias == "left":
+            return "object-left"
+    elif facing == "toward viewer":
+        # Mirrored perspective
+        if yaw_bias == "right":
+            return "object-left"
+        if yaw_bias == "left":
+            return "object-right"
+            
+    return None # Rule does not apply (e.g., 'side' view with no bias)
+
+def process_directory(orientation_path: str, data_path:str, save_path: str):
+    """
+    Scans a directory for orientation files and corrects corresponding data files.
+    """
+    # categories
+    # categories = os.listdir(orientation_path)
+    categories = os.listdir(data_path)
+
+    for category in categories:
+        data_files = glob.glob(os.path.join(data_path, category, "*.json"))
+
+        if not data_files:
+            print(f"No data files (*_orientation.json) found in '{category}'.")
+            return
+
+        print(f"Found {len(data_files)} orientation files. Starting processing...")
+        print("-" * 50)
+
+        for data_file_path in data_files:
+            try:
+                # Derive the corresponding data file name
+                # Assumes data file is named like 'subject_name.json'
+                # and orientation is 'subject_name_orientation.json'
+                base_name = os.path.basename(data_file_path)
+                data_filename = base_name
+                orient_path = os.path.join(orientation_path, category, data_filename)
+
+                # print(os.listdir(os.path.join(data_path, category)))
+
+                os.makedirs(os.path.join(save_path, category), exist_ok=True)
+
+                if not os.path.exists(orient_path):
+                    print(f"Warning: orient file '{data_filename}' not found for '{os.path.basename(orient_path)}'. Skipping.")
+                    continue
+
+                # 1. Load orientation data
+                with open(orient_path, 'r') as f:
+                    orientation_json = json.load(f)
+
+                print(orientation_json)
+                orientation_data = previous_flipped_near_side_orientation(
+                    azimuth=orientation_json.get("azimuth"),
+                    polar=orientation_json.get("polar"),
+                    confidence=orientation_json.get("confidence")
+                )
+
+                print(orientation_data)
+                # break
+
+                original_near_side = orientation_data.get("near_side")
+                correct_near_side = get_correct_orientation(orientation_data)
+
+                # 2. Check if correction is needed
+                if not correct_near_side or original_near_side == correct_near_side:
+                    print(f"No correction needed for {base_name}. Orientation is consistent.")
+                    continue
+
+                # 3. Determine which words to swap
+                if "left" in original_near_side and "right" in correct_near_side:
+                    wrong_side, correct_side = "left", "right"
+                elif "right" in original_near_side and "left" in correct_near_side:
+                    wrong_side, correct_side = "right", "left"
+                else:
+                    print(f"Skipping correction for {base_name}: Unclear which sides to swap.")
+                    continue
+
+                print(f"Inconsistency found for '{base_name}'. Correcting '{wrong_side}' to '{correct_side}'.")
+
+                # 4. Load and process the main data file
+                with open(data_file_path, 'r') as f:
+                    data = json.load(f)
+
+                change_count = 0
+                keypoints = data.get("keypoints", {})
+
+                for key, point_data in keypoints.items():
+                    actor_output = point_data.get("actor_output", {})
+                    
+                    # Fields to check and correct
+                    fields_to_correct = ["part_location", "spatial_location"]
+                    
+                    for field in fields_to_correct:
+                        if field in actor_output and wrong_side in actor_output[field]:
+                            original_text = actor_output[field]
+                            # Replace both lowercase and capitalized versions
+                            corrected_text = original_text.replace(wrong_side, correct_side)
+                            corrected_text = corrected_text.replace(wrong_side.capitalize(), correct_side.capitalize())
+                            
+                            if original_text != corrected_text:
+                                actor_output[field] = corrected_text
+                                change_count += 1
+                
+                # 5. Save the corrected data
+                if change_count > 0:
+                    # with open(data_path, 'w') as f:
+                    #     json.dump(data, f, indent=4)
+                    # os.makedirs(save_path, exist_ok=True)
+                    with open(os.path.join(save_path, category, data_filename), 'w') as f:
+                        json.dump(data, f, indent=4)
+                    print(f"Saved '{data_filename}' with {change_count} total corrections.")
+                else:
+                    print(f"No instances of '{wrong_side}' found in '{data_filename}', though orientation was inconsistent.")
+                
+            except json.JSONDecodeError:
+                print(f"Error: Invalid JSON in '{os.path.basename(orient_path)}' or its corresponding data file.")
+            except Exception as e:
+                print(f"An unexpected error occurred while processing '{os.path.basename(orient_path)}': {e}")
+            finally:
+                print("-" * 50)
+
+
+if __name__ == "__main__":
+    # --- USAGE ---
+    # Set the path to the directory containing your JSON files.
+    # You can use "." for the current directory.
+    # target_directory = "."  
+
+    orientation_path = '../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv/'
+    print(os.listdir(orientation_path))
+
+    data_path = './results_vlm/spair/GPT-5 Low Actor Critic Test 10'
+    print(os.listdir(data_path))
+
+    save_path = './results_vlm/spair/GPT-5 Low Actor Critic Test 10 Near Side Corrected'
+    
+    process_directory(orientation_path=orientation_path, data_path=data_path, save_path=save_path)

Code/sc_dit/openai_api_key.py

@@ -0,0 +1 @@
+OPENAI_API_KEY = "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"

Code/sc_dit/openai_utils.py

@@ -0,0 +1,61 @@
+import base64
+from pydantic import BaseModel, field_validator
+import matplotlib.pyplot as plt
+from typing import List, Union, Any, Optional
+
+
+def img_to_data_url(path: str) -> str:
+    mime = "image/png" if path.lower().endswith(".png") else "image/jpeg"
+    with open(path, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode()
+    return f"data:{mime};base64,{b64}"
+
+
+# use structured output
+class CoarseSemCorrBBox(BaseModel):
+    """Container for the assistant’s JSON array + convenient attrs."""
+    full_response: str                                     # entire response
+    
+    bbox_src: List[int]
+    bbox_tgt: Optional[List[int]] = None  # optional, can be "none"
+    @field_validator("bbox_tgt", mode="before")
+    @classmethod
+    def validate_bbox_tgt(cls, v: Any) -> Optional[List[int]]:
+        """
+        Allows the LLM to return the string 'none' for a missing bounding box.
+        This validator intercepts the input before standard validation.
+        """
+        # If the input is the string "none", convert it to None
+        if v == "none":
+            return None
+        # Otherwise, return the original value for Pydantic to validate as a List[int]
+        return v
+
+def build_messages(system_prompt: str, text_prompt: str, img1_url: str, img2_url: str):
+    """Package vision + text into OpenAI chat format."""
+    return [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": [
+            {"type": "text",      "text": text_prompt},
+            {"type": "image_url", "image_url": {"url": img1_url}},
+            {"type": "image_url", "image_url": {"url": img2_url}},
+        ]},
+    ]
+
+
+def make_preview(src_np, tgt_np, src_bbox, tgt_bbox):
+    """Return a matplotlib Figure with both images + optional boxes."""
+    fig, axes = plt.subplots(1, 2, figsize=(6, 3))
+    axes[0].imshow(src_np); axes[0].axis("off"); axes[0].set_title("Source")
+    axes[1].imshow(tgt_np); axes[1].axis("off"); axes[1].set_title("Target")
+
+    if src_bbox:
+        x1, y1, x2, y2 = src_bbox
+        axes[0].add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1,
+                                        ec="lime", fc="none", lw=2))
+    if tgt_bbox: #and tgt_bbox != "none":
+        x1, y1, x2, y2 = tgt_bbox
+        axes[1].add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1,
+                                        ec="lime", fc="none", lw=2))
+    fig.tight_layout()
+    return fig

Code/sc_dit/optimize_camera_pose_clean.py

@@ -0,0 +1,542 @@
+import os
+import torch
+import numpy as np
+import imageio
+import torch.nn as nn
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+import glob
+import tqdm
+from pathlib import Path
+from torch.optim.optimizer import Optimizer
+
+# from scipy.io import savemat
+
+# Scientific and Image Processing Libraries
+from scipy.ndimage import distance_transform_edt as edt
+from scipy.ndimage import gaussian_filter
+from skimage import img_as_ubyte
+from PIL import Image
+
+# PyTorch3D Imports
+# I/O
+from pytorch3d.io import load_obj
+
+# Data Structures
+from pytorch3d.structures import Meshes
+
+# 3D Transformations
+from pytorch3d.transforms import Rotate, Translate
+
+# Rendering Components
+from pytorch3d.renderer import (
+    FoVPerspectiveCameras,
+    look_at_rotation,
+    RasterizationSettings,
+    MeshRenderer,
+    MeshRasterizer,
+    BlendParams,
+    SoftSilhouetteShader,
+    HardPhongShader,
+    PointLights,
+    TexturesVertex,
+)
+
+# Third-party Libraries
+from geomloss import SamplesLoss  # pip install geomloss
+
+# Local Utilities
+from sc_dit.utils import resize_and_pad, scaled_shifted_sigmoid, get_bbox_from_alpha
+
+import wandb
+
+
+# Set the processing device
+if torch.cuda.is_available():
+    device = torch.device("cuda:0")
+    torch.cuda.set_device(device)
+else:
+    device = torch.device("cpu")
+
+def wasserstein_torch(mask1, mask2, p=2, blur=0.05, backend="tensorized"):
+    """
+    Calculates the differentiable Wasserstein (Sinkhorn) distance between two masks.
+
+    Args:
+        mask1 (np.array): The first binary mask.
+        mask2 (np.array): The second binary mask.
+        p (int): The exponent for the cost function.
+        blur (float): The Sinkhorn regularization strength.
+        backend (str): The backend for geomloss computation.
+
+    Returns:
+        torch.Tensor: A scalar tensor representing the Wasserstein distance.
+    """
+    mask1_t = torch.as_tensor(mask1, dtype=torch.float32, device=device)
+    mask2_t = torch.as_tensor(mask2, dtype=torch.float32, device=device)
+
+    H, W = mask1_t.shape
+
+    # Create a grid of coordinates.
+    coords_y, coords_x = torch.meshgrid(
+        torch.arange(H, dtype=torch.float32, device=device),
+        torch.arange(W, dtype=torch.float32, device=device),
+        indexing="ij"
+    )
+    coords = torch.stack([coords_x, coords_y], dim=-1).view(-1, 2)
+
+    # Normalize the masks to create probability distributions.
+    w1 = mask1_t.flatten()
+    # w1 = scaled_shifted_sigmoid(w1, a=2.0, b=5.0, c=0.0, d=-1)  # Apply sigmoid to ensure non-negativity
+    w1 = w1 / w1.sum()
+
+    w2 = mask2_t.flatten()
+    w2 = w2 / w2.sum()
+
+    loss_fn = SamplesLoss(loss="sinkhorn", p=p, blur=blur, backend=backend)
+    
+    return loss_fn(w1, coords, w2, coords)
+
+
+class CameraPoseEstimator(nn.Module):
+    """
+    A model to optimize camera pose by minimizing the Wasserstein distance
+    between a rendered silhouette and a reference image.
+    """
+    def __init__(self,
+                 meshes,
+                 renderer,
+                 image_ref,
+                 x_init=3.0,
+                 y_init=6.9,
+                 z_init=2.5,
+                 wass_res=64):
+        """
+        Initializes the camera pose estimator.
+        
+        Args:
+            meshes (Meshes): The 3D mesh to be rendered.
+            renderer (MeshRenderer): The PyTorch3D renderer.
+            image_ref (torch.Tensor): The reference image tensor (H, W).
+            x_init (float): Initial x-coordinate of the camera.
+            y_init (float): Initial y-coordinate of the camera.
+            z_init (float): Initial z-coordinate of the camera.
+            wass_res (int): Resolution for downsampling images for Wasserstein loss.
+        """
+        super().__init__()
+        self.meshes = meshes
+        self.device = meshes.device
+        self.renderer = renderer
+        self.register_buffer("image_ref", image_ref)
+        self.wass_res = wass_res
+
+        # Register camera position as a learnable parameter.
+        self.camera_position = nn.Parameter(
+            torch.tensor([x_init, y_init, z_init], dtype=torch.float32, device=self.device)
+        )
+
+    def forward(self):
+        """
+        Performs a forward pass: renders the mesh and computes the loss.
+        """
+        # Get camera rotation and translation from its position.
+        R = look_at_rotation(self.camera_position[None, :], device=self.device)
+        T = -torch.bmm(R.transpose(1, 2), self.camera_position[None, :, None])[:, :, 0]
+
+        # Render the image.
+        image = self.renderer(meshes_world=self.meshes.clone(), R=R, T=T)
+
+        # Downsample the rendered and reference images for loss calculation.
+        rendered_alpha = image[..., 3].unsqueeze(0)
+        image_init_downsampled = F.interpolate(
+            rendered_alpha,
+            size=(self.wass_res, self.wass_res),
+            mode='bilinear',
+            align_corners=False
+        ).squeeze()
+
+        model_image_ref_downsampled = F.interpolate(
+            self.image_ref.unsqueeze(0).unsqueeze(0),
+            size=(self.wass_res, self.wass_res),
+            mode='bilinear',
+            align_corners=False
+        ).squeeze()
+
+        # Compute the Wasserstein loss.
+        loss = wasserstein_torch(
+            image_init_downsampled.float(),
+            model_image_ref_downsampled.float(),
+            p=2, blur=0.05, backend="tensorized"
+        )
+        
+        return loss, image
+
+
+def make_target(mask, mode="gauss", sigma_px=8, normalise=True):
+    """
+    Converts a binary mask into a target representation (Gaussian or SDF).
+
+    Args:
+        mask (np.array): A binary mask (H, W) where foreground is 1.
+        mode (str): The conversion mode, either 'gauss' or 'sdf'.
+        sigma_px (int): Sigma for the Gaussian filter.
+        normalise (bool): Whether to normalize the output to a standard range.
+
+    Returns:
+        np.array: The processed target image as a float32 array.
+    """
+    mask = mask.astype(bool)
+
+    if mode == "gauss":
+        target = gaussian_filter(mask.astype(np.float32), sigma=sigma_px)
+        if normalise:
+            target = (target - target.min()) / (target.max() - target.min() + 1e-6)
+    elif mode == "sdf":
+        # Signed Distance Function (SDF)
+        dist_out = edt(~mask)
+        dist_in = edt(mask)
+        sdf = dist_out.astype(np.float32)
+        sdf[mask] = -dist_in[mask]
+        if normalise:
+            sdf /= (np.abs(sdf).max() + 1e-6)
+        target = sdf
+    else:
+        raise ValueError("Mode must be 'gauss' or 'sdf'")
+        
+    return target.astype(np.float32)
+
+class ZerothOrderOptimizer(Optimizer):
+    """
+    Implements zeroth-order optimization using finite difference methods
+    to approximate gradients.
+    """
+    def __init__(self, params, lr=0.01, n_samples=10, delta=0.1):
+        """
+        Args:
+            params: iterable of parameters to optimize
+            lr (float): learning rate
+            n_samples (int): number of random directions to sample for gradient estimation
+            delta (float): perturbation scale for finite difference
+        """
+        defaults = dict(lr=lr, n_samples=n_samples, delta=delta)
+        super(ZerothOrderOptimizer, self).__init__(params, defaults)
+    def step(self, closure=None):
+        """Performs a single optimization step.
+        Args:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                # Parameters
+                lr = group['lr']
+                n_samples = group['n_samples']
+                delta = group['delta']
+                # Initialize gradient approximation
+                grad_approx = torch.zeros_like(p.data)
+                # Store original parameter value
+                original_params = p.data.clone()
+                # For each random direction
+                for i in range(n_samples):
+                    # Generate random direction (uniform on unit sphere)
+                    u = torch.randn_like(p.data)
+                    u = u / (u.norm() + 1e-8)
+                    # Forward direction evaluation
+                    p.data = original_params + delta * u
+                    loss_pos = closure().item()
+                    # Backward direction evaluation
+                    p.data = original_params - delta * u
+                    loss_neg = closure().item()
+                    # Two-point approximation of directional derivative
+                    grad_direction = (loss_pos - loss_neg) / (2 * delta)
+                    # Accumulate the gradient approximation
+                    grad_approx += grad_direction * u
+                # Average over samples
+                grad_approx /= n_samples
+                # Restore original parameters
+                p.data = original_params
+                # Update parameters using the approximated gradient
+                p.data.add_(-lr * grad_approx)
+        return loss
+
+
+
+def main(file_id, category, dataset, exp_note=None):
+    image_render_size = 256
+    # wass_res = 128
+    wass_res = 64
+    max_iter = 1000
+    learning_rate = 0.01 #0.05
+    min_iter = 50
+    patience = 1000  # Number of iterations to wait for improvement before stopping
+    rel_tol = 0.01  # Relative tolerance for early stopping
+
+
+
+    # --- 1. Initialize WandB ---
+    if exp_note is None:
+        exp_name = f"{dataset}_{category}_{file_id}"
+    else:
+        exp_name = f"{dataset}_{category}_{file_id}_{exp_note}"
+
+    run = wandb.init(
+        project="spair",
+        entity="amazon_intern2025",
+        # name=f"{dataset}_{category}_{file_id}",
+        name=exp_name,
+        config={
+            "file_id": file_id,
+            "category": category,
+            "dataset": dataset,
+            "image_render_size": image_render_size,
+            "wass_res": wass_res,
+            "max_iter": max_iter,
+            "learning_rate": learning_rate,
+            "min_iter": min_iter,
+            "patience": patience,
+            "rel_tol": rel_tol,
+        })
+
+    # --- 2. Path Setup ---
+    mesh_path = f'./example_data/{dataset}/{category}/{file_id}.obj' # no sparc by default 
+    image_path = f'./example_data/{dataset}/{category}/{file_id}_bgd_rmv.png'
+    path_output = f'./example_results/{dataset}/{category}'
+    os.makedirs(path_output, exist_ok=True)
+    filename_output = f'{file_id}.gif'
+    path_file_output = os.path.join(path_output, filename_output)
+
+    # --- 3. Load Mesh ---
+    verts, faces_idx, _ = load_obj(mesh_path)
+    faces = faces_idx.verts_idx
+    
+    # Initialize vertex colors and create a texture object.
+    verts_rgb = torch.ones_like(verts)[None]  # (1, V, 3)
+    textures = TexturesVertex(verts_features=verts_rgb.to(device))
+
+    # Create a Meshes object.
+    obj_mesh = Meshes(
+        verts=[verts.to(device)],
+        faces=[faces.to(device)],
+        textures=textures
+    )
+
+    # --- 4. Setup Renderers ---
+    cameras = FoVPerspectiveCameras(device=device)
+    
+    # Silhouette Renderer (for loss computation)
+    blend_params_sil = BlendParams(sigma=1e-4, gamma=1e-4)
+    raster_settings_sil = RasterizationSettings(
+        image_size=image_render_size,
+        blur_radius=np.log(1. / 1e-4 - 1.) * blend_params_sil.sigma,
+        faces_per_pixel=150, #100
+    )
+    silhouette_renderer = MeshRenderer(
+        rasterizer=MeshRasterizer(cameras=cameras, raster_settings=raster_settings_sil),
+        shader=SoftSilhouetteShader(blend_params=blend_params_sil)
+    )
+
+    # Phong Renderer (for visualization)
+    lights = PointLights(device=device, location=((2.0, 2.0, -2.0),))
+    raster_settings_phong = RasterizationSettings(
+        image_size=image_render_size,
+        blur_radius=0.0,
+        faces_per_pixel=1,
+    )
+    phong_renderer = MeshRenderer(
+        rasterizer=MeshRasterizer(cameras=cameras, raster_settings=raster_settings_phong),
+        shader=HardPhongShader(device=device, cameras=cameras, lights=lights)
+    )
+
+    # --- 5. Load and Process Reference Image ---
+    real_image_ref_rgba = imageio.imread(image_path)
+    print(f"Reference image shape: {real_image_ref_rgba.shape}")
+
+    print("Finding bounding box from alpha channel...")
+    bbox = get_bbox_from_alpha(Path(image_path)) # (x_min, y_min, x_max, y_max)
+    
+    # Extract alpha channel and normalize.
+    # real_silhouette = torch.from_numpy(real_image_ref_rgba[..., 3]).float() / 255.0
+    # image_ref_padded = resize_and_pad(real_silhouette, output_size=image_render_size).to(device)
+
+    # Cropped image
+    with Image.open(image_path).convert("RGBA") as img:
+        # Crop the image using the bounding box
+        img_cropped = img.crop(bbox)
+        
+        # Extract the alpha channel from the CROPPED image
+        real_silhouette_cropped = torch.from_numpy(np.array(img_cropped)[..., 3]).float() / 255.0
+    image_ref_padded = resize_and_pad(real_silhouette_cropped, output_size=image_render_size).to(device)
+
+    # Convert to a target representation (e.g., Gaussian blurred).
+    image_ref_final_pp = make_target(image_ref_padded.cpu().numpy(), sigma_px=1, normalise=True)
+    image_ref_final_pp = torch.from_numpy(image_ref_final_pp).to(device)
+    print(f"Final processed image shape: {image_ref_final_pp.shape}")
+
+    # --- 6. Optimization ---
+    writer = imageio.get_writer(path_file_output, mode='I', duration=0.3)
+    
+    model = CameraPoseEstimator(
+        meshes=obj_mesh,
+        renderer=silhouette_renderer,
+        image_ref=image_ref_final_pp,
+        wass_res=wass_res
+    ).to(device)
+    
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    # optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, nesterov=True)
+    # optimizer = ZerothOrderOptimizer(model.parameters(), lr=0.01, n_samples=5, delta=0.05)
+    # def closure():
+    #     optimizer.zero_grad()
+    #     loss, _ = model()
+    #     # loss = criterion(output, targets)
+    #     return loss
+
+    loss_list = []
+    best_loss = float('inf')
+    patience_counter = 0
+
+    print("\nStarting optimization with early stopping (relative tolerance)...")
+    for i in range(max_iter):
+        optimizer.zero_grad()
+        loss, _ = model()
+        loss.backward()
+        optimizer.step()
+
+        # Use closure for zeroth-order optimization
+        # loss = optimizer.step(closure)
+        
+        loss_item = loss.item()
+        loss_list.append(loss_item)
+
+        run.log({
+            # "iteration": i,
+            "loss": loss_item,
+            # "camera_position": model.camera_position.detach().cpu().numpy().tolist()
+        })
+        
+        # --- Updated Early Stopping Logic ---
+        # Check if the relative loss improvement is significant
+        if i > 0 and (best_loss - loss_item) / (best_loss + 1e-8) > rel_tol:
+            best_loss = loss_item
+            patience_counter = 0  # Reset patience on improvement
+        else:
+            # On the first iteration, just set the best_loss
+            if i == 0:
+                best_loss = loss_item
+            patience_counter += 1 # Increment patience if no significant improvement
+
+        print(
+            f"Iteration {i:04d}, Loss: {loss_item:.4f}, Best Loss: {best_loss:.4f}, Patience: {patience_counter}/{patience}"
+        )
+
+        # Stop if patience is exceeded
+        if i > min_iter and patience_counter >= patience:
+            print(f"\nStopping early at iteration {i}. Loss has not improved for {patience} iterations.")
+            break
+        # --- End of Updated Logic ---
+        
+        # GIF saving logic remains the same
+        if i % 20 == 0:
+            R = look_at_rotation(model.camera_position[None, :], device=model.device)
+            T = -torch.bmm(R.transpose(1, 2), model.camera_position[None, :, None])[:, :, 0]
+            
+            with torch.no_grad():
+                image = phong_renderer(meshes_world=model.meshes.clone(), R=R, T=T)
+            
+            image = image[0, ..., :3].detach().cpu().numpy()
+            run.log({
+                "rendered_image": wandb.Image(image, caption=f"Iteration {i}")
+            })
+            writer.append_data(img_as_ubyte(image))
+            
+    writer.close()
+    print("Optimization finished.")
+    
+    run.finish()
+    # loss_list = []
+    # print("\nStarting optimization...")
+    # for i in range(max_iter):
+    #     optimizer.zero_grad()
+    #     loss, _ = model()
+    #     loss.backward()
+    #     optimizer.step()
+        
+    #     loss_item = loss.item()
+    #     loss_list.append(loss_item)
+    #     print(f"Iteration {i:04d}, Loss: {loss_item:.4f}")
+        
+    #     # Save an image frame for the GIF periodically.
+    #     if i % 20 == 0:
+    #         R = look_at_rotation(model.camera_position[None, :], device=model.device)
+    #         T = -torch.bmm(R.transpose(1, 2), model.camera_position[None, :, None])[:, :, 0]
+            
+    #         with torch.no_grad():
+    #             image = phong_renderer(meshes_world=model.meshes.clone(), R=R, T=T)
+            
+    #         image = image[0, ..., :3].detach().cpu().numpy()
+    #         writer.append_data(img_as_ubyte(image))
+            
+    # writer.close()
+    # print("Optimization finished.")
+
+    # --- 7. Final Results ---
+    # Plot loss curve.
+    plt.figure(figsize=(10, 5))
+    plt.plot(loss_list, label='Loss')
+    plt.xlabel('Iteration')
+    plt.ylabel('Loss Value')
+    plt.title('Loss Across Iterations')
+    plt.legend()
+    plt.grid(True)
+    plt.savefig(f"{path_file_output.replace('.gif', '')}_loss.png")
+    plt.show()
+
+    # Print the final optimized camera position.
+    final_cam_pos = model.camera_position.detach().cpu().numpy()
+    print(f"Final camera position: {final_cam_pos}")
+
+    # Save the final camera position to a json file.
+    import json
+    final_cam_pos_dict = {
+        "file_id": file_id,
+        "category": category,
+        "dataset": dataset,
+        "final_camera_position": final_cam_pos.tolist()
+    }
+    json_output_path = os.path.join(path_output, f"{file_id}_camera_position.json")
+    with open(json_output_path, 'w') as f:
+        json.dump(final_cam_pos_dict, f, indent=4)
+
+if __name__ == "__main__":
+    # --- 1. Configuration ---
+    file_id = '2010_001614' # 2009_004845 2010_001614 2007_006483
+    category = 'motorbike' # person
+    dataset = 'spair'
+    exp_note = 'crop'
+
+    main(file_id, category, dataset, exp_note)  
+
+
+    # #### multiple categories example ####
+    # dataset = 'spair'
+
+    # path_data = './example_data/' + dataset
+    # category_list = os.listdir(path_data)
+
+    # # path_all_files = glob.glob(os.path.join(path_data, '*', '*.obj'))
+    # for category in category_list:
+    #     path_category = os.path.join(path_data, category)
+    #     file_list = os.listdir(path_category)
+    #     for file_id in file_list:
+    #         if file_id.endswith('.obj'):
+    #             file_id = file_id.replace('.obj', '')
+    #             print(f"Processing {file_id} in {category}...")
+    #             main(file_id, category, dataset)
+
+
+   

Code/sc_dit/orient_anything_demo.ipynb

@@ -0,0 +1,25 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "28fc764a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qwen-vl-flash-attn",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Code/sc_dit/part_dictionary.py

@@ -0,0 +1,436 @@
+PART_SCHEMA = {
+    "aeroplane": {
+        "tail": {
+            "is_symmetric": False,
+            "children": {
+                "horizontal stabilizer": {
+                    "is_symmetric": True,
+                    "children": {
+                        "elevator": {"is_symmetric": True, "children": {}}
+                    }
+                },
+                "vertical stabilizer": {
+                    "is_symmetric": False,
+                    "children": {
+                        "rudder": {"is_symmetric": False, "children": {}}
+                    }
+                }
+            }
+        },
+        "wing": {
+            "is_symmetric": True,
+            "children": {
+                "aileron": {"is_symmetric": True, "children": {}},
+                "flap": {"is_symmetric": True, "children": {}},
+                "engine": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "fuselage": {
+            "is_symmetric": False,
+            "children": {
+                "cockpit": {"is_symmetric": False, "children": {}},
+                "nose": {"is_symmetric": False, "children": {}},
+                "landing gear": {
+                    "is_symmetric": False,
+                    "children": {
+                        "main gear": {"is_symmetric": True, "children": {}},
+                        "nose gear": {"is_symmetric": False, "children": {}}
+                    }
+                }
+            }
+        }
+    },
+
+    "car": {
+        "wheel": {
+            "is_symmetric": True,
+            "children": {
+                "tire": {"is_symmetric": True, "children": {}},
+                "rim": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "light": {
+            "is_symmetric": True,
+            "children": {
+                "headlight": {"is_symmetric": True, "children": {}},
+                "taillight": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "glass": {
+            "is_symmetric": False,
+            "children": {
+                "windshield": {"is_symmetric": False, "children": {}},
+                "rear window": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "body panel": {
+            "is_symmetric": False,
+            "children": {
+                "hood": {"is_symmetric": False, "children": {}},
+                "trunk": {"is_symmetric": False, "children": {}},
+                "fender": {"is_symmetric": True, "children": {}},
+                "door": {
+                    "is_symmetric": True,
+                    "children": {
+                        "side mirror": {"is_symmetric": True, "children": {}},
+                        "window": {"is_symmetric": True, "children": {}}
+                    }
+                },
+                "bumper": {
+                    "is_symmetric": False,
+                    "children": {
+                        "license_plate": {"is_symmetric": False, "children": {}}
+                    }
+                }
+            }
+        }
+    },
+
+    "boat": {
+        "hull": {
+            "is_symmetric": False,
+            "children": {
+                "bow": {"is_symmetric": False, "children": {}},
+                "stern": {"is_symmetric": False, "children": {}},
+                "keel": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "deck": {
+            "is_symmetric": False,
+            "children": {
+                "cabin": {"is_symmetric": False, "children": {}},
+                "trampoline": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "mast": {
+            "is_symmetric": False,
+            "children": {
+                "boom": {"is_symmetric": False, "children": {}},
+                "sail": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "steering": {
+            "is_symmetric": False,
+            "children": {
+                "rudder": {"is_symmetric": False, "children": {}}
+            }
+        }
+    },
+
+    "person": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "face": {
+                    "is_symmetric": False,
+                    "children": {
+                        "eye": {"is_symmetric": True, "children": {}},
+                        "ear": {"is_symmetric": True, "children": {}},
+                        "nose": {"is_symmetric": False, "children": {}},
+                        "mouth": {"is_symmetric": False, "children": {}}
+                    }
+                }
+            }
+        },
+        "arm": {
+            "is_symmetric": True,
+            "children": {
+                "hand": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "leg": {
+            "is_symmetric": True,
+            "children": {
+                "foot": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "torso": {"is_symmetric": False, "children": {}}
+    },
+
+    "cat": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "ear": {"is_symmetric": True, "children": {}},
+                "eye": {"is_symmetric": True, "children": {}},
+                "nose": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "leg": {
+            "is_symmetric": True,
+            "children": {
+                "paw": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "torso": {
+            "is_symmetric": False,
+            "children": {
+                "tail": {"is_symmetric": False, "children": {}}
+            }
+        }
+    },
+
+    "dog": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "ear": {"is_symmetric": True, "children": {}},
+                "eye": {"is_symmetric": True, "children": {}},
+                "snout": {"is_symmetric": False, "children": {
+                    "nose": {"is_symmetric": False, "children": {}}
+                }}
+            }
+        },
+        "leg": {
+            "is_symmetric": True,
+            "children": {
+                "paw": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "torso": {
+            "is_symmetric": False,
+            "children": {
+                "tail": {"is_symmetric": False, "children": {}}
+            }
+        }
+    },
+
+    "horse": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "ear": {"is_symmetric": True, "children": {}},
+                "eye": {"is_symmetric": True, "children": {}},
+                "mane": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "leg": {
+            "is_symmetric": True,
+            "children": {
+                "hoof": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "torso": {
+            "is_symmetric": False,
+            "children": {
+                "tail": {"is_symmetric": False, "children": {}}
+            }
+        }
+    },
+
+    "cow": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "ear": {"is_symmetric": True, "children": {}},
+                "eye": {"is_symmetric": True, "children": {}},
+                "horn": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "leg": {
+            "is_symmetric": True,
+            "children": {
+                "hoof": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "torso": {
+            "is_symmetric": False,
+            "children": {
+                "udder": {"is_symmetric": False, "children": {}},
+                "tail": {"is_symmetric": False, "children": {}}
+            }
+        }
+    },
+
+    "sheep": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "ear": {"is_symmetric": True, "children": {}},
+                "eye": {"is_symmetric": True, "children": {}},
+                "horn": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "leg": {
+            "is_symmetric": True,
+            "children": {
+                "hoof": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "torso": {
+            "is_symmetric": False,
+            "children": {
+                "tail": {"is_symmetric": False, "children": {}}
+            }
+        }
+    },
+
+    "bird": {
+        "head": {
+            "is_symmetric": False,
+            "children": {
+                "beak": {"is_symmetric": False, "children": {}},
+                "eye": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "wing": {"is_symmetric": True, "children": {}},
+        "tail": {"is_symmetric": False, "children": {}},
+        "foot": {"is_symmetric": True, "children": {}}
+    },
+
+    "bicycle": {
+        "frame": {
+            "is_symmetric": False,
+            "children": {
+                "fork": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "drivetrain": {
+            "is_symmetric": False,
+            "children": {
+                "pedal": {"is_symmetric": True, "children": {}},
+                "chain": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "control": {
+            "is_symmetric": False,
+            "children": {
+                "handlebar": {"is_symmetric": False, "children": {}},
+                "brake": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "wheel": {
+            "is_symmetric": True,
+            "children": {
+                "tire": {"is_symmetric": True, "children": {}},
+                "rim": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "seat": {"is_symmetric": False, "children": {}}
+    },
+
+    "motorbike": {
+        "handlebar": {
+            "is_symmetric": False,
+            "children": {
+                "mirror": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "wheel": {
+            "is_symmetric": True,
+            "children": {
+                "tire": {"is_symmetric": True, "children": {}},
+                "rim": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "headlight": {"is_symmetric": False, "children": {}},
+        "fender": {"is_symmetric": True, "children": {}},
+        "exhaust": {"is_symmetric": False, "children": {}},
+        "seat": {"is_symmetric": False, "children": {}},
+        "fuel tank": {"is_symmetric": False, "children": {}}
+    },
+
+    "bus": {
+        "body": {
+            "is_symmetric": False,
+            "children": {
+                "door": {"is_symmetric": True, "children": {}},
+                "window": {"is_symmetric": True, "children": {}},
+                "side panel": {"is_symmetric": True, "children": {}},
+                "roof": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "light": {
+            "is_symmetric": True,
+            "children": {
+                "headlight": {"is_symmetric": True, "children": {}},
+                "taillight": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "mirror": {"is_symmetric": True, "children": {}},
+        "wheel": {
+            "is_symmetric": True,
+            "children": {
+                "tire": {"is_symmetric": True, "children": {}},
+                "rim": {"is_symmetric": True, "children": {}}
+            }
+        }
+    },
+
+    "train": {
+        "car": {
+            "is_symmetric": False,
+            "children": {
+                "door": {"is_symmetric": True, "children": {}},
+                "window": {"is_symmetric": True, "children": {}},
+                "wheel": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "roof": {
+            "is_symmetric": False,
+            "children": {
+                "pantograph": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "front": {
+            "is_symmetric": False,
+            "children": {
+                "headlight": {"is_symmetric": True, "children": {}}
+            }
+        }
+    },
+
+    "chair": {
+        "seat": {
+            "is_symmetric": False,
+            "children": {
+                "backrest": {"is_symmetric": False, "children": {}},
+                "armrest": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "leg": {"is_symmetric": True, "children": {}}
+    },
+
+    "tvmonitor": {
+        "screen": {
+            "is_symmetric": False,
+            "children": {
+                "bezel": {"is_symmetric": False, "children": {}},
+                "corner": {"is_symmetric": True, "children": {}}
+            }
+        },
+        "stand": {"is_symmetric": False, "children": {}}
+    },
+
+    "bottle": {
+        "neck": {
+            "is_symmetric": False,
+            "children": {
+                "cap": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "body": {
+            "is_symmetric": False,
+            "children": {
+                "shoulder": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "base": {"is_symmetric": False, "children": {}}
+    },
+
+    "pottedplant": {
+        "pot": {
+            "is_symmetric": False,
+            "children": {
+                "soil": {"is_symmetric": False, "children": {}}
+            }
+        },
+        "stem": {
+            "is_symmetric": False,
+            "children": {
+                "leaf": {"is_symmetric": True, "children": {}},
+                "flower": {"is_symmetric": True, "children": {}}
+            }
+        }
+    }
+}

Code/sc_dit/predict_correspondence_vlm.py

@@ -0,0 +1,336 @@
+import torch
+from PIL import Image
+import numpy as np
+import matplotlib.pyplot as plt
+from io import BytesIO
+import os
+import argparse
+import ast
+
+# data loading
+from utils import load_pascal_data, load_spair_data, load_eval_data, load_img_and_kps
+from dataset import get_dataset_info
+
+# qwen model
+from qwen_utils import QwenVLDetector
+
+# logging
+import wandb
+
+import re
+
+def extract_bounding_box(response: str):
+    """
+    Extracts the bounding box from a model response string.
+    
+    Args:
+        response (str): The full response string containing the "Bounding box: [...]" line.
+
+    Returns:
+        list of int: A list of 4 integers [x1, y1, x2, y2] if found.
+        None: If no bounding box is found.
+    """
+    # Regex to find the bounding box line
+    bbox_match = re.search(r'Bounding box:\s*$\s*([0-9\s,]+)\s*$', response, re.MULTILINE)
+
+    print('bbox_match:', bbox_match)
+    
+    if bbox_match:
+        # Extract and parse the coordinates
+        bbox_str = bbox_match.group(1)
+        bbox = [int(coord.strip()) for coord in bbox_str.split(',')]
+        
+        if len(bbox) == 4:
+            return bbox
+        else:
+            raise ValueError(f"Expected 4 coordinates in bounding box, got {len(bbox)}: {bbox}")
+    
+    return None
+
+def create_image_with_one_kp(img, kps, kps_idx=0, circ_size=200, font_size=24, add_text=False, add_circle=True):
+    """
+    Plots a keypoint on an image and returns it as a new PIL Image with identical dimensions.
+
+    Args:
+        img (PIL.Image or np.ndarray): The input image.
+        kps (np.ndarray): Array of keypoints.
+        kps_idx (int): The index of the keypoint to plot.
+
+    Returns:
+        PIL.Image: A new image with the keypoint plotted, matching the input dimensions.
+    """
+    # 1. Get original image dimensions in pixels
+    if isinstance(img, Image.Image):
+        w_px, h_px = img.size
+    else: # Assuming NumPy array
+        h_px, w_px, _ = img.shape
+    
+    # 2. Set a fixed physical size (e.g., 6 inches) and calculate the required DPI
+    # to make the output pixel count match the input.
+    figsize_inches = 6
+    dpi = w_px / figsize_inches
+
+    # 3. Create the figure with the calculated figsize and DPI
+    fig, ax = plt.subplots(1, 1, figsize=(figsize_inches, figsize_inches), dpi=dpi)
+    
+    # 4. Remove all padding and whitespace from the figure
+    fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
+
+    # 5. Plot the image and keypoint
+    ax.imshow(np.array(img))
+    if add_circle:
+        ax.scatter(kps[kps_idx, 0], kps[kps_idx, 1], edgecolors='red', s=circ_size, facecolors='none', linewidths=2)
+    if add_text:
+        ax.text(kps[kps_idx, 0], kps[kps_idx, 1], "Ref", color='red', fontsize=font_size, verticalalignment='center', horizontalalignment='center')
+    ax.axis('off')
+    
+    # 6. Save the figure to an in-memory buffer
+    buf = BytesIO()
+    fig.savefig(buf, format='png', dpi=dpi)
+    
+    # 7. Close the figure to free memory
+    plt.close(fig)
+    
+    # 8. Create a PIL Image from the buffer
+    buf.seek(0)
+    result_img = Image.open(buf)
+    
+    return result_img
+
+# def get_bbox_semantic_corr(img1, img2, img1_kps, kps_idx_list, vocab, prompt_template, save_path='./results_qwen_demo/'):
+#     text_prompt = prompt_template.format("\n".join(f"- {term}" for term in vocab))
+#     # print(text_prompt)
+
+#     for kps_idx in kps_idx_list:
+#         print(f"Processing keypoint index: {kps_idx}")
+#         img1_kp = create_image_with_one_kp(img1, img1_kps, kps_idx=kps_idx)
+#         # plt.imshow(np.array(img1_kp))
+#         # plt.axis('off')
+#         # plt.show()
+
+#         results = model.chat(img1_kp, text_prompt, prompt_type='self-handled')
+#         print(results)
+
+
+#         extracted_semantics = results.split("Keypoint component:")[-1].strip()
+#         refined_prompt = "Locate the most prominent instance of {} in the image. If found, return a single bounding box in [x1, y1, x2, y2] format. If not found, return an empty list.".format(extracted_semantics)
+#         # refined_prompt = "Outline the position of each **{text_prompt}** in the image and output all bounding box coordinates in JSON format"
+#         print(refined_prompt)
+
+#         results_tgt = model.predict(img2, refined_prompt, prompt_type='object', bbox_refine=False)
+#         # model.plot_bounding_boxes(img2, results_tgt['response'], results_tgt['input_size'], output_path='./results_qwen_demo/{}_kps_{}.png'.format(tgt_id, kps_idx))
+#         bbox = model.predict_bounding_boxes(img2, results_tgt['response'], results_tgt['input_size'])
+
+#         fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+#         axes[0].imshow(np.array(img1_kp))
+#         axes[0].axis('off')
+#         axes[0].set_title('Source Image with Keypoint')
+#         axes[1].imshow(np.array(img2))
+#         axes[1].axis('off')
+#         axes[1].set_title('Target Image with Bounding Box')
+#         # Draw the bounding box on the target image
+#         if bbox:
+#             abs_x1, abs_y1, abs_x2, abs_y2 = bbox
+#             axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='red', facecolor='none', linewidth=2))
+#         fig.tight_layout()
+#         plt.axis('off')
+#         fig.savefig(os.path.join(save_path, f'{tgt_id}_kps_{kps_idx}.png'), bbox_inches='tight')
+#         plt.show()
+
+#         print(results_tgt['response'])
+
+def main(args):
+    # 
+    data_dir, categories, split = get_dataset_info(args, split='test')
+
+    with open(args.SYSTEM_PROMPT_SEM, 'r') as f:
+        system_prompt_sem = f.read()
+
+    with open(args.SYSTEM_PROMPT_BBOX, 'r') as f:
+        system_prompt_bbox = f.read()
+
+    with open(args.TASK_PROMPT_SEM, 'r') as f:
+        task_prompt_sem = f.read()
+
+    with open(args.TASK_PROMPT_BBOX, 'r') as f:
+        task_prompt_bbox = f.read()
+
+    # initialze the Qwen VLM model
+    model = QwenVLDetector(model_dir=None, torch_dtype=torch.bfloat16, model_name="Qwen/Qwen2.5-VL-32B-Instruct", device="auto", flash_attn=True)
+
+    # initialize the WandB logger
+    run = wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        # name=f"{dataset}_{category}_{file_id}",
+        name=args.EXP_NOTE,
+        config={
+            # "category": category,
+            "dataset": args.EVAL_DATASET,
+    })
+
+    # Define the columns for your table
+    table_columns = [
+        "category", "src_id", "tgt_id", "kpt_id", "plot",
+        "extracted_semantics", "src_response", "src_bbox",
+        "tgt_response", "tgt_bbox"
+    ]
+    # Create the table object that will be populated during the run.
+    results_table = wandb.Table(columns=table_columns)
+
+    for category in categories:
+
+        print(f"Processing category: {category}")
+        category_prompt_sem = task_prompt_sem.format(class_name=category)
+        # print(f"Category prompt for semantic extraction: {category_prompt_sem}")
+
+        files, kps, thresholds, used_points = load_eval_data(args, data_dir, category, split)
+        # # print(category_prompt) # N: number of pairs
+        # print(f"Number of files: {len(files)}") # 2*N images, (source, target)
+        # print(f"Number of keypoints: {len(kps)}") # 2*N 
+        # print(f"Number of thresholds: {len(thresholds)}") # N, max bounding box for target pair
+        # # print(thresholds)
+        # print(f"Number of used points: {len(used_points)}") # .any() points across all pairs in the same category
+
+        N = len(files) // 2  # Number of pairs
+
+        for pair_idx in range(N):
+            img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE, edge=False)
+            img2, img2_kps = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE, edge=False)
+
+            src_id = files[2*pair_idx].split('/')[-1].split('.')[0]
+            tgt_id = files[2*pair_idx+1].split('/')[-1].split('.')[0]
+
+            print(f"Processing pair {pair_idx}: {src_id} (source) and {tgt_id} (target)")
+
+            # check the visibility of the source keypoints
+            for kps_idx in range(img1_kps.shape[0]):
+                if img1_kps[kps_idx, 2] == 1:
+                    print(f"Keypoint {kps_idx} in image 1 is visible.")
+
+                    img1_kp = create_image_with_one_kp(img1, img1_kps, kps_idx=kps_idx, add_text=False, add_circle=True)
+
+                    src_results = model.chat(img1_kp, category_prompt_sem, system_prompt=system_prompt_sem, prompt_type='self-handled')
+                    print(f"Source results: {src_results['response']}")
+                    
+                    original_size = img1_kp.size
+                    bbox_with_label_src = model._get_bounding_boxes(
+                        src_results['response'], 
+                        src_results['input_size'], 
+                        original_size
+                    )
+
+                    
+                    src_bbox = list(bbox_with_label_src.values())[0]['bbox'] if bbox_with_label_src else None
+                    # print(f"Extracted bounding box from source image: {src_bbox}")
+                    # print(f"Results for keypoint {kps_idx}: {src_results['response']}")
+                    # print(f"Extracted bounding box: {src_bbox}")
+
+                    extracted_semantics = src_results['response'].split("Keypoint component:")[-1].strip()
+                    print(f"Extracted semantics: {extracted_semantics}")
+
+                    
+                    curr_prompt_bbox = task_prompt_bbox.format(class_name=category, extracted_semantics=extracted_semantics)
+
+                    print(f"Refined task prompt for bounding box: {curr_prompt_bbox}")
+
+
+                    results_tgt = model.predict(img2, curr_prompt_bbox, system_prompt=system_prompt_bbox, prompt_type='object', bbox_refine=False)
+                    tgt_bbox = model.predict_bounding_boxes(img2, results_tgt['response'], results_tgt['input_size'])
+
+                    print(f"Results for target image: {results_tgt['response']}")
+
+
+                    # logging the results
+                    fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+                    axes[0].imshow(np.array(img1_kp))
+                    axes[0].axis('off')
+                    axes[0].set_title('Source Image with Keypoint and Bounding Box')
+                    axes[1].imshow(np.array(img2))
+                    axes[1].axis('off')
+                    axes[1].set_title('Target Image with Bounding Box')
+                    if src_bbox:
+                        abs_x1, abs_y1, abs_x2, abs_y2 = src_bbox
+                        axes[0].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+                    else:
+                        axes[0].text(150, 30, "No bounding box found", color='red', fontsize=12, ha='center', va='center')
+                    if tgt_bbox:
+                        abs_x1, abs_y1, abs_x2, abs_y2 = tgt_bbox
+                        axes[1].add_patch(plt.Rectangle((abs_x1, abs_y1), abs_x2 - abs_x1, abs_y2 - abs_y1, edgecolor='green', facecolor='none', linewidth=2))
+                    else:
+                        axes[1].text(150, 30, "No bounding box found", color='red', fontsize=12, ha='center', va='center')
+                        
+                    fig.tight_layout()
+                    plt.axis('off')
+                    # wandb.log({f"pair_{pair_idx}/kps_{kps_idx}": fig})
+
+
+                    wandb.log({
+                        f"{category}/plot": wandb.Image(fig),
+                        # f"{category}/src_id": src_id,
+                        # f"{category}/tgt_id": tgt_id,
+                        # f"{category}/kpt_id": kps_idx,
+                        # f"{category}/extracted_semantics": extracted_semantics,
+                    })
+                    plt.close(fig) # Close plot to free memory
+
+                    # --- 3. ADD DATA TO FINAL TABLE ---
+                    # Add the same data to the table object in memory.
+                    results_table.add_data(
+                        category,
+                        src_id,
+                        tgt_id,
+                        kps_idx,
+                        wandb.Image(fig), # Create a new wandb.Image as the figure was closed
+                        extracted_semantics,
+                        src_results['response'],
+                        str(src_bbox),
+                        results_tgt['response'],
+                        str(tgt_bbox)
+                    )
+
+                    # run.log({"evaluation_results": results_table})
+
+                    # break
+
+
+            # break
+
+            # print(f"img1_kps shape: {img1_kps.shape}")
+
+        # break
+
+        # print(category_prompt)
+
+    print('Finished processing all categories and logging results.')
+    wandb.log({"evaluation_results": results_table})
+    wandb.finish()
+    print('WandB run finished.')
+
+    # return None
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Predict correspondence using Qwen VLM.")
+    # parser.add_argument('--data_path', type=str, required=True, help='Path to the dataset directory.')
+    parser.add_argument('--SYSTEM_PROMPT_SEM', type=str, required=True, help='Path to the .txt file containing the prompt template.')
+    parser.add_argument('--SYSTEM_PROMPT_BBOX', type=str, required=True, help='Path to the task prompt file.')
+
+    parser.add_argument('--TASK_PROMPT_SEM', type=str, required=True, help='Path to the prompt template file.')
+    parser.add_argument('--TASK_PROMPT_BBOX', type=str, required=True, help='Path to the task prompt file.')
+
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, choices=['pascal', 'spair'], help='Dataset to evaluate on.')
+    parser.add_argument('--ANNO_SIZE', type=int, default=840, help='Size of the annotation circle in pixels.')
+    parser.add_argument('--TEST_SAMPLE', type=int, default=0, help='Number of test samples to process.')
+    # parser.add_argument
+    # parser.add_argument('--img1_path', type=str, required=True, help='Path to the first image.')
+    # parser.add_argument('--img2_path', type=str, required=True, help='Path to the second image.')
+    # parser.add_argument('--kps_path', type=str, required=True, help='Path to the keypoints file.')
+    # parser.add_argument('--prompt_template', type=str, required=True, help='Template for the prompt.')
+
+    parser.add_argument('--EXP_NOTE', type=str, default='Qwen VLM demo', help='Experiment note for WandB logging.')
+
+    args = parser.parse_args()
+
+    main(args)

Code/sc_dit/qwen_utils.py

@@ -0,0 +1,1452 @@
+# class PromptManager():
+#     def __init__(self):
+#         pass
+
+#     def construct_prompt(self, text_prompt, prompt_type):
+#         if prompt_type.lower() == 'object':
+#             prompt = f"""Outline the position of each {text_prompt} and output all bounding box coordinates in JSON format"""
+#         elif prompt_type.lower() == 'self-handled':
+#             prompt = text_prompt
+#         else:
+#             raise NotImplementedError
+
+#         return prompt
+
+import os
+from os import path
+from PIL import Image, ImageDraw, ImageFont
+from PIL import ImageColor
+import json
+import requests
+from io import BytesIO
+from urllib.parse import urlparse
+import pathlib
+import torch
+from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+from qwen_vl_utils import process_vision_info
+
+class PromptManager:
+    """
+    Builds a prompt that forces the LLM to return
+    a *pure* JSON list of bounding-box dictionaries:
+
+        [
+          {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"},
+          ...
+        ]
+    """
+
+    @staticmethod
+    def construct_prompt(text_prompt: str, prompt_type: str = "object") -> str:
+        if prompt_type.lower() == "object":
+            prompt = text_prompt+"""
+                Required format (copy this structure exactly):
+                ```json
+                [
+                {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"},
+                ]
+                ```
+            """
+            return prompt
+    
+        elif prompt_type.lower() == "object_with_conf":
+            prompt = text_prompt+"""
+                Required format (copy this structure exactly):
+                ```json
+                [
+                {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>", "confidence": <confidence-value>},
+                ]
+                ```
+            """
+            return prompt
+        elif prompt_type.lower() == "self-handled":
+            return text_prompt
+        else:
+            raise NotImplementedError("prompt_type must be 'object' or 'self-handled'")
+
+
+def load_image(source, image_path=None):
+    try:
+        parsed = urlparse(source)
+        is_url = bool(parsed.scheme and parsed.netloc)
+        
+        if is_url:
+            response = requests.get(source, stream=True)
+            response.raise_for_status()
+            img = Image.open(BytesIO(response.content))
+        else:
+            if path.exists(source):
+                img = Image.open(source)
+            else:
+                print(f"Error: Local file not found at {source}")
+                return None
+        
+        if image_path is not None:
+            directory = path.dirname(image_path)
+            if directory and not path.exists(directory):
+                pathlib.Path(directory).mkdir(parents=True, exist_ok=True)
+            img.save(image_path)
+            print(f"Image saved to {image_path}")
+                
+        return img
+                
+    except Exception as e:
+        print(f"Error loading image: {e}")
+        return None
+
+
+class QwenVLDetector():
+    def __init__(self, model_dir=None, torch_dtype=torch.bfloat16, device="cuda:0", model_name="Qwen/Qwen2.5-VL-7B-Instruct", flash_attn=False):
+        if model_dir is not None:
+            self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_dir, torch_dtype=torch_dtype, device_map=device, local_files_only=True)
+            self.processor = AutoProcessor.from_pretrained(model_dir)
+        else:
+            attn_impl = "flash_attention_2" if flash_attn else "sdpa"
+            self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch_dtype, device_map=device, attn_implementation=attn_impl)
+            self.processor = AutoProcessor.from_pretrained(model_name)
+        
+
+        self.processor.tokenizer.padding_side = "left"
+        self.prompt_manager = PromptManager()
+        self._init_parameters()
+
+    def _init_parameters(self):
+        self.max_size = 1024
+        self.max_new_tokens = 1024
+        self.min_pixels = 512 * 512
+        self.max_pixels = self.max_size * self.max_size 
+
+    def resize_image(self, img, max_size):
+        width, height = img.size
+        if max(width, height) <= max_size:
+            return img
+        scaling_factor = max_size / max(width, height)
+        new_width = int(width * scaling_factor)
+        new_height = int(height * scaling_factor)
+        return img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+    def _parse_json(self, response_text):
+        """
+        Parses a JSON object from a model's response text.
+        Prioritizes extracting from a ```json markdown fence.
+        """
+        try:
+            # Priority 1: Look for a JSON markdown fence. This is the most reliable.
+            if "```json" in response_text:
+                # Isolate the string between the fences
+                json_str = response_text.split("```json")[1].split("```")[0]
+                return json_str.strip()
+
+            # Priority 2: If no fence, find the first '[' and last ']'
+            # This is less reliable and can cause the error you saw.
+            start_idx = response_text.find('[')
+            end_idx = response_text.rfind(']')
+            
+            if start_idx != -1 and end_idx != -1 and end_idx > start_idx:
+                return response_text[start_idx : end_idx + 1]
+
+        except (IndexError, json.JSONDecodeError):
+            # This will catch errors from malformed markdown or other slicing issues.
+            pass
+
+        # Return None if no valid JSON is found
+        return None
+
+    def calculate_iou(self, box1, box2):
+        x1_1, y1_1, x2_1, y2_1 = box1
+        x1_2, y1_2, x2_2, y2_2 = box2
+        area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+        area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+        x1_i, y1_i = max(x1_1, x1_2), max(y1_1, y1_2)
+        x2_i, y2_i = min(x2_1, x2_2), min(y2_1, y2_2)
+        if x2_i <= x1_i or y2_i <= y1_i:
+            return 0.0
+        intersection_area = (x2_i - x1_i) * (y2_i - y1_i)
+        union_area = area1 + area2 - intersection_area
+        return intersection_area / union_area if union_area > 0 else 0.0
+
+    def _check_bbox(self, bbox_with_label, bbox_coor, size, threshold=0.7):
+        x1, y1, x2, y2 = bbox_coor
+        width, height = size
+        if (x2 - x1) * (y2 - y1) / (width * height) >= threshold:
+            return False
+        for bbox_label in bbox_with_label.values():
+            if self.calculate_iou(bbox_label['bbox'], bbox_coor) >= threshold:
+                return False
+        return True
+
+    def _get_bounding_boxes(self, response, input_size, size):
+        bounding_boxes_str = self._parse_json(response)
+        print(f"Bounding boxes string: {bounding_boxes_str}")
+        if not bounding_boxes_str:
+            return {}
+            
+        input_width, input_height = input_size
+        width, height = size
+    
+        try:
+            # Use robust, standard JSON parsing
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not decode JSON from model output: {bounding_boxes_str}")
+            return {}
+    
+        bbox_with_label = {}
+        if isinstance(json_output, list) and len(json_output) > 0:
+            for i, bounding_box in enumerate(json_output):   
+                try:           
+                    coords = bounding_box["bbox_2d"]
+                    abs_x1 = int(coords[0] / input_width * width)            
+                    abs_y1 = int(coords[1] / input_height * height)
+                    abs_x2 = int(coords[2] / input_width * width)
+                    abs_y2 = int(coords[3] / input_height * height)            
+            
+                    if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                    if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+
+                    if self._check_bbox(bbox_with_label, [abs_x1, abs_y1, abs_x2, abs_y2], size):                        
+                        bbox_with_label[i] = {'bbox': [abs_x1, abs_y1, abs_x2, abs_y2], 'label': bounding_box.get('label')}
+                    
+                except (KeyError, IndexError, TypeError) as e:
+                    print(f"Error processing bounding box {bounding_box}: {e}")                
+
+        return bbox_with_label
+    
+    def _get_bounding_boxes_with_conf(self, response, input_size, size):
+        bounding_boxes_str = self._parse_json(response)
+        print(f"Bounding boxes string: {bounding_boxes_str}")
+        if not bounding_boxes_str:
+            return {}
+
+        input_width, input_height = input_size
+        width, height = size
+
+        try:
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not decode JSON from model output: {bounding_boxes_str}")
+            return {}
+
+        bbox_with_label = {}
+        if isinstance(json_output, list) and len(json_output) > 0:
+            for i, bounding_box in enumerate(json_output):
+                try:
+                    label = bounding_box.get('label')
+                    # NEW: Get the confidence score, default to None if not present
+                    confidence = bounding_box.get('confidence')
+                    coords = bounding_box.get("bbox_2d")
+
+                    # NEW: Handle null bounding boxes
+                    if coords is None:
+                        # Store the prediction even if there's no box
+                        bbox_with_label[i] = {'bbox': None, 'label': label, 'confidence': confidence}
+                        continue # Move to the next item
+
+                    # If we have coordinates, process them
+                    abs_x1 = int(coords[0] / input_width * width)
+                    abs_y1 = int(coords[1] / input_height * height)
+                    abs_x2 = int(coords[2] / input_width * width)
+                    abs_y2 = int(coords[3] / input_height * height)
+
+                    if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                    if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+
+                    processed_bbox = [abs_x1, abs_y1, abs_x2, abs_y2]
+
+                    # Check for overlap and size constraints
+                    if self._check_bbox(bbox_with_label, processed_bbox, size):
+                        bbox_with_label[i] = {
+                            'bbox': processed_bbox,
+                            'label': label,
+                            'confidence': confidence # NEW: Store confidence
+                        }
+
+                except (KeyError, IndexError, TypeError) as e:
+                    print(f"Error processing bounding box {bounding_box}: {e}")
+
+        return bbox_with_label
+
+    def chat(self, image, text_prompt, system_prompt, prompt_type):
+        curr_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+        # Handle the image input: either load from URL or use the PIL Image directly
+        if isinstance(image, str):
+            # It's a URL or path, load the image
+            image_type = 'str'
+            image_pil = load_image(image)
+            size = image_pil.size
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image,
+                            "min_pixels": self.min_pixels,
+                            "max_pixels": self.max_pixels
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            image_inputs, video_inputs = process_vision_info(messages)
+            inputs = self.processor(text=[text], 
+                                    images=image_inputs, 
+                                    videos=video_inputs, 
+                                    padding=True, 
+                                    return_tensors="pt"
+                                   ).to(self.model.device)
+            
+        else:
+            image_type = 'pil'
+            # Assume it's already a PIL Image
+            image_pil = image
+            # For the message content, we need to use the image directly
+
+            size = image_pil.size
+            image_for_message = self.resize_image(image_pil, self.max_size)
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image_for_message
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+        output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+        response = output_text[0]
+
+        input_height = inputs['image_grid_thw'][0][1] * 14
+        input_width = inputs['image_grid_thw'][0][2] * 14
+        input_size = (input_width.item(), input_height.item())
+
+        del text, inputs, output_ids, generated_ids, output_text
+        torch.cuda.empty_cache()
+
+        return {'response': response, 'input_size': input_size}
+
+    # def predict(self, image, text_prompt, system_prompt, prompt_type='object', bbox_refine=False):
+    #     # This method's internal logic remains the same, as it calls _get_bounding_boxes
+    #     # which has been corrected.
+    #     curr_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+    #     print('this is my curr prompt:', curr_prompt)
+
+    #     if isinstance(image, str):
+    #         image_pil = load_image(image)
+    #         image_for_message = image
+    #     else:
+    #         image_pil = image
+    #         image_for_message = self.resize_image(image_pil, self.max_size)
+
+    #     size = image_pil.size
+    #     messages = [
+    #         {"role": "system", "content": system_prompt},
+    #         {"role": "user", "content": [{"type": "text", "text": curr_prompt}, {"type": "image", "image": image_for_message}]}
+    #     ]
+        
+    #     text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    #     inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+    #     output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+    #     generated_ids = output_ids[:, inputs.input_ids.shape[1]:]
+    #     response = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)[0]
+    
+    #     input_height = inputs['image_grid_thw'][0][1] * 14
+    #     input_width = inputs['image_grid_thw'][0][2] * 14
+    #     input_size = (input_width.item(), input_height.item())
+
+    #     # Cleanup
+    #     del text, inputs, output_ids, generated_ids
+    #     torch.cuda.empty_cache()
+        
+    #     # Bbox refine logic can be kept if needed
+    #     # if bbox_refine: ...
+
+    #     bbox_with_label = self._get_bounding_boxes(response, input_size, size)
+    #     results = {'bbox_with_label': bbox_with_label, 'response': response, 'input_size': input_size}
+
+    #     return results
+
+    def predict(self, image, text_prompt, system_prompt, prompt_type='object', bbox_refine=False):
+        curr_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+        print('this is my curr prompt:', curr_prompt)
+
+        # Handle the image input: either load from URL or use the PIL Image directly
+        if isinstance(image, str):
+            # It's a URL or path, load the image
+            image_type = 'str'
+            image_pil = load_image(image)
+            size = image_pil.size
+            image_for_message = image
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image,
+                            "min_pixels": self.min_pixels,
+                            "max_pixels": self.max_pixels
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            image_inputs, video_inputs = process_vision_info(messages)
+            inputs = self.processor(text=[text], 
+                                    images=image_inputs, 
+                                    videos=video_inputs, 
+                                    padding=True, 
+                                    return_tensors="pt"
+                                   ).to(self.model.device)
+        else:
+            image_type = 'pil'
+            # Assume it's already a PIL Image
+            image_pil = image
+            # For the message content, we need to use the image directly
+
+            size = image_pil.size
+            image_for_message = self.resize_image(image_pil, self.max_size)
+            
+            messages = [
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": curr_prompt
+                        },
+                        {
+                            "type": "image",
+                            "image": image_for_message
+                        }
+                    ]
+                }
+            ]
+    
+            text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+        output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+    
+        input_height = inputs['image_grid_thw'][0][1]*14
+        input_width = inputs['image_grid_thw'][0][2]*14
+        
+        response_org = output_text[0]
+        input_size = (input_width.item(), input_height.item())
+
+        del text, inputs, output_ids, generated_ids, output_text
+        torch.cuda.empty_cache()
+
+        if bbox_refine:
+            response = self._bbox_refine(response_org, messages, image_type, image_for_message)
+        else:
+            response = response_org
+
+        results = dict()
+        bbox_with_label = self._get_bounding_boxes(response, input_size, size)
+        results = {'bbox_with_label': bbox_with_label, 'response': response, 'input_size': input_size}
+
+        return results
+
+    def plot_bounding_boxes(self, image, response, input_size, output_path='./temp.png'):
+        img = image.copy()
+        width, height = img.size
+        input_width, input_height = input_size
+    
+        draw = ImageDraw.Draw(img)
+        colors = list(ImageColor.colormap.keys())
+        font = ImageFont.load_default()
+
+        bounding_boxes_str = self._parse_json(response)
+        if not bounding_boxes_str:
+            print("No bounding boxes found in the response.")
+            img.save(output_path)
+            return
+
+        try:
+            # Use robust, standard JSON parsing
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not decode JSON for plotting: {bounding_boxes_str}")
+            img.save(output_path)
+            return
+
+        if isinstance(json_output, list) and len(json_output) > 0:
+            for i, bounding_box in enumerate(json_output):
+                try:                
+                    color = colors[i % len(colors)]
+                    coords = bounding_box["bbox_2d"]
+                    abs_x1 = int(coords[0] / input_width * width)
+                    abs_y1 = int(coords[1] / input_height * height)
+                    abs_x2 = int(coords[2] / input_width * width)
+                    abs_y2 = int(coords[3] / input_height * height) 
+            
+                    if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                    if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+            
+                    draw.rectangle(((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4)
+            
+                    if "label" in bounding_box:
+                        draw.text((abs_x1 + 8, abs_y1 + 6), str(bounding_box["label"]), fill=color, font=font)
+                except (KeyError, IndexError, TypeError) as e:
+                    print(f"Error processing bounding box for plotting {bounding_box}: {e}")                
+    
+        img.save(output_path)
+        print(f"Image with bounding boxes saved to: {output_path}")
+
+    def predict_bounding_boxes(self, image, response, input_size):
+        # This method is for extracting coordinates, so it also benefits from robust parsing
+        width, height = image.size
+        input_width, input_height = input_size
+        
+        bounding_boxes_str = self._parse_json(response)
+        if not bounding_boxes_str:
+            return None
+
+        try:
+            # Use robust, standard JSON parsing
+            json_output = json.loads(bounding_boxes_str)
+        except json.JSONDecodeError:
+            return None
+
+        if isinstance(json_output, list) and len(json_output) > 0:
+            try:
+                bounding_box = json_output[0] # Assuming we only want the first one
+                coords = bounding_box["bbox_2d"]
+                abs_x1 = int(coords[0] / input_width * width)
+                abs_y1 = int(coords[1] / input_height * height)
+                abs_x2 = int(coords[2] / input_width * width)
+                abs_y2 = int(coords[3] / input_height * height)
+                if abs_x1 > abs_x2: abs_x1, abs_x2 = abs_x2, abs_x1
+                if abs_y1 > abs_y2: abs_y1, abs_y2 = abs_y2, abs_y1
+                return [abs_x1, abs_y1, abs_x2, abs_y2]
+            except (KeyError, IndexError, TypeError):
+                return None
+        return None
+
+    # ===================================================================
+    # NEW BATCHED INFERENCE FUNCTIONS
+    # ===================================================================
+    def chat_batch(self, images, text_prompts, system_prompt, prompt_type):
+        """Processes a batch of images and prompts for chat-style interaction."""
+        if not images:
+            return []
+
+        # 1. Prepare all inputs for the batch
+        prompts = [self.prompt_manager.construct_prompt(tp, prompt_type) for tp in text_prompts]
+        images_for_message = [self.resize_image(img, self.max_size) for img in images]
+
+        print(f"Batch size: {len(images)}")
+        print(f"Prompts: {prompts}")
+        
+        # 2. Create message structures for the entire batch
+        batch_messages = []
+        for i in range(len(images)):
+            batch_messages.append([
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": [{"type": "text", "text": prompts[i]}, {"type": "image"}]}
+            ])
+            
+        # 3. Use the processor on the entire batch at once
+        text_for_processor = [self.processor.apply_chat_template(m, tokenize=False, add_generation_prompt=True) for m in batch_messages]
+        inputs = self.processor(
+            text=text_for_processor, 
+            images=images_for_message, 
+            padding=True, 
+            return_tensors="pt"
+        ).to(self.model.device)
+
+        # 4. Generate outputs for the entire batch
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [out[len(inp):] for inp, out in zip(inputs.input_ids, output_ids)]
+        responses = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+
+        # 5. Format results
+        input_height = inputs['image_grid_thw'][0][1] * 14
+        input_width = inputs['image_grid_thw'][0][2] * 14
+        input_size = (input_width.item(), input_height.item())
+
+        batch_results = []
+        for response in responses:
+            batch_results.append({'response': response, 'input_size': input_size})
+            
+        del inputs, output_ids, generated_ids
+        # torch.cuda.empty_cache()
+            
+        return batch_results
+
+    def predict_batch(self, images, text_prompts, system_prompt, prompt_type='object'):
+        """Processes a batch of images and prompts to predict bounding boxes."""
+        if not images:
+            return []
+
+        # 1. Prepare all inputs for the batch
+        prompts = [self.prompt_manager.construct_prompt(tp, prompt_type) for tp in text_prompts]
+        images_for_message = [self.resize_image(img, self.max_size) for img in images]
+        original_sizes = [img.size for img in images]
+
+        # 2. Create message structures for the entire batch
+        batch_messages = []
+        for i in range(len(images)):
+            batch_messages.append([
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": [{"type": "text", "text": prompts[i]}, {"type": "image"}]}
+            ])
+
+        # 3. Use the processor on the entire batch at once
+        text_for_processor = [self.processor.apply_chat_template(m, tokenize=False, add_generation_prompt=True) for m in batch_messages]
+        inputs = self.processor(
+            text=text_for_processor, 
+            images=images_for_message, 
+            padding=True, 
+            return_tensors="pt"
+        ).to(self.model.device)
+
+        # 4. Generate outputs for the entire batch
+        output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+        generated_ids = [out[len(inp):] for inp, out in zip(inputs.input_ids, output_ids)]
+        responses = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+
+        # 5. Format results
+        input_height = inputs['image_grid_thw'][0][1] * 14
+        input_width = inputs['image_grid_thw'][0][2] * 14
+        input_size = (input_width.item(), input_height.item())
+
+        batch_results = []
+        for i, response in enumerate(responses):
+            if prompt_type == 'object_with_conf':
+                bbox_with_label = self._get_bounding_boxes_with_conf(response, input_size, original_sizes[i])
+            else:
+                bbox_with_label = self._get_bounding_boxes(response, input_size, original_sizes[i])
+            batch_results.append({
+                'bbox_with_label': bbox_with_label, 
+                'response': response, 
+                'input_size': input_size
+            })
+
+        del inputs, output_ids, generated_ids
+        # torch.cuda.empty_cache()
+            
+        return batch_results
+
+    def predict_paired_batch(self, images1, images2, text_prompts, system_prompt, prompt_type='self-handled'):
+        """Processes a batch of images and prompts to predict bounding boxes."""
+        if not images1 or not images2:
+            return []
+
+        assert len(images1) == len(images2) == len(text_prompts), "All inputs must have the same length"
+
+        # 1. Prepare prompts
+        prompts = [self.prompt_manager.construct_prompt(tp, prompt_type) for tp in text_prompts]
+
+        # 2. Create batched messages
+        batch_messages = []
+        for i in range(len(images1)):
+            batch_messages.append([
+                {"role": "system", "content": system_prompt},
+                {"role": "user", 
+                "content": [
+                    {"type": "image", "image": images1[i]},
+                    {"type": "image", "image": images2[i]},
+                    {"type": "text", "text": prompts[i]}, 
+                    ]
+                }
+            ])
+
+        # 3. Extract vision inputs (handles batch of conversations)
+        image_inputs, video_inputs = process_vision_info(batch_messages)
+
+        # 4. Apply chat template and tokenize
+        texts = [
+            self.processor.apply_chat_template(msg, tokenize=False, add_generation_prompt=True)
+            for msg in batch_messages
+        ]
+        inputs = self.processor(
+            text=texts,
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt"
+        ).to(self.model.device)
+
+        print('inputs preprocess', inputs['image_grid_thw'])
+
+        # 5. Generate
+        output_ids = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens
+        )
+        generated_ids = [out[len(inp):] for inp, out in zip(inputs.input_ids, output_ids)]
+        response_texts = self.processor.batch_decode(
+            generated_ids,
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=True
+        )
+
+        # 6. Parse responses and compute input sizes per sample
+        batch_results = []
+        for i, text in enumerate(response_texts):
+            print(f"Response text for sample {i}: {text}")
+            # Parse JSON
+            try:
+                clean_text = text.strip()
+                if clean_text.startswith("```"):
+                    clean_text = "\n".join(line for line in clean_text.splitlines()
+                                    if not line.startswith("```"))
+                response = json.loads(clean_text)
+            except json.JSONDecodeError:
+                response = {
+                    "bbox_2d": [0, 0, 0, 0],
+                    "visible": False,
+                    "label": "unknown",
+                    "confidence": 0.0,
+                    "reasoning": "Failed to parse model output."
+                }
+
+            # Get correct image grid for this sample
+            crop_grid_thw = inputs['image_grid_thw'][2*i]  # [T, H, W]
+            crop_height = crop_grid_thw[1].item() * 14  # H patches
+            crop_width = crop_grid_thw[2].item() * 14   # W patches
+            crop_size = (crop_height, crop_width)
+
+            img_grid_thw = inputs['image_grid_thw'][2*i+1]  # [T, H, W]
+            img_height = img_grid_thw[1].item() * 14  # H
+            img_width = img_grid_thw[2].item() * 14   # W
+            img_size = (img_height, img_width)
+
+            batch_results.append({
+                'img2_bbox': response.get('bbox_2d', [0,0,0,0]),
+                'visible': response.get('visible', False),
+                'crop_size': crop_size,
+                'img_size': img_size,
+                'label': response.get('label', 'unknown'),
+                'reasoning': response.get('reasoning', 'No reasoning provided.'),
+                'raw_response_text': text  # useful for debugging
+            })
+
+        # Cleanup
+        del inputs, output_ids, generated_ids
+        return batch_results
+
+
+# class PromptManager:
+#     """
+#     Builds a prompt that forces the LLM to return
+#     a *pure* JSON list of bounding-box dictionaries:
+
+#         [
+#           {"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"},
+#           ...
+#         ]
+#     """
+
+#     @staticmethod
+#     def construct_prompt(text_prompt: str, prompt_type: str = "object") -> str:
+#         """
+#         Parameters
+#         ----------
+#         target_desc : str
+#             Human-readable name of what you want boxed, e.g. "rear wheel of the motorbike".
+#         prompt_type : str
+#             Supported: "object" (build full bounding-box prompt)
+#                         "self-handled" (return target_desc unchanged)
+#         """
+#         if prompt_type.lower() == "object":
+#             # ░░░ Prompt template ░░░
+#             prompt = f"""{text_prompt}
+#                 Required format (copy this structure exactly):
+#                 ```json
+#                 [
+#                 {{"bbox_2d": [x1, y1, x2, y2], "label": "<your-label>"}},
+#                 ]
+#                 ```
+#             """
+#             # Strip leading spaces so the first char is '[' once the model starts its answer
+#             return prompt
+
+#         elif prompt_type.lower() == "self-handled":
+#             return text_prompt
+#         else:
+#             raise NotImplementedError("prompt_type must be 'object' or 'self-handled'")
+
+
+# import os
+# from os import path
+# from PIL import Image, ImageDraw, ImageFont
+# from PIL import ImageColor
+# import json
+# import requests
+# from io import BytesIO
+# from urllib.parse import urlparse
+# import pathlib
+
+# import ast
+# import torch
+# from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+# from qwen_vl_utils import process_vision_info
+
+# # from .prompt_manager import PromptManager
+
+
+# def load_image(source, image_path=None):
+#     """
+#     Load an image from a URL or local file path and return a PIL Image object.
+#     Optionally save the loaded image to a specified path.
+    
+#     Args:
+#         source (str): URL or local file path to the image
+#         image_path (str, optional): Path where to save the loaded image
+        
+#     Returns:
+#         PIL.Image: The loaded image or None if loading fails
+#     """
+#     try:
+#         # Check if the source is a URL or local path
+#         parsed = urlparse(source)
+#         is_url = bool(parsed.scheme and parsed.netloc)
+        
+#         if is_url:
+#             # Handle URL
+#             response = requests.get(source, stream=True)
+#             response.raise_for_status()
+#             img = Image.open(BytesIO(response.content))
+#         else:
+#             # Handle local file path
+#             if path.exists(source):
+#                 img = Image.open(source)
+#             else:
+#                 print(f"Error: Local file not found at {source}")
+#                 return None
+        
+#         # Save the image if image_path is provided
+#         if image_path is not None:
+#             # Make sure the directory exists
+#             directory = path.dirname(image_path)
+#             if directory and not path.exists(directory):
+#                 pathlib.Path(directory).mkdir(parents=True, exist_ok=True)
+            
+#             # Save the image in the appropriate format based on file extension
+#             img.save(image_path)
+#             print(f"Image saved to {image_path}")
+                
+#         return img
+                
+#     except Exception as e:
+#         print(f"Error loading image: {e}")
+#         return None
+
+
+# class QwenVLDetector():
+#     # Qwen 2.5 VL
+    
+#     def __init__(self, model_dir=None, torch_dtype=torch.bfloat16, device="cuda:0", model_name="Qwen/Qwen2.5-VL-7B-Instruct", flash_attn=False):
+#         if model_dir is not None:
+#             # Load model and processor from local directory
+#             self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+#                 model_dir,
+#                 torch_dtype=torch_dtype,
+#                 device_map=device,  # Explicitly use first GPU
+#                 local_files_only=True  # Ensures it only looks for local files
+#             )
+#             self.processor = AutoProcessor.from_pretrained(model_dir)
+#         else:
+#             if flash_attn:
+#                 self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch_dtype, device_map=device, attn_implementation="flash_attention_2")
+#             else:
+#                 self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch_dtype, device_map=device)
+#             self.processor = AutoProcessor.from_pretrained(model_name)
+            
+#         # self.system_prompt = system_prompt
+#         self.prompt_manager = PromptManager()
+#         self._init_parameters()
+
+#     def _init_parameters(self):
+#         self.max_size = 1024
+#         self.max_new_tokens = 1024
+#         self.min_pixels = 512 * 512
+#         self.max_pixels = self.max_size * self.max_size 
+
+#     def resize_image(self, img, max_size):
+#         # Get original dimensions                                                                                                               
+#         width, height = img.size
+#             # If image already satisfies the size limit, return original                                                                                           
+#         if max(width, height) <= max_size:
+#             return img
+    
+#         # Calculate scaling factor                                                                                                                             
+#         if width >= height:
+#             # Width is the long edge                                                                                                                           
+#             scaling_factor = max_size / width
+#             new_width = max_size
+#             new_height = int(height * scaling_factor)
+#         else:
+#             # Height is the long edge                                                                                                                          
+#             scaling_factor = max_size / height
+#             new_height = max_size
+#             new_width = int(width * scaling_factor)
+    
+#         # Resize image                                                
+#         resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+#         return resized_img
+
+#     # @title Parsing JSON output
+#     def _parse_json(self, json_output):
+#         # Parsing out the markdown fencing
+#         lines = json_output.splitlines()
+#         for i, line in enumerate(lines):
+#             if line == "```json":
+#                 json_output = "\n".join(lines[i+1:])  # Remove everything before "```json"
+#                 json_output = json_output.split("```")[0]  # Remove everything after the closing "```"
+#                 return json_output
+#         return None   # Bounding box not found
+
+#     def calculate_iou(self, box1, box2):
+#         """
+#         Calculate the Intersection over Union (IoU) between two bounding boxes.
+        
+#         Args:
+#             box1 (list): First bounding box in format [x1, y1, x2, y2]
+#                          where (x1, y1) is the top-left corner and (x2, y2) is the bottom-right corner
+#             box2 (list): Second bounding box in same format
+        
+#         Returns:
+#             float: IoU value between 0 and 1
+#         """
+#         # Extract coordinates
+#         x1_1, y1_1, x2_1, y2_1 = box1
+#         x1_2, y1_2, x2_2, y2_2 = box2
+        
+#         # Calculate area of each bounding box
+#         area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+#         area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+        
+#         # Calculate coordinates of intersection
+#         x1_i = max(x1_1, x1_2)
+#         y1_i = max(y1_1, y1_2)
+#         x2_i = min(x2_1, x2_2)
+#         y2_i = min(y2_1, y2_2)
+        
+#         # Check if there is an intersection
+#         if x2_i <= x1_i or y2_i <= y1_i:
+#             return 0.0
+        
+#         # Calculate intersection area
+#         intersection_area = (x2_i - x1_i) * (y2_i - y1_i)
+        
+#         # Calculate union area (sum of areas - intersection)
+#         union_area = area1 + area2 - intersection_area
+        
+#         # Calculate IoU
+#         iou = intersection_area / union_area
+        
+#         return iou
+
+#     def _check_bbox(self, bbox_with_label, bbox_coor, size, threshold=0.7):
+#         x1, y1, x2, y2 = bbox_coor
+#         width, height = size
+#         if (x2 - x1) * (y2 - y1) / width / height >= threshold:
+#             return False
+
+#         for idx, bbox_label in bbox_with_label.items():
+#             iou = self.calculate_iou(bbox_label['bbox'], bbox_coor)
+#             if iou >= threshold:
+#                 return False
+
+#         return True
+
+#     def _get_bounding_boxes(self, response, input_size, size):
+#         # Parsing out the markdown fencing
+#         bounding_boxes = self._parse_json(response)
+#         if bounding_boxes is None:
+#             return dict()
+            
+#         input_width, input_height = input_size
+#         width, height = size
+    
+#         try:
+#             json_output = ast.literal_eval(bounding_boxes)
+#         except Exception as e:
+#             end_idx = bounding_boxes.rfind('"}') + len('"}')
+#             truncated_text = bounding_boxes[:end_idx] + "]"
+#             json_output = ast.literal_eval(truncated_text)
+    
+#         # Iterate over the bounding boxes
+#         bbox_with_label = dict()
+
+#         if len(json_output) > 0:        
+#             for i, bounding_box in enumerate(json_output):   
+#                 try:           
+                    
+#                     # Convert normalized coordinates to absolute coordinates
+#                     abs_x1 = int(bounding_box["bbox_2d"][0] / input_width * width)            
+#                     abs_y1 = int(bounding_box["bbox_2d"][1] / input_height * height)
+#                     abs_x2 = int(bounding_box["bbox_2d"][2] / input_width * width)
+#                     abs_y2 = int(bounding_box["bbox_2d"][3] / input_height * height)            
+            
+#                     if abs_x1 > abs_x2:
+#                         abs_x1, abs_x2 = abs_x2, abs_x1
+            
+#                     if abs_y1 > abs_y2:
+#                         abs_y1, abs_y2 = abs_y2, abs_y1     
+
+#                     if self._check_bbox(bbox_with_label, [abs_x1, abs_y1, abs_x2, abs_y2], size):                        
+#                         bbox_with_label[i] = {'bbox': [abs_x1, abs_y1, abs_x2, abs_y2], 'label': bounding_box.get('label')}
+                    
+#                 except Exception as e:
+#                     print(f"Error {str(e)} for bounding box {bounding_box}")                
+
+#         return bbox_with_label
+
+#     def _bbox_refine(self, response_org, messages, image_type, image_for_message):
+#         bbox_text = self._parse_json(response_org)
+#         if bbox_text is None:
+#             return response_org
+
+#         prompt_type = 'bbox_refine'
+#         text_prompt = self.prompt_manager.construct_prompt(bbox_text, prompt_type)
+#         messages[1]['content'][0]['text'] = text_prompt
+        
+#         if image_type == 'str':
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             image_inputs, video_inputs = process_vision_info(messages)
+#             inputs = self.processor(text=[text], 
+#                                     images=image_inputs, 
+#                                     videos=video_inputs, 
+#                                     padding=True, 
+#                                     return_tensors="pt"
+#                                    ).to(self.model.device)            
+#         elif image_type == 'pil':            
+#             # Assume it's already a PIL Image
+#             messages[1]['content'][1]['image'] = image_for_message
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+#         else:
+#             raise NotImplementedError
+            
+#         output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+#         generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+#         output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+#         response = output_text[0]
+
+#         del text, inputs, output_ids, generated_ids, output_text
+#         torch.cuda.empty_cache()
+
+#         return response
+
+#     def chat(self, image, text_prompt, system_prompt, prompt_type):
+#         self.text_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+#         # Handle the image input: either load from URL or use the PIL Image directly
+#         if isinstance(image, str):
+#             # It's a URL or path, load the image
+#             image_type = 'str'
+#             image_pil = load_image(image)
+#             size = image_pil.size
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image,
+#                             "min_pixels": self.min_pixels,
+#                             "max_pixels": self.max_pixels
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             image_inputs, video_inputs = process_vision_info(messages)
+#             inputs = self.processor(text=[text], 
+#                                     images=image_inputs, 
+#                                     videos=video_inputs, 
+#                                     padding=True, 
+#                                     return_tensors="pt"
+#                                    ).to(self.model.device)
+            
+#         else:
+#             image_type = 'pil'
+#             # Assume it's already a PIL Image
+#             image_pil = image
+#             # For the message content, we need to use the image directly
+
+#             size = image_pil.size
+#             image_for_message = self.resize_image(image_pil, self.max_size)
+            
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image_for_message
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+#         output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+#         generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+#         output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+#         response = output_text[0]
+
+#         input_height = inputs['image_grid_thw'][0][1] * 14
+#         input_width = inputs['image_grid_thw'][0][2] * 14
+#         input_size = (input_width.item(), input_height.item())
+
+#         del text, inputs, output_ids, generated_ids, output_text
+#         torch.cuda.empty_cache()
+
+#         return {'response': response, 'input_size': input_size}
+                
+#     def predict(self, image, text_prompt, system_prompt, prompt_type='object', bbox_refine=False):
+#         self.text_prompt = self.prompt_manager.construct_prompt(text_prompt, prompt_type)
+
+#         # Handle the image input: either load from URL or use the PIL Image directly
+#         if isinstance(image, str):
+#             # It's a URL or path, load the image
+#             image_type = 'str'
+#             image_pil = load_image(image)
+#             size = image_pil.size
+#             image_for_message = image
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image,
+#                             "min_pixels": self.min_pixels,
+#                             "max_pixels": self.max_pixels
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             image_inputs, video_inputs = process_vision_info(messages)
+#             inputs = self.processor(text=[text], 
+#                                     images=image_inputs, 
+#                                     videos=video_inputs, 
+#                                     padding=True, 
+#                                     return_tensors="pt"
+#                                    ).to(self.model.device)
+            
+#         else:
+#             image_type = 'pil'
+#             # Assume it's already a PIL Image
+#             image_pil = image
+#             # For the message content, we need to use the image directly
+
+#             size = image_pil.size
+#             image_for_message = self.resize_image(image_pil, self.max_size)
+            
+#             messages = [
+#                 {
+#                     "role": "system",
+#                     "content": system_prompt
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {
+#                             "type": "text",
+#                             "text": self.text_prompt
+#                         },
+#                         {
+#                             "type": "image",
+#                             "image": image_for_message
+#                         }
+#                     ]
+#                 }
+#             ]
+    
+#             text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#             inputs = self.processor(text=[text], images=[image_for_message], padding=True, return_tensors="pt").to(self.model.device)
+            
+#         output_ids = self.model.generate(**inputs, max_new_tokens=self.max_new_tokens)
+#         generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
+#         output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+    
+#         input_height = inputs['image_grid_thw'][0][1]*14
+#         input_width = inputs['image_grid_thw'][0][2]*14
+        
+#         response_org = output_text[0]
+#         input_size = (input_width.item(), input_height.item())
+
+#         del text, inputs, output_ids, generated_ids, output_text
+#         torch.cuda.empty_cache()
+
+#         if bbox_refine:
+#             response = self._bbox_refine(response_org, messages, image_type, image_for_message)
+#         else:
+#             response = response_org
+
+#         results = dict()
+#         bbox_with_label = self._get_bounding_boxes(response, input_size, size)
+#         results = {'bbox_with_label': bbox_with_label, 'response': response, 'input_size': input_size}
+
+#         return results
+
+#     def plot_bounding_boxes(self, image, response, input_size, output_path='./temp.png'):
+    
+#         # Load the image
+#         img = image.copy()
+#         width, height = img.size
+#         input_width, input_height = input_size
+    
+#         # Create a drawing object
+#         draw = ImageDraw.Draw(img)
+
+#         additional_colors = [colorname for (colorname, colorcode) in ImageColor.colormap.items()]
+        
+#         # Define a list of colors
+#         colors = [
+#         'red',
+#         'green',
+#         'blue',
+#         'yellow',
+#         'orange',
+#         'pink',
+#         'purple',
+#         'brown',
+#         'gray',
+#         'beige',
+#         'turquoise',
+#         'cyan',
+#         'magenta',
+#         'lime',
+#         'navy',
+#         'maroon',
+#         'teal',
+#         'olive',
+#         'coral',
+#         'lavender',
+#         'violet',
+#         'gold',
+#         'silver',
+#         ] + additional_colors
+
+#         # Parsing out the markdown fencing
+#         bounding_boxes = self._parse_json(response)
+
+#         # font = ImageFont.truetype("NotoSansCJK-Regular.ttc", size=14)
+#         font = ImageFont.load_default()
+
+#         # print(f"Bounding boxes: {bounding_boxes}")
+    
+#         try:
+#             # print(f"Bounding boxes: {bounding_boxes}")
+#             if bounding_boxes is None:
+#                 print("No bounding boxes found in the response.")
+#                 return
+#             json_output = ast.literal_eval(bounding_boxes)
+#         except Exception as e:
+#             end_idx = bounding_boxes.rfind('"}') + len('"}')
+#             truncated_text = bounding_boxes[:end_idx] + "]"
+#             json_output = ast.literal_eval(truncated_text)
+
+#         print(f"Parsed JSON output: {json_output}")
+        
+#         if len(json_output) > 0:
+            
+#             # Iterate over the bounding boxes
+#             for i, bounding_box in enumerate(json_output):
+#                 try:                
+#                     # Select a color from the list
+#                     color = colors[i % len(colors)]
+#                     # Convert normalized coordinates to absolute coordinates
+#                     abs_x1 = int(bounding_box["bbox_2d"][0] / input_width * width)
+#                     abs_y1 = int(bounding_box["bbox_2d"][1] / input_height * height)
+#                     abs_x2 = int(bounding_box["bbox_2d"][2] / input_width * width)
+#                     abs_y2 = int(bounding_box["bbox_2d"][3] / input_height * height) 
+            
+#                     if abs_x1 > abs_x2:
+#                         abs_x1, abs_x2 = abs_x2, abs_x1
+            
+#                     if abs_y1 > abs_y2:
+#                         abs_y1, abs_y2 = abs_y2, abs_y1
+            
+#                     # Draw the bounding box
+#                     draw.rectangle(
+#                         ((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4
+#                     )
+            
+#                     # Draw the text
+#                     if "label" in bounding_box:
+#                         draw.text((abs_x1 + 8, abs_y1 + 6), bounding_box["label"], fill=color, font=font)
+#                 except Exception as e:
+#                     print(f"Error {str(e)} for bounding box {bounding_box}")                
+    
+#         img.save(output_path)
+#         print(f"Image with bounding boxes saved to: {output_path}")
+        
+
+#     def predict_bounding_boxes(self, image, response, input_size):
+    
+#         # Load the image
+#         img = image.copy()
+#         width, height = img.size
+#         input_width, input_height = input_size
+        
+#         # Create a drawing object
+#         # draw = ImageDraw.Draw(img)
+
+#         additional_colors = [colorname for (colorname, colorcode) in ImageColor.colormap.items()]
+            
+#         # # Define a list of colors
+#         # colors = [
+#         #     'red',
+#         #     'green',
+#         #     'blue',
+#         #     'yellow',
+#         #     'orange',
+#         #     'pink',
+#         #     'purple',
+#         #     'brown',
+#         #     'gray',
+#         #     'beige',
+#         #     'turquoise',
+#         #     'cyan',
+#         #     'magenta',
+#         #     'lime',
+#         #     'navy',
+#         #     'maroon',
+#         #     'teal',
+#         #     'olive',
+#         #     'coral',
+#         #     'lavender',
+#         #     'violet',
+#         #     'gold',
+#         #     'silver',
+#         #     ] + additional_colors
+
+#         # Parsing out the markdown fencing
+#         bounding_boxes = self._parse_json(response)
+
+#             # # font = ImageFont.truetype("NotoSansCJK-Regular.ttc", size=14)
+#             # font = ImageFont.load_default()
+
+#             # print(f"Bounding boxes: {bounding_boxes}")
+        
+#         try:
+#             # print(f"Bounding boxes: {bounding_boxes}")
+#             if bounding_boxes is None:
+#                 print("No bounding boxes found in the response.")
+#                 return
+#             json_output = ast.literal_eval(bounding_boxes)
+#         except Exception as e:
+#             end_idx = bounding_boxes.rfind('"}') + len('"}')
+#             truncated_text = bounding_boxes[:end_idx] + "]"
+#             json_output = ast.literal_eval(truncated_text)
+
+#         print(f"Parsed JSON output: {json_output}")
+            
+#         if len(json_output) > 0:
+                
+#             # Iterate over the bounding boxes
+#             for i, bounding_box in enumerate(json_output):
+#                 try:                
+#                     # # Select a color from the list
+#                     # color = colors[i % len(colors)]
+#                     # Convert normalized coordinates to absolute coordinates
+#                     abs_x1 = int(bounding_box["bbox_2d"][0] / input_width * width)
+#                     abs_y1 = int(bounding_box["bbox_2d"][1] / input_height * height)
+#                     abs_x2 = int(bounding_box["bbox_2d"][2] / input_width * width)
+#                     abs_y2 = int(bounding_box["bbox_2d"][3] / input_height * height) 
+                
+#                     if abs_x1 > abs_x2:
+#                         abs_x1, abs_x2 = abs_x2, abs_x1
+                
+#                     if abs_y1 > abs_y2:
+#                         abs_y1, abs_y2 = abs_y2, abs_y1
+                
+#                         # # Draw the bounding box
+#                         # draw.rectangle(
+#                         #     ((abs_x1, abs_y1), (abs_x2, abs_y2)), outline=color, width=4
+#                         # )
+                
+#                         # # Draw the text
+#                         # if "label" in bounding_box:
+#                         #     draw.text((abs_x1 + 8, abs_y1 + 6), bounding_box["label"], fill=color, font=font)
+                    
+#                     return [abs_x1, abs_y1, abs_x2, abs_y2]
+#                 except Exception as e:
+#                     print(f"Error {str(e)} for bounding box {bounding_box}")                
+        
+#             # img.save(output_path)
+#             # print(f"Image with bounding boxes saved to: {output_path}")
+        

Code/sc_dit/single_dp_pck_results.csv

@@ -0,0 +1,5 @@
+,pascal_zs_dit_t_0.5_layer_10.log,pascal_zs_dit_t_0.6_layer_9.log,pascal_zs_dit_t_0.6_layer_11_no_dino.log,pascal_zs_dit_t_0.3_layer_10_no_dino.log,pascal_zs_dit_t_0.3_layer_15_no_dino.log,pascal_zs_dit_t_0.6_layer_10.log,pascal_zs_dit_t_0.3_layer_18_no_dino.log,pascal_zs_dit_t_0.8_layer_9_no_dino.log,pascal_zs_dit_t_0.8_layer_12.log,pascal_zs_dit_t_0.3_layer_15.log,pascal_zs_dit_t_0.6_layer_20.log,pascal_zs_dit_t_0.8_layer_13.log,pascal_zs_dit_t_0.7_layer_20_no_dino.log,pascal_zs_dit_t_0.8_layer_13_no_dino.log,pascal_zs_dit_t_0.8_layer_12_no_dino.log,pascal_zs_dit_t_0.7_layer_13.log,pascal_zs_dit_t_0.8_layer_15.log,pascal_zs_dit_t_0.7_layer_15_no_dino.log,pascal_zs_dit_t_0.8_layer_18_no_dino.log,pascal_zs_dit_t_0.3_layer_13.log,pascal_zs_dit_t_0.3_layer_9.log,pascal_zs_dit_t_0.5_layer_12_no_dino.log,pascal_zs_dit_t_0.6_layer_15_no_dino.log,pascal_zs_dit_t_0.8_layer_20.log,pascal_zs_dit_t_0.5_layer_12.log,pascal_zs_dit_t_0.7_layer_18_no_dino.log,pascal_zs_dit_t_0.7_layer_10_no_dino.log,pascal_zs_dit_t_0.3_layer_10.log,pascal_zs_dit_t_0.7_layer_5.log,pascal_zs_dit_t_0.8_layer_10.log,pascal_zs_dit_t_0.6_layer_18.log,pascal_zs_dit_t_0.7_layer_13_no_dino.log,pascal_zs_dit_t_0.8_layer_11_no_dino.log,pascal_zs_dit_t_0.3_layer_5_no_dino.log,pascal_zs_dit_t_0.7_layer_18.log,pascal_zs_dit_t_0.6_layer_12.log,pascal_zs_dit_t_0.8_layer_15_no_dino.log,pascal_zs_dit_t_0.7_layer_10.log,pascal_zs_dit_t_0.5_layer_18_no_dino.log,pascal_zs_dit_t_0.6_layer_13_no_dino.log,pascal_zs_dit_t_0.5_layer_5_no_dino.log,pascal_zs_dit_t_0.5_layer_13_no_dino.log,pascal_zs_dit_t_0.3_layer_13_no_dino.log,pascal_zs_dit_t_0.6_layer_10_no_dino.log,pascal_zs_dit_t_0.6_layer_18_no_dino.log,pascal_zs_dit_t_0.3_layer_20.log,pascal_zs_dit_t_0.8_layer_10_no_dino.log,pascal_zs_dit_t_0.7_layer_20.log,pascal_zs_dit_t_0.5_layer_11_no_dino.log,pascal_zs_dit_t_0.7_layer_9_no_dino.log,pascal_zs_dit_t_0.6_layer_5.log,pascal_zs_dit_t_0.7_layer_11_no_dino.log,pascal_zs_dit_t_0.6_layer_11.log,pascal_zs_dit_t_0.6_layer_20_no_dino.log,pascal_zs_dit_t_0.3_layer_9_no_dino.log,pascal_zs_dit_t_0.7_layer_15.log,pascal_zs_dit_t_0.5_layer_13.log,pascal_zs_dit_t_0.7_layer_5_no_dino.log,pascal_zs_dit_t_0.7_layer_11.log,pascal_zs_dit_t_0.3_layer_11_no_dino.log,pascal_zs_dit_t_0.5_layer_5.log,pascal_zs_dit_t_0.5_layer_9.log,pascal_zs_dit_t_0.7_layer_12.log,pascal_zs_dit_t_0.5_layer_18.log,pascal_zs_dit_t_0.3_layer_12_no_dino.log,pascal_zs_dit_t_0.6_layer_9_no_dino.log,pascal_zs_dit_t_0.5_layer_10_no_dino.log,pascal_zs_dit_t_0.8_layer_9.log,pascal_zs_dit_t_0.6_layer_13.log,pascal_zs_dit_t_0.5_layer_20.log,pascal_zs_dit_t_0.3_layer_18.log,pascal_zs_dit_t_0.3_layer_12.log,pascal_zs_dit_t_0.7_layer_9.log,pascal_zs_dit_t_0.8_layer_5.log,pascal_zs_dit_t_0.6_layer_5_no_dino.log,pascal_zs_dit_t_0.5_layer_15.log,pascal_zs_dit_t_0.8_layer_20_no_dino.log,pascal_zs_dit_t_0.5_layer_9_no_dino.log,pascal_zs_dit_t_0.8_layer_11.log,pascal_zs_dit_t_0.6_layer_15.log,pascal_zs_dit_t_0.5_layer_20_no_dino.log,pascal_zs_dit_t_0.5_layer_11.log,pascal_zs_dit_t_0.3_layer_20_no_dino.log,pascal_zs_dit_t_0.5_layer_15_no_dino.log,pascal_zs_dit_t_0.6_layer_12_no_dino.log,pascal_zs_dit_t_0.8_layer_18.log,pascal_zs_dit_t_0.3_layer_5.log,pascal_zs_dit_t_0.3_layer_11.log,pascal_zs_dit_t_0.7_layer_12_no_dino.log,pascal_zs_dit_t_0.8_layer_5_no_dino.log
+PCK0.05,64.95,61.35,57.26,41.10,31.36,67.25,19.31,43.29,61.70,47.27,36.21,60.36,34.58,53.31,55.84,62.98,60.19,53.07,45.76,50.55,56.82,57.35,52.07,42.60,63.05,44.68,55.08,58.41,49.71,62.00,50.80,56.81,51.89,20.05,53.28,64.89,52.27,66.03,36.14,56.82,20.32,53.87,38.30,57.32,41.29,23.45,50.91,40.40,53.99,48.30,49.25,57.73,66.37,30.88,37.42,60.82,60.48,19.65,66.34,40.61,49.00,60.96,64.32,46.22,43.58,49.97,53.61,57.86,63.11,34.61,32.42,54.54,60.53,49.52,20.25,57.55,37.30,47.79,63.04,61.25,27.33,64.61,16.49,47.27,59.92,52.89,49.05,56.93,59.74,19.42
+PCK0.10,79.62,77.80,74.95,60.83,47.56,81.60,32.57,67.88,79.57,65.37,52.50,78.20,51.23,73.36,75.55,78.95,76.89,70.89,64.16,69.53,74.31,73.39,67.90,60.01,79.24,61.27,73.67,75.93,69.18,80.64,66.51,74.27,74.26,43.51,70.29,81.16,70.02,81.43,51.32,74.04,45.04,69.81,56.54,73.77,56.73,38.05,72.25,57.69,71.15,69.74,68.87,75.88,80.98,46.78,57.31,77.81,77.26,45.15,81.32,60.09,68.43,77.05,80.35,63.45,63.45,69.60,70.34,77.06,79.07,51.53,49.18,73.84,78.49,69.49,45.46,73.48,54.09,67.17,80.38,76.22,42.87,79.52,28.75,62.24,76.40,71.06,68.19,74.97,77.74,44.61
+PCK0.01,86.19,84.70,83.24,74.43,57.68,87.15,41.81,79.12,87.16,73.21,61.92,85.48,61.19,82.39,84.58,85.25,84.07,77.95,72.68,78.63,82.30,82.38,74.99,69.73,86.40,69.55,82.56,82.86,79.08,87.58,72.97,82.45,84.39,61.65,77.55,87.74,78.23,87.56,60.80,82.38,63.74,79.05,68.45,82.15,65.26,46.28,81.62,66.74,80.97,79.64,78.19,84.32,87.86,56.43,72.08,84.30,84.18,65.42,88.01,74.07,78.17,84.22,87.38,71.79,75.48,78.95,80.54,85.47,85.81,60.57,57.76,82.20,85.83,79.91,65.32,80.36,64.58,77.99,87.41,82.67,53.48,86.79,37.43,71.27,84.71,79.26,77.78,82.98,85.69,65.22
+Key_1,t_0.5_layer_10,t_0.6_layer_9,t_0.6_layer_11_no_dino,t_0.3_layer_10_no_dino,t_0.3_layer_15_no_dino,t_0.6_layer_10,t_0.3_layer_18_no_dino,t_0.8_layer_9_no_dino,t_0.8_layer_12,t_0.3_layer_15,t_0.6_layer_20,t_0.8_layer_13,t_0.7_layer_20_no_dino,t_0.8_layer_13_no_dino,t_0.8_layer_12_no_dino,t_0.7_layer_13,t_0.8_layer_15,t_0.7_layer_15_no_dino,t_0.8_layer_18_no_dino,t_0.3_layer_13,t_0.3_layer_9,t_0.5_layer_12_no_dino,t_0.6_layer_15_no_dino,t_0.8_layer_20,t_0.5_layer_12,t_0.7_layer_18_no_dino,t_0.7_layer_10_no_dino,t_0.3_layer_10,t_0.7_layer_5,t_0.8_layer_10,t_0.6_layer_18,t_0.7_layer_13_no_dino,t_0.8_layer_11_no_dino,t_0.3_layer_5_no_dino,t_0.7_layer_18,t_0.6_layer_12,t_0.8_layer_15_no_dino,t_0.7_layer_10,t_0.5_layer_18_no_dino,t_0.6_layer_13_no_dino,t_0.5_layer_5_no_dino,t_0.5_layer_13_no_dino,t_0.3_layer_13_no_dino,t_0.6_layer_10_no_dino,t_0.6_layer_18_no_dino,t_0.3_layer_20,t_0.8_layer_10_no_dino,t_0.7_layer_20,t_0.5_layer_11_no_dino,t_0.7_layer_9_no_dino,t_0.6_layer_5,t_0.7_layer_11_no_dino,t_0.6_layer_11,t_0.6_layer_20_no_dino,t_0.3_layer_9_no_dino,t_0.7_layer_15,t_0.5_layer_13,t_0.7_layer_5_no_dino,t_0.7_layer_11,t_0.3_layer_11_no_dino,t_0.5_layer_5,t_0.5_layer_9,t_0.7_layer_12,t_0.5_layer_18,t_0.3_layer_12_no_dino,t_0.6_layer_9_no_dino,t_0.5_layer_10_no_dino,t_0.8_layer_9,t_0.6_layer_13,t_0.5_layer_20,t_0.3_layer_18,t_0.3_layer_12,t_0.7_layer_9,t_0.8_layer_5,t_0.6_layer_5_no_dino,t_0.5_layer_15,t_0.8_layer_20_no_dino,t_0.5_layer_9_no_dino,t_0.8_layer_11,t_0.6_layer_15,t_0.5_layer_20_no_dino,t_0.5_layer_11,t_0.3_layer_20_no_dino,t_0.5_layer_15_no_dino,t_0.6_layer_12_no_dino,t_0.8_layer_18,t_0.3_layer_5,t_0.3_layer_11,t_0.7_layer_12_no_dino,t_0.8_layer_5_no_dino

Code/sc_dit/utils.py

@@ -0,0 +1,869 @@
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+import numpy as np
+import math
+
+def resize_and_pad(image_tensor, output_size):
+    """
+    Resizes an image tensor to a square shape by scaling and padding.
+    
+    Args:
+        image_tensor (torch.Tensor): Input image tensor of shape (H, W).
+        output_size (int): The desired square output size.
+        
+    Returns:
+        torch.Tensor: The resized and padded image tensor of shape (output_size, output_size).
+    """
+    original_h, original_w = image_tensor.shape
+    
+    # 1. Calculate the scale factor to fit the longest side to output_size
+    scale = output_size / max(original_h, original_w)
+    new_h, new_w = int(original_h * scale), int(original_w * scale)
+
+    # Add batch and channel dimensions for F.interpolate
+    image_tensor = image_tensor.unsqueeze(0).unsqueeze(0)
+    
+    # 2. Resize the image, preserving aspect ratio
+    resized_image = F.interpolate(image_tensor, size=(new_h, new_w), mode='bilinear', align_corners=False)
+    
+    # 3. Calculate padding for the shorter side
+    pad_h = output_size - new_h
+    pad_w = output_size - new_w
+    
+    # Padding format is (left, right, top, bottom)
+    padding = (pad_w // 2, pad_w - (pad_w // 2), pad_h // 2, pad_h - (pad_h // 2))
+    
+    # 4. Pad the image with a constant value (0 for black)
+    padded_image = F.pad(resized_image, padding, "constant", 0)
+    
+    return padded_image.squeeze()
+
+
+def resize(img, target_res=224, resize=True, to_pil=True, edge=False):
+    original_width, original_height = img.size
+    original_channels = len(img.getbands())
+    if not edge:
+        canvas = np.zeros([target_res, target_res, 3], dtype=np.uint8)
+        if original_channels == 1:
+            canvas = np.zeros([target_res, target_res], dtype=np.uint8)
+        if original_height <= original_width:
+            if resize:
+                img = img.resize((target_res, int(np.around(target_res * original_height / original_width))), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            canvas[(width - height) // 2: (width + height) // 2] = img
+        else:
+            if resize:
+                img = img.resize((int(np.around(target_res * original_width / original_height)), target_res), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            canvas[:, (height - width) // 2: (height + width) // 2] = img
+    else:
+        if original_height <= original_width:
+            if resize:
+                img = img.resize((target_res, int(np.around(target_res * original_height / original_width))), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            top_pad = (target_res - height) // 2
+            bottom_pad = target_res - height - top_pad
+            img = np.pad(img, pad_width=[(top_pad, bottom_pad), (0, 0), (0, 0)], mode='edge')
+        else:
+            if resize:
+                img = img.resize((int(np.around(target_res * original_width / original_height)), target_res), Image.Resampling.LANCZOS)
+            width, height = img.size
+            img = np.asarray(img)
+            left_pad = (target_res - width) // 2
+            right_pad = target_res - width - left_pad
+            img = np.pad(img, pad_width=[(0, 0), (left_pad, right_pad), (0, 0)], mode='edge')
+        canvas = img
+    if to_pil:
+        canvas = Image.fromarray(canvas)
+    return canvas
+
+def scaled_shifted_sigmoid(
+    x: Tensor,
+    a: float = 1.0,   # vertical scale
+    b: float = 1.0,   # slope (steepness)
+    c: float = 0.0,   # horizontal shift (bias)
+    d: float = 0.0,   # vertical shift (baseline)
+) -> Tensor:
+    """
+    Compute a scaled-and-shifted sigmoid: y = a * sigmoid(b * x + c) + d.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Input tensor.
+    a : float, default 1.0
+        Output scale (amplitude).
+    b : float, default 1.0
+        Input scale (controls slope).
+    c : float, default 0.0
+        Input shift (horizontal translation).
+    d : float, default 0.0
+        Output shift (vertical translation).
+
+    Returns
+    -------
+    torch.Tensor
+        Tensor with the same shape as `x` after applying the transformation.
+    """
+    return a * torch.sigmoid(b * x + c) + d
+
+
+############
+# for 2D to 3D correspondence with cropping
+
+from scipy.ndimage import distance_transform_edt as edt
+from scipy.ndimage import gaussian_filter
+# from skimage import img_as_ubyte
+from PIL import Image
+from pathlib import Path
+import numpy as np
+from typing import Tuple
+
+# ✨ New helper to find the object's bounding box from transparency
+def get_bbox_from_alpha(image_path: Path) -> Tuple[int, int, int, int]:
+    """Calculates a bounding box from the alpha channel of a PNG."""
+    with Image.open(image_path).convert("RGBA") as img:
+        alpha = np.array(img)[:, :, 3]
+        non_transparent_pixels = np.argwhere(alpha > 0)
+        y_min, x_min = non_transparent_pixels.min(axis=0)
+        y_max, x_max = non_transparent_pixels.max(axis=0)
+        return x_min, y_min, x_max, y_max
+
+# ... (rest of your imports and functions)
+
+
+
+#####################
+# dataset utils loading functions
+#####################
+import os
+import json
+import numpy as np
+import pandas as pd
+import torch
+from glob import glob
+# from scipy.io import loadmat as read_mat
+import scipy.io as sio
+
+
+def read_mat(path, obj_name):
+    r"""Reads specified objects from Matlab data file, (.mat)"""
+    mat_contents = sio.loadmat(path)
+    mat_obj = mat_contents[obj_name]
+
+    return mat_obj
+
+def process_kps_pascal(kps):
+    # Step 1: Reshape the array to (20, 2) by adding nan values
+    num_pad_rows = 20 - kps.shape[0]
+    if num_pad_rows > 0:
+        pad_values = np.full((num_pad_rows, 2), np.nan)
+        kps = np.vstack((kps, pad_values))
+        
+    # Step 2: Reshape the array to (20, 3) 
+    # Add an extra column: set to 1 if the row does not contain nan, 0 otherwise
+    last_col = np.isnan(kps).any(axis=1)
+    last_col = np.where(last_col, 0, 1)
+    kps = np.column_stack((kps, last_col))
+
+    # Step 3: Replace rows with nan values to all 0's
+    mask = np.isnan(kps).any(axis=1)
+    kps[mask] = 0
+
+    return torch.tensor(kps).float()
+
+def preprocess_kps_pad(kps, img_width, img_height, size):
+    # Once an image has been pre-processed via border (or zero) padding,
+    # the location of key points needs to be updated. This function applies
+    # that pre-processing to the key points so they are correctly located
+    # in the border-padded (or zero-padded) image.
+    kps = kps.clone()
+    scale = size / max(img_width, img_height)
+    kps[:, [0, 1]] *= scale
+    if img_height < img_width:
+        new_h = int(np.around(size * img_height / img_width))
+        offset_y = int((size - new_h) / 2)
+        offset_x = 0
+        kps[:, 1] += offset_y
+    elif img_width < img_height:
+        new_w = int(np.around(size * img_width / img_height))
+        offset_x = int((size - new_w) / 2)
+        offset_y = 0
+        kps[:, 0] += offset_x
+    else:
+        offset_x = 0
+        offset_y = 0
+    kps *= kps[:, 2:3].clone()  # zero-out any non-visible key points
+    return kps, offset_x, offset_y, scale
+
+
+def load_pascal_data(path="data/PF-dataset-PASCAL", size=256, category='cat', split='test', subsample=None):
+    
+    def get_points(point_coords_list, idx):
+        X = np.fromstring(point_coords_list.iloc[idx, 0], sep=";")
+        Y = np.fromstring(point_coords_list.iloc[idx, 1], sep=";")
+        Xpad = -np.ones(20)
+        Xpad[: len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[: len(X)] = Y
+        Zmask = np.zeros(20)
+        Zmask[: len(X)] = 1
+        point_coords = np.concatenate(
+            (Xpad.reshape(1, 20), Ypad.reshape(1, 20), Zmask.reshape(1,20)), axis=0
+        )
+        # make arrays float tensor for subsequent processing
+        point_coords = torch.Tensor(point_coords.astype(np.float32))
+        return point_coords
+    
+    np.random.seed(42)
+    files = []
+    kps = []
+    test_data = pd.read_csv(f'{path}/{split}_pairs_pf_pascal.csv')
+    cls = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
+                    'bus', 'car', 'cat', 'chair', 'cow',
+                    'diningtable', 'dog', 'horse', 'motorbike', 'person',
+                    'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+    cls_ids = test_data.iloc[:,2].values.astype("int") - 1
+    cat_id = cls.index(category)
+    subset_id = np.where(cls_ids == cat_id)[0]
+    # logger.info(f'Number of Pairs for {category} = {len(subset_id)}')
+    subset_pairs = test_data.iloc[subset_id,:]
+    src_img_names = np.array(subset_pairs.iloc[:,0])
+    trg_img_names = np.array(subset_pairs.iloc[:,1])
+    # print(src_img_names.shape, trg_img_names.shape)
+    if not split.startswith('train'):
+        point_A_coords = subset_pairs.iloc[:,3:5]
+        point_B_coords = subset_pairs.iloc[:,5:]
+    # print(point_A_coords.shape, point_B_coords.shape)
+    for i in range(len(src_img_names)):
+        src_fn= f'{path}/../{src_img_names[i]}'
+        trg_fn= f'{path}/../{trg_img_names[i]}'
+        src_size=Image.open(src_fn).size
+        trg_size=Image.open(trg_fn).size
+
+        if not split.startswith('train'):
+            point_coords_src = get_points(point_A_coords, i).transpose(1,0)
+            point_coords_trg = get_points(point_B_coords, i).transpose(1,0)
+        else:
+            src_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(src_fn))[:-4] + '.mat'
+            trg_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(trg_fn))[:-4] + '.mat'
+            point_coords_src = process_kps_pascal(read_mat(src_anns, 'kps'))
+            point_coords_trg = process_kps_pascal(read_mat(trg_anns, 'kps'))
+
+        # print(src_size)
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(src_fn)
+        files.append(trg_fn)
+    
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+    # logger.info(f'Final number of used key points: {kps.size(1)}')
+    return files, kps, None, used_kps
+
+
+def load_spair_data(path="data/SPair-71k", size=256, category='cat', split='test', subsample=None):
+    np.random.seed(42)
+    pairs = sorted(glob(f'{path}/PairAnnotation/{split}/*:{category}.json'))
+    if subsample is not None and subsample > 0:
+        pairs = [pairs[ix] for ix in np.random.choice(len(pairs), subsample)]
+    files = []
+    thresholds = []
+    kps = []
+    category_anno = list(glob(f'{path}/ImageAnnotation/{category}/*.json'))[0]
+    with open(category_anno) as f:
+        num_kps = len(json.load(f)['kps'])
+    for pair in pairs:
+        source_kps = torch.zeros(num_kps, 3)
+        target_kps = torch.zeros(num_kps, 3)
+        with open(pair) as f:
+            data = json.load(f)
+        assert category == data["category"]
+        source_fn = f'{path}/JPEGImages/{category}/{data["src_imname"]}'
+        target_fn = f'{path}/JPEGImages/{category}/{data["trg_imname"]}'
+        source_json_name = source_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        target_json_name = target_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        source_bbox = np.asarray(data["src_bndbox"])    # (x1, y1, x2, y2)
+        target_bbox = np.asarray(data["trg_bndbox"])
+        with open(source_json_name) as f:
+            file = json.load(f)
+            kpts_src = file['kps']
+        with open(target_json_name) as f:
+            file = json.load(f)
+            kpts_trg = file['kps']
+
+        source_size = data["src_imsize"][:2]  # (W, H)
+        target_size = data["trg_imsize"][:2]  # (W, H)
+
+        for i in range(30):
+            point = kpts_src[str(i)]
+            if point is None:
+                source_kps[i, :3] = 0
+            else:
+                source_kps[i, :2] = torch.Tensor(point).float()  # set x and y
+                source_kps[i, 2] = 1
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps, source_size[0], source_size[1], size)
+        
+        for i in range(30):
+            point = kpts_trg[str(i)]
+            if point is None:
+                target_kps[i, :3] = 0
+            else:
+                target_kps[i, :2] = torch.Tensor(point).float()
+                target_kps[i, 2] = 1
+        # target_raw_kps = torch.cat([torch.tensor(data["trg_kps"], dtype=torch.float), torch.ones(kp_ixs.size(0), 1)], 1)
+        # target_kps = blank_kps.scatter(dim=0, index=kp_ixs, src=target_raw_kps)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps, target_size[0], target_size[1], size)
+        if split == 'test' or split == 'val':
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+        elif split == 'trn':
+            thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0])*src_scale)
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(source_fn)
+        files.append(target_fn)
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+
+    return files, kps, thresholds, used_kps
+
+
+def load_specific_pascal_pair(
+    source_image_id: str,
+    target_image_id: str,
+    path: str = "data/PF-dataset-PASCAL",
+    size: int = 256,
+    split: str = 'test'
+):
+    """
+    Loads and processes a specific pair of source and target images from the PASCAL dataset.
+
+    Args:
+        source_image_id: The identifier of the source image (e.g., '2011_001407').
+        target_image_id: The identifier of the target image (e.g., '2010_004184').
+        path: The base path to the PF-PASCAL dataset directory.
+        size: The target size for preprocessing images.
+        split: The dataset split to use ('test', 'train', etc.).
+
+    Returns:
+        A tuple containing:
+        - files (list): A list with the full paths to the source and target images.
+        - kps (torch.Tensor): A tensor of processed keypoints for the image pair.
+        - None: A placeholder to match the original function's return format.
+        - used_kps_indices (torch.Tensor): A tensor of indices for keypoints present in either image.
+    """
+    
+    def get_points_from_strings(x_str: str, y_str: str) -> torch.Tensor:
+        """Parses coordinate strings, pads them, and returns a tensor."""
+        X = np.fromstring(x_str, sep=";")
+        Y = np.fromstring(y_str, sep=";")
+        
+        # Pad arrays to a fixed size of 20 (as in the original function)
+        Xpad = -np.ones(20)
+        Xpad[:len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[:len(Y)] = Y
+        
+        # Create a mask for valid keypoints
+        Zmask = np.zeros(20)
+        Zmask[:len(X)] = 1
+        
+        point_coords = np.stack((Xpad, Ypad, Zmask), axis=0)
+        return torch.from_numpy(point_coords.astype(np.float32))
+
+    # Construct the path to the CSV file and load it
+    csv_path = os.path.join(path, f'{split}_pairs_pf_pascal.csv')
+    try:
+        pairs_df = pd.read_csv(csv_path)
+    except FileNotFoundError:
+        print(f"Error: CSV file not found at '{csv_path}'")
+        return None, None, None, None
+
+    # Find the specific row matching the source and target image IDs
+    pair_row = pairs_df[
+        pairs_df['source_image'].str.contains(source_image_id) &
+        pairs_df['target_image'].str.contains(target_image_id)
+    ]
+
+    if pair_row.empty:
+        print(f"Error: Pair for source '{source_image_id}' and target '{target_image_id}' not found.")
+        return None, None, None, None
+    
+    # Select the first match
+    pair_data = pair_row.iloc[0]
+
+    # Get full image paths and dimensions
+    src_fn = os.path.join(path, '..', pair_data['source_image'])
+    trg_fn = os.path.join(path, '..', pair_data['target_image'])
+    
+    try:
+        src_size = Image.open(src_fn).size
+        trg_size = Image.open(trg_fn).size
+    except FileNotFoundError as e:
+        print(f"Error: Image file not found: {e.filename}")
+        return None, None, None, None
+
+    # Process keypoints based on the split type
+    if not split.startswith('train'):
+        point_coords_src = get_points_from_strings(pair_data['XA'], pair_data['YA']).T
+        point_coords_trg = get_points_from_strings(pair_data['XB'], pair_data['YB']).T
+    else:
+        # This logic for the 'train' split is preserved from the original function
+        cls_list = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 
+                    'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 
+                    'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+        category = cls_list[pair_data['class'] - 1]
+        
+        src_anns_path = os.path.join(path, 'Annotations', category, os.path.basename(src_fn).replace('.jpg', '.mat'))
+        trg_anns_path = os.path.join(path, 'Annotations', category, os.path.basename(trg_fn).replace('.jpg', '.mat'))
+        
+        point_coords_src = process_kps_pascal(read_mat(src_anns_path, 'kps'))
+        point_coords_trg = process_kps_pascal(read_mat(trg_anns_path, 'kps'))
+
+    # Preprocess keypoints (e.g., padding and scaling)
+    source_kps, _, _, _ = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+    target_kps, _, _, _ = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+
+    # Stack keypoints and find the indices of keypoints present in at least one image
+    kps = torch.stack([source_kps, target_kps])
+    used_kps_indices, = torch.where(kps[:, :, 2].any(dim=0))
+    
+    # Filter the keypoints tensor to include only the used keypoints
+    kps_final = kps[:, used_kps_indices, :]
+
+    return [src_fn, trg_fn], kps_final, None, used_kps_indices
+
+import matplotlib.pyplot as plt
+def load_img_and_kps(idx, files, kps, img_size=224, edge=False, load_masked=False):
+    if load_masked:
+        img_rgba = Image.open(files[idx].replace('JPEGImages', 'JPEGImages_bgd_rmv').replace('.jpg', '_bgd_rmv.png')).convert('RGBA')
+        
+        # img_rgba = Image.open(path_image).convert("RGBA")
+
+        # 2. create a white background and composite
+        img = Image.new("RGB", img_rgba.size, (0, 0, 0))  # choose any colour here
+        img.paste(img_rgba, mask=img_rgba.split()[3])               # mask = alpha channel
+        plt.imsave("img2_masked_before_resize.png", np.array(img))
+        # print(np.array(img).shape)
+    else:
+        img = Image.open(files[idx]).convert('RGB')
+    img = resize(img, img_size, resize=True, to_pil=True, edge=edge)
+    if load_masked:
+        plt.imsave("img2_masked_after_resize.png", np.array(img))
+    img_kps = kps[idx]
+
+    return img, img_kps
+
+
+import os
+import json
+from glob import glob
+import numpy as np
+import torch
+
+# NOTE: The helper function preprocess_kps_pad(kps, width, height, size) 
+# is assumed to be defined elsewhere, as in your original code.
+
+def load_specific_spair_pair(
+    source_image_name: str,
+    target_image_name: str,
+    category: str,
+    path: str = "data/SPair-71k",
+    size: int = 256,
+    split: str = 'test',
+    unfiltered: bool = False
+    
+):
+    """
+    Loads and processes a specific pair of images from the SPair-71k dataset.
+
+    Args:
+        source_image_name (str): Filename of the source image (e.g., '2008_002719.jpg').
+        target_image_name (str): Filename of the target image (e.g., '2008_004100.jpg').
+        category (str): The object category (e.g., 'aeroplane').
+        path (str): The base path to the SPair-71k dataset directory.
+        size (int): The target size for preprocessing images.
+        split (str): The dataset split to use ('test', 'trn', 'val').
+
+    Returns:
+        A tuple containing:
+        - files (list): Full paths to the source and target images.
+        - kps (torch.Tensor): Processed keypoints for the pair.
+        - thresholds (list): Bounding-box based thresholds for the pair.
+        - used_kps_indices (torch.Tensor): Indices of keypoints present in either image.
+    """
+    
+    # Helper to create a keypoint tensor from the annotation dictionary
+    def _get_kps_tensor(kps_dict, num_kps):
+        kps_tensor = torch.zeros(num_kps, 3)
+        for i in range(num_kps):
+            point = kps_dict.get(str(i)) # Use .get() for safety
+            if point is not None:
+                kps_tensor[i, :2] = torch.tensor(point, dtype=torch.float)
+                kps_tensor[i, 2] = 1.0 # Mark as visible
+        return kps_tensor
+
+    # --- 1. Find the correct pair annotation file ---
+    pair_annotation_path = os.path.join(path, 'PairAnnotation', split)
+    candidate_files = glob(os.path.join(pair_annotation_path, f'*:{category}.json'))
+    
+    pair_data = None
+    for file_path in candidate_files:
+        with open(file_path) as f:
+            data = json.load(f)
+            if data['src_imname'] == source_image_name and data['trg_imname'] == target_image_name:
+                pair_data = data
+                break
+    
+    if pair_data is None:
+        print(f"Error: Pair for '{source_image_name}' and '{target_image_name}' not found.")
+        return None, None, None, None
+
+    # --- 2. Process the found pair ---
+    source_fn = os.path.join(path, 'JPEGImages', category, pair_data['src_imname'])
+    target_fn = os.path.join(path, 'JPEGImages', category, pair_data['trg_imname'])
+    files = [source_fn, target_fn]
+
+    # Get total number of keypoints for the category
+    try:
+        category_anno_path = glob(os.path.join(path, 'ImageAnnotation', category, '*.json'))[0]
+        with open(category_anno_path) as f:
+            num_kps = len(json.load(f)['kps'])
+    except IndexError:
+        print(f"Error: No image annotations found for category '{category}'.")
+        return None, None, None, None
+
+    # Get keypoints from individual image annotation files
+    source_json_path = source_fn.replace('JPEGImages', 'ImageAnnotation').replace('.jpg', '.json')
+    target_json_path = target_fn.replace('JPEGImages', 'ImageAnnotation').replace('.jpg', '.json')
+
+    with open(source_json_path) as f:
+        kpts_src_dict = json.load(f)['kps']
+    with open(target_json_path) as f:
+        kpts_trg_dict = json.load(f)['kps']
+        
+    source_kps_raw = _get_kps_tensor(kpts_src_dict, num_kps)
+    target_kps_raw = _get_kps_tensor(kpts_trg_dict, num_kps)
+
+    # print(f"Source keypoints raw: {source_kps_raw.shape}, Target keypoints raw: {target_kps_raw.shape}")
+
+    # Preprocess keypoints (padding, scaling, etc.)
+    w_src, h_src = pair_data["src_imsize"][:2]
+    w_trg, h_trg = pair_data["trg_imsize"][:2]
+    
+    source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps_raw, w_src, h_src, size)
+    target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps_raw, w_trg, h_trg, size)
+    
+    # Calculate thresholds from bounding boxes
+    source_bbox = np.asarray(pair_data["src_bndbox"])
+    target_bbox = np.asarray(pair_data["trg_bndbox"])
+    thresholds = []
+    if split == 'test' or split == 'val':
+        thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0]) * trg_scale)
+    elif split == 'trn':
+        thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0]) * src_scale)
+        thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0]) * trg_scale)
+
+    # --- 3. Format output ---
+    kps = torch.stack([source_kps, target_kps])
+    used_kps_indices, = torch.where(kps[:, :, 2].any(dim=0))
+    kps_final = kps[:, used_kps_indices, :]
+
+    if unfiltered:
+        return files, kps, thresholds, used_kps_indices
+    else:
+        return files, kps_final, thresholds, used_kps_indices
+
+
+
+
+######################################
+# original loading function
+######################################
+
+def load_spair_data(path="data/SPair-71k", size=256, category='cat', split='test', subsample=None):
+    np.random.seed(42)
+    pairs = sorted(glob(f'{path}/PairAnnotation/{split}/*:{category}.json'))
+    if subsample is not None and subsample > 0:
+        pairs = [pairs[ix] for ix in np.random.choice(len(pairs), subsample)]
+    files = []
+    thresholds = []
+    kps = []
+    category_anno = list(glob(f'{path}/ImageAnnotation/{category}/*.json'))[0]
+    with open(category_anno) as f:
+        num_kps = len(json.load(f)['kps'])
+    for pair in pairs:
+        source_kps = torch.zeros(num_kps, 3)
+        target_kps = torch.zeros(num_kps, 3)
+        with open(pair) as f:
+            data = json.load(f)
+        assert category == data["category"]
+        source_fn = f'{path}/JPEGImages/{category}/{data["src_imname"]}'
+        target_fn = f'{path}/JPEGImages/{category}/{data["trg_imname"]}'
+        source_json_name = source_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        target_json_name = target_fn.replace('JPEGImages','ImageAnnotation').replace('jpg','json')
+        source_bbox = np.asarray(data["src_bndbox"])    # (x1, y1, x2, y2)
+        target_bbox = np.asarray(data["trg_bndbox"])
+        with open(source_json_name) as f:
+            file = json.load(f)
+            kpts_src = file['kps']
+        with open(target_json_name) as f:
+            file = json.load(f)
+            kpts_trg = file['kps']
+
+        source_size = data["src_imsize"][:2]  # (W, H)
+        target_size = data["trg_imsize"][:2]  # (W, H)
+
+        for i in range(30):
+            point = kpts_src[str(i)]
+            if point is None:
+                source_kps[i, :3] = 0
+            else:
+                source_kps[i, :2] = torch.Tensor(point).float()  # set x and y
+                source_kps[i, 2] = 1
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps, source_size[0], source_size[1], size)
+        
+        for i in range(30):
+            point = kpts_trg[str(i)]
+            if point is None:
+                target_kps[i, :3] = 0
+            else:
+                target_kps[i, :2] = torch.Tensor(point).float()
+                target_kps[i, 2] = 1
+        # target_raw_kps = torch.cat([torch.tensor(data["trg_kps"], dtype=torch.float), torch.ones(kp_ixs.size(0), 1)], 1)
+        # target_kps = blank_kps.scatter(dim=0, index=kp_ixs, src=target_raw_kps)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps, target_size[0], target_size[1], size)
+        if split == 'test' or split == 'val':
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+        elif split == 'trn':
+            thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0])*src_scale)
+            thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(source_fn)
+        files.append(target_fn)
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+
+    return files, kps, thresholds, used_kps
+
+
+def load_pascal_data(path="data/PF-dataset-PASCAL", size=256, category='cat', split='test', subsample=None):
+    
+    def get_points(point_coords_list, idx):
+        X = np.fromstring(point_coords_list.iloc[idx, 0], sep=";")
+        Y = np.fromstring(point_coords_list.iloc[idx, 1], sep=";")
+        Xpad = -np.ones(20)
+        Xpad[: len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[: len(X)] = Y
+        Zmask = np.zeros(20)
+        Zmask[: len(X)] = 1
+        point_coords = np.concatenate(
+            (Xpad.reshape(1, 20), Ypad.reshape(1, 20), Zmask.reshape(1,20)), axis=0
+        )
+        # make arrays float tensor for subsequent processing
+        point_coords = torch.Tensor(point_coords.astype(np.float32))
+        return point_coords
+    
+    np.random.seed(42)
+    files = []
+    kps = []
+    test_data = pd.read_csv(f'{path}/{split}_pairs_pf_pascal.csv')
+    cls = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
+                    'bus', 'car', 'cat', 'chair', 'cow',
+                    'diningtable', 'dog', 'horse', 'motorbike', 'person',
+                    'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+    cls_ids = test_data.iloc[:,2].values.astype("int") - 1
+    cat_id = cls.index(category)
+    subset_id = np.where(cls_ids == cat_id)[0]
+    # logger.info(f'Number of Pairs for {category} = {len(subset_id)}')
+    subset_pairs = test_data.iloc[subset_id,:]
+    src_img_names = np.array(subset_pairs.iloc[:,0])
+    trg_img_names = np.array(subset_pairs.iloc[:,1])
+    # print(src_img_names.shape, trg_img_names.shape)
+    if not split.startswith('train'):
+        point_A_coords = subset_pairs.iloc[:,3:5]
+        point_B_coords = subset_pairs.iloc[:,5:]
+    # print(point_A_coords.shape, point_B_coords.shape)
+    for i in range(len(src_img_names)):
+        src_fn= f'{path}/../{src_img_names[i]}'
+        trg_fn= f'{path}/../{trg_img_names[i]}'
+        src_size=Image.open(src_fn).size
+        trg_size=Image.open(trg_fn).size
+
+        if not split.startswith('train'):
+            point_coords_src = get_points(point_A_coords, i).transpose(1,0)
+            point_coords_trg = get_points(point_B_coords, i).transpose(1,0)
+        else:
+            src_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(src_fn))[:-4] + '.mat'
+            trg_anns = os.path.join(path, 'Annotations', category,
+                                    os.path.basename(trg_fn))[:-4] + '.mat'
+            point_coords_src = process_kps_pascal(read_mat(src_anns, 'kps'))
+            point_coords_trg = process_kps_pascal(read_mat(trg_anns, 'kps'))
+
+        # print(src_size)
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(src_fn)
+        files.append(trg_fn)
+    
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+    # logger.info(f'Final number of used key points: {kps.size(1)}')
+    return files, kps, None, used_kps
+
+
+def load_eval_data(args, path, category, split):
+    # if args.EVAL_DATASET == 'ap10k':
+    #     files, kps, thresholds, used_kps = load_ap10k_data(path, args.ANNO_SIZE, category, split, args.TEST_SAMPLE)
+    print(f"Loading evaluation data for dataset: {args.EVAL_DATASET}, category: {category}, split: {split}, test sample: {args.TEST_SAMPLE}")
+    if args.EVAL_DATASET == 'pascal':
+        files, kps, thresholds, used_kps = load_pascal_data(path, args.ANNO_SIZE, category, split, args.TEST_SAMPLE)
+    elif args.EVAL_DATASET == 'spair':
+        files, kps, thresholds, used_kps = load_spair_data(path, args.ANNO_SIZE, category, split, args.TEST_SAMPLE)
+
+    return files, kps, thresholds, used_kps
+
+
+###### plot helper
+from PIL import Image, ImageDraw, ImageFont
+
+def draw_bbox_point_grid(
+    image,
+    bbox=None,
+    point=None,
+    box_color=(0, 255, 0),
+    pt_color=(255, 0, 0),
+    width=5,
+    draw_grid=False,
+    step=50,                # pixels between grid lines
+    grid_color=(255, 255, 255),
+    grid_width=1,
+    add_text=True,
+    dilation=28
+):
+    """Draw bbox, point, and optional grid on a PIL image.
+
+    Args
+    ----
+    image (PIL.Image): target image (modified in place if not copied).
+    bbox  (list | tuple): [x1, y1, x2, y2] or None.
+    point (tuple): (x, y) or None.
+    color (tuple): RGB for bbox / point.
+    width (int): line width for bbox.
+    draw_grid (bool): enable/disable grid.
+    step (int): grid spacing in pixels.
+    grid_color (tuple): RGB for grid.
+    grid_width (int): line width for grid.
+    """
+    draw = ImageDraw.Draw(image)
+
+    if dilation > 0 and bbox is not None:
+        # Dilation logic: expand bbox by dilation pixels
+        x1, y1, x2, y2 = bbox
+        bbox = (x1 - dilation, y1 - dilation, x2 + dilation, y2 + dilation)
+
+    # ── draw grid ───────────────────────────────────────────
+    if draw_grid and step > 0:
+        w, h = image.size
+        # vertical lines
+        for x in range(0, w, step):
+            draw.line([(x, 0), (x, h)], fill=grid_color, width=grid_width)
+        # horizontal lines
+        for y in range(0, h, step):
+            draw.line([(0, y), (w, y)], fill=grid_color, width=grid_width)
+
+    # ── draw bbox ──────────────────────────────────────────
+    if bbox is not None:
+        draw.rectangle(bbox, outline=box_color, width=width)
+
+    # ── draw point ─────────────────────────────────────────
+    if point is not None:
+        radius = 20
+        x, y = point
+        draw.ellipse(
+            (x - radius, y - radius, x + radius, y + radius),
+            fill=pt_color
+        )
+        # add a white text at the center of the point
+        # add a white text at the center of the point
+        if add_text:
+            text = "Ref"
+            # Try to use a better font, or fall back to the default if not found
+            # try:
+            font = ImageFont.truetype("DejaVuSans.ttf", size=26)
+            # except IOError:
+            #     print('test')
+            #     font = ImageFont.load_default()
+
+            # Get text bounding box for centering
+            print(font)
+            bbox_text = draw.textbbox((0, 0), text, font=font)
+            text_width = bbox_text[2] - bbox_text[0]
+            text_height = bbox_text[3] - bbox_text[1]
+
+            text_x = x - text_width // 2
+            text_y = y - text_height // 2
+            draw.text((text_x, text_y), text, font=font, fill=(255, 255, 255), text_anchor = "mm")
+
+
+    return image
+
+
+def square_bbox_to_multiple(bbox, multiple=14):
+    """
+    Expand a rectangle to the smallest *square* box whose side length
+    
+    1. is at least the longer side of `bbox`, and  
+    2. is the nearest *upper* multiple of `multiple`.
+    
+    The square is centred on the original box.
+    
+    Parameters
+    ----------
+    bbox : list | tuple
+        [x1, y1, x2, y2] (top-left / bottom-right in pixels)
+    multiple : int, optional
+        Grid size to snap the side length to (default: 14).
+    
+    Returns
+    -------
+    list
+        [new_x1, new_y1, new_x2, new_y2] square bounding box.
+    """
+    x1, y1, x2, y2 = map(float, bbox)
+    w, h = x2 - x1, y2 - y1
+    
+    # 1) choose the longer side, then round **up** to nearest multiple
+    side = math.ceil(max(w, h) / multiple) * multiple
+    
+    # 2) centre the square on the original box
+    cx, cy = (x1 + x2) / 2, (y1 + y2) / 2
+    half = side / 2
+    
+    new_x1 = int(round(cx - half))
+    new_y1 = int(round(cy - half))
+    new_x2 = new_x1 + side
+    new_y2 = new_y1 + side
+    
+    return [new_x1, new_y1, new_x2, new_y2]

Code/sc_dit/utils_actor_critic.py

@@ -0,0 +1,408 @@
+import json
+from typing import Optional, Dict, Any
+from PIL import Image
+import base64
+import io
+from typing import Tuple
+from PIL import ImageDraw
+import re
+import os
+
+def _actor_prompt(
+    x: int,
+    y: int,
+    class_name: str,
+    feedback: Optional[str] = None,
+    previous_json: Optional[Dict[str, Any]] = None,
+    orientation_hint: Optional[str] = None,  # NEW ARG
+) -> str:
+    """
+    Generate the prompt for the actor (GPT-4o vision-enabled).
+    """
+
+    if feedback and previous_json:
+        prev_str = json.dumps(previous_json, ensure_ascii=False, indent=2)
+        return (
+            f"Critic feedback: \"{feedback}\"\n\n"
+            "Here is your previous response:\n"
+            f"{prev_str}\n\n"
+            f"The query point is at pixel coordinates (x={x}, y={y}) in a 840×840 image.\n"
+            "Please return a corrected JSON object with the **same keys**. Only modify what is incorrect.\n"
+            "**Strictly return one valid JSON block only. No markdown, no explanation.**"
+        )
+
+    # --- Base prompt for first iteration --- #
+    orientation_context = (
+        f"Note: The object’s canonical front-facing direction is toward the {orientation_hint} side of the image.\n\n"
+        if orientation_hint else ""
+    )
+
+    return (
+        f"# Task: Describe the part of a {class_name} touched by the keypoint.\n\n"
+        f"Image resolution: 840 × 840 pixels\n"
+        f"Keypoint location: (x={x}, y={y})\n"
+        f"{orientation_context}"
+        "You will output a JSON object describing:\n"
+        "- What the part is\n"
+        "- Where it is located **within the object**\n"
+        "- Which direction the whole object is facing in the image\n"
+        "- A bounding box that tightly encloses the part and includes the keypoint\n"
+        "- Confidence and visibility status\n\n"
+        "## Required JSON fields (with strict meanings):\n\n"
+        "1. **part_name** (string)\n"
+        "   - What it describes: The specific component name touched by the keypoint\n"
+        "   - Frame of reference: identity only\n"
+        "   - Example: 'propeller', 'left aileron', 'starboard hull'\n\n"
+
+        "2. **orientation** (string)\n"
+        "   - What it describes: A concise directional label of where the part is located **within the object**\n"
+        "   - Frame of reference: object-relative (not camera)\n"
+        "   - Example: 'front-left', 'upper-rear', 'center'\n\n"
+
+        "3. **spatial_location** (string)\n"
+        "   - What it describes: A free-form natural language phrase describing the part’s position within the object\n"
+        "   - Frame of reference: object-relative\n"
+        "   - Example: 'rear edge of the left wing', 'centerline between the hulls'\n\n"
+
+        "4. **object_facing_direction** (string)\n"
+        "   - What it describes: Which direction the **entire object** is facing in the image\n"
+        "   - Frame of reference: camera-relative (viewer’s perspective)\n"
+        "   - Example: 'facing the viewer', 'top-down', 'facing right'\n\n"
+
+        "5. **visibility_notes** (string)\n"
+        "   - What it describes: Visibility condition of the part in the current view\n"
+        "   - Example: 'fully visible', 'partially occluded', 'mostly obscured'\n\n"
+
+        "6. **proposed_bbox** ([x1, y1, x2, y2])\n"
+        "   - What it describes: Tight bounding box around the identified part, in pixel coordinates\n"
+        f"   - Must strictly contain the keypoint (x={x}, y={y}) ⇒ x1 < {x} < x2 and y1 < {y} < y2\n\n"
+
+        "7. **bbox_confidence** (float)\n"
+        "   - What it describes: Your confidence (between 0 and 1) that the box tightly encloses the described part\n\n"
+
+        "## Output Format:\n"
+        "Return ONLY the following JSON object:\n"
+        "{\n"
+        '  "part_name":               string,\n'
+        '  "orientation":             string,  // object-relative (e.g. "front-left")\n'
+        '  "spatial_location":        string,  // object-relative free-form description\n'
+        '  "object_facing_direction": string,  // camera-relative (e.g. "facing viewer")\n'
+        '  "visibility_notes":        string,  // fully or partially visible\n'
+        '  "proposed_bbox":           [x1, y1, x2, y2],\n'
+        '  "bbox_confidence":         float    // 0–1\n'
+        "}\n\n"
+        "**Do NOT include markdown, extra comments, or explanations. Return only the JSON object.**"
+    )
+
+
+def _critic_prompt(
+    desc: dict,
+    class_name: str,
+    x: int,
+    y: int,
+    orientation_hint: str | None = None,
+    hypothesis: str | None = None,
+) -> str:
+    blob = json.dumps(desc, ensure_ascii=False, indent=2)
+
+    orientation_txt = f"Orientation: {orientation_hint}.\n" if orientation_hint else ""
+    hypothesis_txt = f"My hypothesis: \"{hypothesis}\"\n" if hypothesis else ""
+
+    return (
+        "You are an expert vision auditor.\n\n"
+        "Image 1: a crop focused on the predicted part region.\n"
+        "Image 2: the full image with red dot and blue bounding box overlay.\n"
+        " - Red dot = query keypoint\n"
+        " - Blue box = predicted bounding box\n\n"
+        f"Object class: {class_name}\n"
+        f"Key-point: (x={x}, y={y}) in a 840×840 image.\n"
+        f"{orientation_txt}{hypothesis_txt}\n"
+        "Actor-supplied JSON:\n"
+        f"{blob}\n\n"
+        "Check each field in order and STOP at the first inconsistency:\n"
+        "1. **part_name** — Must match the visible component inside the box.\n"
+        "2. **orientation** — Must be object-relative (e.g., front-left) and accurate.\n"
+        "3. **spatial_location** — Must be a plausible free-form object-relative phrase.\n"
+        "4. **object_facing_direction** — Must be camera-relative and visually supported.\n"
+        "5. **visibility_notes** — Must match visual visibility.\n"
+        "6. **proposed_bbox** — Must tightly contain the part *and* include the keypoint (x1 < x < x2, y1 < y < y2).\n"
+        "7. **bbox_confidence** — Must be a float between 0 and 1.\n\n"
+        "Respond with ONE JSON only:\n"
+        '{"is_consistent": true | false, "reason": "concise explanation of the first error"}'
+    )
+
+def _encode_image_to_data_url(img: Image.Image, fmt: str = "PNG") -> str:
+    """Convert PIL image → base64 data-URL suitable for GPT-4o vision."""
+    buf = io.BytesIO()
+    img.save(buf, format=fmt)
+    b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+    return f"data:image/{fmt.lower()};base64,{b64}"
+
+
+
+def _make_overlay(
+    image: Image.Image,
+    point: Tuple[int, int],
+    bbox: list,
+    dot_radius: int = 6
+) -> Image.Image:
+    """Return a copy of `image` with a red dot and a blue bbox."""
+    x, y = point
+    x1, y1, x2, y2 = bbox
+    out = image.copy()
+    draw = ImageDraw.Draw(out)
+    draw.ellipse([x-dot_radius, y-dot_radius, x+dot_radius, y+dot_radius],
+                 fill="red", outline="white", width=2)
+    draw.rectangle([x1, y1, x2, y2], outline="blue", width=2)
+    return out
+
+
+_JSON_RE = re.compile(r"\{[\s\S]*\}")
+
+
+def _extract_json(block: str) -> Optional[Dict[str, Any]]:
+    """Grab first {...} block and parse; None if invalid."""
+    m = _JSON_RE.search(block)
+    if not m:
+        return None
+    try:
+        return json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return None
+
+
+# def save_actor_critic_output(
+#     save_dir: str,
+#     category: str,
+#     image_id: str,
+#     kpt_id: int,
+#     query_point: Tuple[int, int],
+#     actor_desc: Dict[str, Any],
+#     critic_report: Dict[str, Any],
+#     model_name: str,
+# ):
+#     """
+#     Saves the actor and critic outputs to a structured JSON file for a given image.
+
+#     This function uses a read-modify-write pattern. It loads an existing JSON if one
+#     exists for the image, adds or updates the data for the given keypoint, and then
+#     saves the file.
+
+#     Args:
+#         save_dir (str): The root directory for saving results (e.g., './results_vlm/').
+#         category (str): The object category (e.g., 'car'), used for subdirectories.
+#         image_id (str): The filename of the image (e.g., '0001.jpg').
+#         kpt_id (int): The unique ID of the keypoint being described.
+#         query_point (Tuple[int, int]): The (x, y) coordinates of the keypoint.
+#         actor_desc (Dict[str, Any]): The JSON output from the actor model.
+#         critic_report (Dict[str, Any]): The JSON output from the critic model.
+#         model_name (str): The name of the OpenAI model used.
+#     """
+#     # 1. Create the directory path (e.g., ./results_vlm/car/)
+#     category_dir = os.path.join(save_dir, category)
+#     os.makedirs(category_dir, exist_ok=True)
+
+#     # 2. Define the output file path
+#     image_basename = os.path.splitext(os.path.basename(image_id))[0]
+#     json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+#     # 3. Load existing data or initialize a new structure
+#     if os.path.exists(json_path):
+#         with open(json_path, 'r') as f:
+#             data = json.load(f)
+#     else:
+#         data = {
+#             "metadata": {
+#                 "image_id": image_id,
+#                 "category": category,
+#                 "model_name": model_name,
+#             },
+#             "keypoints": {}
+#         }
+
+#     # 4. Add the new keypoint data
+#     # Use str(kpt_id) because JSON keys must be strings.
+#     data["keypoints"][str(kpt_id)] = {
+#         "query_point": query_point,
+#         "actor_output": actor_desc,
+#         "critic_output": critic_report,
+#     }
+
+#     # 5. Write the updated data back to the file
+#     with open(json_path, 'w') as f:
+#         json.dump(data, f, indent=4)
+
+#     # print(f"Saved annotation for kpt_id {kpt_id} to {json_path}")
+
+
+import numpy as np
+import collections.abc
+
+def sanitize_for_json(obj):
+    """
+    Recursively traverses a dictionary or list and converts any
+    NumPy number types to their Python native equivalents.
+    This is essential for ensuring data is JSON serializable.
+    """
+    if isinstance(obj, (str, bytes)):
+        return obj
+    if isinstance(obj, collections.abc.Mapping):
+        return {k: sanitize_for_json(v) for k, v in obj.items()}
+    if isinstance(obj, collections.abc.Iterable):
+        return [sanitize_for_json(item) for item in obj]
+    if isinstance(obj, (np.integer, np.int64)):
+        return int(obj)
+    if isinstance(obj, (np.floating, np.float32, np.float64)):
+        return float(obj)
+    return obj
+
+
+def save_actor_critic_output(
+    save_dir: str,
+    category: str,
+    image_id: str,
+    kpt_id: int,
+    query_point: Tuple[int, int],
+    actor_desc: Dict[str, Any],
+    critic_report: Dict[str, Any],
+    model_name: str,
+):
+    # ... (path creation logic is the same) ...
+    category_dir = os.path.join(save_dir, category)
+    os.makedirs(category_dir, exist_ok=True)
+    image_basename = os.path.splitext(os.path.basename(image_id))[0]
+    json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+    # --- Robust Loading ---
+    data = None
+    if os.path.exists(json_path):
+        try:
+            with open(json_path, 'r') as f:
+                data = json.load(f)
+        except json.JSONDecodeError:
+            print(f"Warning: Corrupted JSON file at {json_path}. Overwriting.")
+            data = None
+
+    if data is None:
+        data = {"metadata": {"image_id": image_id, "category": category, "model_name": model_name}, "keypoints": {}}
+
+    # --- NEW: Robust Writing - Sanitize the data before adding it ---
+    clean_actor_desc = sanitize_for_json(actor_desc)
+    clean_critic_report = sanitize_for_json(critic_report)
+
+    # print('this is the cleaned critic report', clean_critic_report)
+
+    # Add the sanitized keypoint data
+    data["keypoints"][str(kpt_id)] = {
+        "query_point": query_point,  # Already clean from the main loop
+        "actor_output": clean_actor_desc,
+        "critic_output": clean_critic_report,
+    }
+
+    # Write the updated data back to the file
+    with open(json_path, 'w') as f:
+        json.dump(data, f, indent=4)
+
+
+#
+# NEW FUNCTION TO CHECK FOR COMPLETED WORK
+#
+def check_if_done(save_dir: str, category: str, image_id: str, kpt_id: int) -> bool:
+    """
+    Checks if a keypoint has already been processed and saved with non-empty content.
+
+    Args:
+        save_dir (str): The root directory where results are saved.
+        category (str): The object category.
+        image_id (str): The filename of the image.
+        kpt_id (int): The keypoint ID to check.
+
+    Returns:
+        bool: True if the keypoint exists and has content, False otherwise.
+    """
+    # 1. Construct the expected path to the JSON file
+    category_dir = os.path.join(save_dir, category)
+    image_basename = os.path.splitext(os.path.basename(image_id))[0]
+    json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+    # 2. If the file doesn't exist, it's definitely not done.
+    if not os.path.exists(json_path):
+        return False
+
+    try:
+        # 3. Read the existing JSON file
+        with open(json_path, 'r') as f:
+            data = json.load(f)
+
+        # 4. Check for the keypoint ID (as a string key)
+        kpt_entry = data.get("keypoints", {}).get(str(kpt_id))
+
+        if not kpt_entry:
+            # Keypoint not found in the file
+            return False
+
+        # 5. Check that the content is non-empty.
+        # We check if both actor and critic outputs exist and are not empty dictionaries.
+        actor_output = kpt_entry.get("actor_output")
+        critic_output = kpt_entry.get("critic_output")
+
+        if actor_output and critic_output:
+            # Both exist and are not empty/None, so we consider it done.
+            return True
+        else:
+            # One or both are missing or empty
+            return False
+
+    except (json.JSONDecodeError, FileNotFoundError):
+        # If the file is corrupted or can't be opened, treat it as not done.
+        # The robust saving function will overwrite it later.
+        print(f"Warning: Could not read or decode {json_path}. Will re-process.")
+        return False
+
+    return False
+
+
+def get_existing_result(save_dir: str, category: str, image_id: str, kpt_id: int) -> Optional[Dict[str, Any]]:
+    """
+    Checks if a keypoint has already been processed and, if so, returns the saved data.
+
+    Args:
+        save_dir (str): The root directory where results are saved.
+        category (str): The object category.
+        image_id (str): The filename of the image.
+        kpt_id (int): The keypoint ID to check.
+
+    Returns:
+        Optional[Dict[str, Any]]: The dictionary for the keypoint entry if it exists
+                                  and is valid, otherwise None.
+    """
+    # 1. Construct the expected path to the JSON file
+    category_dir = os.path.join(save_dir, category)
+    image_basename = os.path.splitext(os.path.basename(image_id))[0]
+    json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+    if not os.path.exists(json_path):
+        return None
+
+    try:
+        with open(json_path, 'r') as f:
+            data = json.load(f)
+
+        kpt_entry = data.get("keypoints", {}).get(str(kpt_id))
+
+        if not kpt_entry:
+            return None
+
+        # Check that the content is non-empty and valid
+        actor_output = kpt_entry.get("actor_output")
+        critic_output = kpt_entry.get("critic_output")
+
+        if actor_output and critic_output:
+            # Success! Return the entire entry for this keypoint.
+            return kpt_entry
+        else:
+            return None
+
+    except (json.JSONDecodeError, FileNotFoundError):
+        print(f"Warning: Could not read or decode {json_path}. Will re-process.")
+        return None

Code/sc_dit/utils_actor_critic_with_ort.py

@@ -0,0 +1,445 @@
+import json
+from typing import Optional, Dict, Any, List
+from PIL import Image
+import base64
+import io
+from typing import Tuple
+from PIL import ImageDraw
+import re
+import os
+import numpy as np
+import collections.abc
+from part_dictionary import PART_SCHEMA
+
+def get_all_parts_from_schema(schema_level: dict) -> List[str]:
+    """Recursively traverses the schema to get a flat list of all part names."""
+    part_names = []
+    for part_name, properties in schema_level.items():
+        part_names.append(part_name)
+        # If the part has children, recurse into them
+        if "children" in properties and properties["children"]:
+            part_names.extend(get_all_parts_from_schema(properties["children"]))
+    return part_names
+
+
+def _actor_prompt(
+    x: int,
+    y: int,
+    class_name: str,
+    feedback: Optional[str] = None,
+    previous_json: Optional[dict] = None,
+    orientation_hint: Optional[dict] = None,
+    part_schema: dict = PART_SCHEMA,
+) -> str:
+    """
+    Generates a state-aware prompt for the actor, ensuring both Exploration
+    and Refinement modes have the necessary context.
+    """
+    
+    # --- Define the JSON response format once to avoid repetition ---
+    JSON_FORMAT_TEMPLATE = (
+        "## RESPONSE FORMAT\n\n"
+        "Return ONLY a valid JSON object with the following structure:\n"
+        "{\n"
+        '  "part_name":               string,\n'
+        '  "part_location":           string,  // OBJECT-centric, e.g., "front-left"\n'
+        '  "spatial_location":        string,  // OBJECT-centric free-form phrase\n'
+        '  "object_facing_direction": string,  // camera-relative, e.g., "toward viewer"\n'
+        '  "visibility_notes":        string,\n'
+        '  "proposed_bbox":           [x1, y1, x2, y2], //\n'
+        '  "bbox_confidence":         float\n'
+        "}"
+    )
+
+    # The context block with core rules is needed in BOTH modes.
+    context_block = _create_context_block(class_name, orientation_hint)
+
+    class_specific_schema = part_schema.get(class_name, {})
+    vocabulary_list = []
+    if class_specific_schema:
+        all_parts = get_all_parts_from_schema(class_specific_schema)
+        vocabulary_list = sorted(list(set(all_parts)))
+        
+    part_selection_guide = (
+        f"## Part Selection Guide\n\n"
+        f"**1. Reference Vocabulary:**\n"
+        f"Your `part_name` choice IS ENCOURAGED come from this list: {vocabulary_list}\n\n"
+        f"**2. Selection Rule:**\n"
+        f"Aim for the most specific part name possible from the vocabulary. If you are uncertain, a more general parent part is acceptable."
+    )
+
+    # --- REFINEMENT MODE (An anchor part has been confirmed) ---
+    if feedback and previous_json:
+        return (
+            f"# Original TASK: Describe the part of a {class_name} at keypoint (x={x}, y={y}).\n\n"
+            f"Previous json: {json.dumps(previous_json, indent=2) if previous_json else 'None'}\n\n"
+            f"**Critic's Last Feedback:** \"{feedback}\"\n\n"
+            f"{context_block}  # <-- CRITICAL ADDITION: Provide the rules for geometric reasoning.\n\n"
+            "The bounding box should enclose the part in the center and includes the keypoint.\n\n"
+            f"{part_selection_guide}\n"
+            f"---\n"
+            f"{JSON_FORMAT_TEMPLATE}"
+        )
+
+    # --- EXPLORATION MODE (No anchor, this is the first attempt or a reset) ---
+    else:
+        return (
+            f"# TASK: Describe the part of a {class_name} at keypoint (x={x}, y={y}).\n\n"
+            f"Use the context and guide below to form your answer. A bounding box should tightly enclose the part and includes the keypoint.\n\n"
+            f"{context_block}\n\n"
+            "The bounding box should enclose the part in the center and includes the keypoint.\n\n"
+            f"{part_selection_guide}\n"
+            f"---\n"
+            f"{JSON_FORMAT_TEMPLATE}"
+        )
+
+
+def _critic_prompt(
+    desc: dict,
+    class_name: str,
+    x: int,
+    y: int,
+    part_schema: dict,
+    orientation_hint: Optional[dict] = None,
+    anchor_part: Optional[str] = None,  # NEW: Anchor part for sibling checks
+    img_size: int = 840,  # Default image size for bounding box calculations
+    #... other args
+) -> str:
+    """
+    Generates the final, streamlined prompt for the critic, guiding it
+    to produce intelligent, hierarchical feedback.
+    """
+    actor_part_name = desc.get("part_name", "unknown")
+    class_schema = part_schema.get(class_name, {})
+    
+    # --- Prepare all necessary data for the dynamic prompt ---
+    top_level_parts = list(class_schema.keys())
+    part_info, _ = find_part_in_schema(class_schema, actor_part_name)
+    
+    # Prepare lists for feedback
+    go_deeper_options = list(part_info["children"].keys()) if part_info and part_info.get("children") else [] # hint of whether it is specific enough
+    check_other_children_options = []
+    if anchor_part:
+        anchor_info, _ = find_part_in_schema(class_schema, anchor_part)
+        if anchor_info and anchor_info.get("children"):
+            check_other_children_options = list(anchor_info["children"].keys())
+            
+    # --- NEW: Generate the conditional geometric instruction ---
+    is_symmetric = part_info.get("is_symmetric", False) if part_info else False
+    if is_symmetric:
+        geometric_audit_instruction = (
+            "This is a **symmetric part**. Your primary task is to verify the left/right description "
+            "in `part_location` by strictly applying the Golden Rule to the visual evidence."
+        )
+    else:
+        geometric_audit_instruction = (
+            "This is a **singular/central part**. Your primary task is to verify its position along "
+            "the main axes (e.g., front, rear, top, center) as described in `part_location`."
+        )
+
+    context_block = _create_context_block(class_name, orientation_hint)
+
+    return (
+        f"You are a vision auditor. Follow the decision tree below to verify the actor's proposal. Show the reasoning traces (which passed and which does not) in the final answer as `reason` key.\n\n"
+        "=== DECISION PRIORITY (must follow) ==="
+        "1) Part identity"
+        "2) Geometry (facing/side/front-rear/vertical)"
+        "3) Visibility"
+        "4) Approved"
+        f"## Context & Evidence\n"
+        "Image 1: a crop focused on the predicted part region.\n"
+        "Image 2: the full image with red dot and blue bounding box overlay.\n"
+        " - Red dot = query keypoint\n"
+        " - Blue box = predicted bounding box\n\n"
+        f"Object class: {class_name}\n"
+        f"Key-point: (x={x}, y={y}) in a {img_size}x{img_size} image.\n"
+        f"**Actor's Proposal:**\n{json.dumps(desc, indent=2)}\n"
+        f"**Current Anchor Part:** {anchor_part or 'None (top-level)'}\n"
+        f"**Rules:**\n{context_block}\n\n"
+        f"## AUDIT DECISION TREE (Follow Strictly)\n\n"
+        f"**1. First, audit the `part_name` ('{actor_part_name}').**\n"
+        f"1a) CORRECT & SPECIFIC  → **Approved (Part)** "
+        f"    - The named part matches the component at the keypoint."  
+        f"    - It is already specific enough, or there are no children to refine (go_deeper_options = [])."
+        f"1b) CORRECT BUT TOO GENERAL  → **Go Deeper**"
+        f"    - The named part is a valid parent, but there is a more specific child clearly indicated." 
+        f"    - Suggest children to try next: {go_deeper_options}."
+        f"1c) INCORRECT & TOP-LEVEL NOT FIXED  → **Go Back** " 
+        f"- The named part is wrong and we do NOT have a confirmed parent (“anchor”)."  
+        f"- Suggest trying one of the top-level parents: {top_level_parts}."
+        f"1d) INCORRECT BUT PARENT (ANCHOR) IS KNOWN  → **Check Other Children** " 
+        f"- The named part is wrong, but the confirmed parent (“anchor”) is correct."  
+        f"- Suggest trying one of the anchor’s children: {check_other_children_options}."
+        f"**2. If `part_name` passed, audit the GEOMETRY.**\n"
+        f"   - **Your specific instruction for this part is:** {geometric_audit_instruction}\n"
+        f"   - Following this instruction, is the actor's `part_location` correct? If not, respond with `feedback_type: 'Geometric Error'` and a concise reason.\n\n"
+        f"**3. If geometry passed, audit the VISIBILITY.**\n"
+        f"   - Check the `visibility_notes`. Is it consistent with the part's location? If not, respond with `feedback_type: 'Visibility Error'`.\n\n"
+        f"**4. If all checks pass, the proposal is APPROVED.**\n"
+        f"   - Respond with `feedback_type: 'Approved'` and set `is_consistent` to `true`.\n\n"
+        f"---\n"
+        f"## YOUR RESPONSE\n"
+        f"Respond with ONE valid JSON object with the mandatory `feedback_type`."
+    )
+
+
+def find_part_in_schema(schema_level: dict, part_name_to_find: str, parent_name: str = None):
+    """
+    Recursively searches the nested schema for a part.
+    Returns the part's properties and its immediate parent's name.
+    """
+    # Check keys at the current level
+    if part_name_to_find in schema_level:
+        return schema_level[part_name_to_find], parent_name
+
+    # If not found, search in the children of each part at this level
+    for current_part_name, properties in schema_level.items():
+        if "children" in properties and properties["children"]:
+            found_info, found_parent = find_part_in_schema(
+                properties["children"], part_name_to_find, parent_name=current_part_name
+            )
+            if found_info:
+                return found_info, found_parent
+                
+    return None, None
+
+
+def _create_context_block(
+    class_name: str,
+    orientation_hint: Optional[dict] = None
+) -> str:
+    """
+    Consolidates all rules and hints into a single, clean markdown block
+    to be used as context for the VLM.
+    """
+    # 1. Format the orientation hint
+    hint_str = json.dumps(orientation_hint) if orientation_hint else "Not available."
+    
+    # 2. Define the core geometric principles
+    golden_rule = (
+        "- If facing 'toward viewer'**: It's a mirror. A part on the **viewer's left** is the **object's right**, and a part on the **viewer's right** is the **object's left**.\n"
+        "- **If facing 'away from viewer'**: It's direct. Image-left is object-left.\n"
+        # "- **If facing 'left' or 'right'**: Use near-side/far-side logic based on the object's orientation."
+    )
+
+    # 3. Assemble all pieces into the final markdown block
+    context = (
+        f"## CONTEXT & RULES\n\n"
+        f"**1. Object Class:** `{class_name}`\n"
+        f"**2. Orientation Prior (Hint):** `{hint_str}`\n"
+        f"**3. The Golden Rule of Geometry:**\n{golden_rule}\n"
+    )
+        
+    return context
+
+
+def _encode_image_to_data_url(img: Image.Image, fmt: str = "PNG") -> str:
+    """Convert PIL image → base64 data-URL suitable for GPT-4o vision."""
+    buf = io.BytesIO()
+    img.save(buf, format=fmt)
+    b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+    return f"data:image/{fmt.lower()};base64,{b64}"
+
+
+
+def _make_overlay(
+    image: Image.Image,
+    point: Tuple[int, int],
+    bbox: list,
+    dot_radius: int = 6
+) -> Image.Image:
+    """Return a copy of `image` with a red dot and a blue bbox."""
+    x, y = point
+    x1, y1, x2, y2 = bbox
+    out = image.copy()
+    draw = ImageDraw.Draw(out)
+    draw.ellipse([x-dot_radius, y-dot_radius, x+dot_radius, y+dot_radius],
+                 fill="red", outline="white", width=2)
+    draw.rectangle([x1, y1, x2, y2], outline="blue", width=2)
+    return out
+
+
+_JSON_RE = re.compile(r"\{[\s\S]*\}")
+
+
+def _extract_json(block: str) -> Optional[Dict[str, Any]]:
+    """Grab first {...} block and parse; None if invalid."""
+    m = _JSON_RE.search(block)
+    if not m:
+        return None
+    try:
+        return json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return None
+
+
+
+
+def sanitize_for_json(obj):
+    """
+    Recursively traverses a dictionary or list and converts any
+    NumPy number types to their Python native equivalents.
+    This is essential for ensuring data is JSON serializable.
+    """
+    if isinstance(obj, (str, bytes)):
+        return obj
+    if isinstance(obj, collections.abc.Mapping):
+        return {k: sanitize_for_json(v) for k, v in obj.items()}
+    if isinstance(obj, collections.abc.Iterable):
+        return [sanitize_for_json(item) for item in obj]
+    if isinstance(obj, (np.integer, np.int64)):
+        return int(obj)
+    if isinstance(obj, (np.floating, np.float32, np.float64)):
+        return float(obj)
+    return obj
+
+
+def save_actor_critic_output(
+    save_dir: str,
+    category: str,
+    image_id: str,
+    kpt_id: int,
+    query_point: Tuple[int, int],
+    actor_desc: Dict[str, Any],
+    critic_report: Dict[str, Any],
+    model_name: str,
+):
+    # ... (path creation logic is the same) ...
+    category_dir = os.path.join(save_dir, category)
+    os.makedirs(category_dir, exist_ok=True)
+    image_basename = os.path.splitext(os.path.basename(image_id))[0]
+    json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+    # --- Robust Loading ---
+    data = None
+    if os.path.exists(json_path):
+        try:
+            with open(json_path, 'r') as f:
+                data = json.load(f)
+        except json.JSONDecodeError:
+            print(f"Warning: Corrupted JSON file at {json_path}. Overwriting.")
+            data = None
+
+    if data is None:
+        data = {"metadata": {"image_id": image_id, "category": category, "model_name": model_name}, "keypoints": {}}
+
+    # --- NEW: Robust Writing - Sanitize the data before adding it ---
+    clean_actor_desc = sanitize_for_json(actor_desc)
+    clean_critic_report = sanitize_for_json(critic_report)
+
+    # print('this is the cleaned critic report', clean_critic_report)
+
+    # Add the sanitized keypoint data
+    data["keypoints"][str(kpt_id)] = {
+        "query_point": query_point,  # Already clean from the main loop
+        "actor_output": clean_actor_desc,
+        "critic_output": clean_critic_report,
+    }
+
+    # Write the updated data back to the file
+    with open(json_path, 'w') as f:
+        json.dump(data, f, indent=4)
+
+
+#
+# NEW FUNCTION TO CHECK FOR COMPLETED WORK
+#
+def check_if_done(save_dir: str, category: str, image_id: str, kpt_id: int) -> bool:
+    """
+    Checks if a keypoint has already been processed and saved with non-empty content.
+
+    Args:
+        save_dir (str): The root directory where results are saved.
+        category (str): The object category.
+        image_id (str): The filename of the image.
+        kpt_id (int): The keypoint ID to check.
+
+    Returns:
+        bool: True if the keypoint exists and has content, False otherwise.
+    """
+    # 1. Construct the expected path to the JSON file
+    category_dir = os.path.join(save_dir, category)
+    image_basename = os.path.splitext(os.path.basename(image_id))[0]
+    json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+    # 2. If the file doesn't exist, it's definitely not done.
+    if not os.path.exists(json_path):
+        return False
+
+    try:
+        # 3. Read the existing JSON file
+        with open(json_path, 'r') as f:
+            data = json.load(f)
+
+        # 4. Check for the keypoint ID (as a string key)
+        kpt_entry = data.get("keypoints", {}).get(str(kpt_id))
+
+        if not kpt_entry:
+            # Keypoint not found in the file
+            return False
+
+        # 5. Check that the content is non-empty.
+        # We check if both actor and critic outputs exist and are not empty dictionaries.
+        actor_output = kpt_entry.get("actor_output")
+        critic_output = kpt_entry.get("critic_output")
+
+        if actor_output and critic_output:
+            # Both exist and are not empty/None, so we consider it done.
+            return True
+        else:
+            # One or both are missing or empty
+            return False
+
+    except (json.JSONDecodeError, FileNotFoundError):
+        # If the file is corrupted or can't be opened, treat it as not done.
+        # The robust saving function will overwrite it later.
+        print(f"Warning: Could not read or decode {json_path}. Will re-process.")
+        return False
+
+    return False
+
+
+def get_existing_result(save_dir: str, category: str, image_id: str, kpt_id: int) -> Optional[Dict[str, Any]]:
+    """
+    Checks if a keypoint has already been processed and, if so, returns the saved data.
+
+    Args:
+        save_dir (str): The root directory where results are saved.
+        category (str): The object category.
+        image_id (str): The filename of the image.
+        kpt_id (int): The keypoint ID to check.
+
+    Returns:
+        Optional[Dict[str, Any]]: The dictionary for the keypoint entry if it exists
+                                  and is valid, otherwise None.
+    """
+    # 1. Construct the expected path to the JSON file
+    category_dir = os.path.join(save_dir, category)
+    image_basename = os.path.splitext(os.path.basename(image_id))[0]
+    json_path = os.path.join(category_dir, f"{image_basename}.json")
+
+    if not os.path.exists(json_path):
+        return None
+
+    try:
+        with open(json_path, 'r') as f:
+            data = json.load(f)
+
+        kpt_entry = data.get("keypoints", {}).get(str(kpt_id))
+
+        if not kpt_entry:
+            return None
+
+        # Check that the content is non-empty and valid
+        actor_output = kpt_entry.get("actor_output")
+        critic_output = kpt_entry.get("critic_output")
+
+        if actor_output and critic_output:
+            # Success! Return the entire entry for this keypoint.
+            return kpt_entry
+        else:
+            return None
+
+    except (json.JSONDecodeError, FileNotFoundError):
+        print(f"Warning: Could not read or decode {json_path}. Will re-process.")
+        return None

Code/sc_dit/vlm_judge_bbox_pred.py

@@ -0,0 +1,216 @@
+from openai import OpenAI
+import os
+from io import BytesIO
+from PIL import Image
+import base64
+import numpy as np
+import argparse
+import pandas as pd
+from tqdm import tqdm
+from openai import AsyncClient, OpenAI
+import wandb
+from pydantic import BaseModel
+from typing import Literal
+import matplotlib.pyplot as plt
+
+# custom imports
+from utils import resize, draw_bbox_point_grid
+from dataset import get_dataset_info
+
+
+def encode_image_to_base64(image: Image.Image) -> str:
+    """Encodes a PIL image to a base64 data URI."""
+    buffered = BytesIO()
+    image.save(buffered, format="JPEG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/jpeg;base64,{img_str}"
+
+# use structured output
+class VLMJudgeOutput(BaseModel):
+    full_response: str  # entire response
+    final_answer: Literal["yes", "no"]
+
+def make_preview(src_display, tgt_display):
+    """Return a matplotlib Figure with both images + optional boxes."""
+    fig, axes = plt.subplots(1, 2, figsize=(6, 3))
+    axes[0].imshow(src_display); axes[0].axis("off"); axes[0].set_title("Source")
+    axes[1].imshow(tgt_display); axes[1].axis("off"); axes[1].set_title("Target")
+
+    fig.tight_layout()
+    return fig
+
+# cnt = 0
+def run_batched_evaluation(args, model, system_prompt, task_prompt):
+
+    run = wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        # config=vars(args)
+    )
+
+    columns = [
+            "category", "src_id", "tgt_id", "kpt_id",
+            "preview", "full_response",
+            "final_answer",
+            #"src_img_size", "tgt_img_size"
+    ]
+    results_tb = wandb.Table(columns=columns)
+
+    results_df = pd.read_csv(args.BBOX_FILE)
+
+    data_dir, categories, split = get_dataset_info(args, split='test')
+
+    for idx, row in tqdm(results_df.iterrows(), total=len(results_df)):
+        category, src_id, tgt_id = row['category'], str(row['src_id']), str(row['tgt_id'])
+        kpt_id = int(row['kpt_id'])
+        src_bbox = row['src_bbox']
+        tgt_bbox = row['tgt_bbox']
+
+        src_bbox = eval(src_bbox) if isinstance(src_bbox, str) else src_bbox
+        tgt_bbox = eval(tgt_bbox) if isinstance(tgt_bbox, str) else []
+
+        # return an empty list if tgt_bbox is nan
+        # if np.isnan(np.array(tgt_bbox).any()):
+        #     tgt_bbox = []
+
+        src_img = Image.open(os.path.join(data_dir, 'JPEGImages', category, f"{src_id}.jpg"))
+        tgt_img = Image.open(os.path.join(data_dir, 'JPEGImages', category, f"{tgt_id}.jpg"))
+
+        src_img = resize(src_img, args.ANNO_SIZE)
+        tgt_img = resize(tgt_img, args.ANNO_SIZE)
+
+        src_image_display = draw_bbox_point_grid(
+            src_img.copy(),
+            bbox=src_bbox,
+            dilation=args.DILATION_SRC,
+        )
+
+        if len(tgt_bbox) == 0:
+            tgt_image_display = draw_bbox_point_grid(
+                tgt_img.copy(),
+                # bbox=tgt_bbox
+            )
+        elif len(tgt_bbox) > 0:
+            tgt_image_display = draw_bbox_point_grid(
+                tgt_img.copy(),
+                bbox=tgt_bbox,
+                dilation=args.DILATION_TGT,
+            )
+
+        print(f"Processing {category} - {src_id} to {tgt_id}")
+        print(f"Source bbox: {src_bbox}, Target bbox: {tgt_bbox}")
+
+        # response = model.chat.completions.create(
+        # # 1. Using a valid and powerful vision model
+        # model="gpt-4.1-mini",
+
+        # # 2. Consolidating text and images into a single user message
+        # messages=[
+        #     {"role": "system", "content": system_prompt},
+        #     {
+        #         "role": "user",
+        #         "content": [
+        #             {"type": "text", "text": task_prompt},
+        #             {"type": "image_url", "image_url": {"url": encode_image_to_base64(src_image_display)}},
+        #             {"type": "image_url", "image_url": {"url": encode_image_to_base64(tgt_image_display)}}
+        #         ]
+        #     }
+        # ],
+        # max_tokens=1000,
+        # temperature=0.0,
+        # top_p=1.0,
+        # n=1,
+        # # 3. Correctly formatting the 'response_format' parameter as a dictionary
+        # # response_format={"type": "json_object"}
+        # )
+
+        fig = make_preview(src_image_display, tgt_image_display)
+        wandb_img = wandb.Image(fig)
+        plt.close(fig)
+
+        response = model.responses.parse(
+            model=args.MODEL_NAME,
+            input=[
+                {"role": "system", "content": f"{system_prompt}"},
+                {
+                    "role": "user",
+                    "content": [
+                    {"type": "input_text", "text": f"{task_prompt}"},
+                    {"type": "input_image", "image_url": encode_image_to_base64(src_image_display)},
+                    {"type": "input_image", "image_url": encode_image_to_base64(tgt_image_display)}
+                    ],
+                },
+            ],
+            text_format=VLMJudgeOutput,
+        )
+
+        # print(response.choices[0].message.content)
+        output = response.output_parsed
+        # print(output)
+        print(f"Final answer: {output.final_answer}")
+        print(f"Full response: {output.full_response}")
+
+        results_tb.add_data(
+            category,
+            src_id,
+            tgt_id,
+            kpt_id,
+            wandb_img,
+            output.full_response,
+            output.final_answer,
+        )
+
+    
+        # print(type(src_bbox), type(tgt_bbox))
+        # for debugging purposes
+        if args.TEST_RUN_SAMPLE > 0 and idx >= args.TEST_RUN_SAMPLE - 1:
+            break
+        
+
+    wandb.log({"evaluation_results": results_tb})
+    run.finish()
+        # break
+
+def main(args):
+
+    # pass
+
+    with open(args.SYSTEM_PROMPT, 'r') as f:
+        system_prompt = f.read()
+
+    with open(args.TASK_PROMPT, 'r') as f:
+        task_prompt = f.read()
+
+    # print(system_prompt)
+    # print(task_prompt)
+
+    # Initialize the OpenAI VLM model
+    print("Initializing OpenAI model...")
+    # model = OpenAI()
+    model = OpenAI(api_key="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")
+    run_batched_evaluation(args, model, system_prompt, task_prompt)
+
+    
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Process some images.")
+    parser.add_argument("--SYSTEM_PROMPT", type=str, required=True, help="System prompt for the model.")
+    parser.add_argument("--TASK_PROMPT", type=str, required=True, help="Text prompt for the model.")
+    parser.add_argument("--EVAL_DATASET", type=str, required=True, choices=['pascal', 'spair'], help="Dataset to use for evaluation.")
+    # parser.add_argument("--TEST_SAMPLE", type=int, default=10, help
+    parser.add_argument("--BBOX_FILE", type=str, required=True, help="Path to the bounding box file.")
+    
+
+    # arguments with default values
+    parser.add_argument("--ANNO_SIZE", type=int, default=840, help="Size of the annotation.")
+    parser.add_argument("--DILATION_SRC", type=int, default=28, help="Dilation for source bounding box.")
+    parser.add_argument("--DILATION_TGT", type=int, default=0, help="Dilation for target bounding box.")
+    parser.add_argument("--DATA_DIR", type=str, default="./data", help="Path to the dataset directory.")
+    parser.add_argument("--EXP_NOTE", type=str, default="gpt_judge", help="Experiment note for WandB logging.")
+    parser.add_argument("--TEST_RUN_SAMPLE", type=int, default=0, help="Number of test samples to use (0 for all).")
+    parser.add_argument("--MODEL_NAME", type=str, default="gpt-4.1-mini", help="Name of the OpenAI model to use.")
+
+    args = parser.parse_args()
+    main(args)

Code/sc_dit/vlm_judge_bbox_pred_batched.py

@@ -0,0 +1,208 @@
+import os
+import asyncio
+import json
+import base64
+from io import BytesIO
+from typing import Literal
+
+import argparse
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from tqdm.asyncio import tqdm_asyncio
+from openai import AsyncClient
+import wandb
+from pydantic import BaseModel, ValidationError
+from tqdm import tqdm
+import instructor
+
+# custom imports
+from utils import resize, draw_bbox_point_grid
+from dataset import get_dataset_info
+
+# --- Constants & Configuration ---
+# Set a reasonable concurrency limit to avoid API rate limiting
+CONCURRENCY_LIMIT = 4
+
+# --- Helper Functions & Pydantic Models ---
+
+def encode_image_to_base64(image: Image.Image) -> str:
+    """Encodes a PIL image to a base64 data URI."""
+    buffered = BytesIO()
+    image.save(buffered, format="JPEG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/jpeg;base64,{img_str}"
+
+class VLMJudgeOutput(BaseModel):
+    """Pydantic model for structured output from the VLM."""
+    full_response: str
+    final_answer: Literal["yes", "no"]
+
+def make_preview(src_display: Image.Image, tgt_display: Image.Image) -> plt.Figure:
+    """Return a matplotlib Figure with both source and target images."""
+    fig, axes = plt.subplots(1, 2, figsize=(6, 3))
+    axes[0].imshow(src_display); axes[0].axis("off"); axes[0].set_title("Source")
+    axes[1].imshow(tgt_display); axes[1].axis("off"); axes[1].set_title("Target")
+    fig.tight_layout()
+    return fig
+
+# --- Core Asynchronous Logic ---
+
+async def process_single_item(
+    client: AsyncClient,
+    semaphore: asyncio.Semaphore,
+    messages: list,
+    model_name: str
+) -> dict:
+    """Acquires semaphore and makes a single async API call to OpenAI."""
+    async with semaphore:
+        try:
+            response = await client.chat.completions.create(
+                model=model_name,
+                messages=messages,
+                max_tokens=1000,
+                temperature=0.0,
+                top_p=1.0,
+                n=1,
+                # response_format={"type": "json_object"}
+                response_model=VLMJudgeOutput
+            )
+            return response
+        except Exception as e:
+            # Return the exception to be handled later
+            return e
+
+
+
+async def run_batched_evaluation(args, client: AsyncClient, system_prompt: str, task_prompt: str):
+    """Prepares data, runs asynchronous evaluations IN BATCHES, and logs results."""
+    run = wandb.init(
+        project=args.EVAL_DATASET,
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+    results_tb = wandb.Table(columns=[
+        "category", "src_id", "tgt_id", "kpt_id", "preview",
+        "full_response", "final_answer", "error"
+    ])
+    
+    df = pd.read_csv(args.BBOX_FILE)
+    if args.TEST_RUN_SAMPLE > 0:
+        df = df.head(args.TEST_RUN_SAMPLE)
+        
+    data_dir, _, _ = get_dataset_info(args, split='test')
+    
+    # Process the dataframe in smaller batches to control memory usage
+    num_batches = (len(df) - 1) // args.BATCH_SIZE + 1
+    for i in range(num_batches):
+        start_index = i * args.BATCH_SIZE
+        end_index = start_index + args.BATCH_SIZE
+        batch_df = df.iloc[start_index:end_index]
+        
+        print(f"\n--- Processing Batch {i+1}/{num_batches} (items {start_index}-{end_index-1}) ---")
+        
+        # 1. PREPARE PAYLOADS FOR THE CURRENT BATCH
+        payloads = []
+        for _, row in batch_df.iterrows():
+            category, src_id, tgt_id = row['category'], str(row['src_id']), str(row['tgt_id'])
+            
+            src_img_path = os.path.join(data_dir, 'JPEGImages', category, f"{src_id}.jpg")
+            tgt_img_path = os.path.join(data_dir, 'JPEGImages', category, f"{tgt_id}.jpg")
+            
+            src_img = resize(Image.open(src_img_path), args.ANNO_SIZE)
+            tgt_img = resize(Image.open(tgt_img_path), args.ANNO_SIZE)
+            
+            src_bbox = eval(row['src_bbox'])
+            tgt_bbox = eval(row['tgt_bbox']) if 'tgt_bbox' in row and pd.notna(row['tgt_bbox']) else []
+
+            src_display = draw_bbox_point_grid(src_img.copy(), bbox=src_bbox, dilation=args.DILATION_SRC)
+            tgt_display = draw_bbox_point_grid(tgt_img.copy(), bbox=tgt_bbox if tgt_bbox else None, dilation=args.DILATION_TGT)
+            
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": [
+                    {"type": "text", "text": task_prompt},
+                    {"type": "image_url", "image_url": {"url": encode_image_to_base64(src_display)}},
+                    {"type": "image_url", "image_url": {"url": encode_image_to_base64(tgt_display)}}
+                ]}
+            ]
+            
+            fig = make_preview(src_display, tgt_display)
+            payloads.append({
+                "messages": messages,
+                "metadata": row.to_dict(),
+                "wandb_img": wandb.Image(fig)
+            })
+            plt.close(fig)
+
+        # 2. EXECUTE API CALLS FOR THE CURRENT BATCH
+        print(f"Sending {len(payloads)} requests for this batch...")
+        semaphore = asyncio.Semaphore(CONCURRENCY_LIMIT)
+        tasks = [
+            process_single_item(client, semaphore, p["messages"], args.MODEL_NAME)
+            for p in payloads
+        ]
+        # Use the standard asyncio.gather which correctly handles return_exceptions
+        api_responses = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # 3. PROCESS AND LOG RESULTS FOR THE CURRENT BATCH
+        # Wrap the results loop in tqdm for a progress bar
+        # 3. PROCESS AND LOG RESULTS FOR THE CURRENT BATCH
+        for payload, parsed_output in tqdm(zip(payloads, api_responses), total=len(payloads), desc="Processing responses"):
+            meta = payload['metadata']
+            
+            # Since instructor handles parsing, the response is either a VLMJudgeOutput object or an Exception
+            if isinstance(parsed_output, Exception):
+                print(f"ERROR processing {meta['src_id']}->{meta['tgt_id']}: {parsed_output}")
+                results_tb.add_data(
+                    meta['category'], meta['src_id'], meta['tgt_id'], int(meta['kpt_id']),
+                    payload['wandb_img'], None, None, str(parsed_output)
+                )
+            else:
+                # No need for try-except block, 'parsed_output' is already a validated Pydantic object
+                results_tb.add_data(
+                    meta['category'], meta['src_id'], meta['tgt_id'], int(meta['kpt_id']),
+                    payload['wandb_img'], parsed_output.full_response,
+                    parsed_output.final_answer, None
+                )
+        
+        # Log the table periodically to save progress
+        wandb.log({"evaluation_results": results_tb})
+
+    run.finish()
+    print("\nEvaluation complete.")
+
+async def main(args):
+    """Main function to set up and run the evaluation."""
+    with open(args.SYSTEM_PROMPT, 'r') as f:
+        system_prompt = f.read()
+    with open(args.TASK_PROMPT, 'r') as f:
+        task_prompt = f.read()
+        
+    # Use the async client
+    # The client automatically reads the OPENAI_API_KEY environment variable
+    client = instructor.patch(AsyncClient(api_key="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"))
+    await run_batched_evaluation(args, client, system_prompt, task_prompt)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run batched VLM evaluation asynchronously.")
+    parser.add_argument("--SYSTEM_PROMPT", type=str, required=True, help="Path to the system prompt file.")
+    parser.add_argument("--TASK_PROMPT", type=str, required=True, help="Path to the task prompt file.")
+    parser.add_argument("--EVAL_DATASET", type=str, required=True, choices=['pascal', 'spair'], help="Dataset for evaluation.")
+    parser.add_argument("--BBOX_FILE", type=str, required=True, help="Path to the CSV file with bounding box data.")
+    
+    # Arguments with default values
+    parser.add_argument("--ANNO_SIZE", type=int, default=840, help="Size to resize images to.")
+    parser.add_argument("--DILATION_SRC", type=int, default=28, help="Dilation for the source bounding box overlay.")
+    parser.add_argument("--DILATION_TGT", type=int, default=0, help="Dilation for the target bounding box overlay.")
+    parser.add_argument("--DATA_DIR", type=str, default="./data", help="Path to the dataset directory.")
+    parser.add_argument("--EXP_NOTE", type=str, default="gpt_judge_async", help="Experiment note for WandB logging.")
+    parser.add_argument("--TEST_RUN_SAMPLE", type=int, default=0, help="Number of samples to run (0 for all).")
+    parser.add_argument("--MODEL_NAME", type=str, default="gpt-4o-mini", help="Name of the OpenAI model to use.")
+    parser.add_argument("--BATCH_SIZE", type=int, default=10, help="Number of items to process in each batch.")
+
+    args = parser.parse_args()
+    
+    # Run the main async function
+    asyncio.run(main(args))

Code/sc_env_torch_113.yaml

@@ -0,0 +1,232 @@
+name: sc_env_torch_113
+channels:
+  - defaults
+  - conda-forge
+  - nvidia
+  - pytorch
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - asttokens=3.0.0=pyhd8ed1ab_1
+  - blas=1.0=mkl
+  - brotli-python=1.0.9=py39h6a678d5_9
+  - bzip2=1.0.8=h5eee18b_6
+  - ca-certificates=2025.4.26=hbd8a1cb_0
+  - certifi=2025.4.26=pyhd8ed1ab_0
+  - charset-normalizer=3.3.2=pyhd3eb1b0_0
+  - comm=0.2.2=pyhd8ed1ab_1
+  - cuda-cudart=11.7.99=0
+  - cuda-cupti=11.7.101=0
+  - cuda-libraries=11.7.1=0
+  - cuda-nvrtc=11.7.99=0
+  - cuda-nvtx=11.7.91=0
+  - cuda-runtime=11.7.1=0
+  - cudatoolkit=11.7.0=hd8887f6_10
+  - debugpy=1.8.14=py39hf88036b_0
+  - decorator=5.2.1=pyhd8ed1ab_0
+  - exceptiongroup=1.3.0=pyhd8ed1ab_0
+  - executing=2.2.0=pyhd8ed1ab_0
+  - ffmpeg=4.3=hf484d3e_0
+  - freetype=2.13.3=h4a9f257_0
+  - gmp=6.3.0=h6a678d5_0
+  - gnutls=3.6.15=he1e5248_0
+  - idna=3.7=py39h06a4308_0
+  - intel-openmp=2023.1.0=hdb19cb5_46306
+  - ipykernel=6.29.5=pyh3099207_0
+  - ipython=8.18.1=pyh707e725_3
+  - jedi=0.19.2=pyhd8ed1ab_1
+  - jpeg=9e=h5eee18b_3
+  - jupyter_client=8.6.3=pyhd8ed1ab_1
+  - jupyter_core=5.7.2=pyh31011fe_1
+  - keyutils=1.6.1=h166bdaf_0
+  - krb5=1.21.3=h659f571_0
+  - lame=3.100=h7b6447c_0
+  - lcms2=2.16=h92b89f2_1
+  - ld_impl_linux-64=2.40=h12ee557_0
+  - lerc=4.0.0=h6a678d5_0
+  - libcublas=11.10.3.66=0
+  - libcufft=10.7.2.124=h4fbf590_0
+  - libcufile=1.9.1.3=0
+  - libcurand=10.3.5.147=0
+  - libcusolver=11.4.0.1=0
+  - libcusparse=11.7.4.91=0
+  - libdeflate=1.22=h5eee18b_0
+  - libedit=3.1.20191231=he28a2e2_2
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc=15.1.0=h767d61c_2
+  - libgcc-ng=15.1.0=h69a702a_2
+  - libgomp=15.1.0=h767d61c_2
+  - libiconv=1.16=h5eee18b_3
+  - libidn2=2.3.4=h5eee18b_0
+  - libnpp=11.7.4.75=0
+  - libnvjpeg=11.8.0.2=0
+  - libpng=1.6.39=h5eee18b_0
+  - libsodium=1.0.20=h4ab18f5_0
+  - libstdcxx=15.1.0=h8f9b012_2
+  - libstdcxx-ng=15.1.0=h4852527_2
+  - libtasn1=4.19.0=h5eee18b_0
+  - libtiff=4.7.0=hde9077f_0
+  - libunistring=0.9.10=h27cfd23_0
+  - libwebp-base=1.3.2=h5eee18b_1
+  - lz4-c=1.9.4=h6a678d5_1
+  - matplotlib-inline=0.1.7=pyhd8ed1ab_1
+  - mkl=2023.1.0=h213fc3f_46344
+  - mkl-service=2.4.0=py39h5eee18b_2
+  - mkl_fft=1.3.11=py39h5eee18b_0
+  - mkl_random=1.2.8=py39h1128e8f_0
+  - ncurses=6.4=h6a678d5_0
+  - nest-asyncio=1.6.0=pyhd8ed1ab_1
+  - nettle=3.7.3=hbbd107a_1
+  - openh264=2.1.1=h4ff587b_0
+  - openjpeg=2.5.2=h0d4d230_1
+  - openssl=3.5.0=h7b32b05_1
+  - packaging=25.0=pyh29332c3_1
+  - parso=0.8.4=pyhd8ed1ab_1
+  - pexpect=4.9.0=pyhd8ed1ab_1
+  - pickleshare=0.7.5=pyhd8ed1ab_1004
+  - pip=25.1=pyhc872135_2
+  - platformdirs=4.3.8=pyhe01879c_0
+  - prompt-toolkit=3.0.51=pyha770c72_0
+  - psutil=7.0.0=py39h8cd3c5a_0
+  - ptyprocess=0.7.0=pyhd8ed1ab_1
+  - pure_eval=0.2.3=pyhd8ed1ab_1
+  - pygments=2.19.1=pyhd8ed1ab_0
+  - pysocks=1.7.1=py39h06a4308_0
+  - python=3.9.21=he870216_1
+  - python-dateutil=2.9.0.post0=pyhff2d567_1
+  - python_abi=3.9=2_cp39
+  - pytorch=1.13.1=py3.9_cuda11.7_cudnn8.5.0_0
+  - pytorch-cuda=11.7=h778d358_5
+  - pytorch-mutex=1.0=cuda
+  - pyzmq=26.4.0=py39h4e4fb57_0
+  - readline=8.2=h5eee18b_0
+  - requests=2.32.3=py39h06a4308_1
+  - setuptools=78.1.1=py39h06a4308_0
+  - six=1.17.0=pyhd8ed1ab_0
+  - sqlite=3.45.3=h5eee18b_0
+  - stack_data=0.6.3=pyhd8ed1ab_1
+  - tbb=2021.8.0=hdb19cb5_0
+  - tk=8.6.14=h39e8969_0
+  - torchvision=0.14.1=py39_cu117
+  - tornado=6.5=py39h8cd3c5a_0
+  - traitlets=5.14.3=pyhd8ed1ab_1
+  - typing_extensions=4.12.2=py39h06a4308_0
+  - wcwidth=0.2.13=pyhd8ed1ab_1
+  - wheel=0.45.1=py39h06a4308_0
+  - xz=5.6.4=h5eee18b_1
+  - zeromq=4.3.5=h3b0a872_7
+  - zipp=3.21.0=pyhd8ed1ab_1
+  - zlib=1.2.13=h5eee18b_1
+  - zstd=1.5.6=hc292b87_0
+  - pip:
+      - absl-py==2.2.2
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.11.18
+      - aiosignal==1.3.2
+      - albumentations==1.3.0
+      - annotated-types==0.7.0
+      - antlr4-python3-runtime==4.8
+      - appdirs==1.4.4
+      - async-timeout==5.0.1
+      - attrs==25.3.0
+      - beautifulsoup4==4.13.4
+      - black==21.4b2
+      - boto3==1.38.21
+      - botocore==1.38.21
+      - click==8.1.8
+      - cloudpickle==3.1.1
+      - contourpy==1.3.0
+      - cycler==0.12.1
+      - cython==3.1.1
+      - detectron2==0.6
+      - diffdist==0.1
+      - docker-pycreds==0.4.0
+      - einops==0.3.0
+      - eval-type-backport==0.2.2
+      - filelock==3.18.0
+      - fonttools==4.58.0
+      - frozenlist==1.6.0
+      - fsspec==2025.5.0
+      - ftfy==6.3.1
+      - future==1.0.0
+      - fvcore==0.1.5.post20221221
+      - gdown==5.2.0
+      - gitdb==4.0.12
+      - gitpython==3.1.44
+      - grpcio==1.71.0
+      - huggingface-hub==0.31.4
+      - hydra-core==1.1.1
+      - imageio==2.37.0
+      - importlib-metadata==8.7.0
+      - importlib-resources==6.5.2
+      - iopath==0.1.9
+      - jmespath==1.0.1
+      - joblib==1.5.0
+      - kiwisolver==1.4.7
+      - kornia==0.6.0
+      - lazy-loader==0.4
+      - loguru==0.7.3
+      - lvis==0.5.3
+      - markdown==3.8
+      - markupsafe==3.0.2
+      - matplotlib==3.9.4
+      - multidict==6.4.4
+      - mypy-extensions==1.1.0
+      - networkx==3.2.1
+      - nltk==3.9.1
+      - numpy==1.23.5
+      - omegaconf==2.1.1
+      - open-clip-torch==2.0.2
+      - opencv-python==4.6.0.66
+      - opencv-python-headless==4.11.0.86
+      - pandas==2.2.3
+      - panopticapi==0.1
+      - pathspec==0.12.1
+      - pillow==9.5.0
+      - portalocker==3.1.1
+      - propcache==0.3.1
+      - protobuf==6.31.0
+      - pycocotools==2.0.8
+      - pydantic==2.11.4
+      - pydantic-core==2.33.2
+      - pydeprecate==0.3.1
+      - pydot==4.0.0
+      - pyparsing==3.2.3
+      - pyre-extensions==0.0.23
+      - pytorch-lightning==1.4.2
+      - pytz==2025.2
+      - pyyaml==6.0.2
+      - qudida==0.0.4
+      - regex==2024.11.6
+      - s3transfer==0.12.0
+      - scikit-image==0.24.0
+      - scikit-learn==1.6.1
+      - scipy==1.13.1
+      - sentry-sdk==2.29.1
+      - setproctitle==1.3.6
+      - smmap==5.0.2
+      - soupsieve==2.7
+      - stable-diffusion-sdkit==2.1.3
+      - tabulate==0.9.0
+      - tensorboard==2.19.0
+      - tensorboard-data-server==0.7.2
+      - termcolor==3.1.0
+      - test-tube==0.7.5
+      - threadpoolctl==3.6.0
+      - tifffile==2024.8.30
+      - timm==0.6.11
+      - tokenizers==0.13.3
+      - toml==0.10.2
+      - torchmetrics==0.6.0
+      - tqdm==4.67.1
+      - transformers==4.26.1
+      - typing-inspect==0.9.0
+      - typing-inspection==0.4.1
+      - tzdata==2025.2
+      - urllib3==1.26.20
+      - wandb==0.19.11
+      - werkzeug==3.1.3
+      - xformers==0.0.16
+      - yacs==0.1.8
+      - yarl==1.20.0
+prefix: /opt/conda/envs/sc_env_torch1_13

README.md

@@ -0,0 +1 @@
+# SemCorrVLM_raw