LAION/collect_results_domainbed.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 matplotlib import pyplot as plt\n",
    "from pprint import pprint\n",
    "import pandas as pd\n",
    "from IPython.display import display\n",
    "\n",
    "sys.path.append('../DomainBed')\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",
    "setup = \"clip_laion\"\n",
    "\n",
    "dataset_all = ['PACS', 'VLCS', 'OfficeHome', 'TerraIncognita', 'DomainNet']\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": "code",
   "execution_count": 4,
   "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').replace(\"SupConOutCLIPBottleneckBase\", \"SupConOut\"))\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)-1.0, np.max(plt_ys)+0.5])\n",
    "    plt.title(plot_dataset)\n",
    "        \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0de790a1",
   "metadata": {},
   "source": [
    "# Get Results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "automatic-volleyball",
   "metadata": {},
   "source": [
    "Collect all results for each model setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e1f16849",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Pretrained_0_3e-3': 'CLIPPretrained_0_3e-3',\n",
       " 'Tuned_Base_0_3e-3': 'ContrastCLIPBottleneckBase_0_3e-3',\n",
       " 'Tuned_Ent_1_1e-3': 'ContrastCLIPBottleneckEnt_1_1e-3'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "base_algorithm_dict = {\n",
    "    'Pretrained': 'CLIPPretrained',\n",
    "    'Tuned_Base': 'ContrastCLIPBottleneckBase',\n",
    "    'Tuned_Ent': 'ContrastCLIPBottleneckEnt'\n",
    "}\n",
    "\n",
    "algorithm_all = {}\n",
    "for base_algorithm_short, base_algorithm in base_algorithm_dict.items():\n",
    "    base_path = f'{base_output_dir}/{setup}_{base_algorithm}_*'\n",
    "    \n",
    "    for path in glob.glob(base_path):\n",
    "        alg_name_short = base_algorithm_short + path.split(base_algorithm)[-1]\n",
    "        alg_name = base_algorithm + path.split(base_algorithm)[-1]\n",
    "        algorithm_all.update({alg_name_short: alg_name})\n",
    "\n",
    "algorithm_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eee3a480",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading records from: ./checkpoints/clip_laion_CLIPPretrained_0_3e-3/eval/PACS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckBase_0_3e-3/eval/PACS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckEnt_1_1e-3/eval/PACS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_CLIPPretrained_0_3e-3/eval/VLCS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckBase_0_3e-3/eval/VLCS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckEnt_1_1e-3/eval/VLCS\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_CLIPPretrained_0_3e-3/eval/OfficeHome\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckBase_0_3e-3/eval/OfficeHome\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckEnt_1_1e-3/eval/OfficeHome\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_CLIPPretrained_0_3e-3/eval/TerraIncognita\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckBase_0_3e-3/eval/TerraIncognita\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckEnt_1_1e-3/eval/TerraIncognita\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 20\n",
      "Loading records from: ./checkpoints/clip_laion_CLIPPretrained_0_3e-3/eval/DomainNet\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 30\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckBase_0_3e-3/eval/DomainNet\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 30\n",
      "Loading records from: ./checkpoints/clip_laion_ContrastCLIPBottleneckEnt_1_1e-3/eval/DomainNet\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 30\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "result_dict = {}\n",
    "\n",
    "for dataset in dataset_all:\n",
    "    result_dict[dataset] = {}\n",
    "    sub_result_dict = result_dict[dataset]\n",
    "    \n",
    "    for alg_name, alg_name_long in algorithm_all.items():\n",
    "        sub_result_dict[alg_name] = {}\n",
    "        subsub_result_dict = sub_result_dict[alg_name]\n",
    "        \n",
    "\n",
    "        output_dir = f'{base_output_dir}/{setup}_{alg_name_long}/eval/{dataset}'\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",
    "        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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f78ece",
   "metadata": {},
   "source": [
    "# Plot & Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adverse-despite",
   "metadata": {},
   "source": [
    "Finetuning CLIP with entropy bottleneck leads to better domain generalization performance than finetuning without on all datasets. Note that both fientuned models are worse than pretrained CLIP, probably due to the quality of the LAION-400M dataset.\n",
    "\n",
    "The results could be slightly different from those in the paper, due to code cleaning and randomness."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3624a38",
   "metadata": {},
   "source": [
    "## PACS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "revolutionary-biology",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAE5CAYAAABoCayPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAkqUlEQVR4nO3deZxU1Z338c9XUPZHHW2isohbXILK0uJEh7iMghIMxjhGoy/UGUSMG2JizJiJMS5RSdTHqANEkSTu0TGPGwqaKDgasVVkiSQmShSMERAwiCLL7/nj3A5lW91dl+6iq+H7fr3uq+rup/pCf/ucc+tcRQRmZmZ5bNHSBTAzs9bH4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm8PDzMxyc3iY5SBpvqSPJK2Q9DdJkyR1ztadJikkfb3Ifp+X9CtJiyUtlzRL0hhJbbL1/yFpnqS/Z8d9TFKXjf35zErl8DDL75iI6Az0A6qB72XLTwXeB4YXbixpN+AF4G1g34jYGvi3bN8ukg4BrgJOioguwN7AvRvjg5htqLYtXQCz1ioiFkqaDPSWtDNwCCkU7pW0Q0S8m216GfBcRIwp2PcPwDcAJB0APB8Rr2Tr3gd+vhE/illurnmYbSBJPYAhwCuk2kZNRDwAvAacXLDpEcD9DRzqBWCwpMskHSypXbnKbNZcHB5m+f1a0jLgWeAZUpPTcOCubP1dfLrpajvgr/UdLCKmA8eRmsEeBZZIuq62P8SsEjk8zPI7NiK2iYidI+KbpF/6uwD3ZOvvAvaV1CebXwLs2NABI2JyRBwD/BMwDDgNGFGGsps1C4eHWdOdCgiYKeldUjNU7XKAJ4GvlXKgiFgXEU8BvwF6N3dBzZqLw8OsCSS1B04ARgJ9CqZzgW9IagtcChwkaaykHbL9dpd0h6RtJA2TdKKkbZUMIHW+/27jfyKz0jg8zJrmWOAj4BcR8W7tBEwk3c14VET8Gfgi0AuYK2k58ABQA/wdWAqcAbwOfADcAYyNiDs38mcxK5n8MCgzM8vLNQ8zM8vN4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3DapgRG333776NWrV0sXw8ys1XjppZcWR0RV3v02qfDo1asXNTU1LV0MM7NWQ9JfNmQ/N1uZmVluDg8zM8vN4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm8PDzMxyc3iYmVluDg8zM8vN4WFmVo+JE2G33aBDBxg8GBYu/PT6RYtg++1Bgh//uPgxFi2CPn2gUyfo0gUOOQTmzNnwMr33HnTsCCtXNr7t+PHQvXsq/7BhsGRJ/dtKfFVirsQqibclTmjo2A4PM7MiampgxAjo1g2uuQaefhpGjfr0NuefDx991Pixjj4abrkFzjoLpk2DMWMa3n7+/BRIxTzxBAwcmAKkIa+8ksq7995w2WXw6KNwwQXFt5XoA9wPrAXOBcYBbRo6vsPDzKyIadMgAs48E847D/r1S7+Aa/96f+wxePhh+M53Gj5OVRVccQUMGQKHH56WbdGE37yTJ6cwasykSen1qqvgoovgoIPg7rvh44+Lbj6GlAfHAb+M4MoI7m7o+A4PM7MiqrJByp99FubNg9dfT2Eyfz6sWJFqET/6EfTs2fixZs+Grl3TL/1u3eCGG4pvt3w5LF4MS5em+cWL01TbRLVuHUyZko6zatX69cuXf/ZYb76ZXrt1S6/du8OaNfD220VPvQ+wGpgMrJSYI7FvQ5/J4WFmVsQJJ8DBB8O4canp55NP0vL27VMzVseOMGhQ6oOAVCOp/aVf1+67p+amyy+Hd96Ba68tvt2wYSm0+vVL81VVaardfsYM2Hpr2HPPVIuoXT9sWOOfJ6LB1e2ALYHHgDOAvYH/bmiHTep5HmZmzaVdu9R0NXs2tG0Lo0enWsiuu6a/3ufNS7/Ea119deoU/973UtPQFlvAVluldZ07p6AZNAh+9jO4777UGV/XT36SAuhvf4NTToGpU9PyXXdNr4VNVoMHr1+/7bafPdYuu6TXBQtgp51SZ3/bttCjB6xdC6tXw5Zb/mPzN4HewC0R/EHicmC3hn4+Dg8zsyLWrk0d2337wosvwpNPpvkOHeCcc2Do0LTd00/DzTfD8OFw/PFpWYcO8IUvpLuqbr8dZs5Md1zNmgVvvQUHHFD8nP37p9f589PrEUd8ev3kyXDppen9jjumqT7Dh8ONN8Ill8CRR8Jzz8FJJ6Wa06RJcPrpMHbsPzb/OXAM8J8SrwE7APc19PNxeJiZFSHBM8+k2107dUqBcdVVaV11dZog9X8A7Lsv7LXXZ49TVZU618eNSzWQoUPhuuvyl2fRIpg7d32ne2P690+hduWVMH16qrFcf33xbSN4QOKHwNnAMNKdV+c0dHxFIw1hrUl1dXX4MbRmtim64440Pf548x5X0ksRUZ13P3eYm5m1Aqec0vzB0RRlDQ9J50uaI2mupNF11l0oKSRtX8++ayXNzKaHyllOMzPLp2x9HpJ6k275GgB8Ajwu6ZGI+JOkHsAg4K0GDvFRRPQpV/nMzGzDlbPmsTfwQkSsjIg1wDOkby8CXA9cBGw6HS5mZpuRcobHHGCgpO0kdQSGAD0kDQMWRsSrjezfXlKNpN9JOraM5TQzs5zK1mwVEa9JugaYAnwIzCR9i/E/SU1Wjdk5IhZK2hX4jaTZEfHnuhtJGgmMBOhZyjgBZmbWZGXtMI+I2yKif0R8CVgKzAV2AV6VNB/oDrwsaYci+y7MXt8Angb61nOOCRFRHRHVVbWD0ZiZWVmV+26rrtlrT1J/x88jomtE9IqIXsACoF9EvFtnv20ltcvebw8cDPy+nGU1M7PSlfsb5g9I2o40WuPZEbGsvg0lVQOjImIEqbN9vKR1pIC7OiIcHmZmFaKs4RERAxtZ36vgfQ0wInv/HDQ8HLCZmbUcf8PczMxyc3iYmVluDg8zM8vN4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm59hbmYbRa+LH23pImyy5l/95Y1+Ttc8zMwsN4eHmZnl5vAwM7PcHB5mZpabw8PMzHJzeJiZWW4ODzMzy83hYWZmuTk8zMwsN4eHmZnl5vAwM7PcHB5mZpabw8PMzHJzeJiZWW4ODzMzy83hYWZmuTk8zMwsN4eHmZnl5vAwM7PcHB6t1MSJsNtu0KEDDB4MCxem5YsWQZ8+0KkTdOkChxwCc+YUP8ahh4L06enQQze8TPffDwMHNr7dmjVw9tmw9daw7bbw7W/DunXFt506NX2eDh2ga1c480z45JMNL6OZNQ+HRytUUwMjRkC3bnDNNfD00zBq1Pr1Rx8Nt9wCZ50F06bBmDHFj/P978Pdd6fpm99My/r1a/jckybVHzCTJ8OQIY2X/6c/TeUbPhyOPx5+/ON03GJOOw3mzoUf/Qj22gsmTIB77238HGZWXg6PVmjaNIhIf4Wfd176hf/oo7BkCVRVwRVXpF/ihx+ett+inqt8+OFw4olp+stf0rIzz9zwcj3+eAquxkyalGpFN9yQgmSrreD224tvu24ddOwIRxwBe++dlm2zzYaX0cyaR1nDQ9L5kuZImitpdJ11F0oKSdvXs++pkl7PplPLWc7WpqoqvT77LMybB6+/nsJk/vy0fPbs1MRz9NGpdnLDDQ0f7623Uq3h8MNhzz2Lb7N4cZpWrIDVq9fPr16d1r/6aipDnz5pm9r1K1d+9lhvvgk77ABt2kD79rDddvDGG8XP+8tfpuPuu2+qdYwYAccc08gPyMzKrmzhIak3cAYwANgfGCpp92xdD2AQ8FY9+/4TcClwYLb/pZK2LVdZW5sTToCDD4Zx49Jf47V9AO3bp9fdd4cnnoDLL4d33oFrr234eLfemv7CL2z6qquqKk3nngvPPbd+/n//N62fPHl9reOcc9avb+zckMKhPmPHpprT3XfDKaeksv76140f08zKq5w1j72BFyJiZUSsAZ4BjsvWXQ9cBNT3a2MwMDUi3o+IpcBU4KgylrVVadcuNV3NnJk6ww88MAXHrrum9Z07w6BB8L3vQY8ecN99afm6dfDxx6nDutaaNXDbbakmcOyx9Z9z6tQ0ffvbsN9+6+f33z+tLwyPiy5av3748M8ea5dd4K9/hbVrU3mWLFlf9tWr07KI1Pk/ZQpUV6emtdomtalTN/QnZ2bNpW0Zjz0HuFLSdsBHwBCgRtIwYGFEvCqpvn27AW8XzC/Iln2GpJHASICePXs2U9Er29q1qRO8b1948UV48sk036FD6juYOTM1H82alZqkDjgg7TdtGhx2WLrT6aab0rKHH061k0sugS23rP+cRxyRXhcsgBkz1s8DLF+eynHkkWl+n33SVJ9TT4ULL4TRo2HVqhQYp52W1p1xBvz85+l4ffumO7Kefz6Vd8qUtE19TWtmtvGULTwi4jVJ1wBTgA+BmUA74D9JTVbNdZ4JwASA6urqBhpANh0SPPMMjB+fbsk95xy46qq0rqoKHnssNWl17gxDh8J119V/rPHjU7PQyJEbXp4nn0wBtfXWpW1/7rmpn+YXv0if5YIL4PTTP7tdmzap1vSd76TaTJcuqfbRUPOamW0cioYanJvzRNJVwN+AS4DabtTuwDvAgIh4t2Dbk4BDI+LMbH488HRE3N3QOaqrq6OmpqYcxbcGjBiR+lkuvrilS2KVrNfFj7Z0ETZZ86/+8gbvK+mliKjOu185m62Q1DUi3pPUk9Tf8c8R8X8L1s8HqiNicZ1dnwCuKugkHwR8t5xltQ13660tXQIz29jKGh7AA1mfx2rg7IhYVt+GkqqBURExIiLel3Q58GK2+ocR8X6Zy2pmZiUqa3hERIODVUREr4L3NcCIgvmJwMSyFc7MzDaYv2FuZma5OTzMzCw3h4eZmeXm8DAzs9wcHmZmlpvDw8zMcnN4mJlZbg4PMzPLzeFhZma5OTzMzCw3h4eZmeXm8DAzs9wcHmZmlpvDw8zMcnN4mJlZbg4PMzPLrdxPEmw1/Hzl8mnK85XNrDI1WvOQdIwk11DMzOwfSgmFrwOvS7pW0l7lLpCZmVW+RsMjIk4B+gJ/BiZJel7SSEldyl46MzOrSCU1R0XEB8D9wD3AjsBXgZclnVvGspmZWYUqpc/jK5IeBJ4GtgQGRMTRwP7AheUtnpmZVaJS7rb6GnB9REwrXBgRKyX9R3mKZWZmlayU8PgB8NfaGUkdgM9FxPyIeKpcBTMzs8pVSp/Hr4B1BfNrs2VmZraZKiU82kbEJ7Uz2futylckMzOrdKWExyJJX6mdkTQMWFy+IpmZWaUrpc9jFHCnpJsAAW8Dw8taKjMzq2iNhkdE/Bn4Z0mds/kVZS+VmZlVtJIGRpT0ZeALQHtJAETED8tYLjMzq2ClfElwHGl8q3NJzVb/Buxc5nKZmVkFK6XD/KCIGA4sjYjLgC8Cny/l4JLOlzRH0lxJo7Nll0uaJWmmpCmSdqpn37XZNjMlPVTi5zEzs42glPD4OHtdmf2iX00a36pBknoDZwADSEOZDJW0OzA2IvaLiD7AI8D36znERxHRJ5u+Us82ZmbWAkoJj4clbQOMBV4G5gN3lbDf3sALEbEyItYAzwDHZYMs1uoERK4Sm5lZi2uwwzx7CNRTEbEMeEDSI0D7iFhewrHnAFdK2g74CBgC1GTHvZJ0u+9y4LB69m8vqQZYA1wdEb+up4wjgZEAPXv2LKFYZmbWVA3WPCJiHXBzwfyqEoODiHgNuAaYAjwOzCQNbUJEXBIRPYA7gXPqOcTOEVENfAO4QdJu9ZxnQkRUR0R1VVVVKUUzM7MmKqXZ6ilJX1PtPbo5RMRtEdE/Ir4ELAX+WGeTO0mj9hbbd2H2+gZpOPi+ec9vZmblUUp4nEkaCHGVpA8k/V3SB43tBCCpa/baEzgOuEvSHgWbDAPmFdlvW0ntsvfbAwcDvy/lnGZmVn6lfMO8KY+bfSDr81gNnB0RyyTdJmlP0ki9fyENf4KkamBURIwgdbaPl7SOFHBXR4TDw8ysQpTyJcEvFZtKOXhEDIyIfSJi/9pnf0TE1yKid3a77jEFzVM1WXAQEc9FxL7ZfvtGxG1N+ZBmlWDiRNhtN+jQAQYPhoUL0/JFi6BPH+jUCbp0gUMOgTlzih/jrbfg4IOhfXuQ4P77m1am996Djh1h5crGtx0/Hrp3T+UfNgyWLCm+3RVXwB57pO169oTrrmtaGa0yldJs9e2C6b+Ah0kPiDKzEtXUwIgR0K0bXHMNPP00jBq1fv3RR8Mtt8BZZ8G0aTBmTPHjrFoFu+4KAweWfu7581PQFPPEE+lYHTs2fIxXXknl3XtvuOwyePRRuOCC4tvOmAHHHgs33ghbbQUXXgjPPFN6ea11KKXZ6pjCeUk9gBvKVSCzTdG0aRABZ54JJ58Md9+dfgEvWQJVVemv9fffh899DsaOhS3q+bNujz3gl7+EH/wAnnyy6eWaPDkFV2MmTUqvV10FBxwAjzySPsOECakWVOj++1NoAHz8MZx3Hsyd2/SyWmUppeZR1wJSn4SZlaj2LvJnn4V58+D111OYzJ+fls+eDV27pl/k3brBDTc0/ZzLl8PixbB0aZpfvDhNtU1U69bBlCnpnKtWrV+/vMjN+G++mV67dUuv3bvDmjXw9tuf3XargkfFTZmSgvDgg5v+eayylNLn8VNJN2bTTcB00jfNzaxEJ5yQfoGOG5eafj7Jns1Z+1f77runJqTLL4d33oFrr236OYcNS6HVr1+ar6pKU+2xZ8yArbeGPfdMtYja9cOGNX7sKGFciAsvTDWUK6+E/fff8M9hlamUIdlrCt6vAe6OiP8tU3nMNknt2qWmq9mzoW1bGD061UJ23TWt79wZBg1K089+BvfdlzrY161LQdO2bZry+MlPUq3jb3+DU06BqVPT8tpzFjZZDR68fv222372WLvskl4XLICddkqd/W3bQo8esHYtrF4NW24Jbdqk7c4/P/V5/Nd/wcUX5yu3tQ6l/HO8H/g4ItYCSGojqWNElHB/hplB+gU7Zgz07Qsvvpj6K8aMSXck3X47zJyZ7riaNSvdUXXAAWm/adPgsMPg7LPhpptgxQq45x54Oav7P/UULFuWOuPr6t8/vdY2jR1xxKfXT54Ml16a3u+4Y5rqM3x4CoNLLoEjj4TnnoOTTko1p0mT4PTTU1/Nt74F3/1u2nbAANhnn1Te3r036MdmFayU8HgKOAKofYJgB9KQIweVq1Bmmxop3XE0fny6Jfecc1LnM6SmosceS01anTvD0KH13966eDGcccb6+XHj0mux8GjIokWpE/vww0vbvn9/uPnm1AQ1fXqqsVx/ffFtn38+vc6YkQIG1oeUbToUjTReSpqZDZ/e4LJKUF1dHTU1NY1vWESvix9t5tJYrflXf7mli2B13HFHmh5/fOOd0//Hyqcp/8ckvZSNI5hLKXdbfSipX8GJ+pNGyTWzVuqUUzZucNimp5Rmq9HAryS9Q3oM7Q6kx9KamdlmqpQvCb4oaS9gz2zRHyJidXmLZWZmlayU73mcDXSKiDkRMQfoLOmb5S+amZlVqlL6PM7IniQIQEQsJT2b3MzMNlOlhEebwgdBSWoDbNXA9mZmtokrpcP8ceBeSeOz+TOByeUrkpmZVbpSwuM7wEiyhzYBs0h3XJmZ2Waq0WariFgHvADMBwYAhwOvlbdYZmZWyeqteUj6PHBSNi0G7gWIiMM2TtHMzKxSNdRsNY80/PrQiPgTgKR6nh1mZmabk4aarY4D/gr8VtLPJP0r6RvmZma2mas3PCLi1xFxIrAX8FvSMCVdJf23pEEbqXxmZlaBSukw/zAi7sqeZd4deIV0B5aZmW2mcj3DPCKWRsSEiPjXchXIzMwqX67wMDMzA4eHmZltAIeHmZnlVsrwJGYVx480LR8/NthK4ZqHmZnl5vAwM7PcHB5mZpabw8PMzHIra3hIOl/SHElzJY3Oll0uaZakmZKmSNqpnn1PlfR6Np1aznKamVk+ZQsPSb1JzzofAOwPDJW0OzA2IvaLiD7AI8D3i+z7T8ClwIHZ/pdK2rZcZTUzs3zKWfPYG3ghIlZGxBrgGeC4iPigYJtOQBTZdzAwNSLej4ilwFTgqDKW1czMcihneMwBBkraTlJHYAjQA0DSlZLeBk6mSM0D6Aa8XTC/IFv2GZJGSqqRVLNo0aJm/QBmZlZc2cIjIl4DrgGmAI8DM4G12bpLIqIHcCdwThPPMyEiqiOiuqqqqmmFNjOzkpS1wzwibouI/hHxJWAp8Mc6m9wJfK3IrgvJaimZ7tkyMzOrAOW+26pr9tqT9GTCuyTtUbDJMNLjbut6Ahgkaduso3xQtszMzCpAuce2ekDSdsBq4OyIWCbpNkl7AuuAvwCjACRVA6MiYkREvC/pcuDF7Dg/jIj3y1xWMzMrUVnDIyIGFllWrJmKiKgBRhTMTwQmlq90Zma2ofwNczMzy83hYWZmuTk8zMwsN4eHmZnl5vAwM7PcHB5mZpabw8PMzHJzeJiZWW4ODzMzy83hYWZmuTk8zMwsN4eHmZnl5vAwM7PcHB5mZpabw8PMzHJzeJiZWW4ODzMzy83hYWZmuTk8zMwsN4eHmZnl5vAwM7PcHB5mZpabw8PMzHJzeJiZWW4ODzMzy83hYWZmuTk8zMwsN4eHmZnl5vAwM7PcHB5mZpabw8PMzHIra3hIOl/SHElzJY3Olo2VNE/SLEkPStqmnn3nS5otaaakmnKW08zM8ilbeEjqDZwBDAD2B4ZK2h2YCvSOiP2APwLfbeAwh0VEn4ioLlc5zcwsv3LWPPYGXoiIlRGxBngGOC4ipmTzAL8DupexDGZmVgblDI85wEBJ20nqCAwBetTZ5t+ByfXsH8AUSS9JGlnfSSSNlFQjqWbRokXNUnAzM2tY23IdOCJek3QNMAX4EJgJrK1dL+kSYA1wZz2H+JeIWCipKzBV0ryImFbkPBOACQDV1dXRvJ/CzMyKKWuHeUTcFhH9I+JLwFJSHweSTgOGAidHRNFf+BGxMHt9D3iQ1HdiZmYVoNx3W3XNXnsCxwF3SToKuAj4SkSsrGe/TpK61L4HBpGawczMrAKUrdkq84Ck7YDVwNkRsUzSTUA7UlMUwO8iYpSknYBbI2II8DngwWx9W+CuiHi8zGU1M7MSlTU8ImJgkWW717PtO6ROdSLiDdLtvWZmVoH8DXMzM8vN4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm8PDzMxyc3iYmVluDg8zM8vN4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm8PDzMxyc3iYmVluDg8zM8vN4WFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm8PDzMxyc3iYmVluDg8zM8vN4WFmZrkpIlq6DM1G0iLgLy1djo1ge2BxSxfCcvE1a302l2u2c0RU5d1pkwqPzYWkmoiobulyWOl8zVofX7OGudnKzMxyc3iYmVluDo/WaUJLF8By8zVrfXzNGuA+DzMzy801DzMzy83hYWZmuTk8mpmktZJmSpoj6VeSOubYt5ekb2zgeZ/bkP3qKcOc5jjWpkbSdtm1nSnpXUkLC+a3auZz+To0A1+z8nF4NL+PIqJPRPQGPgFGFa6U1LaBfXsBRcOjkf2IiINyltNyiogl2bXtA4wDrq+dj4hPWrh4VoSvWfk4PMprOrC7pEMlTZf0EPB7SW0kjZX0oqRZks7Mtr8aGJj9VXSBpNMkPSTpN8BTkjpLekrSy5JmSxpWeyJJK7LXQyU9Lel+SfMk3SlJ2br+kp6R9JKkJyTtWLD8VUmvAmdvzB9QaydpkqTjC+Z9HSqcr1nzcHiUSVZTOBqYnS3qB5wfEZ8H/gNYHhEHAAcAZ0jaBbgYmJ79VXR9wX7HR8QhwMfAVyOiH3AY8JPaf9x19AVGA/sAuwIHS9oS+Gl2rP7ARODKbPvbgXMjYv/m+wkYvg6tka9ZiRpsCrEN0kHSzOz9dOA24CBgRkS8mS0fBOxX8NfP1sAepGauuqZGxPvZewFXSfoSsA7oBnwOeLfOPjMiYgFAVpZewDKgNzA1y5s2wF8lbQNsExHTsn1/SQo9azpfh9bH16xEDo/m91HWvvoP2T+4DwsXkf5aeaLOdocWOV7hficDVUD/iFgtaT7Qvsg+qwreryVdZwFzI+KLdc65Tb2fxEqxhqwGL2kLoLAT1tehMvmaNQM3W7WMJ4Czsuowkj4vqRPwd6BLA/ttDbyXBcdhwM45zvkHoErSF7NzbinpCxGxDFgm6V+y7U7O+Vk2d/OB/tn7rwBbNrK9r0PLm4+vWZM5PFrGrcDvgZezW/vGk/7CmQWszTrgLiiy351AtaTZwHBgXqknzO4sOR64Juvcm0lqTgM4Hbg5q6YX60Ox+v0MOCT7mX6RT9cUP8PXoSL4mjUDD09iZma5ueZhZma5OTzMzCw3h0crI+koSX+Q9CdJF7d0eTZnWj8UzavZFzf9Lf9WpOD61U4N/n/KvkToa5zxrbqtiKQ2wM3AkcAC4EVJD0XE71u2ZJutf9yWLWkw8CPgkBYtkeXxmdvqG3EosAJolnHkWjvXPFqXAcCfIuKN7A6Qe4BhjexjG8f/AZYCqJ5hZCR1kvRoVlOZI+nr2fKiQ19Yy5A0X9JlBddvL0m9SOPUXZDVUga2cDFbnGserUs34O2C+QXAgS1UFls/mkB7YEfg8Gx57TAyH0jaHvid0rhmRwHvRMSXASRtXTD0xbCIWJQFypXAv2/kz7I5KhwNAuBHEXFv9n5xRPST9E3gWxExQtI4YEVE/Hijl7QCOTzMNlxhs9UXgV9I6k39w8jMJo1Hdg3wSERMz7b/zNAXG/2TbJ4aarb6n+z1JeC4jVOc1sXh0bosBHoUzHfPllkLi4jns1pGFTCEIsPIRMQfJfXL1l8h6SngQYoMfWEtrnaYktohSqwO93m0Li8Ce0jaRelBNicCD7VwmQyQtBep1rCEeoaRkbQTsDIi7gDGkkZMLjr0RUt8BmtUY8MHbVacqK1IRKyRdA5pbKw2wMSImNvCxdqcFbaZCzg1ItZKuhN4OBtGpob1w8jsC4yVtA5YDZwVEZ9koyvfKGlr0v/JGwBf1/Kr2+fxeEQ0dLvuw8D92Q0Q50bE9LKWrsJ5eBIzM8vNzVZmZpabw8PMzHJzeJiZWW4Ojwoiqb2kGdk3kOdKumxj7Gvl47HIWh9JEyW9lz1rx+rhDvMKovQtsU4RsSL75vGzwPkR8bty7mvlkY1F9kcKxiIDTvJYZJUt+3LnCuAXEdG7pctTqVzzqCCRrMhmt8ymKGXso/r23Tglt3p4LLJWKCKmAe+3dDkqncOjwkhqk917/h4wFXiZNPbR8RHRH5hIGvuo0X0j4oWNUmirT7GxyLq1UFnMmpW/JFhhImIt0EfSNqShK/akxLGP6u4rqXdEuN3WzJqdw6NCRcQySb8FvkqRsY8k9SB94xVgXESMK7LvUYDDo+V4LDLbZLnZqoJIqspqDUjqQOpofZUiYx9FxNsR0SebxtWz77yiJ7KNxWOR2SbLNY/KsiPw8+wunS2A+yLiIUlv0fjYR8X2fWTjFd3q8lhkrZOku0lPDdxe0gLg0oi4rWVLVXl8q66ZmeXmZiszM8vN4WFmZrk5PMyawEPKtD5NGX5E0uMF12tc1se4WXKfh1kTeEiZ1qcpw49I+j8R8UF27e4HfhUR95SjnJXONQ+zJvCQMq1PseFHJO2W1SpekjQ9e6xwsX0/yN62BbZiM75eDg+zJvKQMpuECaRHy/YHvgXcUt+Gkp4gXa+/k2ofmyV/z8OsiTykTOsmqTNwEPCr7HoBtKtv+4gYLKk9cCdwOOkPhs2Ow8OsmXhImVZrC2BZRPQpXJh1hr+UzT4UEd+vXRcRH0v6f6RRkjfL8HCzlVkTeEiZ1i/rx3hT0r9BupFB0v4Rsbbgen1fUufavitJbYEvsxlfL9c8zJrGQ8q0MsWGHwFOBv5b0vdINy7cQ/ojoFAn4CFJ7UjX67fAODZTvlXXzMxyc7OVmZnl5vAwM7PcHB5mZpabw8PMzHJzeJiZWW4OD7MGSApJdxTMt5W0SFKDt9RK6iNpSMH8DyR9qwnlaNL+Zs3N4WHWsA+B3tmX+CB9kW9hCfv1AYY0tpFZa+XwMGvcY6RvEwOcBNxdu0JSp+z5EDMkvSJpmKStgB8CX5c0U9LXs833kfS0pDcknVdwjDGS5mTT6ILll0j6o6RnSeNlmVUMh4dZ4+4BTswGw9sPKBz59hLgNxExADgMGEv6hvL3gXuzoS3uzbbdCxgMDAAuzYYt6Q+cDhwI/DNwhqS+2fITWV+DOaDMn9EsFw9PYtaIiJglqRep1vFYndWDgK8U9Ee0B3rWc6hHI2IVsErSe8DngH8BHoyIDwEk/Q8wkPSH3YMRsTJb/lAzfiSzJnN4mJXmIeDHpDGRtitYLuBrEfGHwo0lHVjkGKsK3q/F//+sFXOzlVlpJgKXRcTsOsufAM7NHkuKpL7Z8r8DXUo47nTgWEkdJXUiDec+HZiWLe8gqQtwTHN8CLPm4vAwK0FELIiIG4usupzUxzFL0txsHtKIq/vU6TAvdtyXgUnADFJfyq0R8Uq2/F7SyK6TgReb7cOYNQOPqmtmZrm55mFmZrk5PMzMLDeHh5mZ5ebwMDOz3BweZmaWm8PDzMxyc3iYmVluDg8zM8vt/wP9eDmoS+uIzgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(result_dict, 'PACS', plot_y='acc_tgt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d8e7440",
   "metadata": {},
   "source": [
    "## VLCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "06d1223c",
   "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(result_dict, 'VLCS', plot_y='acc_tgt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "563a051b",
   "metadata": {},
   "source": [
    "## OfficeHome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "529a9f3e",
   "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(result_dict, 'OfficeHome', plot_y='acc_tgt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cace334",
   "metadata": {},
   "source": [
    "## TerraIncognita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5301da3d",
   "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(result_dict, 'TerraIncognita', plot_y='acc_tgt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "367072c3",
   "metadata": {},
   "source": [
    "# DomainNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "96352cbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAE5CAYAAABoCayPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlt0lEQVR4nO3deZwV1Z338c9XUHBBMdrygKjgxGiMRoRWR8UF4wJiRE0y4mhER0EnajLO+Dg65ol7EmWieUVNFOOG4p4hwYUtKolZXBoXQIM7KrgACgpRQeD3/HGqp6/N7e5b3X27b9Pf9+tVr6o6Vafq3C64v3vOqTqliMDMzCyP9dq7AGZm1vE4eJiZWW4OHmZmlpuDh5mZ5ebgYWZmuTl4mJlZbg4eZm1E0raSlkvq0t5lMWspBw9b50maJ+lTScskLZX0F0mnS2rTf/8R8VZEbBIRq5vaV1I/SSHp4Xrpd0i6qJTzZZ/74GYW16xRDh7WWXwzInoA2wE/Bf4TuKl9i1SSvSTt096FMKvPwcM6lYj4KCImAccCoyTtImkzSeMlLZL0pqQf1tZKJJ0k6c+Srs5qLa9L2idLf1vSQkmjao8vabikZyV9nG2/qGBbbW2ia7Y+Q9Kl2fGXSZomact6Rb4SuLyhzyPpCEnPFdSovp6l3w5sCzyQNZWd20p/QjPAwcM6qYh4CpgP7AdcA2wGbA8cAJwInFyw+17ALGAL4E7gbmAP4MvACcC1kjbJ9v17lr8nMBz4V0lHNVKUf87OtRWwAXBOve2/BL5SrPlJ0u7AzcBpWdluACZJ6hYR3wXeItW4NomIKxv/i5jl4+Bhndk7wJeAkcD5EbEsIuYBPwO+W7DfGxFxS9ZXcQ+wDXBJRKyIiGnASlIgISJmRMTsiFgTEbOAu0gBqSG3RMTLEfEpcC8woN72T0k1j8uK5B0D3BART0bE6oi4DVgB/GOOv4FZszh4WGe2NdAVWB94syD9zWxbrfcLlj8FiIj6aZsASNpL0mNZE9hHwOlA/aaoQu8VLH9Se5x6fg30kvTNeunbAf+RNVktlbSUFNj6NHI+s1bh4GGdkqQ9SAHit8DnpC/iWtsCC5p56DuBScA2EbEZcD2g5pcUImIlcDFwab1jvQ1cHhE9C6aNIuKu2qwtOa9ZYxw8rFORtKmkI0j9FndExPOk5qLLJfWQtB3w78AdzTxFD+DDiPhM0p6kPo3WcDvQHRhakHYjcHpW25GkjbMO+x7Z9vdJ/Thmrc7BwzqLByQtI/1avwC4irpO8bNIHd2vA38i1R5ubuZ5vgdckp3rR6TA1GJZf8uPSH00tWk1wGjgWmAJ8CpwUkG2nwA/zJq06nfEm7WI/DIoMzPLyzUPMzPLzcHDzMxyc/AwM7PcHDzMzCw3Bw8zM8uta3sXoDVtueWW0a9fv/YuhplZhzFz5szFEVGVN986FTz69etHTU1NexfDzKzDkPRm03utzc1WZmaWm4OHmZnl5uBhZma5OXiYmVluDh5mZpabg4eZmeXm4GFmZrk5eHRQ/fqBVDcNGJDSX3kFhgyBLbaAHj3gkEPgtdeKH2PFCjj1VKiqgg03hN13h0cfbX6ZFi6EjTaCTz5pet8bboC+fdN5R4yADz4ovt/MmVBdDV27ps/px3jMKoODRwe2//5w111puuKKlLZgAaxZAxdfDCefDL//fQoQxYwfDzfdlALPpZfC88/D6NGNn3PevPQlXszUqbDffimANObZZ+H00+GrX03lfOghOPvs4vt++mkq3+67N35MM2tb69QT5p1N//4wfHiqYdTaZx/4wx/q1idMgBdeKJ5/zZo032UXOPhg6NYNevZsfnkmT4Zhw5re79Zb0/zHP4Y99oAHH0wBcNw46N79i/sOHpymk05yrcOskrjm0YGNHw+bbgpbbZVqEAAbbFC3vaYGPvww1VCKGTUKjj4afv7z9Mt+o43qvtjr++gjWLwYlixJ64sXp6m2iWrNGpg2LQWPFSvqtn/00drHeuONNN966zTv2xdWrYK3387z6c2sPTl4dFCjR8O998Ltt6eAcdppdV/KAHPnwpFHpr6Ra64pfownnkhNRscfD3ffDatXp1/4xd5MPGJE6hsZODCtV1Wl6cor0/pTT8Fmm8GOO6ZaRO32ESOa/ix+E7JZx+Nmqw7qggvqlp99Fq66Cl5+OTVlvfgiHHRQagJ69FHo3TvtF5FqBV26wPrrw333wcqVqf9h8GC48UZ45JFUY6iqN8bmz36Wah3vvw8nnADTp6f07bdP88Imq8MOq9u++eZrl71//zSfPx/69En9NF27wjbbpAD2+eepfF26tM7fysxan4NHBzRrVgoeQ4emL9vx49NdS7vumpp+hgxJdy9ddhk8+WSaRo6EN9+s6yd58MG6L/4rr0yd5X/9a7pLa8st1z7noEFpPm9emh988Be3T54MF16Ylnv3rgtYxZx4IvziF+kzHHII/OUvcNxxKdjdemvq6B87Fs45B959N9WOXnkl5f3d79LdY8ce29y/npm1iogo2wTMA2YDzwE1WdqlwKwsbRrQp4G8o4BXsmlUKecbNGhQdAbvvBMxbFjEFltEbLhhxKBBEVOmpG2PPRaR6hhfnCIi3ngjLQ8fntY//TTilFMittoqHWfgwIhHH2383LXHKLRwYcRGG0V88knpn+G66yL69Ino1i3iiCMiFi1K6bfcko4/dmzDn2e77Uo/j5k1rva7Oe+kKGODs6R5QHVELC5I2zQiPs6Wvw/sHBGn18v3JaAGqAYCmAkMiogljZ2vuro6/D6PtnfHHWmaMqW9S2JmeUmaGRHVefO1eYd5beDIbEwKDvUdBkyPiA+zgDEdGNoW5bP8TjjBgcOssyl3n0cA0yQFcENEjAOQdDlwIvARMKRIvq2Bwhs352dpa5E0BhgDsO2227Zeyc3MrEHlrnkMjoiBwDDgDEn7A0TEBRGxDTABOLMlJ4iIcRFRHRHVVfVvETIzs7Ioa/CIiAXZfCEwEdiz3i4TgG8VyboA2KZgvW+WZmZmFaBswUPSxpJ61C4DhwJzJO1QsNsIYG6R7FOBQyVtLmnzLO/UcpXVzMzyKWefRy9gotIoel2BOyNiiqTfSNoRWAO8CZwOIKkaOD0iTo2IDyVdCjydHeuSiPiwjGU1M7McynqrblvzrbpmZvl0mFt1zcys43PwMDOz3Bw8zMwsNwcPMzPLzcHDzMxyc/AwM7PcHDzMzCw3Bw8zM8vNbxLM9DvvofYuwjpr3k+Ht3cRzKyVueZhZma5OXiYmVluDh5mZpabg4eZmeXm4GFmZrk5eJiZWW4OHmZmlpuDh5lZA/r1A6luGjAgpb/yCgwZAltsAT16wCGHwGuvFT/GnDnw1a9C9+7QsyccfjgsWND8MtXUwLbblrbvxRdDVRVssgmcdBJ89lnx/SSGScyWWCMREls2dWwHDzOzRuy/P9x1V5quuCKlLVgAa9akL+eTT4bf/x5OPbV4/vXWg5EjYdw4OOYYmDw55WvMjBkpcBUzeTIMG9Z0uSdOhIsugm98A77/fbjtNvjxjxvcfSPgj0ADIXBtfsLczKwR/fvD8OGphlFrn33gD3+oW58wAV54oXj+nXeG88+HpUth5Uq45ZYUUJpr8mQ499ym97v11jS/5ppU+7jjjnTuSy5Ze98IfgP8RmIG8OVSyuGah5lZI8aPh003ha22gptuSmkbbFC3vaYGPvww1VAa8vDD0KsXjB4NX/tawzWPJUtg8WL46KNUs1m8OE0rVqTtH34Izz2XahOffFK3ffnytY/1xhuw/vopcAD07ZtqTCtX5v4TFOXgYWbWgNGj4d574fbbU8A47bT0pVxr7lw48sjUxHTNNQ0fZ999U43hBz9INZQbbii+3+67py/7o46Ct99Oy1VVqckMYNo02HvvVAu68sq67Wee2fRniSj1U5fGzVZmZg244IK65WefhauugpdfTk1ZL74IBx2UOsIffRR69077RaSaQpcu6Zc/pC/4oUNTx/o116SA9KMfrX2+CRPg00/h+edh7NjU1ASptgJf7O848UQYPDgt9+mz9rH694fZs2HhwlRrWrAAtt46BcFVq9JUWIPKy8HDzKyIWbNS8Bg6FFavTs1XG24Iu+6aagVDhsAHH8Bll8GTT6Zp5Eh48826fpIHH4Sf/CQ1Q+20Uwoya9akfpBi9t03zbt2TUHp4IPrtkXA1Kl1/R3bb5+mhowaBZMmpdpO//6pzD/8Ydp22WWp6ey++9K6xA7AAUAWAjlB4pUIGhxu3MHDzKyIqqoUNC68MPUv7LwzXH55+pU/Y0b6RQ+pM7zWyJHFj3P99fDee+lW3eOOg5//PH95nnkGunWrq4U05Zhj4P/9P/jlL9Mtut/9LvzXfzW4+77AjQXrVwN/gIaDh6K1G8IKDy7NA5YBq4FVEVEtaSzwTWAl6bawkyNiaSl5mzpfdXV11NTUNKusfp9H+fh9HmYtd9llMH9+CkStSdLMUr5f62uLmseQiFhcsD4dOD8iVkm6Ajgf+M8S85qZdUq1TU6Vos3vtoqIaRGxKlt9Aujb1mUwM7OWKXfwCGCapJmSxhTZ/i/A5GbmBUDSGEk1kmoWLVrUCkU2M7OmlLvZanBELJC0FTBd0tyI+COApAuAVcCEvHkLRcQ4YBykPo/yfAwzMytU1ppHRCzI5guBicCeAJJOAo4Ajo8GeuwbymtmZu2vbMFD0saSetQuA4cCcyQNBc4FjoyIT/LkLVdZzcwsn3I2W/UCJkqqPc+dETFF0qtAN1JTFMATEXG6pD7AryPi8IbylrGsZmaWQ9mCR0S8DuxWJL3oiI0R8Q5weGN5zcysMnhgRDMzy83Bw8zMcnPwMDOz3Bw8zMwsNwcPMzPLzcHDzMxyc/AwM7Pc/DIoM2sTfmdO+bTHO3Nc8zAzs9wcPMzMLDcHDzMzy83Bw8zMcnPwMDOz3Bw8zMwsNwcPMzPLzcHDzMxyc/AwM7PcHDzMzCw3Bw8zM8vNwcPMzHJz8DAzs9wcPMzMLDcHDzMzy83Bw8zMcitr8JA0T9JsSc9JqsnSxkqaK2mWpImSejaQd6iklyS9Kum8cpbTzMzyaYuax5CIGBAR1dn6dGCXiPg68DJwfv0MkroA1wHDgJ2B4yTt3AZlNTOzErR5s1VETIuIVdnqE0DfIrvtCbwaEa9HxErgbmBEW5XRzMwaV+7gEcA0STMljSmy/V+AyUXStwbeLlifn6WtRdIYSTWSahYtWtTiApuZWdPKHTwGR8RAUvPTGZL2r90g6QJgFTChJSeIiHERUR0R1VVVVS0rrZmZlaSswSMiFmTzhcBEUnMUkk4CjgCOj4goknUBsE3Bet8szczMKkCTwUPSNyXlDjKSNpbUo3YZOBSYI2kocC5wZER80kD2p4EdJPWXtAEwEpiUtwxmZlYepQSFY4FXJF0paaccx+4F/EnS88BTwEMRMQW4FugBTM9u4b0eQFIfSQ8DZB3qZwJTgb8B90bECznObWZmZdS1qR0i4gRJmwLHAbdKCuAW4K6IWNZIvteB3Yqkf7mB/d8BDi9Yfxh4uMlPYGZmba6k5qiI+Bi4n3TLbG/gaOAZSWeVsWxmZlahSunzOFLSRGAGsD6wZ0QMI9Uq/qO8xTMzs0rUZLMV8C3g6oj4Y2FiRHwi6ZTyFMvMzCpZKcHjIuDd2hVJGwK9ImJeRDxSroKZmVnlKqXP4z5gTcH66izNzMw6qVKCR9dsfCkAsuUNylckMzOrdKUEj0WSjqxdkTQCWFy+IpmZWaUrpc/jdGCCpGsBkQYsPLGspTIzs4pWykOCrwH/KGmTbH152UtlZmYVrZSaB5KGA18DuksCICIuKWO5zMysgpXykOD1pPGtziI1W30H2K7M5TIzswpWSof5PhFxIrAkIi4G9ga+Ut5imZlZJSsleHyWzT+R1Af4nDS+lZmZdVKl9Hk8IKknMBZ4hvRq2RvLWSgzM6tsjQaP7CVQj0TEUuA3kh4EukfER21RODMzq0yNNltFxBrguoL1FQ4cZmZWSp/HI5K+pdp7dM3MrNMrJXicRhoIcYWkjyUtk/RxmctlZmYVrJQnzHu0RUHMzKzjaDJ4SNq/WHr9l0OZmVnnUcqtuv+3YLk7sCcwEzioLCUyM7OKV0qz1TcL1yVtA/y8XAUyM7PKV0qHeX3zga+2dkHMzKzjKKXP4xrSU+WQgs0A0pPmZmbWSZXS51FTsLwKuCsi/lzKwSXNA5aR3nu+KiKqJX0HuIhUe9kzImpKzVvKOc3MrPxKCR73A59FxGoASV0kbRQRn5R4jiERUfja2jnAMcANzchrZmYVoKQnzIENC9Y3BH7f3BNGxN8i4qXm5jczs/ZXSvDoXvjq2Wx5oxKPH8A0STMljclZtpLyShojqUZSzaJFi3KewszMmqOU4PF3SQNrVyQNAj4t8fiDI2IgMAw4o6EHDluSNyLGRUR1RFRXVVXlOLyZmTVXKX0e/wbcJ+kd0mto/w/ptbRNiogF2XyhpImkBwxLejK9JXnNzKy8SnlI8GlJOwE7ZkkvRcTnTeWTtDGwXkQsy5YPBS4ppVAtyWtmZuXXZLOVpDOAjSNiTkTMATaR9L0Sjt0L+JOk54GngIciYoqkoyXNJ70L/SFJU7Pz9JH0cGN58388MzMrh1KarUZHROELoZZIGg38srFMEfE6sFuR9InAxCLp7wCHN5bXzMwqQykd5l0KXwQlqQuwQfmKZGZmla6UmscU4B5JtQ/1nQZMLl+RzMys0pUSPP4TGAOcnq3PIt1xZWZmnVSTzVYRsQZ4EphHul32IOBv5S2W2bqnXz+Q6qYBA+q2ff/70KtXSj/iiMaP8+c/w9e/Dt26wcCB8EwLhildtQp69oTXXmt639/+Fr78ZejeHQ48EN54o/h+b70F++6b9pPg/vubXz6rXA0GD0lfkXShpLnANcBbABExJCKubasCmq1L9t8f7rorTVdc8cVtI0c2nf+zz+Bb34Jly+Dqq+H99+Hb34bVqxvPJ8G8eWun//WvKWj9wz80nv+991L5Nt0Uxo6FmTNh1Kji+65YAdtvD/vt1/TnsY6rsZrHXFIt44iIGBwR15BGuDWzZurfH4YPT1/Ehx1Wl/6LX8DZZzedf/LkFDC+9700nXJKqgHMmNG88kyeDMOGNb3fXXeloHD++XDWWXD00fD448VrLDvsALffnmoftu5qLHgcA7wLPCbpRknfID1hbmbNNH58+vW+1VZw003589c2FW29dZr37Zvmr7++9r7Ll8PixWkCWLIkLS9fXrdPbfD4/PO6fZcsadl5rXNoMHhExG8jYiSwE/AYaZiSrST9StKhbVQ+s3XG6NFw773pV/kGG8BppzXcb1CqiIa3nXkmVFWlCVL/SFVVSgd491145ZXUf/HnP9ftu/vuLTuvdQ6lDE/yd+BO4E5JmwPfId2BNa3MZTNbp1xwQd3ys8/CVVfByy+npqzGrFiR5t261e07f36aL1iQ5ttvv3a+c8+FE05Iy4ccAnfckfo3+vRJaVOmpMDRrRvsthtMn57SN9xw7WM1dt41a2DlSujaNU3WOeS61BGxBBiXTWZWolmzUvAYOjR1bo8fn76kd901bX/oIZgzJy2//Tb8+tdwwAGp/2DHHeuam4YNS01ev/oV9OiRmr769UtBoL6dd05TrX33TfvWKuzv2HxzOPjghss/ciScd17q5H//fZg4EQYPTh3tM2bAkCFwxhlw7bWpnHffXXcX2COPwNKlzfqzWQUr5QlzM2uhqqoUNC68MH0Jb7dd+gKurQWMHZvSIQWa0aNTU1J93bvDfffBJpvAD36QAsl990GXLvnKs3p1qmkcfnhp+/funTrNly6Fc85JTVu33lp838WLU/kfeCCtX399Wrd1iyuZZm2gd294+OGGtzd2t1T9W2z33x9mz853/vp9FLW36DbVZFbomGPSVN+BB37x+P36Fe8T6Xde6eeyyueah1knNHgwzJ3b3qWwjszBw8zMcnPwMDOz3Bw8zMwsNwcPMzPLzcHDzMxyc/AwM7PcHDzMzCw3Bw8zM8vNwcPMzHJz8DAzs9wcPMzMLLeyBg9J8yTNlvScpJos7TuSXpC0RlJ1I3mHSnpJ0quSPKSamVkFaYtRdYdExOKC9TmkV9ze0FAGSV2A64BDgPnA05ImRcSLZS2pmZmVpM2HZI+IvwFIjb4OfU/g1Yh4Pdv3bmAE4OBhZlYByh08ApgmKYAbIqLUNxBuDbxdsD4f2KvYjpLGAGMAtt122xYU1TqSfuc91N5FWGfN++nw9i6CdQDl7jAfHBEDgWHAGZL2b+0TRMS4iKiOiOqqqqrWPryZmRVR1uAREQuy+UJgIqk5qhQLgG0K1vtmaWZmVgHKFjwkbSypR+0ycCips7wUTwM7SOovaQNgJDCpPCU1M7O8ylnz6AX8SdLzwFPAQxExRdLRkuYDewMPSZoKIKmPpIcBImIVcCYwFfgbcG9EvFDGspqZWQ5l6zDP7pTarUj6RFITVv30d4DDC9YfBh4uV/nMzKz5/IS5mZnl5uBhZma5OXiYmVluDh5mZpabg4eZmeXm4GFmZrk5eJiZWW4OHmZmlpuDh5mZ5ebgYWZmuTl4mJlZbg4eZmaWm4OHmZnl5uBhZma5OXiYmVluDh5mZpabg4eZmeXm4GFmZrk5eJiZWW4OHmZmlpuDh5mZ5ebgYWZmuTl4mJlZbg4eZmaWW9dyHlzSPGAZsBpYFRHVkr4E3AP0A+YB/xQRS4rkXQ3Mzlbfiogjy1lWMzMrXVvUPIZExICIqM7WzwMeiYgdgEey9WI+zfINcOAwM6ss7dFsNQK4LVu+DTiqHcpgZmYtUO7gEcA0STMljcnSekXEu9nye0CvBvJ2l1Qj6QlJRzV0Akljsv1qFi1a1HolNzOzBpW1zwMYHBELJG0FTJc0t3BjRISkaCDvdlne7YFHJc2OiNfq7xQR44BxANXV1Q0dy8zMWlFZax4RsSCbLwQmAnsC70vqDZDNFzaR93VgBrB7OctqZmalK1vwkLSxpB61y8ChwBxgEjAq220U8LsieTeX1C1b3hLYF3ixXGU1M7N8ytls1QuYKKn2PHdGxBRJTwP3SjoFeBP4JwBJ1cDpEXEq8FXgBklrSAHupxHh4GFmViHKFjyy5qbdiqR/AHyjSHoNcGq2/Bdg13KVzczMWsZPmJuZWW4OHmZmlpuDh5mZ5ebgYWZmuTl4mJlZbg4eZmaWm4OHmZnl5uBhZma5OXiYmVluDh5mZpabg4eZmeXm4GFmZrk5eJiZWW4OHmZmlpuDh5mZ5ebgYWZmuTl4mJlZbg4eZmaWm4OHmZnl5uBhZma5OXiYmVluDh5mZpabg4eZmeXm4GFmZrmVNXhImidptqTnJNVkaV+SNF3SK9l88wbyjsr2eUXSqHKW08zM8mmLmseQiBgQEdXZ+nnAIxGxA/BItv4Fkr4EXAjsBewJXNhQkDEzs7bXHs1WI4DbsuXbgKOK7HMYMD0iPoyIJcB0YGjbFM/MzJrStczHD2CapABuiIhxQK+IeDfb/h7Qq0i+rYG3C9bnZ2lrkTQGGJOtLpf0UquUvLJtCSxu70KUSle0dwkqQoe5Zr5e/6uzXLPtmpOp3MFjcEQskLQVMF3S3MKNERFZYGm2LCCNa8kxOhpJNQXNgNYB+Jp1PL5mjStrs1VELMjmC4GJpP6L9yX1BsjmC4tkXQBsU7DeN0szM7MKULbgIWljST1ql4FDgTnAJKD27qlRwO+KZJ8KHCpp86yj/NAszczMKkA5m616ARMl1Z7nzoiYIulp4F5JpwBvAv8EIKkaOD0iTo2IDyVdCjydHeuSiPiwjGXtaDpVM906wtes4/E1a4QiWtTlYGZmnZCfMDczs9wcPMzMLDcHj1YmaXU2HMscSfdJ2ihH3n6S/rmZ5/1Lc/I1UIY5rXGsdY2kLbJr+5yk9yQtKFjfoJXP5evQCnzNysfBo/V9mg3HsguwEji9cKOkxm5S6AcUDR5N5CMi9slZTsspIj7Iru0A4Hrg6tr1iFjZzsWzInzNysfBo7weB74s6UBJj0uaBLwoqYuksZKeljRL0mnZ/j8F9st+FZ0t6SRJkyQ9CjwiaRNJj0h6JhtwckTtiSQtz+YHSpoh6X5JcyVNUHbLm6RBkv4gaaakqQXP2wyS9Lyk54Ez2vIP1NFJulXStwvWfR0qnK9Z63DwKJOspjAMmJ0lDQR+EBFfAU4BPoqIPYA9gNGS+pMGiXw8+1V0dUG+b0fEAcBnwNERMRAYAvys9h93PbsD/wbsDGwP7CtpfeCa7FiDgJuBy7P9bwHOiojdWu8vYPg6dES+ZiUq9/AkndGGkp7Llh8HbgL2AZ6KiDey9EOBrxf8+tkM2IHUzFXf9IJnXAT8WNL+wBrSeF+9SGOEFXoqIuYDZGXpBywFdiENEwPQBXhXUk+gZ0T8Mct7OynoWcv5OnQ8vmYlcvBofZ9m7av/K/sH9/fCJNKvlan19juwyPEK8x0PVAGDIuJzSfOA7kXyrChYXk26zgJeiIi9652zZ4OfxEqxiqwGL2k9oLAT1tehMvmatQI3W7WPqcC/ZtVhJH1FaQiXZUCPRvJtBizMAscQ8o2G+RJQJWnv7JzrS/paRCwFlkoanO13fM7P0tnNAwZly0cC6zexv69D+5uHr1mLOXi0j18DLwLPZLf23UD6hTMLWJ11wJ1dJN8EoFrSbOBEYG6RfYrK7iz5NnBF1rn3HKk5DeBk4Lqsml6sD8UadiNwQPY33Zsv1hTX4utQEXzNWoGHJzEzs9xc8zAzs9wcPMzMLDcHjw5G0lBJL0l6VdJ57V2ezkx1Q9E8nz246af8O5CC61c7Nfr/KXuI0Nc441t1OxBJXYDrgENI73V/WtKkiHixfUvWaf3vbdmSDgN+AhzQriWyPNa6rb4JBwLLgVYZR66jc82jY9kTeDUiXs/uALkbGNFEHmsbmwJLANTAMDJKb9d8KKupzJF0bJZedOgLax+S5km6uOD67SSpH2mcurOzWsp+7VzMdueaR8eyNfB2wfp8YK92KovVjSbQHegNHJSl1w4j87GkLYEnlMY1Gwq8ExHDASRtVjD0xYiIWJQFlMuBf2njz9IZFY4GAfCTiLgnW14cEQMlfQ84JyJOlXQ9sDwi/rvNS1qBHDzMmq+w2WpvYLykXWh4GJnZpPHIrgAejIjHs/3XGvqizT9J59RYs9X/ZPOZwDFtU5yOxcGjY1kAbFOw3jdLs3YWEX/NahlVwOEUGUYmIl6WNDDbfpmkR4CJFBn6wtpd7TAltUOUWD3u8+hYngZ2kNRf6UU2I4FJ7VwmAyTtRKo1fEADw8hI6gN8EhF3AGNJIyYXHfqiPT6DNamp4YM6FUfUDiQiVkk6kzQ2Vhfg5oh4oZ2L1ZkVtpkLGBURqyVNAB7IhpGpoW4YmV2BsZLWAJ8D/xoRK7PRlX8haTPS/8mfA76u5Ve/z2NKRDR2u+4DwP3ZDRBnRcTjZS1dhfPwJGZmlpubrczMLDcHDzMzy83Bw8zMcnPwqCCSukt6KnsC+QVJF7dFXisfj0XW8Ui6WdLC7F071gB3mFcQpafENo6I5dmTx38CfhART5Qzr5VHNhbZyxSMRQYc57HIKlv2cOdyYHxE7NLe5alUrnlUkEiWZ6vrZ1OUMvZRQ3nbpuTWAI9F1gFFxB+BD9u7HJXOwaPCSOqS3Xu+EJgOPEMa++jbETEIuJk09lGTeSPiyTYptDWk2FhkW7dTWcxalR8SrDARsRoYIKknaeiKHSlx7KP6eSXtEhFutzWzVufgUaEiYqmkx4CjKTL2kaRtSE+8AlwfEdcXyTsUcPBoPx6LzNZZbraqIJKqsloDkjYkdbQ+T5GxjyLi7YgYkE3XN5B3btETWVvxWGS2znLNo7L0Bm7L7tJZD7g3IiZJeoumxz4qlvfBtiu61eexyDomSXeR3hq4paT5wIURcVP7lqry+FZdMzPLzc1WZmaWm4OHmZnl5uBh1gIeUqbjacnwI5KmFFyv67M+xk7JfR5mLeAhZTqelgw/ImnTiPg4u3b3A/dFxN3lKGelc83DrAU8pEzHU2z4EUn/kNUqZkp6PHutcLG8H2eLXYEN6MTXy8HDrIU8pMw6YRzp1bKDgHOAXza0o6SppOu1jFT76JT8nIdZC3lImY5N0ibAPsB92fUC6NbQ/hFxmKTuwATgINIPhk7HwcOslXhImQ5rPWBpRAwoTMw6w2dmq5Mi4ke12yLiM0m/I42S3CmDh5utzFrAQ8p0fFk/xhuSvgPpRgZJu0XE6oLr9SNJm9T2XUnqCgynE18v1zzMWsZDynQwxYYfAY4HfiXph6QbF+4m/QgotDEwSVI30vV6DLieTsq36pqZWW5utjIzs9wcPMzMLDcHDzMzy83Bw8zMcnPwMDOz3Bw8zBohKSTdUbDeVdIiSY3eUitpgKTDC9YvknROC8rRovxmrc3Bw6xxfwd2yR7ig/Qg34IS8g0ADm9qJ7OOysHDrGkPk54mBjgOuKt2g6SNs/dDPCXpWUkjJG0AXAIcK+k5Scdmu+8saYak1yV9v+AY/y5pTjb9W0H6BZJelvQn0nhZZhXDwcOsaXcDI7PB8L4OFI58ewHwaETsCQwBxpKeUP4RcE82tMU92b47AYcBewIXZsOWDAJOBvYC/hEYLWn3LH0kdTWYPcr8Gc1y8fAkZk2IiFmS+pFqHQ/X23wocGRBf0R3YNsGDvVQRKwAVkhaCPQCBgMTI+LvAJL+B9iP9MNuYkR8kqVPasWPZNZiDh5mpZkE/DdpTKQtCtIFfCsiXircWdJeRY6xomB5Nf7/Zx2Ym63MSnMzcHFEzK6XPhU4K3stKZJ2z9KXAT1KOO7jwFGSNpK0MWk498eBP2bpG0rqAXyzNT6EWWtx8DArQUTMj4hfFNl0KamPY5akF7J1SCOu7lyvw7zYcZ8BbgWeIvWl/Doins3S7yGN7DoZeLrVPoxZK/CoumZmlptrHmZmlpuDh5mZ5ebgYWZmuTl4mJlZbg4eZmaWm4OHmZnl5uBhZma5OXiYmVlu/x9kUlnHv6jipAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(result_dict, 'DomainNet', plot_y='acc_tgt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "rising-nashville",
   "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
}