notebooks/09_dot_product_eval.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8a099dd4-cd60-4df7-9fbf-2136e00cfa76",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-03-06 08:40:27.821322: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-03-06 08:40:27.822626: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-03-06 08:40:27.925954: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append(\"../\")\n",
    "\n",
    "import jax\n",
    "import jax.numpy as np\n",
    "from transformers import FlaxCLIPModel, AutoProcessor, AutoTokenizer\n",
    "\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ca87e85f-3e24-4e66-ab8a-1cf4af3c44fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = FlaxCLIPModel.from_pretrained(\"openai/clip-vit-base-patch16\")\n",
    "processor = AutoProcessor.from_pretrained(\"openai/clip-vit-base-patch16\")\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"openai/clip-vit-base-patch16\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fc3a1bfa-d17d-49c5-a009-eb7b82b56120",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.pylab as pylab\n",
    "\n",
    "from matplotlib import cm\n",
    "cmap = matplotlib.colormaps.get_cmap('viridis_r')\n",
    "\n",
    "# Ignore warning\n",
    "import warnings\n",
    "import logging\n",
    "\n",
    "logging.getLogger('matplotlib').setLevel(logging.ERROR)\n",
    "warnings.filterwarnings(\"ignore\",category=matplotlib.MatplotlibDeprecationWarning)\n",
    "\n",
    "# Get plot params\n",
    "\n",
    "from plot_params import params\n",
    "pylab.rcParams.update(params)\n",
    "\n",
    "# Set default colors to load at will\n",
    "cols_default = plt.rcParams['axes.prop_cycle'].by_key()['color']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cb8e92d8-d6c5-4331-a341-ebeb05d54831",
   "metadata": {},
   "outputs": [],
   "source": [
    "import yaml\n",
    "from ml_collections.config_dict import ConfigDict\n",
    "\n",
    "logging_dir = '/n/holystore01/LABS/iaifi_lab/Users/smsharma/multimodal-data/logging/proposals/'\n",
    "run_name = 'glistening-kumquat-123'\n",
    "\n",
    "config_file = \"{}/{}/config.yaml\".format(logging_dir, run_name)\n",
    "\n",
    "with open(config_file, 'r') as file:\n",
    "    config = yaml.safe_load(file)\n",
    "    \n",
    "config = ConfigDict(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2d83087c-1986-44ff-8953-694c3a2a31fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import optax \n",
    "from flax.training import checkpoints, common_utils, train_state\n",
    "\n",
    "import flax\n",
    "\n",
    "replicate = flax.jax_utils.replicate\n",
    "unreplicate = flax.jax_utils.unreplicate\n",
    "\n",
    "schedule = optax.warmup_cosine_decay_schedule(\n",
    "    init_value=0.0,\n",
    "    peak_value=1e-4,\n",
    "    warmup_steps=5_000,\n",
    "    decay_steps=100_000,\n",
    ")\n",
    "\n",
    "tx = optax.adamw(learning_rate=schedule, weight_decay=1e-4)\n",
    "state = train_state.TrainState.create(apply_fn=model.__call__, params=model.params, tx=tx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "238f857a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import orbax.checkpoint as ocp\n",
    "\n",
    "ckpt_dir = \"{}/{}\".format(logging_dir, run_name)  # Load SLURM run\n",
    "\n",
    "best_fn = lambda metrics: metrics[f\"val/top_10_accuracy\"]\n",
    "\n",
    "mgr_options = ocp.CheckpointManagerOptions(step_prefix=f'step', best_fn=best_fn, best_mode='min', create=False)\n",
    "\n",
    "ckpt_mgr_load_ckpt = ocp.CheckpointManager(\n",
    "    f\"{ckpt_dir}/ckpts/\",\n",
    "    options=mgr_options,\n",
    ")\n",
    "\n",
    "restored_state = ckpt_mgr_load_ckpt.restore(\n",
    "    ckpt_mgr_load_ckpt.latest_step(),\n",
    "    args=ocp.args.StandardRestore(state)\n",
    ")\n",
    "\n",
    "if state is restored_state:\n",
    "    raise FileNotFoundError(f\"Did not load checkpoint correctly\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9a06d988-f08e-4136-8264-e7e20859cd77",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cosine_similarity(vec1, vec2):\n",
    "    \n",
    "    norm_vec1 = np.linalg.norm(vec1, axis=-1,)\n",
    "    norm_vec2 = np.linalg.norm(vec2, axis=-1,)\n",
    "        \n",
    "    return np.dot(vec1, vec2) / (norm_vec1 * norm_vec2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bbb923-23ed-4f9e-ae99-4188dbb43d42",
   "metadata": {},
   "source": [
    "## Regular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "55eb3de5-f20d-4db1-91bf-1fe8e3773f27",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.text_utils import process_truncate_captions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c783dec2-b2f3-454c-8782-576da5bf6761",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "import tensorflow as tf\n",
    "from utils.dataset_utils import make_dataloader, create_input_iter\n",
    "from dm_pix import center_crop, random_crop, rotate, random_flip_up_down, random_flip_left_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a3d12481",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Loading the dataframes\n",
    "sum1_filename = \"../data/summary_sum1_v3.csv\"\n",
    "sum1_df = pd.read_csv(sum1_filename)\n",
    "\n",
    "summaries_filename = \"../data/summary_v2.csv\"\n",
    "summaries_df = pd.read_csv(summaries_filename)\n",
    "\n",
    "# Merging the dataframes\n",
    "sum_merged = pd.merge(summaries_df, sum1_df, on='proposal_id')\n",
    "\n",
    "# Function to process each caption\n",
    "def get_objects_phenomena(caption):\n",
    "    first_part = caption.split(';')[0]\n",
    "    match = sum_merged[sum_merged['objects_phenomena_x'] == first_part]['objects_phenomena_y']\n",
    "    return match.values[0] if not (match.empty or pd.isna(match.values[0])) else \"None\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d92a1d51-08ae-4fd6-9df8-06b91238cf89",
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "from einops import rearrange\n",
    "import numpy as onp\n",
    "\n",
    "@partial(jax.pmap, axis_name=\"batch\")\n",
    "def get_features(state, input_ids, pixel_values, attention_mask):\n",
    "    captions_feat = model.get_text_features(input_ids, attention_mask, params=state.params)\n",
    "    images_feat = model.get_image_features(pixel_values, params=state.params)\n",
    "    return images_feat, captions_feat\n",
    "    \n",
    "def get_features_ds(state, ds, truncate=False, use_sum1=False, randomize_objects=False, num_rnd=3):\n",
    "\n",
    "    batches = iter(ds)\n",
    "\n",
    "    image_feat_stack = []\n",
    "    images_stack = []\n",
    "    captions_stack = []\n",
    "    captions_feat_stack = []\n",
    "    \n",
    "    num_local_devices = jax.local_device_count()\n",
    "    replicate = flax.jax_utils.replicate\n",
    "    \n",
    "    total_batches = sum(1 for _ in ds) - 1\n",
    "    current_batch = 0\n",
    "\n",
    "    for (images, captions) in tqdm(batches, total=total_batches):\n",
    "        if current_batch == total_batches - 1:\n",
    "            break\n",
    "    \n",
    "        images = np.array(images)\n",
    "\n",
    "        if truncate:\n",
    "            rng_seed = onp.random.randint(99999)\n",
    "            captions = process_truncate_captions(captions, jax.random.PRNGKey(rng_seed), max_length_words=config.data.max_length_words)\n",
    "        else:\n",
    "            captions = captions.numpy().tolist()\n",
    "            captions = [c.decode('utf-8') for c in captions]\n",
    "\n",
    "        if randomize_objects:\n",
    "            captions_rnd = []\n",
    "            for caption in captions:\n",
    "                list_rnd = onp.random.choice(\", \".join(caption.split(';')).split(', '), num_rnd)\n",
    "                # Join into comma separated string\n",
    "                list_rnd = \", \".join(list_rnd)\n",
    "                captions_rnd.append(list_rnd)\n",
    "    \n",
    "            captions = captions_rnd\n",
    "        \n",
    "        if use_sum1:\n",
    "            captions_sum1 = []\n",
    "            for caption in captions:\n",
    "                sum1 = sum_merged[sum_merged['objects_phenomena_x'] == caption.split(';')[0]]['objects_phenomena_y'].values[0]\n",
    "                if sum1 is np.nan:\n",
    "                    sum1 = \"None\"\n",
    "                captions_sum1 += [sum1]\n",
    "                \n",
    "            captions_stack += captions_sum1\n",
    "        else:\n",
    "            captions_stack += captions\n",
    "\n",
    "        images_stack.append(images)\n",
    "\n",
    "        rng_eval = jax.random.PRNGKey(onp.random.randint(99999))\n",
    "        \n",
    "        # Rotation angles in rad\n",
    "        rot_angles_90 = np.array([0.0, np.pi / 2, np.pi, 3 * np.pi / 2])\n",
    "\n",
    "        # Rotations\n",
    "        rng_eval, _ = jax.random.split(rng_eval)\n",
    "        # rotation_angles = jax.random.uniform(rng_eval, shape=(images.shape[0],)) * 2 * np.pi  # Angles in radians\n",
    "        rotation_angles = jax.random.choice(\n",
    "            rng_eval, rot_angles_90, shape=(images.shape[0],)\n",
    "        )  # Angles in radians\n",
    "\n",
    "        images = jax.vmap(partial(rotate, mode='constant', cval=1.))(images, rotation_angles)\n",
    "        \n",
    "        # Flips\n",
    "        rng_eval, _ = jax.random.split(rng_eval)\n",
    "        images = jax.vmap(partial(random_flip_up_down, key=rng_eval))(image=images)\n",
    "\n",
    "        rng_eval, _ = jax.random.split(rng_eval)\n",
    "        images = jax.vmap(partial(random_flip_left_right, key=rng_eval))(image=images)\n",
    "\n",
    "        images = jax.vmap(random_crop, in_axes=(None,0,None))(rng_eval, images, (model.config.vision_config.image_size, model.config.vision_config.image_size, 3))\n",
    "\n",
    "        input = processor(text=captions_sum1 if use_sum1 else captions, images=(images * 255.).astype(np.uint8), return_tensors=\"np\", padding=\"max_length\", truncation=True, max_length=77)\n",
    "    \n",
    "        batch = jax.tree_map(lambda x: np.split(x, num_local_devices, axis=0), input.data)\n",
    "    \n",
    "        image_feat, captions_feat = get_features(replicate(state), np.array(batch[\"input_ids\"]), np.array(batch[\"pixel_values\"]), np.array(batch[\"attention_mask\"]))\n",
    "\n",
    "        image_feat = rearrange(image_feat, \"d b e -> (d b) e\")\n",
    "        captions_feat = rearrange(captions_feat, \"d b e -> (d b) e\")\n",
    "\n",
    "        captions_feat_stack.append(captions_feat)\n",
    "        image_feat_stack.append(image_feat)\n",
    "\n",
    "        current_batch += 1\n",
    "\n",
    "    return image_feat_stack, captions_feat_stack, images_stack, captions_stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e336a92d-4f40-4840-a41a-eceae6edd554",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 98/99 [02:13<00:01,  1.36s/it]\n",
      " 99%|█████████▉| 98/99 [01:41<00:01,  1.04s/it]\n"
     ]
    }
   ],
   "source": [
    "files = tf.io.gfile.glob(f\"/n/holyscratch01/iaifi_lab/smsharma/hubble_data/tfrecords_v5/*val*.tfrecord\")\n",
    "ds = make_dataloader(files, batch_size=config.training.batch_size, seed=config.seed, split=\"val\", shuffle=False, caption_type=\"summary\")\n",
    "\n",
    "image_feat_stack, captions_feat_stack, images_stack, captions_stack = get_features_ds(restored_state, ds)\n",
    "image_base_feat_stack, captions_feat_base_stack, images_base_stack, captions_base_stack = get_features_ds(state, ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bd43e886-a1c9-4d89-b3c5-1c3899bc58bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x446.4 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bins = np.linspace(-1, 1, 40)\n",
    "lw = 2\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(7, 6.2))\n",
    "\n",
    "ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_base_feat_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_base_stack)[:])), histtype='step', label=\"Base (incorrect pairs)\", bins=bins, lw=lw, color=cols_default[3], ls='--', alpha=0.4)\n",
    "ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_base_feat_stack), np.vstack(captions_feat_base_stack)), histtype='step', label=\"Base (correct pairs)\", bins=bins, lw=lw, color=cols_default[3])\n",
    "\n",
    "ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_stack)[:])), histtype='step', label=\"Fine-tuned (incorrect pairs)\", bins=bins, lw=lw, color=cols_default[0], ls='--', alpha=0.4)\n",
    "ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_stack), np.vstack(captions_feat_stack)[:]), histtype='step', label=\"Fine-tuned (correct pairs)\", bins=bins, lw=lw, color=cols_default[0])\n",
    "\n",
    "ax.set_xlabel(\"$x_i\\cdot y_i$\")\n",
    "ax.legend()\n",
    "ax.set_title(r\"\\textbf{Cosine Similarities (Summarized Abstracts)}\", y=1.01)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../paper/plots/sim_val.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5c980d4d-038e-485e-9cd7-cd82636c39ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# files = tf.io.gfile.glob(f\"/n/holyscratch01/iaifi_lab/smsharma/hubble_data/tfrecords_v5/*train_9.tfrecord\")\n",
    "# ds = make_dataloader(files, batch_size=config.training.batch_size, seed=config.seed, split=\"val\", shuffle=False, caption_type=\"summary\")\n",
    "\n",
    "# image_feat_train_stack, captions_feat_train_stack, images_train_stack, captions_train_stack = get_features_ds(restored_state, ds)\n",
    "# image_base_feat_train_stack, captions_feat_train_base_stack, images_train_base_stack, captions_train_base_stack = get_features_ds(state, ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4b924b36-f24f-43b5-868a-728d2bf4a4dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# bins = np.linspace(-1, 1, 30)\n",
    "# lw = 2\n",
    "\n",
    "# fig, ax = plt.subplots(1, 2, figsize=(14, 6))\n",
    "\n",
    "# ax[0].hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_stack), np.vstack(captions_feat_stack)[:]), histtype='step', label=\"Fine-tuned\", bins=bins, lw=lw)\n",
    "# ax[0].hist(jax.vmap(cosine_similarity)(np.vstack(image_base_feat_stack), np.vstack(captions_feat_base_stack)), histtype='step', label=\"Base\", bins=bins, lw=lw)\n",
    "# ax[0].hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_stack)[:])), histtype='step', label=\"Fine-tuned, shuffled\", bins=bins, lw=lw, color=cols_default[0], ls='--', alpha=0.4)\n",
    "# ax[0].hist(jax.vmap(cosine_similarity)(np.vstack(image_base_feat_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_base_stack)[:])), histtype='step', label=\"Base, shuffled\", bins=bins, lw=lw, color=cols_default[1], ls='--', alpha=0.4)\n",
    "\n",
    "# ax[0].set_xlabel(\"$x_i\\cdot y_i$\")\n",
    "# ax[0].legend()\n",
    "# ax[0].set_title(r\"\\textbf{Validation examples}\", y=1.01)\n",
    "\n",
    "# ax[1].hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_train_stack), np.vstack(captions_feat_train_stack)[:]), histtype='step', label=\"Fine-tuned\", bins=bins, lw=lw)\n",
    "# ax[1].hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_train_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_train_stack)[:])), histtype='step', label=\"Fine-tuned, shuffled\", bins=bins, lw=lw, color=cols_default[0], ls='--', alpha=0.4)\n",
    "# ax[1].hist(jax.vmap(cosine_similarity)(np.vstack(image_base_feat_train_stack), np.vstack(captions_feat_train_base_stack)), histtype='step', label=\"Base\", bins=bins, lw=lw)\n",
    "# ax[1].hist(jax.vmap(cosine_similarity)(np.vstack(image_base_feat_train_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_train_base_stack)[:])), histtype='step', label=\"Base, shuffled\", bins=bins, lw=lw, color=cols_default[1], ls='--', alpha=0.4)\n",
    "\n",
    "# ax[1].set_xlabel(\"$x_i\\cdot y_i$\")\n",
    "# ax[1].legend()\n",
    "# ax[1].set_title(r\"\\textbf{Training examples}\", y=1.01)\n",
    "\n",
    "# fig.suptitle(r\"\\textbf{Cosine Similarities}\", fontsize=20)\n",
    "\n",
    "# plt.tight_layout()\n",
    "# # plt.savefig(\"../paper/plots/sim_valtrain.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c85a2c0-e69f-4e64-9cf5-5da43b9e55fd",
   "metadata": {},
   "source": [
    "## Single-concept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7a0e024d-5b0a-4300-abc4-f17e26832a08",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# run_name = \"compassionate-admirer-129\"\n",
    "\n",
    "# ckpt_dir = \"{}/{}\".format(logging_dir, run_name)  # Load SLURM run\n",
    "\n",
    "# best_fn = lambda metrics: metrics[f\"val/top_10_accuracy\"]\n",
    "\n",
    "# mgr_options = ocp.CheckpointManagerOptions(step_prefix=f'step', best_fn=best_fn, best_mode='min', create=False)\n",
    "\n",
    "# ckpt_mgr_load_ckpt = ocp.CheckpointManager(\n",
    "#     f\"{ckpt_dir}/ckpts/\",\n",
    "#     options=mgr_options,\n",
    "# )\n",
    "\n",
    "# restored_state = ckpt_mgr_load_ckpt.restore(\n",
    "#     ckpt_mgr_load_ckpt.latest_step(),\n",
    "#     args=ocp.args.StandardRestore(state)\n",
    "# )\n",
    "\n",
    "# if state is restored_state:\n",
    "#     raise FileNotFoundError(f\"Did not load checkpoint correctly\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0ef16248-4b36-49ad-be66-fb1da53fae07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# files = tf.io.gfile.glob(f\"/n/holyscratch01/iaifi_lab/smsharma/hubble_data/tfrecords_v5/*val*.tfrecord\")\n",
    "# ds = make_dataloader(files, batch_size=config.training.batch_size, seed=config.seed, split=\"val\", shuffle=True, caption_type=\"summary\")\n",
    "\n",
    "# image_feat_stack, captions_feat_stack, images_stack, captions_stack = get_features_ds(restored_state, ds, use_sum1=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cfdbc845-75a4-4743-8049-e6db1af6036d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# run_name = \"glistening-kumquat-123\"\n",
    "\n",
    "# ckpt_dir = \"{}/{}\".format(logging_dir, run_name)  # Load SLURM run\n",
    "\n",
    "# best_fn = lambda metrics: metrics[f\"val/top_10_accuracy\"]\n",
    "\n",
    "# mgr_options = ocp.CheckpointManagerOptions(step_prefix=f'step', best_fn=best_fn, best_mode='min', create=False)\n",
    "\n",
    "# ckpt_mgr_load_ckpt = ocp.CheckpointManager(\n",
    "#     f\"{ckpt_dir}/ckpts/\",\n",
    "#     options=mgr_options,\n",
    "# )\n",
    "\n",
    "# restored_state = ckpt_mgr_load_ckpt.restore(\n",
    "#     ckpt_mgr_load_ckpt.latest_step(),\n",
    "#     args=ocp.args.StandardRestore(state)\n",
    "# )\n",
    "\n",
    "# if state is restored_state:\n",
    "#     raise FileNotFoundError(f\"Did not load checkpoint correctly\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4a162b59-65a9-4363-8421-bd87c69e40ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# image_feat_sum1_stack, captions_feat_sum1_stack, images_sum1_stack, captions_sum1_stack = get_features_ds(restored_state, ds, use_sum1=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6d40142f-99d3-4e12-baf1-456e47c6312b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# bins = np.linspace(-1, 1, 30)\n",
    "# lw = 2\n",
    "\n",
    "# fig, ax = plt.subplots(1, 1, figsize=(7, 6))\n",
    "\n",
    "# ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_sum1_stack), np.vstack(captions_feat_sum1_stack)[:]), histtype='step', label=\"Fine-tuned on single-concept\", bins=bins, lw=lw, color=cols_default[0])\n",
    "# ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_sum1_stack), jax.random.permutation(jax.random.PRNGKey(42), np.vstack(captions_feat_sum1_stack)[:])), histtype='step', bins=bins, lw=lw, ls='--', alpha=0.4, label=r\"---''---, shuffled\", color=cols_default[0])\n",
    "\n",
    "# ax.hist(jax.vmap(cosine_similarity)(np.vstack(image_feat_stack), np.vstack(captions_feat_stack)[:]), histtype='step', label=\"Fine-tuned on summarized abstract\", bins=bins, lw=lw, color=cols_default[3])\n",
    "\n",
    "# ax.legend(frameon=True, framealpha=0.9)\n",
    "# ax.set_title(r\"\\textbf{Cosine Similarities (Single-Concept)}\", y=1.01)\n",
    "# ax.set_xlabel(\"$x_i\\cdot y_i$\")\n",
    "\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(\"../paper/plots/sim_summ1.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a331940-9759-4b2c-94b6-d2372ce36587",
   "metadata": {},
   "source": [
    "## Multiple runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ef189285-df3e-4360-98b1-80a8868bd283",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_roc(image_feat, captions_feat):\n",
    "    \n",
    "    roc_mat = np.matmul(image_feat, captions_feat.T)\n",
    "    \n",
    "    correct_indices = np.arange(roc_mat.shape[0])[:, None]\n",
    "    top_indices = np.argsort(roc_mat, axis=-1)\n",
    "    \n",
    "    accuracy_list = []\n",
    "    for k in np.arange(1, roc_mat.shape[0], 100):\n",
    "        correct_in_top_k = np.any(top_indices[:, -k:] == correct_indices, axis=-1)\n",
    "        accuracy = np.mean(correct_in_top_k.astype(np.float32))\n",
    "        accuracy_list.append(accuracy)\n",
    "\n",
    "    return accuracy_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "976345c4-c4a8-4d0e-9679-731b65312b29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrieval_eval_metric(text_embeds, image_embeds, k=[1, 5, 10, 20]):\n",
    "    \"\"\" Compute the top-k retrieval accuracy.\n",
    "    \"\"\"\n",
    "\n",
    "    # Get shapes\n",
    "    bs = text_embeds.shape[0]\n",
    "    axis_size = jax.lax.psum(1, axis_name=\"batch\")\n",
    "\n",
    "    # Gather the embeddings from all devices\n",
    "    all_text_embeds = jax.lax.all_gather(text_embeds, axis_name=\"batch\").reshape(-1, text_embeds.shape[-1])\n",
    "    all_image_embeds = jax.lax.all_gather(image_embeds, axis_name=\"batch\").reshape(-1, image_embeds.shape[-1])\n",
    "\n",
    "    # Compute the full matrix of logitseval\n",
    "    all_logits = np.matmul(all_text_embeds, all_image_embeds.T)\n",
    "\n",
    "    # Compute the global top-k indices for the maximum k value\n",
    "    max_k = max(k)\n",
    "    top_k_indices = np.argsort(all_logits, axis=-1)[:, -max_k:]\n",
    "\n",
    "    # Compute the correct indices for each row\n",
    "    correct_indices = np.arange(bs * axis_size)[:, None]\n",
    "\n",
    "    metrics = {}\n",
    "    for current_k in k:\n",
    "        # Check if the correct image (diagonal) is in the current top-k for each text embedding\n",
    "        correct_in_top_k = np.any(top_k_indices[:, -current_k:] == correct_indices, axis=-1)\n",
    "        accuracy = np.mean(correct_in_top_k.astype(np.float32))\n",
    "        metrics[f\"top_{current_k}_accuracy\"] = accuracy\n",
    "\n",
    "    return metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "394863d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "run_labels = ['glistening-kumquat-123',\n",
    "              'enchanting-lantern-125',\n",
    "              # 'passionate-sweetheart-127',\n",
    "              'fragrant-date-128',\n",
    "              \"base\"\n",
    "            #   'compassionate-admirer-129',\n",
    "              ]\n",
    "\n",
    "run_legends = ['Fine-tune (summaries)', \n",
    "               'Fine-tune (abstract)',\n",
    "              #  \"Fine-tune head (summaries)\",\n",
    "               'Train from scratch (summaries)',\n",
    "               \"Base\"\n",
    "            #    'Fine-tune (single concepts)',\n",
    "               ]\n",
    "\n",
    "# data_type = [\"abstract\", \"summary\"] # , \"summary\",]\n",
    "# use_sum1 = [False, False]  #, True,]\n",
    "\n",
    "data_type = [\"summary\", \"summary\", \"summary\",\"summary\",]\n",
    "# data_type = [\"abstract\", \"abstract\", \"abstract\",\"abstract\",]\n",
    "use_sum1 = [False, False, False, False,]\n",
    "\n",
    "cols_list = [cols_default[0], cols_default[1], cols_default[5], cols_default[3]]\n",
    "ls_list = ['-', '-', '-', '-', '-']\n",
    "transf_list = [False, False, False, False,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2d21cb68",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.clip_transfer import FlaxCLIPModelTransfer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "404f1ac0-3e64-4d6b-8c24-8a3ad8510453",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 30/31 [01:41<00:03,  3.37s/it]\n",
      " 97%|█████████▋| 30/31 [01:16<00:02,  2.56s/it]\n",
      " 97%|█████████▋| 30/31 [01:14<00:02,  2.48s/it]\n",
      " 97%|█████████▋| 30/31 [01:14<00:02,  2.47s/it]\n",
      "100%|██████████| 4/4 [06:06<00:00, 91.66s/it]\n"
     ]
    }
   ],
   "source": [
    "accuracy_lists = []\n",
    "for idx, run_name in enumerate(tqdm(run_labels[:])):\n",
    "\n",
    "    files = tf.io.gfile.glob(f\"/n/holyscratch01/iaifi_lab/smsharma/hubble_data/tfrecords_v5/*val*.tfrecord\")\n",
    "    ds = make_dataloader(files, batch_size=100, seed=324, split=\"val\", shuffle=True, caption_type=data_type[idx])\n",
    "    \n",
    "    if run_name == \"base\":\n",
    "        restored_state = state  \n",
    "    else:\n",
    "        ckpt_dir = \"{}/{}\".format(logging_dir, run_name)  # Load SLURM run\n",
    "        \n",
    "        best_fn = lambda metrics: metrics[f\"val/loss\"]\n",
    "        \n",
    "        mgr_options = ocp.CheckpointManagerOptions(step_prefix=f'step', best_fn=best_fn, best_mode='min', create=False)\n",
    "\n",
    "        ckpt_mgr_load_ckpt = ocp.CheckpointManager(\n",
    "            f\"{ckpt_dir}/ckpts/\",\n",
    "            options=mgr_options,\n",
    "        )\n",
    "\n",
    "        if transf_list[idx]:\n",
    "            model_transfer = FlaxCLIPModelTransfer(\n",
    "                config=model.config, d_head=config.clip.d_transfer_head\n",
    "            )\n",
    "\n",
    "            # Transfer text and vision backbones\n",
    "            model_transfer.params[\"text_model\"][\"text_backbone\"] = model.params[\n",
    "                \"text_model\"\n",
    "            ]\n",
    "            model_transfer.params[\"vision_model\"][\"vision_backbone\"] = model.params[\n",
    "                \"vision_model\"\n",
    "            ]\n",
    "\n",
    "            state_transfer = train_state.TrainState.create(\n",
    "                apply_fn=model_transfer.__call__,\n",
    "                params=model_transfer.params,\n",
    "                tx=tx,\n",
    "            )\n",
    "\n",
    "            restored_state = ckpt_mgr_load_ckpt.restore(\n",
    "                ckpt_mgr_load_ckpt.latest_step(),\n",
    "                args=ocp.args.StandardRestore(state_transfer)\n",
    "            )\n",
    "        \n",
    "        else:\n",
    "\n",
    "            restored_state = ckpt_mgr_load_ckpt.restore(\n",
    "                ckpt_mgr_load_ckpt.latest_step(),\n",
    "                args=ocp.args.StandardRestore(state)\n",
    "            )\n",
    "        \n",
    "        if state is restored_state:\n",
    "            raise FileNotFoundError(f\"Did not load checkpoint correctly\")\n",
    "\n",
    "    image_feat_stack, captions_feat_stack, _, _ = get_features_ds(restored_state, ds, truncate=data_type[idx] == \"abstract\", use_sum1=use_sum1[idx], randomize_objects=False, num_rnd=3)\n",
    "    \n",
    "    accuracy_list = get_roc(np.vstack(image_feat_stack), np.vstack(captions_feat_stack))\n",
    "    accuracy_lists.append(accuracy_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "16259b63",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig, ax = plt.subplots(1, 1, figsize=(7, 6.2))\n",
    "\n",
    "# for idx, accuracy_list in enumerate(accuracy_lists):\n",
    "#     ax.plot(np.linspace(0., 1., len(accuracy_list)), accuracy_list, label=run_legends[idx], color=cols_list[idx], ls=ls_list[idx])\n",
    "\n",
    "# ax.plot([0, 1], [0, 1], ls='--', alpha=0.5, color='grey')\n",
    "    \n",
    "# ax.legend()\n",
    "\n",
    "# ax.set_xlim(0, 1)\n",
    "# ax.set_ylim(0, 1)\n",
    "\n",
    "# ax.set_xlabel(\"Retrieval fraction\")\n",
    "# ax.set_ylabel(\"Retrieval accuracy\")\n",
    "\n",
    "# ax.legend(frameon=False, framealpha=0.9)\n",
    "# ax.set_title(r\"\\textbf{Retrieval Accuracy on Snippets of Summarized Abstracts}\", y=1.01)\n",
    "\n",
    "# plt.tight_layout()\n",
    "\n",
    "# plt.savefig(\"../paper/plots/retrieval_summ_snip.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ce36de59-cc1f-42fc-b663-6ac59802448f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x446.4 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(7, 6.2))\n",
    "\n",
    "for idx, accuracy_list in enumerate(accuracy_lists):\n",
    "    ax.plot(np.linspace(0., 1., len(accuracy_list)), accuracy_list, label=run_legends[idx], color=cols_list[idx], ls=ls_list[idx])\n",
    "\n",
    "ax.plot([0, 1], [0, 1], ls='--', alpha=0.5, color='grey')\n",
    "    \n",
    "ax.legend()\n",
    "\n",
    "ax.set_xlim(0, 1)\n",
    "ax.set_ylim(0, 1)\n",
    "\n",
    "ax.set_xlabel(\"Retrieval fraction\")\n",
    "ax.set_ylabel(\"Retrieval accuracy\")\n",
    "\n",
    "ax.legend(frameon=False, framealpha=0.9)\n",
    "ax.set_title(r\"\\textbf{Retrieval Accuracy on Summarized Abstracts}\", y=1.01)\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(\"../paper/plots/retrieval.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bc03099-062c-4f78-9628-e2eae94f03b3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}