DomainBed/collect_clip_results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "791508b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import json\n",
    "import os\n",
    "import glob\n",
    "import sys\n",
    "from pprint import pprint\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from domainbed.lib import misc, reporting\n",
    "from domainbed import datasets\n",
    "from domainbed import algorithms\n",
    "from domainbed.lib.query import Q\n",
    "from domainbed.model_selection import OracleSelectionMethod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad41f226",
   "metadata": {},
   "source": [
    "# Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "88a64e37",
   "metadata": {},
   "outputs": [],
   "source": [
    "base_output_dir=\"./checkpoints\"\n",
    "dataset_all = ['PACS', 'VLCS', 'OfficeHome', 'TerraIncognita', 'DomainNet']\n",
    "algorithm_all = {'CLIPPretrained': 'CLIPPretrained',\n",
    "                 'CLIPBase': 'SupCLIPBottleneckBase',\n",
    "                 'CLIPCondCAD': 'SupCLIPBottleneckCondCAD'}\n",
    "\n",
    "select_method = OracleSelectionMethod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f77dfeec",
   "metadata": {},
   "source": [
    "# Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d5339eed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pretty(d, indent=0):\n",
    "    for key, value in d.items():\n",
    "        print('\\t' * indent + str(key))\n",
    "        if isinstance(value, dict):\n",
    "             pretty(value, indent+1)\n",
    "        else:\n",
    "             print('\\t' * (indent+1) + str(value))\n",
    "\n",
    "def get_record(output_dir):\n",
    "    print(\"Loading records from:\", output_dir)\n",
    "    records = reporting.load_records(output_dir)\n",
    "    print(\"Total records:\", len(records))\n",
    "\n",
    "    return records\n",
    "\n",
    "def get_results(out_dir, selection_method):\n",
    "    \"\"\"Given all records, print a results table for each dataset.\"\"\"\n",
    "    records = get_record(out_dir)\n",
    "    \n",
    "    grouped_records = reporting.get_grouped_records(records,\n",
    "                                                    group_test_envs=True).map(\n",
    "        lambda group:\n",
    "        {**group, \"sweep_acc\": selection_method.sweep_acc(group[\"records\"], return_extra=True)}\n",
    "        ).filter(lambda g: g[\"sweep_acc\"] is not None)\n",
    "\n",
    "    # read algorithm names and sort (predefined order)\n",
    "    alg_names = Q(records).select(\"args.algorithm\").unique()\n",
    "    assert len(alg_names) == 1\n",
    "    algorithm = alg_names[0]\n",
    "\n",
    "    # read dataset names and sort (lexicographic order)\n",
    "    dataset_names = Q(records).select(\"args.dataset\").unique().sorted()\n",
    "    assert len(dataset_names) == 1\n",
    "    dataset = dataset_names[0]\n",
    "\n",
    "    trial_averages = (grouped_records\n",
    "                      .filter_equals(\"algorithm, dataset\", (algorithm, dataset))\n",
    "                      .group(\"trial_seed\")\n",
    "                      .map(lambda trial_seed, group:\n",
    "#                            group.select(\"sweep_acc\").mean()\n",
    "                           tuple(map(lambda y: sum(y) / float(len(y)), zip(*group.select(\"sweep_acc\"))))\n",
    "                           )\n",
    "                      )\n",
    "    \n",
    "    tgt_all, src_all, tgt_in_all = zip(*trial_averages) \n",
    "    tgt_mean, src_mean, tgt_in_mean = 100 * np.mean(list(tgt_all)), 100 * np.mean(list(src_all)), 100 * np.mean(list(tgt_in_all))\n",
    "    tgt_std, src_std, tgt_in_std = 100 * np.std(list(tgt_all)), 100 * np.std(list(src_all)), 100 * np.std(list(tgt_in_all))\n",
    "    \n",
    "    return (tgt_mean, src_mean, tgt_in_mean), (tgt_std, src_std, tgt_in_std)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0de790a1",
   "metadata": {},
   "source": [
    "# Collect Results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suitable-sullivan",
   "metadata": {},
   "source": [
    "Collect the result dict for each setup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "british-overall",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_result(setup):\n",
    "    result_dict = {}\n",
    "    for dataset in dataset_all:\n",
    "        result_dict[dataset] = {}\n",
    "        sub_result_dict = result_dict[dataset]\n",
    "        basedir = f'{base_output_dir}/{dataset}/{setup}'\n",
    "\n",
    "        for alg_name, alg_name_long in algorithm_all.items():\n",
    "            if alg_name in ['CLIPPretrained', 'CLIPBase']:\n",
    "                sub_result_dict[alg_name] = {}\n",
    "                subsub_result_dict = sub_result_dict[alg_name]\n",
    "\n",
    "                output_dir = os.path.join(basedir, f'{alg_name_long}/base')\n",
    "                (acc_tgt, acc_src, acc_tgt_in), (acc_tgt_std, acc_src_std, acc_tgt_in_std) = get_results(output_dir, select_method)\n",
    "                subsub_result_dict['acc_tgt'] = acc_tgt\n",
    "                subsub_result_dict['acc_src'] = acc_src\n",
    "                subsub_result_dict['acc_tgt_in'] = acc_tgt_in\n",
    "                subsub_result_dict['acc_diff'] = acc_src - acc_tgt\n",
    "                subsub_result_dict['acc_tgt_std'] = acc_tgt_std\n",
    "                subsub_result_dict['acc_src_std'] = acc_src_std\n",
    "                subsub_result_dict['acc_tgt_in_std'] = acc_tgt_in_std\n",
    "            else:\n",
    "                lambda_str_array = list(map(lambda s: s.split('_')[-1], glob.glob(os.path.join(basedir, f'{alg_name_long}/*'))))\n",
    "                lambda_str_array = sorted(lambda_str_array, key=lambda r: float(r))\n",
    "                lambda_val_array = np.array(list(map(lambda s: float(s), lambda_str_array)))\n",
    "\n",
    "                for lambda_str in lambda_str_array:\n",
    "                    sub_result_dict[alg_name + '_lambda_{}'.format(lambda_str)] = {}\n",
    "                    subsub_result_dict = sub_result_dict[alg_name + '_lambda_{}'.format(lambda_str)]\n",
    "                    output_dir = os.path.join(basedir, f'{alg_name_long}/lambda_{lambda_str}')\n",
    "\n",
    "                    (acc_tgt, acc_src, acc_tgt_in), (acc_tgt_std, acc_src_std, acc_tgt_in_std) = get_results(output_dir, select_method)\n",
    "\n",
    "\n",
    "                    subsub_result_dict['acc_tgt'] = acc_tgt\n",
    "                    subsub_result_dict['acc_src'] = acc_src\n",
    "                    subsub_result_dict['acc_tgt_in'] = acc_tgt_in\n",
    "                    subsub_result_dict['acc_diff'] = acc_src - acc_tgt\n",
    "                    subsub_result_dict['acc_tgt_std'] = acc_tgt_std\n",
    "                    subsub_result_dict['acc_src_std'] = acc_src_std\n",
    "                    subsub_result_dict['acc_tgt_in_std'] = acc_tgt_in_std\n",
    "                    \n",
    "    return result_dict\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "molecular-manual",
   "metadata": {},
   "source": [
    "Result with CLIP-RN50 (CLIP S in our paper):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "eee3a480",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading records from: ./checkpoints/PACS/clip_resnet/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/PACS/clip_resnet/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/PACS/clip_resnet/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/VLCS/clip_resnet/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/VLCS/clip_resnet/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/VLCS/clip_resnet/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/OfficeHome/clip_resnet/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/OfficeHome/clip_resnet/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 200\n",
      "Loading records from: ./checkpoints/OfficeHome/clip_resnet/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 200\n",
      "Loading records from: ./checkpoints/TerraIncognita/clip_resnet/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/TerraIncognita/clip_resnet/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2181\n",
      "Loading records from: ./checkpoints/TerraIncognita/clip_resnet/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2122\n",
      "Loading records from: ./checkpoints/DomainNet/clip_resnet/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 30\n",
      "Loading records from: ./checkpoints/DomainNet/clip_resnet/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 300\n",
      "Loading records from: ./checkpoints/DomainNet/clip_resnet/SupCLIPBottleneckCondCAD/lambda_1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 300\n"
     ]
    }
   ],
   "source": [
    "resnet_result_dict = get_result('clip_resnet')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attractive-insertion",
   "metadata": {},
   "source": [
    "Result with CLIP-ViT-B/32 (CLIP L in our paper):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b736ed34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading records from: ./checkpoints/PACS/clip_vit/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/PACS/clip_vit/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/PACS/clip_vit/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/VLCS/clip_vit/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/VLCS/clip_vit/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/VLCS/clip_vit/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2000\n",
      "Loading records from: ./checkpoints/OfficeHome/clip_vit/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/OfficeHome/clip_vit/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 200\n",
      "Loading records from: ./checkpoints/OfficeHome/clip_vit/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 200\n",
      "Loading records from: ./checkpoints/TerraIncognita/clip_vit/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/TerraIncognita/clip_vit/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2015\n",
      "Loading records from: ./checkpoints/TerraIncognita/clip_vit/SupCLIPBottleneckCondCAD/lambda_1e-2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 2008\n",
      "Loading records from: ./checkpoints/DomainNet/clip_vit/CLIPPretrained/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 30\n",
      "Loading records from: ./checkpoints/DomainNet/clip_vit/SupCLIPBottleneckBase/base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 300\n",
      "Loading records from: ./checkpoints/DomainNet/clip_vit/SupCLIPBottleneckCondCAD/lambda_1e-1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 300\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "vit_result_dict = get_result('clip_vit')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f78ece",
   "metadata": {},
   "source": [
    "# Plot Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "098eca7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_result(result_dict, plot_dataset, plot_y='acc_tgt', include=None, exclude=None, plot_std=False):\n",
    "    plt.figure()\n",
    "    sub_result_dict = result_dict[plot_dataset]\n",
    "    plt_xs = []\n",
    "    plt_ys = []\n",
    "    plt_errs = []\n",
    "    \n",
    "    for k, v in sub_result_dict.items():\n",
    "        subsub_result_dict = sub_result_dict[k]\n",
    "        \n",
    "        if include is not None and k not in include:\n",
    "            continue\n",
    "            \n",
    "        if exclude is not None and k in exclude:\n",
    "            continue\n",
    "            \n",
    "        plt_xs.append(k.replace('_', '\\n'))\n",
    "        plt_ys.append(subsub_result_dict[plot_y])\n",
    "        plt_errs.append(subsub_result_dict[plot_y + '_std'])\n",
    "    \n",
    "    \n",
    "    if not plot_std:\n",
    "        plt.bar(plt_xs, plt_ys)\n",
    "    else:\n",
    "        plt.bar(plt_xs, plt_ys, yerr=plt_errs)\n",
    "        \n",
    "    for plt_x, plt_y, plt_err in zip(plt_xs, plt_ys, plt_errs):\n",
    "        plt.text(plt_x, plt_y + .25, '{:.1f} +/- {:.1f}'.format(plt_y, plt_err) , color='blue', fontweight='bold')\n",
    "            \n",
    "    \n",
    "    plt.xlabel('Method')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.ylim([np.min(plt_ys)-0.5, np.max(plt_ys)+0.5])\n",
    "        \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unlikely-render",
   "metadata": {},
   "source": [
    "Visualize the results. Note that the results may be slightly different from the paper due to code cleaning. \n",
    "\n",
    "Finetuning without bottlenecks (CLIPBase) could be worse than CLIPPretrained due to overfitting to source domains, while finetuning with bottlenecks (CLIPCondCAD) leads to consistent improvement."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "367072c3",
   "metadata": {},
   "source": [
    "# DomainNet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "developed-terrorist",
   "metadata": {},
   "source": [
    "CAD leads to significant improvments on DomainNet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "37ddb89b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(resnet_result_dict, plot_dataset='DomainNet', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0ac4d0b3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(vit_result_dict, plot_dataset='DomainNet', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d8e7440",
   "metadata": {},
   "source": [
    "## VLCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7045a46b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(resnet_result_dict, plot_dataset='VLCS', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2ab13a3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(vit_result_dict, plot_dataset='VLCS', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3624a38",
   "metadata": {},
   "source": [
    "## PACS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "346fa449",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(resnet_result_dict, plot_dataset='PACS', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "92080d30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(vit_result_dict, plot_dataset='PACS', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "563a051b",
   "metadata": {},
   "source": [
    "## OfficeHome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bcb1e4e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(resnet_result_dict, plot_dataset='OfficeHome', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "04c8f35e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(vit_result_dict, plot_dataset='OfficeHome', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cace334",
   "metadata": {},
   "source": [
    "## TerraIncognita"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "centered-ballet",
   "metadata": {},
   "source": [
    "The poor performance on TerraIncognita is likely because CLIP's dataset does not cover such images (camera traps monitoring animals)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "77bc9684",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(resnet_result_dict, plot_dataset='TerraIncognita', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8e48e8f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(vit_result_dict, plot_dataset='TerraIncognita', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "neither-grade",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "optdom",
   "language": "python",
   "name": "optdom"
  },
  "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}