DomainBed/collect_e2e_results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3656a8d8",
   "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 IIDAccuracySelectionMethod, OracleSelectionMethod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eef906af",
   "metadata": {},
   "source": [
    "# Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "565d281f",
   "metadata": {},
   "outputs": [],
   "source": [
    "base_output_dir=\"./checkpoints\"\n",
    "\n",
    "dataset_all = ['PACS', 'VLCS', 'OfficeHome', 'TerraIncognita', 'DomainNet']\n",
    "algorithm_all = {'CondCAD': 'CondCAD'}\n",
    "\n",
    "select_method = OracleSelectionMethod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "129d8f69",
   "metadata": {},
   "source": [
    "# Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "28bd7ecd",
   "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": "0f801139",
   "metadata": {},
   "source": [
    "# Get Results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "203dc1e4",
   "metadata": {},
   "source": [
    "Gollect result dict for each setup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4b98af23",
   "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",
    "                print(output_dir)\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": "code",
   "execution_count": 5,
   "id": "linear-athletics",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading records from: ./checkpoints/PACS/e2e_dombed/CondCAD/lambda_0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4350\n",
      "Loading records from: ./checkpoints/PACS/e2e_dombed/CondCAD/lambda_1e-5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4357\n",
      "Loading records from: ./checkpoints/VLCS/e2e_dombed/CondCAD/lambda_0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4736\n",
      "Loading records from: ./checkpoints/VLCS/e2e_dombed/CondCAD/lambda_1e-5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4418\n",
      "Loading records from: ./checkpoints/OfficeHome/e2e_dombed/CondCAD/lambda_0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4329\n",
      "Loading records from: ./checkpoints/OfficeHome/e2e_dombed/CondCAD/lambda_1e-5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4358\n",
      "Loading records from: ./checkpoints/TerraIncognita/e2e_dombed/CondCAD/lambda_0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4356\n",
      "Loading records from: ./checkpoints/TerraIncognita/e2e_dombed/CondCAD/lambda_1e-5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 4332\n",
      "Loading records from: ./checkpoints/DomainNet/e2e_dombed/CondCAD/lambda_0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 315\n",
      "Loading records from: ./checkpoints/DomainNet/e2e_dombed/CondCAD/lambda_1e-5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total records: 341\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "result_dict = get_result('e2e_dombed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "03e9343c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PACS\n",
      "\tCondCAD_lambda_0\n",
      "\t\tacc_tgt\n",
      "\t\t\t86.33591410627369\n",
      "\t\tacc_src\n",
      "\t\t\t95.16513704448127\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t86.33591410627369\n",
      "\t\tacc_diff\n",
      "\t\t\t8.829222938207579\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.6791788822747292\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.45871507040448006\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.6791788822747292\n",
      "\tCondCAD_lambda_1e-5\n",
      "\t\tacc_tgt\n",
      "\t\t\t86.55205805186893\n",
      "\t\tacc_src\n",
      "\t\t\t95.08893459917446\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t86.55205805186893\n",
      "\t\tacc_diff\n",
      "\t\t\t8.536876547305539\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.9810885154184971\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.8578185763711921\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.9810885154184971\n",
      "VLCS\n",
      "\tCondCAD_lambda_0\n",
      "\t\tacc_tgt\n",
      "\t\t\t77.41422831677936\n",
      "\t\tacc_src\n",
      "\t\t\t83.34467023367367\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t77.41422831677936\n",
      "\t\tacc_diff\n",
      "\t\t\t5.93044191689431\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.43339674909050313\n",
      "\t\tacc_src_std\n",
      "\t\t\t1.0809741926668301\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.43339674909050313\n",
      "\tCondCAD_lambda_1e-5\n",
      "\t\tacc_tgt\n",
      "\t\t\t78.04251944509234\n",
      "\t\tacc_src\n",
      "\t\t\t83.7188189021876\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t78.04251944509234\n",
      "\t\tacc_diff\n",
      "\t\t\t5.6762994570952685\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.298538031227598\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.8008362550358982\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.298538031227598\n",
      "OfficeHome\n",
      "\tCondCAD_lambda_0\n",
      "\t\tacc_tgt\n",
      "\t\t\t65.84778010441134\n",
      "\t\tacc_src\n",
      "\t\t\t80.16764695640651\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t65.84778010441134\n",
      "\t\tacc_diff\n",
      "\t\t\t14.319866851995172\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.32553945841453363\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.24135134449820572\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.32553945841453363\n",
      "\tCondCAD_lambda_1e-5\n",
      "\t\tacc_tgt\n",
      "\t\t\t67.85918532939824\n",
      "\t\tacc_src\n",
      "\t\t\t81.30596963567393\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t67.85918532939824\n",
      "\t\tacc_diff\n",
      "\t\t\t13.446784306275688\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.575790940853746\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.3366381229135932\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.575790940853746\n",
      "TerraIncognita\n",
      "\tCondCAD_lambda_0\n",
      "\t\tacc_tgt\n",
      "\t\t\t52.460940152287975\n",
      "\t\tacc_src\n",
      "\t\t\t86.00896913365709\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t52.460940152287975\n",
      "\t\tacc_diff\n",
      "\t\t\t33.548028981369114\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t1.5838533965565782\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.99365495772129\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t1.5838533965565782\n",
      "\tCondCAD_lambda_1e-5\n",
      "\t\tacc_tgt\n",
      "\t\t\t53.125569377727814\n",
      "\t\tacc_src\n",
      "\t\t\t86.54760329403994\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t53.125569377727814\n",
      "\t\tacc_diff\n",
      "\t\t\t33.42203391631213\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.5588914878421977\n",
      "\t\tacc_src_std\n",
      "\t\t\t1.4540338252186045\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.5588914878421977\n",
      "DomainNet\n",
      "\tCondCAD_lambda_0\n",
      "\t\tacc_tgt\n",
      "\t\t\t40.03782805292275\n",
      "\t\tacc_src\n",
      "\t\t\t55.24246739174009\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t40.03782805292275\n",
      "\t\tacc_diff\n",
      "\t\t\t15.204639338817344\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.8941260606158961\n",
      "\t\tacc_src_std\n",
      "\t\t\t1.4082954710045983\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.8941260606158961\n",
      "\tCondCAD_lambda_1e-5\n",
      "\t\tacc_tgt\n",
      "\t\t\t40.950161281559346\n",
      "\t\tacc_src\n",
      "\t\t\t57.099750657536234\n",
      "\t\tacc_tgt_in\n",
      "\t\t\t40.950161281559346\n",
      "\t\tacc_diff\n",
      "\t\t\t16.149589375976888\n",
      "\t\tacc_tgt_std\n",
      "\t\t\t0.16594064896396712\n",
      "\t\tacc_src_std\n",
      "\t\t\t0.28422488829345144\n",
      "\t\tacc_tgt_in_std\n",
      "\t\t\t0.16594064896396712\n"
     ]
    }
   ],
   "source": [
    "pretty(result_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9fcf8a9",
   "metadata": {},
   "source": [
    "# Plot & Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fcee6a26",
   "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": "interracial-medium",
   "metadata": {},
   "source": [
    "Visualize the results. Note that the results may be slightly different from the paper due to code cleaning. \n",
    "\n",
    "Note that as the claim of our paper, the algorithms in this setup lack access to the information of the target domain, so we don't expect our bottlenecks and other algorithms to necessarily outperform ERM.\n",
    "\n",
    "However, we surprisingly find training our CAD bottleneck (lambda = 1e-5) does lead to consistent improvement over training without (lambda = 0)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc4070f4",
   "metadata": {},
   "source": [
    "## VLCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "296b5549",
   "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(result_dict, plot_dataset='VLCS', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15052766",
   "metadata": {},
   "source": [
    "## PACS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a079371b",
   "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, plot_dataset='PACS', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd6fec1",
   "metadata": {},
   "source": [
    "## OfficeHome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ed62ab7f",
   "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, plot_dataset='OfficeHome', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f525be6",
   "metadata": {},
   "source": [
    "## TerraIncognita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6ca77b17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEeCAYAAACQfIJ4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAh5klEQVR4nO3de5xV5X3v8c9X7gLGS0YiagJqoiVGEEdsFQl4IeCNU20iOdqEpEJoNZeeGqrlVU00npOGJE0be0OSeFTARM14Ui8IR6XWxtugiKiIihiBGMZ4JSgG+PWPZ42zHZ6Z2TCsGWb4vl+v/dp7XZ61ng179nev51nrWYoIzMzMmtujsytgZma7JgeEmZllOSDMzCzLAWFmZlkOCDMzy3JAmJlZVs8yNy5pNfAWsAXYHBG1kq4EJgFbgfXAlIhYlyn7YWAOcDAQwGkRsbq1/X3wgx+MIUOG7My3sNt55plnADj88MM7uSZmLfPndOdZsmTJKxFRk1umMq+DKAKiNiJeqZi3V0S8Wbz+CjAsIqZnyi4GroqIRZIGAFsjYmNr+6utrY36+vqd+RZ2O2PHjgVg8eLFnVoPs9b4c7rzSFoSEbW5ZaUeQeQ0hkOhP+no4H0kDQN6RsSiosyGDqqemZkVyu6DCGChpCWSpjXOlHSVpJeA84DLMuU+Brwu6eeSHpM0S1KP3A4kTZNUL6m+oaGhlDdhZrY7KjsgRkfESGAicKGkMQARMTMiDgbmAhdlyvUETgQuBo4FDgGm5HYQEbMjojYiamtqss1oZma2A0oNiIhYWzyvB+qAUc1WmQuckym6BlgaEasiYjNwKzCyxKqamVkzpQWEpP6SBja+BsYDyyV9tGK1ScCKTPFHgL0lNR4SnAQ8VVZdzcxsW2V2Ug8C6iQ17mdeRCyQdIukw0mnub4ITAeQVAtMj4gLImKLpIuBu5U2sAS4psS6mplZM6UFRESsAoZn5uealIiIeuCCiulFwFFl1c/MzFrnK6nNzCzLAWFmZlkOCDMzy3JAmJlZlgPCzMyyHBBmZpblgDAzsywHhJmZZTkgzMwsywFhZmZZDggzM8tyQJiZWZYDwszMshwQZmaW5YAwM7MsB4SZmWU5IMzMLKvUgJC0WtITkpZKqi/mXSlpWTFvoaTBrZTfS9IaSVeXWU8z65qGDAGp6TFiRNOy446DgQNhzz2hthbuuy+/jbffhpNPhgED0ja++9321WnzZth7b3j++bbXvfVWOOww6NsXxo6FF15oed377oNjj4U+feBDH4J/+If21bMaHXEEMS4iRkREbTE9KyKOiogRwG3AZa2UvRJo4b/VzAzGjIH589Pj7/6uaf7xx8M//iP87d/C0qVwwQX58lu2wL77woQJ27dfCVav3nb+Aw/AoEFw6KGtl3/5ZZg8GfbaC2bNgiVL4POfb3ndiRNh/Xr43vdgxgzYowO+vUu7J3VLIuLNisn+QOTWk3QMMAhYANTm1jEzGzoUTj89HS1U+v734be/hVWr4FvfavkLdcAAuOkmuPZauOWW9tfnzjvTl3lb5s+HTZvg0kvh05+GRx6B669PRx7Nw+Wf/xk2boQf/QhOOAH69Wt/PatRdgYFsFDSEknTGmdKukrSS8B5ZI4gJO0BfA+4uOT6mVkXd9116Vf4/vunL9BGb7wBNTWpqal3b5gzp/372rABXnklPQBeey293rChaZ3GgPj975vWfe21bbfV2Jx04IHp+aCD0vOqVduu+9RT6fkrX0lNZh/5CCxe3P7305ayA2J0RIwEJgIXShoDEBEzI+JgYC5wUabcXwB3RMSatnYgaZqkekn1DQ0NO7PuZraLmzoVfvaz9Mu7d2/40peavngHDICFC1Mz0zvvwGWtNWZX6aKLUujU1KTpkSPT64uKb7Ff/xqefTb1J/zXfzWte/TRbW87sm0pyaZN6Xn48HTk8eqrcP757XorVSm1iSki1hbP6yXVAaN4f5/CXOAO4PJmRf8IOFHSXwADgN6SNkTEJZl9zAZmA9TW1rbyT2xm3c3MmU2vH3ssNSutXJmanXr2hFNPTY+bb4Z7702/5vfbL33h9ugBvXpt3/5mzGj6Yj71VLjhhtTfMLg41WbBghQOffqkL/NFi9L8XJPQ0KHpeU3xM3jt2vR8yCGwdSu8+256Dz17Nq07ZQp86lOpg/qhh1Lw9e27fe9he5QWEJL6A3tExFvF6/HAFZI+GhHPFqtNAlY0LxsR51VsZwpQmwsHM9t9bdhwCGeemTqXt2xJTU39+sEnPgF33ZWOLI4/Hl56CX75y/RFvt9+8OKLTf0Wt92WtjVnTloH4OGH0/TkyekopNKwYenR6IQT0plUjSr7H/bZB045peX6T54Ml1ySOtZ/8xuoq4PRo1P/w+LFMG4cXHghXH116rz+4Q/T0dCzz6ZO92OPLTccoNwjiEFAnaTG/cyLiAWSbpF0OLAVeBGYDiCpFpgeES2ca2Bm1qRXr9fZsgUuvzx14A4bBlddlX7Nr12bfmHPm5d+zY8eDd/5TjrzKGfq1KbXN92UHqecsm1AtGbLlnTEUHkmVWsOOCA1F33963Dxxamv5Cc/ya97zDGpo/pb30qnu44Zk6bLpmit4auLqa2tjfr6+s6uRpc2duxYABZ3RA+Y2Q7aFT+n99+fTqVdsU2byK5N0pKKyxDex1dSm5ntBKNHd71waIsDwszMshwQZmaW5YAwM7MsB4SZmWU5IMzMLMsBYWZmWQ4IMzPLckCYmVmWA8LMzLIcEGZmluWAMDOzLAeEmZllOSDMzCzLAWFmZlkOCDMzy3JAmJlZVqkBIWm1pCckLZVUX8y7UtKyYt5CSYMz5UZIekDSk8W655ZZTzMz21ZHHEGMi4gRFbe0mxURR0XECOA24LJMmY3A5yLi48AE4AeS9u6AupqZWaFnR+8wIt6smOwPbHNT7IhYWfF6naT1QA3weukVNDMzoPyACGChpAD+LSJmA0i6Cvgc8AYwrrUNSBoF9AaeL7muZmZWoewmptERMRKYCFwoaQxARMyMiIOBucBFLRWWdABwPfCFiNjawjrTJNVLqm9oaNj578DMbDdVakBExNrieT1QB4xqtspc4JxcWUl7AbcDMyPiwVb2MTsiaiOitqamZudU3MzMygsISf0lDWx8DYwHlkv6aMVqk4AVmbK9SYFyXUTcXFYdzcysZWX2QQwC6iQ17mdeRCyQdIukw4GtwIvAdABJtcD0iLgA+AwwBthP0pRie1MiYmmJ9TUzswqlBURErAKGZ+Znm5Qioh64oHh9A3BDWXUzM7O2+UpqMzPLckCYmVmWA8LMzLIcEGZmltXhQ22Y2Y4ZcsntnV2FXcbLq34L+N+k0epvn17Kdn0EYWZmWQ4IMzPLckCYmVmWA8LMzLIcEGZmluWAMDOzLAeEmZllOSDMzCzLAWFmZlkOCDMzy3JAmJlZlgPCzMyyHBBmZpZVakBIWi3pCUlLJdUX866UtKyYt1DS4BbKfl7Ss8Xj82XW08zMttURRxDjImJERNQW07Mi4qiIGAHcBlzWvICkfYHLgeOAUcDlkvbpgLqamVmhw5uYIuLNisn+QGRW+xSwKCJejYjXgEXAhI6on5mZJWXfMCiAhZIC+LeImA0g6Srgc8AbwLhMuQOBlyqm1xTztiFpGjAN4MMf/vDOq7mZ2W6u7COI0RExEpgIXChpDEBEzIyIg4G5wEXt2UFEzI6I2oiorampaX+NzcwMKDkgImJt8bweqCP1J1SaC5yTKboWOLhi+qBinpmZdZDSAkJSf0kDG18D44Hlkj5asdokYEWm+F3AeEn7FJ3T44t5ZmbWQcrsgxgE1Elq3M+8iFgg6RZJhwNbgReB6QCSaoHpEXFBRLwq6UrgkWJbV0TEqyXW1czMmiktICJiFTA8Mz/XpERE1AMXVEz/GPhxWfUzM7PWtdnEJOlMSb7i2sxsN1PNF/+5wLOSviPpiLIrZGZmu4Y2AyIizgeOBp4HrpX0gKRpjR3QZmbWPVXVdFRc/XwzcCNwAPDHwKOSvlxi3czMrBNV0wdxlqQ6YDHQCxgVERNJHdB/VW71zMyss1RzFtM5wN9HxH2VMyNio6Q/K6daZmbW2aoJiG8Av26ckNQPGBQRqyPi7rIqZmZmnauaPoibSBe1NdpSzDMzs26smoDoGRHvNk4Ur3uXVyUzM9sVVBMQDZLOapyQNAl4pbwqmZnZrqCaPojpwFxJVwMi3afhc6XWyszMOl2bARERzwN/KGlAMb2h9FqZmVmnq2qwPkmnAx8H+hajsxIRV5RYLzMz62TVXCj3r6TxmL5MamL6NPCRkutlZmadrJpO6uMj4nPAaxHxTeCPgI+VWy0zM+ts1QTEO8XzRkmDgd+TxmMyM7NurJo+iH+XtDcwC3gUCOCaMitlZmadr9WAKG4UdHdEvA7cIuk2oG9EvFHNxiWtBt4iXX29OSJqJc0CzgTeJQ0h/oVi+83L/iXpDnMBPFGs907z9czMrBytNjFFxFbgnyqmN1UbDhXGRcSIiKgtphcBR0bEUcBK4NLmBSQdCHwFqI2II4EewOTt3K+ZmbVDNX0Qd0s6R43nt7ZTRCyMiM3F5IPAQS2s2hPoJ6knsCewbmfs38zMqlNNQHyJNDjfJklvSnpL0ptVbj+AhZKWSJqWWf5F4M5tCkWsBb4L/Io0kuwbEbEwt4Pi7nb1kuobGhqqrJaZmbWlmluODoyIPSKid0TsVUzvVeX2R0fESGAicKGkMY0LJM0ENgNzmxeStA8wCRgKDAb6Szq/hfrNjojaiKitqampslpmZtaWNs9iqvxSr9T8BkItrLO2eF5f3JVuFHCfpCnAGcDJERGZoqcAL0REQ1GHnwPHAze0tU8zM9s5qjnN9esVr/uSvuSXACe1VkhSf2CPiHireD0euELSBGAG8MmI2NhC8V+Rxn/aE3gbOBmor6KuZma2k1TTxHRmxeNU4EjgtSq2PQi4X9LjwMPA7RGxALgaGAgskrS0GMoDSYMl3VHs8yHgZtJ1F08U9Zy9/W/PdtSQISA1PUaMSPOffRbGjYP99oOBA+HUU+H55/PbWL36/duQ4Gtf2/E6rV8Pe+4JG1v6WVF4+204+WQYMCDt87vfbX395cvhpJOgX7/0vmbM2PE6mnUnVQ3W18wa4A/aWikiVgHDM/MPa2H9dcBpFdOXA5fvQP1sJxkzBv78z9PrffZJz2vXwtat8M1vwsqV8MMfwgUXwL33tryd6dPhk59Mrw8/vPV9rl4NQ4dCruHxrrvgxBNTSLRmyxbYd1+YMAFuuaX1dd9+O6339ttwxRVp26/4bidmQHV9ED8knY0E6Zf8CNIve+vmhg6F009PRwqNjj8e/uM/mqbnzoUnn2x9O7W1cNZZbX+xt+XOO2HixLbXGzAAbroJrr227YCYPz+F3jXXwHnnpaMIM0uqOc21ntTnsAR4APjriMieUWTdy3XXwV57wf77w49+lOb1rrjZbH09vPpqOtJozdSp0L8/fPzj8OCD+XXeeCP9cn+taLx85ZX0aGxO2roVFi5MAbFpU9PyN7b3ss1mnnoqPX//+ynAamrgZz9r3zbNuotqAuJm4IaI+L8RMRd4sOg8tm5s6tT0RXn99SkUvvQleOGFpuUrVqSjgiFDUjNTTv/+qSnq1ltTP8DKlelXes6kSenLeeTINF1Tkx7f+U6afvhh+MAHUhPV/PlNyydNat/73LQpPR9wQDra6NMHpkyBt95q33bNuoNq+iDuJp122ngnuX7AQtJpp9ZNzZzZ9Pqxx9Iv7JUrU7PTU0+lTt2+feGee9KXK6R+g02boEcP6NUrfYFfdlnTdubNg0cfhXfeSWUrfe976ejhN7+B88+HRYvS/EMOSc+VzUuf+lTT8sa+kWo1r+PQoWn+Zz4DZ5+dmqZuvBHWrWu7v8Ssu6smIPpW3mY0Ijb4CKJ727DhEM48M3XebtmSmpr69YNPfAJeeimdxfTb38K3vgUPPZQekyfDiy829Vvcdltq13/kETjuOFi1CpYuheHDtw0HgGOOSc+rV6fnU055//I774TLi1MWDjigKZRaMmcO/PKX6fXDD6fpyZNTs1RlHSdPhr/5G/jJT2CPPeDuu+HAA+HQQ3f0X8+s+6gmIH4naWREPAog6RjStQnWTfXq9TpbtqQv5I0bYdgwuOoqGDwYFi9Op5sCXFoxzOLkzFCKH/tY6ruYPx969kyB84MfbH99GhpSR/hJrV55835Tpza9vumm9GgeOpDe07x58PWvw1e/mk7nvfrqVF+z3V01fwZfA26StI50y9EPkW5Bat1Unz6vcscd+WVjx+ZPQYXUH1G57JOfbLlTuiXNtwFNp7duzxlGLdUxt+zss9PDzN6vzYCIiEckHQE0tsg+ExG/L7daZk3OPz89zKxjtXkWk6QLgf4RsTwilgMDJP1F+VUzM7POVM1prlMr7/gWEa8BU1te3czMuoNqAqJH5c2CJPUAereyvpmZdQPVdFIvAH4q6d+K6S+RucmPmZl1L9UExF8D04DpxfQy0plMZmbWjVUz3PdW4CFgNeleECcBT5dbLTMz62wtHkFI+hjw2eLxCvBTgIgY1zFVMzOzztRaE9MK4D+BMyLiOQBJf9khtTIzs07XWhPT2cCvgXslXSPpZNKV1GZmthtoMSAi4taImAwcAdxLGnJjf0n/Iml8NRuXtFrSE8WtReuLebMkrZC0TFKdpL1bKLu3pJuLdZ+W9Efb++bMzGzHVdNJ/buImBcRZwIHAY+Rzmyq1riIGBERtcX0IuDIiDgKWAlc2kK5fwAWRMQRpFuXumPczKwDVXOh3Hsi4rWImB0RJ+/oDiNiYURsLiYfJIXO+0j6ADAG+FFR5t3Kq7nNzKx82xUQOyCAhZKWSJqWWf5F8hfdDQUagJ9IekzSHEn9czuQNE1SvaT6hoaGnVdzM7PdXNkBMToiRgITgQslvXf3Ykkzgc3A3Ey5nsBI4F8i4mjgd8AluR0URzS1EVFbU1Oz09+AmdnuqtSAiIi1xfN6oI50oR2SpgBnAOdFZEfuXwOsiYiHiumbSYFhZmYdpLSAkNRf0sDG18B4YLmkCcAM4KyI2JgrGxEvAy9JarwHxcnAU2XV1czMtlXmjRUHAXXFQLA9gXkRsUDSc0AfYFGx7MGImC5pMDAnIk4ryn8ZmCupN7AK+EKJdTWzLuRD//PbnV2F3UJpARERq0inpzaff1gL668DTquYXgrU5tY1M7Pyld1JbWZmXZQDwszMshwQZmaW5YAwM7MsB4SZmWU5IMzMLMsBYWZmWQ4IMzPLckCYmVmWA8LMzLIcEGZmluWAMDOzrDJHc+1Shlxye2dXYZfw8qrfAv73qLT626d3dhXMOoWPIMzMLMsBYWZmWQ4IMzPLckCYmVlWqZ3UklYDbwFbgM0RUStpFnAm8C7wPPCFiHi9hfI9gHpgbUScUWZdzczs/TriCGJcRIyIiMbbhy4CjoyIo4CVwKWtlP0q8HTZFTQzs211eBNTRCyMiM3F5IPAQbn1JB0EnA7M6ai6mZlZk7IDIoCFkpZImpZZ/kXgzhbK/gCYAWxtbQeSpkmql1Tf0NDQrsqamVmTsgNidESMBCYCF0oa07hA0kxgMzC3eSFJZwDrI2JJWzuIiNkRURsRtTU1NTux6mZmu7dSAyIi1hbP64E6YBSApCnAGcB5ERGZoicAZxWd3DcCJ0m6ocy6mpnZ+5UWEJL6SxrY+BoYDyyXNIHUdHRWRGzMlY2ISyPioIgYAkwG7omI88uqq5mZbavM01wHAXWSGvczLyIWSHoO6AMsKpY9GBHTJQ0G5kTEaSXWyczMqlRaQETEKmB4Zv5hLay/DtgmHCJiMbB4J1fPzMza4CupzcwsywFhZmZZDggzM8tyQJiZWZYDwszMshwQZmaW5YAwM7MsB4SZmWU5IMzMLMsBYWZmWQ4IMzPLckCYmVmWA8LMzLIcEGZmluWAMDOzLAeEmZllOSDMzCyr1ICQtFrSE5KWSqov5s2StELSMkl1kvbOlDtY0r2SnpL0pKSvlllPMzPbVkccQYyLiBERUVtMLwKOjIijgJXApZkym4G/iohhwB8CF0oa1gF1NTOzQoc3MUXEwojYXEw+CByUWefXEfFo8fot4GngwI6rpZmZlR0QASyUtETStMzyLwJ3trYBSUOAo4GHWlg+TVK9pPqGhob21tfMzAplB8ToiBgJTCQ1E41pXCBpJqkpaW5LhSUNAG4BvhYRb+bWiYjZEVEbEbU1NTU7t/ZmZruxUgMiItYWz+uBOmAUgKQpwBnAeRERubKSepHCYW5E/LzMepqZ2bZKCwhJ/SUNbHwNjAeWS5oAzADOioiNLZQV8CPg6Yj4fll1NDOzlpV5BDEIuF/S48DDwO0RsQC4GhgILCpOf/1XAEmDJd1RlD0B+FPgpGKdpZJOK7GuZmbWTM+yNhwRq4DhmfmHtbD+OuC04vX9gMqqm5mZtc1XUpuZWZYDwszMshwQZmaW5YAwM7MsB4SZmWU5IMzMLMsBYWZmWQ4IMzPLckCYmVmWA8LMzLIcEGZmluWAMDOzLAeEmZllOSDMzCzLAWFmZlkOCDMzy3JAmJlZVqkBIWm1pCeKW4bWF/NmSVohaZmkOkl7t1B2gqRnJD0n6ZIy62lmZtvqiCOIcRExIiJqi+lFwJERcRSwEri0eQFJPYB/AiYCw4DPShrWAXU1M7NChzcxRcTCiNhcTD4IHJRZbRTwXESsioh3gRuBSR1VRzMzKz8gAlgoaYmkaZnlXwTuzMw/EHipYnpNMW8bkqZJqpdU39DQ0O4Km5lZUnZAjI6IkaSmogsljWlcIGkmsBmY254dRMTsiKiNiNqampr21dbMzN5TakBExNrieT1QR2o6QtIU4AzgvIiITNG1wMEV0wcV88zMrIOUFhCS+ksa2PgaGA8slzQBmAGcFREbWyj+CPBRSUMl9QYmA78oq65mZratniVuexBQJ6lxP/MiYoGk54A+wKJi2YMRMV3SYGBORJwWEZslXQTcBfQAfhwRT5ZYVzMza6a0gIiIVcDwzPzDWlh/HXBaxfQdwB1l1c/MzFqnfBdA1ySpAXixs+vRDXwQeKWzK2HWBn9Od46PRET2DJ9uFRC2c0iqr7iw0WyX5M9p+TwWk5mZZTkgzMwsywFhObM7uwJmVfDntGTugzAzsywfQZiZWZYDoguT9CFJN0p6vhgQ8Q5JH2vnNsdKuq1iemIxGOJTkh6T9L1m6y+VdGOzeddKekHS45JWSrpOUm7UXuvm/Bnt2hwQXZTSZeh1wOKIODQijiHdW2PQTtzHkcDVwPkRMQyoBZ6rWP4HpCvdTyyGU6n09YgYDhwOPAbcUwybYrsJf0a7PgdE1zUO+H1E/GvjjIh4HLi/uGvf8uJufufCe7+6Fku6ubij39ziD7jx7n0rJD0KnF2xjxnAVRGxotj+loj4l4rlnwWuBxbSwv06Ivl74GXSqL62+/BntItzQHRdRwJLMvPPBkaQhjk5BZgl6YBi2dHA10h36TsEOEFSX+Aa4EzgGOBDVeyj0bmkmznNJ/0htuZR4Ig21rHuxZ/RLs4B0f2MBuYXv6R+A/wHcGyx7OGIWBMRW4GlwBDSH8QLEfFsMfT6DdXsRFIt8EpE/Aq4Gzha0r6tFdmhd2PdkT+jXYQDout6kvRrantsqni9hbYHa2xtH58FjpC0Gnge2As4p5VtHQ08XV01rZvwZ7SLc0B0XfcAfSpv5SrpKOB14FxJPSTVAGOAh1vZzgpgiKRDi+nKw/BZwN80nnUiaQ9J0yXtAXwG+EREDImIIaT23W0O4ZV8BTgAWLBjb9W6KH9GuzgHRBdVHGr/MXBKcQrhk8D/AeYBy4DHSX+gMyLi5Va28w4wDbi96ABcX7FsGak9eL6kp4HlpHbhE4G1xRDtje4DhlW0Jc+S9DiwktR8MC4i3m3/O7euwp/Rrs9XUpuZWZaPIMzMLMsBYWZmWQ4IMzPLckB0M5I27KTtfEPSxVWsd62kP9kZ+7Tdgz+jXYcDwszMshwQ3ZSkAZLulvRoMd7NpGL+kGJMm2uLUSznSjpF0n9JelbSqIrNDJf0QDF/alFekq6W9Iyk/w/sX7HPyyQ9UoyxM7txHB2zHH9Gu4CI8KMbPYANxXNPYK/i9QdJI1yKNHTBZuATpB8IS4AfF8smAbcWZb5BOk+9X1H+JWAwaRydRaQRMgeTLnr6k6LMvhX1uB44s7P/PfzY9R7+jHadR1uXsVvXJeB/SxoDbAUOpGmY5Rci4gmA4uKluyMiJD1B+uNs9P8i4m3gbUn3AqNIV73Oj4gtwDpJ91SsP07SDGBPYF/SMAj/Xto7tK7On9FdnAOi+zoPqAGOiYjfF+PR9C2WVY53s7Vieivv/0w0v4qyxasqlUbc/GegNiJekvSNiv2Z5fgzuotzH0T39QFgffGHNw74yA5sY5KkvpL2A8YCj5CGK2gcR+cA0pj/0PSH9oqkAYDPGrG2+DO6i/MRRPc1F/j34pC8njTg2fZaBtxLat+9MiLWSaoDTgKeAn4FPAAQEa9LuoY0Fs7LpD9Us9b4M7qL81hMZmaW5SYmMzPLckCYmVmWA8LMzLIcEPY+kiYUV6A+J+mSzq6P7V4k/VjSeknLd6Ds4uKzu7R47N92KWuNA8LeI6kH8E/ARGAY8FlJwzq3VrabuRaY0I7y50XEiOKxvu3VrTUOCKs0CnguIlZFuvXijaShDcw6RETcB7xaOU/SoZIWSFoi6T8lHdFJ1dvtOCCs0oGk8WwarSnmmXWm2cCXI+IY4GLS1dAt+UnRvPS3Hoiv/XyhnJntsoorno8Hbqr4vu/TwurnRcRaSQOBW4A/Ba4rv5bdlwPCKq0FDq6YPqiYZ9ZZ9gBej4gRlTOL/rIlxeQvIuKyiFgLEBFvSZpHajJ1QLSDm5is0iPARyUNldQbmAz8opPrZLuxiHgTeEHSp+G9ez0Mj4gtFZ3Rl0nqKemDxTq9gDNIQ2pYOzgg7D0RsRm4CLgLeBr4WUQ82bm1st2JpPmksZMOl7RG0p+RRn39M0mPk4bnzp040Qe4S9IyYCnpyPeajql19+WxmMzMLMtHEGZmluWAMDOzLAeEmZllOSDMzCzLAWFmZlkOCLNWSApJN1RM95TUIOm2NsqNkHRaxfQ3JF3cjnq0q7zZjnBAmLXud8CRkvoV06dS3dXlI4DT2lrJbFfmgDBr2x3A6cXrzwLzGxdI6l/cw+BhSY9JmlRchX4FcG4xcNy5xerDinsWrJL0lYpt/C9Jy4vH1yrmz5S0UtL9wOFlv0mz5hwQZm27EZgsqS9wFPBQxbKZwD0RMQoYB8wCegGXAT8thoL4abHuEcCnSGMEXS6pl6RjgC8AxwF/CEyVdHQxfzJNRyLHlvwezbbhwfrM2hARyyQNIR093NFs8XjgrIr+gb7Ah1vY1O0RsQnYJGk9MAgYDdRFxO8AJP0cOJH0460uIjYW8z0mlnU4B4RZdX4BfBcYC+xXMV/AORHxTOXKko7LbGNTxest+O/PdnFuYjKrzo+Bb0bEE83m3wV8ufHmNJKOLua/BQysYrv/CfwPSXtK6g/8cTHvvmJ+v+L+BmfujDdhtj0cEGZViIg1EfGPmUVXkvoclkl6spgGuJfUKV3ZSZ3b7qOk+zA/TOrbmBMRjxXzfwo8DtxJGordrEN5NFczM8vyEYSZmWU5IMzMLMsBYWZmWQ4IMzPLckCYmVmWA8LMzLIcEGZmlvXfYSFrw7pK4yUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(result_dict, plot_dataset='TerraIncognita', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de1fb526",
   "metadata": {},
   "source": [
    "# DomainNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "26cf40ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEeCAYAAACdYvI/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAguUlEQVR4nO3deZxWZf3/8ddbUHDNhTGRscalNNwwJurnimiFomKJCT8U8+uSufYl13pkSraoFebXsq+aS6ng9jNxQfSrYOW30hlBhDBFwAAXBhM1F1T4/P64zsTNzD0z95nhnvX9fDzOY+5znXOdcx0e98yb61xnUURgZmZWqvU6ugFmZta1ODjMzCwXB4eZmeXi4DAzs1wcHGZmlouDw8zMcund0Q1oD/369YuqqqqOboaZWZdSW1u7PCIqGpb3iOCoqqqipqamo5thZtalSHqpWLlPVZmZWS4ODjMzy8XBYWZmuTg4zMwsFweHmZnl4uAwM7NcHBxmZpaLg8PMzHJxcJiZWS4ODjMzy8XBYWZmuTg4zMwsFweHmZnl4uAwM7NcHBxmZpaLg8PMzHJxcJiZWS5lDw5JvSTNlHR/Nn+GpPmSQlK/JuoMkvRnSXMlzZZ0TMGymyQtlDQrmwaV+xjMzGyN9nh17NnAPGCzbP4J4H5gRjN13gXGRcQLkrYFaiVNi4gV2fJzI+KuMrXXzMyaUdYeh6RKYARwfX1ZRMyMiEXN1YuI5yPihezzy8AyoNEL083MmvL++7DzziDBGWesKf/xj+ETn0jlu+3W/DbmzYO994Y+fdK2Hn64bW3abTd49NGW13viCdhjj7Tfz34Wnn66+HpTpqTlm24K/frBf/wHvPde29pYinKfqroSOA9Y3doNSBoCbAC8WFD8w+wU1kRJfdrWRDPrjiZMgCVLGpd/+CEce2xp2xgzBp57Dn7+c1h/fTj6aHjzzebrVFXBjBmNyxcvhpdegv32a77+++/DUUfB22/DxInw2mswahSsWtV43WeegYEDU/sGD4Ybb4TLLy/t2NqibMEh6TBgWUTUtmEb/YHfASdERH34XAjsAnwO2BI4v4m6p0iqkVRTV1fX2iaYWRc0e3b6o3vJJY2XXXQR/OhHLW9j5sz0h3nMGDj9dBg/Ht56C+5q5UnyqVPhoINggw1aXu+11+C009J04omwcGHxMDr/fLjlFjj5ZPjpT1PZ3Lmta18e5exx7AMcIWkRMBkYJumWUitL2gx4APhuRPylvjwiXolkJXAjMKRY/Yi4NiKqI6K6osJnucx6itWr4aST0h/76urWb2fhwvRzwID0s7Iy/VywoPG6774Ly5enafXq1CtZvnzt3snUqXDIIWl5/brLl7dtv4UhNG1a+rn//qUdX1uULTgi4sKIqIyIKmA08FhElNRBlLQBcA/w24aD4FkvBEkCjgTmrMt2m1nXduONsGgRjBsHS5emsjffhLaeeIhoetnll0NFRZoWL4Yjj0yfR45Myz/8MI1tHHoo/OMfa9Yt5f+0ze233t13w3e+k7b/zW+WdDht0h5XVa1F0lmkcY9tgNmSHoyIkyRVA6dGxEnA14D9ga0kfT2r+vWImAXcKqkCEDALOLWdD8HMOrHFi1NI7LnnmrJbbkkDzddf33Q9gA8+SD2Cvn1h++1TWf04SX0I7bBD43rjxsG++6bPxx4L556b9r/FFqnsT39KA/LbbZfGMB55pOk2NLffCFi5Enr1SmMuAHfcAWPHwrBhKUB69Wr+GNeJiOj20+DBg8PMeoa5cyPuvDNNF18cARHDh0fU1KTljz8ecd11qXzbbdPn2tq07IADUnldXZrfY4+ILbaIuPrqiF13jdh004g33mh+/5/8ZMT06WuXnXtuxDnnlNb+996L2HrriKqqiF/9KrWxqirio48iFi5M7RsxIq17//0RvXpF9OsXceONEZMmRTz6aGn7KQVQE0X+pvrOcTPrVgYOTFchjRoFBxyQynbcMV11BHDDDWkwGeDll9PnKVOKb+u229JluOPHp97IHXfA5pvnb9PUqek0Uin69oU774RNNoGzz4att07zxXoSTz2VrrZavhxOOCEN5E+YkL99eSlKOYHWxVVXV0dNTU1HN8PMeqAlS1KYvf76mtNLXYWk2ohodIlBu49xmJn1JJWV6TLe7sSnqszMLBcHh5mZ5eLgMDOzXBwcZmaWi4PDzMxycXCYmVkuDg4zM8vFwWFm3cbQoUMZOnRoRzej23NwmJlZLg4OMzPLxcFhZma5ODjMzCwXB4eZmeXi4DAzs1wcHGZmlouDw8zMcil7cEjqJWmmpPuz+TMkzZcUkvo1U+94SS9k0/EF5YMlPZtt4ypJKvcxmJnZGu3R4zgbmFcw/wRwMPBSUxUkbQl8H/g8MAT4vqQtssXXACcDn8qm4WVos5mZNaGswSGpEhgBXF9fFhEzI2JRC1W/DDwSEf+MiDeAR4DhkvoDm0XEXyK9LP23wJFlabyZmRVV7h7HlcB5wOqc9QYAiwvml2RlA7LPDcvNzKydlC04JB0GLIuI2nLto4X9nyKpRlJNXV1dRzTBzKxbKmePYx/gCEmLgMnAMEm3lFh3KbBdwXxlVrY0+9ywvJGIuDYiqiOiuqKiIm/bzcysCWULjoi4MCIqI6IKGA08FhHHllh9GvAlSVtkg+JfAqZFxCvAW5K+kF1NNQ64txztNzOz4tr9Pg5JZ0laQuotzJZ0fVZeXf85Iv4J/AB4KpsmZGUAp5EG2+cDLwJT2/kQzMx6tN7tsZOImAHMyD5fBVxVZJ0a4KSC+RuAG5pYb7cyNdXMzFrgO8fNzCyXdulxmFn5VF3wQEc3odN4dcHrgP9N6i36yYiybNc9DjMzy8XBYSUbOnQoQ4cO7ehmmFkHc3CYmVkuDg4zM8vFwWFmZrk4OMzMLBcHh5mZ5eLgMDOzXBwcZmaWi4PDzMxycXCYmVkuDg4zM8vFwWFmZrk4OMzMLBcHh5mZ5eLgMDOzXBwcZmaWi4PDzMxyKfurYyX1AmqApRFxmKTtgcnAVkAtcFxEfNCgzljg3IKiPYDPRsQsSTOA/sB72bIvRcSyMh+GmXUB2/zfn3R0E3qE9uhxnA3MK5i/DJgYETsBbwAnNqwQEbdGxKCIGAQcByyMiFkFq4ytX+7QMDNrX2UNDkmVwAjg+mxewDDgrmyVm4EjW9jMGFIPxczMOoFy9ziuBM4DVmfzWwErIuKjbH4JMKCFbRwDTGpQdqOkWZK+l4WRmZm1k7IFh6TDgGURUduGbXweeDci5hQUj42I3YH9sum4JuqeIqlGUk1dXV1rm2BmZg2Us8exD3CEpEWkU03DgF8Am0uqH5SvBJY2s43RNOhtRMTS7OfbwG3AkGIVI+LaiKiOiOqKioq2HIeZmRUoW3BExIURURkRVaQAeCwixgLTgVHZascD9xarL2k94GsUjG9I6i2pX/Z5feAwYE6x+mZmVh4dcR/H+cB4SfNJYx6/AZB0hKQJBevtDyyOiAUFZX2AaZJmA7NIvZXr2qXVZmYGtMN9HAARMQOYkX1eQJHTSxExBZjSoM4XGqzzDjC4fC01M7OW+M5xMzPLxcFhZma5ODjMzCyXFoND0uHZFU5mZmYl9TiOAV6QdLmkXcrdIDMz69xaDI6IOBbYC3gRuEnSn7O7sjcte+vMzKzTKekUVES8RXow4WTSI82/Ajwt6cwyts3MzDqhUsY4jpB0D+k+jPWBIRFxCLAn8O3yNs/MzDqbUm4APIr0/ow/FBZGxLuSGr1Lw8zMurdSguNi4JX6GUkbAh+PiEUR8Wi5GmZmZp1TKWMcd7LmfRoAq7IyMzPrgUoJjt6F7wTPPm9QviaZmVlnVkpw1Ek6on5G0khgefmaZGZmnVkpYxynArdKuhoQsBgYV9ZWmZlZp9VicETEi8AXJG2Szf+r7K0yM7NOq6T3cUgaAewK9JUEQERMaLaSmZl1S6XcAPhr0vOqziSdqjoa+GSZ22VmZp1UKYPje0fEOOCNiLgE+D/Ap8vbLDMz66xKCY73s5/vStoW+JD0vCozM+uBSgmO+yRtDlwBPA0sAm4rdQeSekmaKen+bH57SX+VNF/S7ZIa3RMiqUrSe5JmZdOvC5YNlvRsVv8q1Q+6mJlZu2g2OLIXOD0aESsi4m7S2MYuEXFRjn2cDcwrmL+M9OyrnYA3gKaed/ViRAzKplMLyq8BTgY+lU3Dc7TFzMzaqNngiIjVwC8L5ldGxJulblxSJTACuD6bFzCM9Ih2gJuBI3Nsrz+wWUT8JSIC+G2e+mZm1nalnKp6VNJRrTwldCVwHmuedbUVsCIiPsrmlwADmqi7fXaK63FJ+2VlA7I69Zqrb2ZmZVBKcHyD9FDDlZLekvS2pLdaqiTpMGBZRNS2ol2vAJ+IiL2A8cBtkjbLs4HsLYU1kmrq6upa0QQzMyumlDvHW/uK2H2AIyQdCvQFNgN+AWwuqXfW66gElhbZ50pgZfa5VtKLpEuAl2Z16hWtn9W7FrgWoLq6Olp5DGZm1kApNwDuX2xqqV5EXBgRlRFRBYwGHouIscB0YFS22vHAvUX2WSGpV/Z5B9Ig+IKIeAV4S9IXslNn44rVNzOz8inlkSPnFnzuCwwBakmD3K1xPjBZ0qXATOA3kF5RC1RnV2ztD0yQ9CFpfOTUiPhnVv804CZgQ2BqNpmZWTsp5VTV4YXzkrYjDXqXLCJmkN5ZTkQsIIVPw3WmAFOyz3cDdzexrRpgtzz7NzOzdaeUwfGGlgCfWdcNMTOzrqHFHoek/wLqB5fXAwaR7iA3M7MeqJQxjpqCzx8BkyLiiTK1x8zMOrlSguMu4P2IWAX/fvbURhHxbnmbZmZmnVFJd46TrmCqtyHwP+VpjpmZdXalBEffwtfFZp83Kl+TzMysMyslON6R9Nn6GUmDgffK1yQzM+vMShnj+BZwp6SXSa+O3Yb0KlkzM+uBSrkB8ClJuwA7Z0V/j4gPy9ssMzPrrEp5VtXpwMYRMSci5gCbSDqt/E0zM7POqJQxjpMjYkX9TES8QXoDn5mZ9UClBEevwpc4ZU+tbfSecOtZ3n8fdt4ZJDjjjDXl8+bB3ntDnz5p+cMPN72N3/8edtoJ+vaFoUNh4cLWt2fZMthoI3i3hLuL/vu/obISNtwQRo6E118vvt7LL6flm20GAwbANde0vn1m3UkpwfEQcLukgyQdBEzCT6Tt8SZMgCVLGpePGQPPPQc//zmsvz4cfTS8WeRlw6++CqNHpz/KV1wBtbVw/PHN73PRohRUxUybBvvtl8KjOTNnwqmnwmc+A5dcAg88AP/5n8XX/cY34L774Pvfh913h9NOS+006+lKCY7zgceAU7PpWda+IdB6mNmzYeLE9Ie30MyZ8MwzKTxOPx3Gj4e33oK77mq8jUmTYOVKuPBCOPNM+MpX4I9/hBdfbF2bpk6FQw5peb2bbko/f/QjOO+81DuaNCn1oBp6/HHYcUf49rfXhMvNN7eufWbdSYvBERGrgb8Ci0iPQx8GzCtvs6yzihAnnZSCobp67WX1p5oGZG+Br8ze1bhgQePt5Fn3zTdh+XJ44400v3x5mupPS61enU6JHXJICqP65cV6OsX2+9FHsHhx43UrKtLpqtmzYcaMteub9WRNBoekT0v6vqTngP8C/gEQEQdGxNXt1UDrXF599RAWLYJx42Bp9tLeN9+EYq91jxwv7G1u3ZEj0x/xz2a3oVZUpOnyy9P8k0/Cxz6WxlQmTVqzfOTItu33sstSKO25J/zyl6msb9/SjsesO2vuPo7ngD8Ch0XEfABJTZwNtp5i5cqtqatLf0zr3XJLGgw//fQ0Xz/2UR8sO+yQfr7/Pqy3HmywAWy/ffPrFvrZz1Jv47XX4Nhj4ZFH1l638DTVl7+8ZvkWWzTeVuF+t9027bd3b9huO1i1Cj78MI3N9OoFo0bBAQfA/Plp/yNGwMCBpf9bmXVXzQXHV0nvCp8u6SFgMunOcevBKiqm89Offh2AuXPh4oth+HD45jdhr71gjz1g8mTYddd0FdKmm8JRR6W6G26YyufMSQPjF1yQ/lf/2mtwzz2w775pTKGhwYPTz0WL0s+DD157+dSpaQAboH//NDVl3Di46ir47nfhi1+E//3fNCbTt28a/zjhhDRYf845cPvtqW0bbJDCa6ON0nGa9XRNnqqKiN9HxGhgF2A66dEjW0u6RtKX2ql91slsvPFLjBq15n/jkP7Y1/9xv+22dMpo/Hj44AO44w7YfPPG2+nfP51WWrEi/ZHea681A9d51NWlABs2rLT1Bw9Op53+9je46KLUU5k4sfi677wDl14KZ52Vrv568EHYZpv8bTTrbhQ5TkRL2gI4GjgmIg4qW6vWserq6qipqWl5RWvW0KFDAZhRP1LcCdxyS5oeeqijW9Jxqi54oKObYJ3Uop+MaFN9SbURUd2wPNc7xyPijYi4Nk9oZC9+minp/mx+e0l/lTRf0u2SGt1MKOmLkmolPZv9HFawbIakv0ualU1b5zkG616OPbZnh4ZZR8gVHK10NmtfvnsZMDEidgLeAE4sUmc5cHhE7A4cD/yuwfKxETEom5aVo9FmZlZcWYNDUiUwArg+mxfpPpD6W8JuBo5sWC8iZkbEy9nsXGBDSX3K2VYzMytNuXscVwLnAauz+a2AFRHxUTa/BBjQwjaOAp6OiJUFZTdmp6m+V/gcLTMzK7+yBYekw4BlEdHqp/tI2pV0ausbBcVjs1NY+2XTcU3UPUVSjaSaumJ3p5mZWauUs8exD3CEpEWke0CGAb8ANpdUf/9IJbC0WOXsNNc9wLiI+PcTjCJiafbzbeA20mNQGskG8asjorqiomLdHJGZmZUvOCLiwoiojIgq0o2Ej0XEWNI9IaOy1Y4H7m1YV9LmwAPABRHxREF5b0n9ss/rA4cBc8p1DGZm1lh7XFXV0PnAeEnzSWMevwGQdISkCdk6ZwA7ARc1uOy2DzBN0mxgFqm3cl17H4CZWU/W4jvH14WImAHMyD4voMjppYiYAkzJPl8KXNrE5gaXpZFmZlaSjuhxmJlZF+bgMDOzXBwcZmaWi4PDzMxycXCYmVkuDg4zM8vFwWFmZrk4OMzMLBcHh5mZ5eLgMDOzXBwcZmaWi4PDzMxycXCYmVkuDg4zM8vFwWFmZrk4OMzMLBcHh5mZ5eLgMDOzXBwcZmaWS9nfOS6pF1ADLI2IwyRtD0wGtgJqgeMi4oMi9S4ETgRWAWdFxLSsfDjwC6AXcH1E/KSc7a+64IFybr5LeXXB64D/Teot+smIjm6CWYdojx7H2cC8gvnLgIkRsRPwBikc1iJpIDAa2BUYDvxKUq8shH4JHAIMBMZk65qZWTspa3BIqgRGANdn8wKGAXdlq9wMHFmk6khgckSsjIiFwHxgSDbNj4gFWS9lcraumZm1k3L3OK4EzgNWZ/NbASsi4qNsfgkwoEi9AcDigvn69ZoqNzOzdlK24JB0GLAsImrLtY8W9n+KpBpJNXV1dR3RBDOzbqmcg+P7AEdIOhToC2xGGtTeXFLvrNdRCSwtUncpsF3BfOF6TZWvJSKuBa4FqK6ujjYch5mZFShbjyMiLoyIyoioIg10PxYRY4HpwKhsteOBe4tUnwKMltQnuwrrU8CTwFPApyRtL2mDbLtTynUMZmbWWEfcx3E+MF7SfNKYx28AJB0haQJARMwF7gD+BjwEnB4Rq7JeyhnANNKVWndk65qZWTsp+30cABExA5iRfV5Aujqq4TpTKOg9RMQPgR8WWe9B4MEyNdXMzFrgO8fNzCwXB4eZmeXi4DAzs1wcHGZmlouDw8zMcnFwmJlZLg4OMzPLxcFhZma5ODjMzCwXB4eZmeXi4DAzs1wcHGZmlouDw8zMcnFwmJlZLg4OMzPLxcFhZma5ODjMzCwXB4eZmeXi4DAzs1wcHGZmlkvZgkNSX0lPSnpG0lxJl2TlwyQ9LWmOpJsl9S5S90BJswqm9yUdmS27SdLCgmWDynUMZmbWWKM/2uvQSmBYRPxL0vrAnyRNA24GDoqI5yVNAI4HflNYMSKmA4MAJG0JzAceLljl3Ii4q4xtNzOzJpStxxHJv7LZ9bNpFfBBRDyflT8CHNXCpkYBUyPi3fK01MzM8ijrGIekXpJmActIIfEk0FtSdbbKKGC7FjYzGpjUoOyHkmZLmiipTxP7PkVSjaSaurq61h+EmZmtpazBERGrImIQUAkMAXYlBcFESU8Cb5N6IUVJ6g/sDkwrKL4Q2AX4HLAlcH4T+742IqojorqiomIdHI2ZmUE7XVUVESuA6cDwiPhzROwXEUOAPwDPN1P1a8A9EfFhwbZeyU6DrQRuJAWSmZm1k3JeVVUhafPs84bAF4HnJG2dlfUh9RZ+3cxmxtDgNFXWC0GSgCOBOeu67WZm1rRy9jj6A9MlzQaeAh6JiPuBcyXNA2YD90XEYwCSqiVdX19ZUhVp/OPxBtu9VdKzwLNAP+DSMh6DmZk1ULbLcSNiNrBXkfJzgXOLlNcAJxXMLwIGFFlv2DptqJmZ5eI7x83MLBcHh5mZ5eLgMDOzXBwcZmaWi4PDzMxycXCYmVkuDg4zM8vFwWFmZrk4OMzMLBcHh5mZ5eLgMDOzXBwcZmaWi4PDzMxycXCYmVkuDg4zM8vFwWFmZrk4OMzMLBcHh5mZ5eLgMDOzXBQRHd2GspNUB7zU0e3oJvoByzu6EWbN8Hd03flkRFQ0LOwRwWHrjqSaiKju6HaYNcXf0fLzqSozM8vFwWFmZrk4OCyvazu6AWYt8He0zDzGYWZmubjHYWZmuTg4uilJ20iaLOlFSbWSHpT06TZuc6ik+wvmD5FUI+lvkmZK+lmD9WdJmtyg7CZJCyU9I+l5Sb+VVNmWdlnX5O9o1+Xg6IYkCbgHmBERO0bEYOBC4OPrcB+7AVcDx0bEQKAamF+w/DNAL2A/SRs3qH5uROwJ7AzMBB6TtMG6apt1fv6Odm0Oju7pQODDiPh1fUFEPAP8SdIVkuZIelbSMfDv/6XNkHSXpOck3Zr9YiNpeFb2NPDVgn2cB/wwIp7Ltr8qIq4pWD4G+B3wMDCyWCMjmQi8Chyyzo7eugJ/R7swB0f3tBtQW6T8q8AgYE/gYOAKSf2zZXsB3wIGAjsA+0jqC1wHHA4MBrYpYR/1jgEmA5NIv6DNeRrYpYV1rHvxd7QLc3D0LPsCk7L/eb0GPA58Llv2ZEQsiYjVwCygivSLsjAiXoh0+d0tpexEUjWwPCL+ATwK7CVpy+aqtOporDvyd7QLcHB0T3NJ//vKY2XB51VA7zbsYwywi6RFwIvAZsBRzWxrL2Beac20bsLf0S7MwdE9PQb0kXRKfYGkPYAVwDGSekmqAPYHnmxmO88BVZJ2zOYLu/NXAN+pvwpG0nqSTpW0HvA1YPeIqIqIKtL540anApScBfQHHmrdoVoX5e9oF+bg6IayLvtXgIOzSx3nAj8GbgNmA8+QfnHPi4hXm9nO+8ApwAPZwOOygmWzSeebJ0maB8whnXfeD1gaES8XbOoPwMCCc9VXSHoGeJ50GuLAiPig7UduXYW/o12b7xw3M7Nc3OMwM7NcHBxmZpaLg6OHkPSvdbSdiyWdU8J6N0katS72aT2Dv6Ndh4PDzMxycXD0MJI2kfSopKezRzqMzMqrssc23JQ92O1WSQdLekLSC5KGFGxmT0l/zspPzupL0tWS/i7pf4CtC/Z5kaSnssdIXFv/qAizYvwd7QIiwlMPmIB/ZT97A5tln/uRHvom0l24HwG7k/5DUQvckC0bCfw+q3Mx6VLJDbP6i4FtSY+KeIT00LhtSdfjj8rqbFnQjt8Bh3f0v4enzjf5O9p1ppbuvLTuR8CPJO0PrAYGsOaJpAsj4lmA7Lr6RyMiJD1L+qWtd29EvAe8J2k6MIR0o9akiFgFvCzpsYL1D5R0HrARsCXpjt77ynaE1tX5O9rJOTh6nrFABTA4Ij7MHrnQN1tW+EiH1QXzq1n7u9Lw5p8mbwZSegjdr4DqiFgs6eKC/ZkV4+9oJ+cxjp7nY8Cy7BfyQOCTrdjGSEl9JW0FDAWeIt15W/+oiP6kx2bDml/A5ZI2AXwVi7XE39FOzj2OnudW4L6sa19DetZPXrOB6aTzxz+IiJcl3QMMA/4G/AP4M0BErJB0HelxD6+SfoHNmuPvaCfnR46YmVkuPlVlZma5ODjMzCwXB4eZmeXi4LCSSBqe3XE7X9IFHd0e63kk3SBpmaQ5rag7I/v+zsqmrVuuZU1xcFiLJPUCfgkcAgwExkga2LGtsh7oJmB4G+qPjYhB2bSs5dWtKQ4OK8UQYH5ELIj0FrTJpEc8mLWbiPgD8M/CMkk7SnpIUq2kP0rapYOa16M4OKwUA0jP+6m3JCsz62jXAmdGxGDgHNId4E25MTtN9T0/xLBtfAOgmXVJ2V3eewN3FuRAnyZWHxsRSyVtCtwNHAf8tvyt7J4cHFaKpcB2BfOVWZlZR1oPWBERgwoLszG52mx2SkRcFBFLASLibUm3kU6/OjhayaeqrBRPAZ+StL2kDYDRwJQObpP1cBHxFrBQ0tHw7/dt7BkRqwoGwS+S1FtSv2yd9YHDSI8XsVZycFiLIuIj4AxgGjAPuCMi5nZsq6ynkTSJ9HypnSUtkXQi6Um6J0p6hvQo9GIXbfQBpkmaDcwi9Zava59Wd09+VpWZmeXiHoeZmeXi4DAzs1wcHGZmlouDw8zMcnFwmJlZLg4Os1aSFJJuKZjvLalO0v0t1Bsk6dCC+YslndOGdrSpvlleDg6z1nsH2E3Shtn8FyntjvpBwKEtrWTWWTk4zNrmQWBE9nkMMKl+gaSNs3dIPClppqSR2Z33E4BjsgfuHZOtPjB7Z8QCSWcVbGO8pDnZ9K2C8u9Kel7Sn4Cdy32QZoUcHGZtMxkYLakvsAfw14Jl3wUei4ghwIHAFcD6wEXA7dkjMW7P1t0F+DLpGUrfl7S+pMHACcDngS8AJ0vaKysfzZqey+fKfIxma/FDDs3aICJmS6oi9TYebLD4S8ARBeMPfYFPNLGpByJiJbBS0jLg48C+wD0R8Q6ApP8H7Ef6D989EfFuVu7nhlm7cnCYtd0U4KfAUGCrgnIBR0XE3wtXlvT5IttYWfB5Ff7dtE7Mp6rM2u4G4JKIeLZB+TTgzPqXBknaKyt/G9i0hO3+EThS0kaSNga+kpX9ISvfMHu/xOHr4iDMSuXgMGujiFgSEVcVWfQD0pjGbElzs3mA6aTB8MLB8WLbfZr0nu0nSWMn10fEzKz8duAZYCrpsfdm7cZPxzUzs1zc4zAzs1wcHGZmlouDw8zMcnFwmJlZLg4OMzPLxcFhZma5ODjMzCwXB4eZmeXy/wHEs1DGA3jeiAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_result(result_dict, plot_dataset='DomainNet', plot_y='acc_tgt', \n",
    "            exclude=None, plot_std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "550fabb8",
   "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
}