post_hoc_cd_diagram.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np;\n",
    "import pandas as pd;\n",
    "import operator;\n",
    "import math;\n",
    "from scipy.stats import friedmanchisquare;\n",
    "from scipy.stats import wilcoxon;\n",
    "import networkx;\n",
    "import matplotlib.pyplot as plt;\n",
    "from matplotlib import rcParams;\n",
    "# rcParams['font.family'] = 'Times New Roman';\n",
    "rcParams['font.family'] = 'sans-serif'\n",
    "rcParams['font.sans-serif'] = ['Lucida Grande']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def form_cliques(p_values, nnames):\n",
    "    \"\"\"\n",
    "    This method forms the cliques\n",
    "    \"\"\"\n",
    "    # first form the numpy matrix data\n",
    "    m = len(nnames)\n",
    "    g_data = np.zeros((m, m), dtype=np.int64)\n",
    "    for p in p_values:\n",
    "        if p[3] == False:\n",
    "            i = np.where(nnames == p[0])[0][0]\n",
    "            j = np.where(nnames == p[1])[0][0]\n",
    "            min_i = min(i, j)\n",
    "            max_j = max(i, j)\n",
    "            g_data[min_i, max_j] = 1\n",
    "\n",
    "    g = networkx.Graph(g_data)\n",
    "    return networkx.find_cliques(g)\n",
    "\n",
    "# inspired from orange3 https://docs.orange.biolab.si/3/data-mining-library/reference/evaluation.cd.html\n",
    "def graph_ranks(avranks, names, p_values, cd=None, cdmethod=None, lowv=None, highv=None,\n",
    "                width=6, textspace=1, reverse=False, filename=None, labels=False, **kwargs):\n",
    "    \"\"\"\n",
    "    Draws a CD graph, which is used to display  the differences in methods'\n",
    "    performance. See Janez Demsar, Statistical Comparisons of Classifiers over\n",
    "    Multiple Data Sets, 7(Jan):1--30, 2006.\n",
    "    Needs matplotlib to work.\n",
    "    The image is ploted on `plt` imported using\n",
    "    `import matplotlib.pyplot as plt`.\n",
    "    Args:\n",
    "        avranks (list of float): average ranks of methods.\n",
    "        names (list of str): names of methods.\n",
    "        cd (float): Critical difference used for statistically significance of\n",
    "            difference between methods.\n",
    "        cdmethod (int, optional): the method that is compared with other methods\n",
    "            If omitted, show pairwise comparison of methods\n",
    "        lowv (int, optional): the lowest shown rank\n",
    "        highv (int, optional): the highest shown rank\n",
    "        width (int, optional): default width in inches (default: 6)\n",
    "        textspace (int, optional): space on figure sides (in inches) for the\n",
    "            method names (default: 1)\n",
    "        reverse (bool, optional):  if set to `True`, the lowest rank is on the\n",
    "            right (default: `False`)\n",
    "        filename (str, optional): output file name (with extension). If not\n",
    "            given, the function does not write a file.\n",
    "        labels (bool, optional): if set to `True`, the calculated avg rank\n",
    "        values will be displayed\n",
    "    \"\"\"\n",
    "    try:\n",
    "        import matplotlib\n",
    "        import matplotlib.pyplot as plt\n",
    "        from matplotlib.backends.backend_agg import FigureCanvasAgg\n",
    "    except ImportError:\n",
    "        raise ImportError(\"Function graph_ranks requires matplotlib.\")\n",
    "\n",
    "    width = float(width)\n",
    "    textspace = float(textspace)\n",
    "\n",
    "    def nth(l, n):\n",
    "        \"\"\"\n",
    "        Returns only nth elemnt in a list.\n",
    "        \"\"\"\n",
    "        n = lloc(l, n)\n",
    "        return [a[n] for a in l]\n",
    "\n",
    "    def lloc(l, n):\n",
    "        \"\"\"\n",
    "        List location in list of list structure.\n",
    "        Enable the use of negative locations:\n",
    "        -1 is the last element, -2 second last...\n",
    "        \"\"\"\n",
    "        if n < 0:\n",
    "            return len(l[0]) + n\n",
    "        else:\n",
    "            return n\n",
    "\n",
    "    def mxrange(lr):\n",
    "        \"\"\"\n",
    "        Multiple xranges. Can be used to traverse matrices.\n",
    "        This function is very slow due to unknown number of\n",
    "        parameters.\n",
    "        >>> mxrange([3,5])\n",
    "        [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]\n",
    "        >>> mxrange([[3,5,1],[9,0,-3]])\n",
    "        [(3, 9), (3, 6), (3, 3), (4, 9), (4, 6), (4, 3)]\n",
    "        \"\"\"\n",
    "        if not len(lr):\n",
    "            yield ()\n",
    "        else:\n",
    "            # it can work with single numbers\n",
    "            index = lr[0]\n",
    "            if isinstance(index, int):\n",
    "                index = [index]\n",
    "            for a in range(*index):\n",
    "                for b in mxrange(lr[1:]):\n",
    "                    yield tuple([a] + list(b))\n",
    "\n",
    "    def print_figure(fig, *args, **kwargs):\n",
    "        canvas = FigureCanvasAgg(fig)\n",
    "        canvas.print_figure(*args, **kwargs)\n",
    "\n",
    "    sums = avranks\n",
    "\n",
    "    nnames = names\n",
    "    ssums = sums\n",
    "\n",
    "    if lowv is None:\n",
    "        lowv = min(1, int(math.floor(min(ssums))))\n",
    "    if highv is None:\n",
    "        highv = max(len(avranks), int(math.ceil(max(ssums))))\n",
    "\n",
    "    cline = 0.4\n",
    "\n",
    "    k = len(sums)\n",
    "\n",
    "    lines = None\n",
    "\n",
    "    linesblank = 0\n",
    "    scalewidth = width - 2 * textspace\n",
    "\n",
    "    def rankpos(rank):\n",
    "        if not reverse:\n",
    "            a = rank - lowv\n",
    "        else:\n",
    "            a = highv - rank\n",
    "        return textspace + scalewidth / (highv - lowv) * a\n",
    "\n",
    "    distanceh = 0.25\n",
    "\n",
    "    cline += distanceh\n",
    "\n",
    "    # calculate height needed height of an image\n",
    "    minnotsignificant = max(2 * 0.2, linesblank)\n",
    "    height = cline + ((k + 1) / 2) * 0.2 + minnotsignificant\n",
    "\n",
    "    fig = plt.figure(figsize=(width, height))\n",
    "    fig.set_facecolor('white')\n",
    "    ax = fig.add_axes([0, 0, 1, 1])  # reverse y axis\n",
    "    ax.set_axis_off()\n",
    "\n",
    "    hf = 1. / height  # height factor\n",
    "    wf = 1. / width\n",
    "\n",
    "    def hfl(l):\n",
    "        return [a * hf for a in l]\n",
    "\n",
    "    def wfl(l):\n",
    "        return [a * wf for a in l]\n",
    "\n",
    "    # Upper left corner is (0,0).\n",
    "    ax.plot([0, 1], [0, 1], c=\"w\")\n",
    "    ax.set_xlim(0, 1)\n",
    "    ax.set_ylim(1, 0)\n",
    "\n",
    "    def line(l, color='k', **kwargs):\n",
    "        \"\"\"\n",
    "        Input is a list of pairs of points.\n",
    "        \"\"\"\n",
    "        ax.plot(wfl(nth(l, 0)), hfl(nth(l, 1)), color=color, **kwargs)\n",
    "\n",
    "    def text(x, y, s, *args, **kwargs):\n",
    "        ax.text(wf * x, hf * y, s, *args, **kwargs)\n",
    "\n",
    "    line([(textspace, cline), (width - textspace, cline)], linewidth=2)\n",
    "\n",
    "    bigtick = 0.3\n",
    "    smalltick = 0.15\n",
    "    linewidth = 2.0\n",
    "    linewidth_sign = 4.0\n",
    "\n",
    "    tick = None\n",
    "    for a in list(np.arange(lowv, highv, 0.5)) + [highv]:\n",
    "        tick = smalltick\n",
    "        if a == int(a):\n",
    "            tick = bigtick\n",
    "        line([(rankpos(a), cline - tick / 2),\n",
    "              (rankpos(a), cline)],\n",
    "             linewidth=2)\n",
    "\n",
    "    for a in range(lowv, highv + 1):\n",
    "        text(rankpos(a), cline - tick / 2 - 0.05, str(a),\n",
    "             ha=\"center\", va=\"bottom\", size=12)\n",
    "\n",
    "    k = len(ssums)\n",
    "\n",
    "    def filter_names(name):\n",
    "        return name\n",
    "\n",
    "    space_between_names = 0.24\n",
    "\n",
    "    for i in range(math.ceil(k / 2)):\n",
    "        chei = cline + minnotsignificant + i * space_between_names\n",
    "        line([(rankpos(ssums[i]), cline),\n",
    "              (rankpos(ssums[i]), chei),\n",
    "              (textspace - 0.1, chei)],\n",
    "             linewidth=linewidth)\n",
    "        if labels:\n",
    "            text(textspace + 0.45, chei - 0.11, format(ssums[i], '.4f'), ha=\"right\", va=\"center\", size=12)\n",
    "        text(textspace - 0.2, chei, filter_names(nnames[i]), ha=\"right\", va=\"center\", size=14)\n",
    "\n",
    "    for i in range(math.ceil(k / 2), k):\n",
    "        chei = cline + minnotsignificant + (k - i - 1) * space_between_names\n",
    "        line([(rankpos(ssums[i]), cline),\n",
    "              (rankpos(ssums[i]), chei),\n",
    "              (textspace + scalewidth + 0.1, chei)],\n",
    "             linewidth=linewidth)\n",
    "        if labels:\n",
    "            text(textspace + scalewidth - 0.45, chei - 0.11, format(ssums[i], '.4f'), ha=\"left\", va=\"center\", size=12)\n",
    "        text(textspace + scalewidth + 0.2, chei, filter_names(nnames[i]),\n",
    "             ha=\"left\", va=\"center\", size=14)\n",
    "\n",
    "    # no-significance lines\n",
    "    def draw_lines(lines, side=0.05, height=0.1):\n",
    "        start = cline + 0.2\n",
    "\n",
    "        for l, r in lines:\n",
    "            line([(rankpos(ssums[l]) - side, start),\n",
    "                  (rankpos(ssums[r]) + side, start)],\n",
    "                 linewidth=linewidth_sign)\n",
    "            start += height\n",
    "            print('drawing: ', l, r)\n",
    "\n",
    "    # draw_lines(lines)\n",
    "    start = cline + 0.2\n",
    "    side = -0.02\n",
    "    height = 0.1\n",
    "\n",
    "    # draw no significant lines\n",
    "    # get the cliques\n",
    "    cliques = form_cliques(p_values, nnames)\n",
    "    i = 1\n",
    "    achieved_half = False\n",
    "    print(nnames)\n",
    "    for clq in cliques:\n",
    "        if len(clq) == 1:\n",
    "            continue\n",
    "        print(clq)\n",
    "        min_idx = np.array(clq).min()\n",
    "        max_idx = np.array(clq).max()\n",
    "        if min_idx >= len(nnames) / 2 and achieved_half == False:\n",
    "            start = cline + 0.25\n",
    "            achieved_half = True\n",
    "        line([(rankpos(ssums[min_idx]) - side, start),\n",
    "              (rankpos(ssums[max_idx]) + side, start)],\n",
    "             linewidth=linewidth_sign)\n",
    "        start += height\n",
    "def wilcoxon_holm(alpha=0.05, df_perf=None):\n",
    "    \"\"\"\n",
    "    Applies the wilcoxon signed rank test between each pair of algorithm and then use Holm\n",
    "    to reject the null's hypothesis\n",
    "    \"\"\"\n",
    "    print(pd.unique(df_perf['classifier_name']))\n",
    "    # count the number of tested datasets per classifier\n",
    "    df_counts = pd.DataFrame({'count': df_perf.groupby(\n",
    "        ['classifier_name']).size()}).reset_index()\n",
    "    # get the maximum number of tested datasets\n",
    "    max_nb_datasets = df_counts['count'].max()\n",
    "    # get the list of classifiers who have been tested on nb_max_datasets\n",
    "    classifiers = list(df_counts.loc[df_counts['count'] == max_nb_datasets]\n",
    "                       ['classifier_name'])\n",
    "    # test the null hypothesis using friedman before doing a post-hoc analysis\n",
    "    friedman_p_value = friedmanchisquare(*(\n",
    "        np.array(df_perf.loc[df_perf['classifier_name'] == c]['accuracy'])\n",
    "        for c in classifiers))[1]\n",
    "    if friedman_p_value >= alpha:\n",
    "        # then the null hypothesis over the entire classifiers cannot be rejected\n",
    "        print('the null hypothesis over the entire classifiers cannot be rejected')\n",
    "        exit()\n",
    "    # get the number of classifiers\n",
    "    m = len(classifiers)\n",
    "    # init array that contains the p-values calculated by the Wilcoxon signed rank test\n",
    "    p_values = []\n",
    "    # loop through the algorithms to compare pairwise\n",
    "    for i in range(m - 1):\n",
    "        # get the name of classifier one\n",
    "        classifier_1 = classifiers[i]\n",
    "        # get the performance of classifier one\n",
    "        perf_1 = np.array(df_perf.loc[df_perf['classifier_name'] == classifier_1]['accuracy']\n",
    "                          , dtype=np.float64)\n",
    "        for j in range(i + 1, m):\n",
    "            # get the name of the second classifier\n",
    "            classifier_2 = classifiers[j]\n",
    "            # get the performance of classifier one\n",
    "            perf_2 = np.array(df_perf.loc[df_perf['classifier_name'] == classifier_2]\n",
    "                              ['accuracy'], dtype=np.float64)\n",
    "            # calculate the p_value\n",
    "            p_value = wilcoxon(perf_1, perf_2, zero_method='pratt')[1]\n",
    "            # appen to the list\n",
    "            p_values.append((classifier_1, classifier_2, p_value, False))\n",
    "    # get the number of hypothesis\n",
    "    k = len(p_values)\n",
    "    # sort the list in acsending manner of p-value\n",
    "    p_values.sort(key=operator.itemgetter(2))\n",
    "\n",
    "    # loop through the hypothesis\n",
    "    for i in range(k):\n",
    "        # correct alpha with holm\n",
    "        new_alpha = float(alpha / (k - i))\n",
    "        # test if significant after holm's correction of alpha\n",
    "        if p_values[i][2] <= new_alpha:\n",
    "            p_values[i] = (p_values[i][0], p_values[i][1], p_values[i][2], True)\n",
    "        else:\n",
    "            # stop\n",
    "            break\n",
    "    # compute the average ranks to be returned (useful for drawing the cd diagram)\n",
    "    # sort the dataframe of performances\n",
    "    sorted_df_perf = df_perf.loc[df_perf['classifier_name'].isin(classifiers)]. \\\n",
    "        sort_values(['classifier_name', 'dataset_name'])\n",
    "    # get the rank data\n",
    "    rank_data = np.array(sorted_df_perf['accuracy']).reshape(m, max_nb_datasets)\n",
    "\n",
    "    # create the data frame containg the accuracies\n",
    "    df_ranks = pd.DataFrame(data=rank_data, index=np.sort(classifiers), columns=\n",
    "    np.unique(sorted_df_perf['dataset_name']))\n",
    "\n",
    "    # number of wins\n",
    "    dfff = df_ranks.rank(ascending=False)\n",
    "    print(dfff[dfff == 1.0].sum(axis=1))\n",
    "\n",
    "    # average the ranks\n",
    "    average_ranks = df_ranks.rank(ascending=False).mean(axis=1).sort_values(ascending=False)\n",
    "    # return the p-values and the average ranks\n",
    "    return p_values, average_ranks, max_nb_datasets\n",
    "\n",
    "def draw_cd_diagram(df_perf=None, alpha=0.05, title=None, labels=False, diagram_name='cd-diagram'):\n",
    "    \"\"\"\n",
    "    Draws the critical difference diagram given the list of pairwise classifiers that are\n",
    "    significant or not\n",
    "    \"\"\"\n",
    "    p_values, average_ranks, _ = wilcoxon_holm(df_perf=df_perf, alpha=alpha)\n",
    "\n",
    "    print(average_ranks)\n",
    "\n",
    "    for p in p_values:\n",
    "        print(p)\n",
    "\n",
    "\n",
    "    graph_ranks(average_ranks.values, average_ranks.keys(), p_values,\n",
    "                cd=None, reverse=True, width=9, textspace=1.5, labels=labels)\n",
    "\n",
    "    font = {'family': 'Lucida Grande',\n",
    "        'color':  'black',\n",
    "        'weight': 'normal',\n",
    "        'size': 14,\n",
    "        }\n",
    "    if title:\n",
    "        plt.title(title,fontdict=font, y=0.9, x=0.5)\n",
    "    plt.savefig('csv_xls/sig_diag/{}.png'.format(diagram_name), bbox_inches='tight', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ACDNet' 'DIcL' 'DAFL' 'AL-KNC' 'AL-LogisticReg' 'AL-RidgeC']\n",
      "ACDNet              0.0\n",
      "AL-KNC              1.0\n",
      "AL-LogisticReg    312.0\n",
      "AL-RidgeC         180.0\n",
      "DAFL              470.0\n",
      "DIcL                4.0\n",
      "dtype: float64\n",
      "ACDNet            5.4060\n",
      "AL-KNC            4.8670\n",
      "DIcL              4.4935\n",
      "AL-RidgeC         2.4345\n",
      "AL-LogisticReg    2.0545\n",
      "DAFL              1.7445\n",
      "dtype: float64\n",
      "('ACDNet', 'DAFL', 3.3174190890829604e-165, True)\n",
      "('ACDNet', 'AL-LogisticReg', 3.937569207475103e-165, True)\n",
      "('ACDNet', 'AL-RidgeC', 1.280409133691516e-164, True)\n",
      "('AL-KNC', 'DAFL', 1.4169982161095985e-164, True)\n",
      "('AL-KNC', 'AL-LogisticReg', 8.317679493090257e-164, True)\n",
      "('DAFL', 'DIcL', 1.51830271647646e-163, True)\n",
      "('AL-KNC', 'AL-RidgeC', 3.1083402861493002e-161, True)\n",
      "('AL-LogisticReg', 'DIcL', 1.453348283674043e-160, True)\n",
      "('AL-RidgeC', 'DIcL', 8.629884709509334e-152, True)\n",
      "('ACDNet', 'DIcL', 2.44752785424545e-79, True)\n",
      "('AL-RidgeC', 'DAFL', 1.3314173853907763e-49, True)\n",
      "('ACDNet', 'AL-KNC', 5.639126754064207e-34, True)\n",
      "('AL-KNC', 'DIcL', 9.952540826349092e-18, True)\n",
      "('AL-LogisticReg', 'AL-RidgeC', 2.6172608155164365e-17, True)\n",
      "('AL-LogisticReg', 'DAFL', 1.5855161599280513e-14, True)\n",
      "Index(['ACDNet', 'AL-KNC', 'DIcL', 'AL-RidgeC', 'AL-LogisticReg', 'DAFL'], dtype='object')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x126 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.read_csv('csv_xls/microal_esc50_1k_run.csv',index_col=False)\n",
    "cols = df.columns.tolist();\n",
    "classifiers = [cls for c in cols for cls in [c]*1000 ];\n",
    "datasets = ['Dataset_{}'.format(i) for c in cols for i in range(1,1001)];\n",
    "accuracy = [a for cls in cols for a in list(df[cls])];\n",
    "df_perf = pd.DataFrame([classifiers, datasets, accuracy]).T;\n",
    "df_perf.columns = ['classifier_name', 'dataset_name', 'accuracy'];\n",
    "draw_cd_diagram(df_perf=df_perf, title='Accuracy', labels=True, diagram_name='micro_esc50_sig_diag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ACDNet' 'DIcL' 'DAFL' 'AL-KNC' 'AL-LogisticReg' 'AL-RidgeC']\n",
      "ACDNet             12.0\n",
      "AL-KNC            140.0\n",
      "AL-LogisticReg    171.0\n",
      "AL-RidgeC          20.0\n",
      "DAFL              595.0\n",
      "DIcL               56.0\n",
      "dtype: float64\n",
      "ACDNet            5.0795\n",
      "AL-RidgeC         4.5330\n",
      "DIcL              3.8445\n",
      "AL-KNC            2.9850\n",
      "AL-LogisticReg    2.8710\n",
      "DAFL              1.6870\n",
      "dtype: float64\n",
      "('ACDNet', 'DAFL', 6.271831629645068e-163, True)\n",
      "('AL-RidgeC', 'DAFL', 8.046613384541528e-157, True)\n",
      "('DAFL', 'DIcL', 1.4775630543935732e-136, True)\n",
      "('ACDNet', 'AL-LogisticReg', 1.2078249251703072e-132, True)\n",
      "('ACDNet', 'AL-KNC', 4.276678563191547e-130, True)\n",
      "('AL-LogisticReg', 'AL-RidgeC', 5.940217602804331e-99, True)\n",
      "('AL-KNC', 'AL-RidgeC', 2.4124479987053615e-91, True)\n",
      "('AL-KNC', 'DAFL', 8.813612988052462e-86, True)\n",
      "('AL-LogisticReg', 'DAFL', 5.318985943837266e-72, True)\n",
      "('ACDNet', 'DIcL', 8.858762337114246e-69, True)\n",
      "('AL-LogisticReg', 'DIcL', 8.051376995193506e-49, True)\n",
      "('AL-KNC', 'DIcL', 2.48040371755319e-39, True)\n",
      "('ACDNet', 'AL-RidgeC', 9.108702150670236e-24, True)\n",
      "('AL-RidgeC', 'DIcL', 6.088107384461563e-23, True)\n",
      "('AL-KNC', 'AL-LogisticReg', 0.058134134183536565, False)\n",
      "Index(['ACDNet', 'AL-RidgeC', 'DIcL', 'AL-KNC', 'AL-LogisticReg', 'DAFL'], dtype='object')\n",
      "[3, 4]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp8AAACQCAYAAABOIQD0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2wElEQVR4nO3deVyN6f8/8NdpOXW0nRaVREeoENnNUqMh+75LTNaMJeZjMGZsWT/GiCGGMYvIKJ/sCmM3ZSRbk0KWitNC0mKoTtv794df99dREdU5yvv5eNyPh3Nf133f7+uuzv1239d9XSIiIjDGGGOMMaYCGuoOgDHGGGOMfTg4+WSMMcYYYyrDySdjjDHGGFMZTj4ZY4wxxpjKcPLJGGOMMcZUhpNPxhhjjDGmMpx8MsZqrPT0dIjFYnTv3l3doTDGGKsgTj4ZYzVWUFAQCgoKcPr0aaSmpqo7HMYYYxXAySdjrMYKCAiAm5sbioqKEBgYqJYYioqKUFRUpJZjM8ZYTcTJJ2OsRrp9+zYiIyPh4+ODtm3bYufOnUrld+/exYABA2BkZARdXV3Y29vj2bNnAIC0tDSMGTMGpqamEIvFaNSoEe7evQsAkMlk8PHxEfaTmJgIkUiEs2fPCutEIhH8/PwwfPhw6OvrQy6XIzU1FSNHjoSVlRXq1KkDFxcXJCYmKsW0fv16NG3aFGKxGKampvD19cXq1athaGiI3NxcoV5eXh6MjY0REhJStSeNMcbeA5x8MsZqpICAAMhkMnzyyScYNWoUrl27hps3bwIAcnNz0a1bN9y7dw9Hjx5FQkICNm7cCLFYDCLCgAEDcObMGezatQv379/Hjh07YGJi8lbHX7lyJVxdXXHnzh3Ur18fubm56N69O/766y/8888/ePToEVasWCHU37JlC7766it4enri7t27CAsLQ9euXeHu7o5nz57h8OHDQt39+/dDLBajZ8+eVXOyGGPsPaKl7gAYY+xtERF27twJd3d3iEQijBgxAnPnzkVAQABWrlyJXbt2ITExEVeuXEHbtm0BAPXq1QMAnDp1ChEREdi7dy969OihVPY2PD09MXXqVOGzra0tbG1thc8ff/wx4uPjhc8rVqxAv379sGDBglL7+uyzzxAYGIjhw4cDAPz9/eHu7g4tLf6KZozVPnznkzFW44SHhyMxMREeHh4AAGtra7i4uGDXrl0gIsTGxsLQ0FBIPF8WGxsLAPj8888rFYODg4PSZyLCtm3b4OrqCplMhqCgIKEv6NOnT5GUlFTuMT08PHD06FFkZWUhOTkZJ0+exBdffFGp+Bhj7H3FySdjrMYJCAgAALRr1w66urrQ1dVFeHg47t+/j7CwMGhqakJDo+yvN01NTQAv+m1WpcWLF2PatGkYPHgwQkJC0K9fP6FMQ0MDIpGo3GMOGzYMALBv3z7s2LEDzZo1KzNxZoyx2oCTT8ZYjaJQKBAcHIylS5ciKipKWC5fvgyJRIKdO3eiffv2yMrKwrVr10pt3759ewDAmTNnyty/pqYmFAqF8Dk4OLhCce3ZswcTJkzAjBkz4OjoCH19faFMX18f9vb25R5TKpWid+/e2LVrF7Zv3w5PT88KHZMxxmoi7lDEGKtRDh8+jLy8PEyfPh3GxsZKZUOHDsWePXvg5+eHVq1aYfTo0di6dSsaNWqEyMhIuLq6olOnTujTpw+8vb0hkUjg5OSE69evw87ODjKZDPb29jh06BBcXV1x8uRJHDt2rEJxNWjQAJGRkUhISMCFCxdw7NgxiMViPH78GHXr1sWyZcswbNgwLFu2DJ6ensjOzsajR4/g5uYG4MWj96FDh0JTU1PoTsAYY7UR3/lkjNUoAQEBGDx4cKnEEwAmTpyIzMxMhIaG4siRI7Czs0P37t3RvHlz+Pr6orCwEADwxx9/oFu3bhgxYgSaNm2KBQsWCEMdff/999DQ0MCQIUOQnJxcagin8qxduxYKhQItW7bE8ePHceTIEeTn52PixIkAXiTGv/zyC7Zt24amTZtiwIABwtv5ANC3b18YGRmha9eusLKyquxpYoyx95aIiEjdQTDG2IdOoVDA2toaP/74I9/5ZIzVanznkzHG3gN79uyBQqHAoEGD1B0KY4xVK77zyRhj7wFnZ2c0bdoU27ZtU3cojDFWrTj5ZIwxxhhjKsOP3RljjDHGmMpw8skYY4wxxlSGk0/GGGOMMaYynHwyxhhjjDGV4eSTMcYYY4ypDCefjDHGGGNMZTj5ZIwxxhhjKsPJJ2OMMcYYUxlOPhljjDHGmMpw8skYY4wxxlSGk0/GGGOMqY1CocCZM2cQFBSk7lCYinDyWQsQEZYvX44GDRrAyMgILVu2RGxsrLrDqvH8/f0hFoshlUqFJTs7W91h1So5OTlo0aIFxo4dq+5QaoV169ahfv36kEqlkMlk8PX1VXdItcL69ethb28PqVQKJycnnDp1St0h1RrXrl2DjY0NPD094e/vr+5wmIpw8lkLrF+/HkeOHEFERASys7Oxf/9+WFpaqjusWmHUqFHIysoSFiMjI3WHVKtMnToVhYWF6g6j1hg0aBDi4+ORlZWFNWvWYM6cOcjNzVV3WDWeqakpTp06hczMTEyePBlDhgzB8+fP1R1WrdC8eXMkJSVh/Pjx6g6FqRAnnzVccXEx1qxZgx9++AH169cHADRp0gSmpqZqjoyx1/P394dcLsfcuXPVHUqtIZPJoKOjg6ysLERFRaFXr16QSCTqDqvGGz16NKytrSESiTB27FhkZ2fj3r176g6rVtDR0YGWlpa6w2AqxslnDZecnIzk5GTcvn0bTZo0QYMGDTB//nwUFxerO7QaTyQSYffu3XBwcMCsWbOQlZWl7pBqjRs3bmDlypUIDAyEpqamusOpVaysrGBsbIxz585h+/bt6g6n1omIiICBgQFsbW3VHQpjNRYnnzVcSkoKAODq1auIjo7G0aNHsXXrVmzbtk3NkdV8np6eeP78OQ4ePIhbt25h+PDh6g6pVsjJyYGHhwf8/f1hbm6u7nBqnZSUFCQlJcHOzg4uLi5QKBTqDqnWSE1NxZdffomtW7dCX19f3eEwVmOJiIjUHQR7dzdv3kTz5s2RmZkJqVQKAJg2bRrS09Oxe/du9QZXiyQlJaFBgwZITk6GlZWVusOp0QICAjBhwgSYmJgAAHJzc5Gfn49evXph3759ao6u9igoKIChoSEOHTqEbt26qTucGi8xMRG9evWCj48PRowYoe5wah0fHx9ERETg2LFj6g6FqQB3tKjhbGxsoKuri8ePHwvJp1gshqGhoXoDq2X09PQAgF8yqAJDhw5VSobWrFkDuVyOzZs3qzGq2kdLSwtisRgaGvyAq7LS0tLg5uaGdevWoV+/fuoOh7Eaj7+Varg6derA09MT8+fPR05ODhISErB7926MHDlS3aHVeHK5HHl5eSgoKMCSJUvg4OCAxo0bqzusGk8ikcDS0lJY9PX1IZFIhDuh7N2dOHECT548QWFhIZYvXw5dXV106NBB3WHVeF5eXnBxceHEk7EqwslnLbB69WpoaGigXr166Nq1K3x8fNC1a1d1h1XjHT58GNbW1mjQoAHi4+Nx+PBhvovE3msHDhyAvb096tatiz///BMhISH8FKQKHDx4ELt371Ya8/fBgwfqDqtWiIiIgFQqxapVq3Dq1ClIpVJs3LhR3WGxasZ9PhljjDHGmMrwbRzGGGOMMaYynHwyxhhjjDGV4eSTMcYYY4ypDCeftYRIJIJIJFJ3GLUSn9vqwee1evB5rT58bqsHn9cPDyefjDHGGGNMZTj5ZIwxxhhjKsPJJ2OMMcYYUxlOPhljjDHGmMpw8slUjjuXVx8+t9WDz2v14XNbPfi8svcZJ5+MMcYYY0xlOPlkjDHGGGMqw8knY4wxxhhTGU4+GWOMMcaYynDyyRhjjDHGVEZERKTuIFjl8VuNjDHGajJORz4cfOeTMcYYY4ypjJa6A2BVg//HWDkld45r4nmsybG/rQ+prZVV0XPF5/T9xD8XVpvxnU/GGGOMMaYynHwyxhhjjDGV4eSTMcYYY4ypDCefjDHGGGNMZTj5ZIwxxhhjKsPJJ2OMMcYYUxlOPhljjDHGmMpw8skYY4wxxlSGk0/GGGOMMaYynHwyxhhjjDGV4eSTMcYYY4ypDCefjDHGGGNMZTj5ZIwxxhhjKsPJJ2OMMcYECoUCZ86cQVBQkLpDYbUUJ581iL+/P8RiMaRSqbBkZ2eXWTcwMBA2NjaQSqWYMmUKCgsLhbK+ffsq7UNfXx+NGjUSys+ePQsnJycYGhqie/fuSE5OVirT0tJS2v769evV12jGWKWIRKLXLoy97Nq1a7CxsYGnpyf8/f1fWzc8PBwdO3aEkZERrKys4OvrK5QREebOnQsrKyuYmppi5syZKC4uBgA8ePBA6RoilUohFouxZMkSYft169bB0tISZmZmWLx4cbW0lakPJ581zKhRo5CVlSUsRkZGpercuHED3t7eOHToEORyOe7du4fvv/9eKA8JCVHax4QJEzBy5EgAQEpKCgYNGoQNGzYgIyMDHTp0wLhx45T27+zsrLR9y5Ytq7fRjDHGVKJ58+ZISkrC+PHjX1uv5Frh4+ODzMxM3Lx5E7179xbKg4ODERkZiTt37iAuLg5Hjx7FsWPHAAANGzZUuoYkJSXBysoKQ4YMAQAcP34c69evR2RkJG7evIkDBw7gjz/+qL5GM5Xj5LMW2rx5M4YNGwYnJycYGBhg/vz58PPzE/7X+bKYmBiEhoZi4cKFAF4kps2aNUPnzp2hpaWFxYsX4++//8bdu3dV3QzGGGMqpqOjAy0trTfW8/Pzw8CBA9G7d29oaGjAyMgIzZo1E8ofPnyIZs2aQU9PD2ZmZmjWrBlMTEzK3Nfy5csxbNgwODo6CvueMmUKGjZsiLp162LWrFlYv3591TSQvRc4+axBRCIRdu/eDQcHB8yaNQtZWVll1ouKilK6G+no6IhHjx7h4cOHpep6e3tj9erVqFOnDgAgNzcX+fn5QnnJY/64uDhh3d9//43GjRtjwoQJSElJqaLWMcYYqykiIyNhamoKNzc3mJmZoVevXrh//75QPmbMGFy4cAH+/v44f/48HB0d8dFHH5Xaz+3btxEUFKT0aL2sa1h0dDSIqHobxVSGk88axNPTE8+fP8fBgwdx69YtDB8+vMx6aWlpMDQ0FD6X/DstLU2p3u7du/H8+XMMHjxYWNezZ09cv34dhw8fRkFBATZv3oxHjx4hNzcXAODq6gqFQoHTp0+jqKgIPXr0gEKhqOqmMsaqCBG9dmHsXaSkpODw4cPYtGkT7t+/Dz09PYwePVoo19LSQtu2bUFEmDx5MoyMjMr8fZs5cybmzJkDfX19YV1Z1zCFQlHuOw6s5uHks4bR0NCAvb09tm7dihMnTpR559Hc3BxPnz4VPpf8wVpYWAjr8vLyMHfuXKUO3gBgb2+P3bt345tvvoFMJkNhYSEMDQ3RsGFDoY5IJIKNjQ1++eUX3L17F1euXKnqZjLGGHuPGRoaYtKkSbC3t4eenh6++eYbnD9/Hjk5OQCASZMmoXPnzhg3bhwuXLiAvXv3Yvny5Ur7CA0NRUxMDCZNmqS0vqxrmI6OTpnvOLCaqVYln+np6RCLxejevXuZ5RcvXsTAgQNRt25diMVimJubw8XFRRhOwt/fX+ktUIlEgsaNG8Pb2xuPHz9W2pdMJkPLli2V3iIv2YdMJquW9r1MT08PAPD8+fNSZW3atFF6Az06OhqWlpZKyeemTZsgFovRs2fPUtsPHDgQN27cQHJyMnr06AGRSCT0xXmZtrY2xGJxmTEwxhirvRwcHJSui2KxGGKxGLq6ugBevD9gbW0NADAwMICnpycOHTok1CcifPvtt/Dy8oJYLFbad1nXMCcnp9eOzuDq6ipcuzU0NCCVSvHRRx/h119/LbP+f/7zH4hEIvz999+lysaOHVvmyBCFhYVITEyESCTCgQMH3nySWLlqVfIZFBSEgoICnD59GqmpqUpl+/btg7OzM8zNzXH69Gncv38fBw4cQLdu3Ur1nUxMTER6ejquX7+OBQsWYP/+/XB2dkZGRoZSvZiYGGzcuLFSMR8/fhzbtm2rUF25XI68vDwUFBRgyZIlcHBwQOPGjREZGQkHBwdERkYCAKZOnYo9e/YgOjoa//77L1asWAFvb29oaPzfj/unn36Cp6dnqT9mIhJeLnr06BEmT56MOXPmCH1CHz58iKdPn6K4uBi+vr7Q1dVFx44dK3UOGGOMvd9evc5MmTIFv/32G2JjY1FQUIC1a9di2LBhwnXG0dERGzduRE5ODrKysvC///1P6VoRHh6O69evlxpNBQBmzJiBLVu2QC6XIy0tDWvXrsXMmTPfGGPv3r2RmZmJlJQUnDp1Cs7OzvDy8sLs2bOV6hUVFSEwMBAAsHPnzjL35ejoiMzMTKWlIi9isQqiWqRjx47k5uZGAMjX11dY//TpU5JKpTRs2LDXbr9t2zYCQJmZmUrrY2NjSUNDg2bOnCmss7GxIRMTEzI0NKTU1FSlfdjY2FQ4Zk9PT+rcuXOF6m7atIlMTU3JwsKC+vXrR3fu3CEiojNnzhAAOnPmjFA3MDCQrK2tycjIiL788ksqKCgQyu7du0cA6Pz586WOUVRURC1btiQDAwOysrKipUuXUnFxsVB+8OBBMjc3JzMzM3J1daXLly9XuK3vMwBUU/8canLsb+tDamtlVfRc8Tl9P6nr53LhwgUyMjIiHR0d0tLSIiMjI/Lz8yvzOrN582aysrIiMzMzGj16tNK18+7du9SrVy8yNjYmS0tLmjRpEv37779C+cKFC6lp06blxrFu3ToyNzcnU1NTWrRo0Rvj7ty5Mw0YMKDU+nnz5pFIJKKrV68K644cOUKampr0+eefk6mpKeXn5ytt4+npSU5OTmUeJyEhgQDQ/v373xgTK1+t+caJi4sjABQeHk5t27alNm3aCGU7duwgAEq/fGUpL/kkIho8eDCZm5sLn21sbGjVqlVkZGREY8aMUdrHq8mnr68vWVlZkbGxMU2YMIFycnKIiGjx4sXCFwyACiehrOrV5AtwTY79bX1Iba0sTj5rNv65vJ3yks/09HTS1tamuXPnCuvc3d3Jzc2NDh06RADo4MGDSttw8ln9as1j94CAAMhkMnzyyScYNWoUrl27hps3bwJ4MWyDlpYWWrVq9c77b9OmDdLS0vDkyRNhnYWFBZYuXYqAgACEh4eXud2uXbuwdu1a7Nu3D3///TcuXryIFStWAADmzZsHd3d3fPrpp8jMzERISMg7x8cYY4wxZaampmjYsCFu3LgBAPj3339x4MABeHh4oGfPnjAxMSn30TurPrUi+SQi7Ny5E+7u7hCJRBgxYgQ0NDQQEBAA4MWbcmZmZtDU1HznY5iZmQFAqWGFpk2bhlatWmH69OkoKioqtd2qVaswdepUdOrUCQ4ODhg/fjx2794NANDV1YVYLBamq3x5qImyvGmaPF7efWGMsfeRur8b35elMszMzIRr9969e0FEGDx4MLS1tTFkyBAcPnxY6e16ALh+/brS9J/79u2rVAxMWa1IPsPDw5GYmAgPDw8AgLW1NVxcXLBr1y4QEQwNDZGenl7qzfS3kZKSAg0NjVIzNGhqamLjxo34559/8NNPPymVFRYW4ubNm1ixYoXwCzx//nzI5fJ3joNVn5enhmOMMXXi76Oqk5KSItxACggIQN++fYVxREeNGoW8vDzs2bNHaRt7e3tERUUJS48ePVQed21WK17dKrnD2a5dO2FdYWEhioqKEBYWhlatWqGwsBDXrl1Dhw4d3ukYV65cQcuWLYVhJF7m4uKC0aNHY9GiRfj222+F9cXFxSgqKsJ3330nJMaVQTwgNGOMfRBCQ0PVHUKtkJqaipSUFHTs2BFJSUk4e/YsNDQ0Sl3Ld+7cqTSfvVgsVsmwiR+qGn/nU6FQIDg4GEuXLlX6X8rly5chkUiwc+dODBw4EPr6+krTd72NmJgYHD16FBMnTiy3zg8//IDi4mKsXr1aWCcWi9G6dWtcvHgRMplMaSmhqamJgoKCd4qLMcYYY+Vbu3YtdHR0MGrUKPzxxx+oW7cuoqOjlfIFb29vnDt3DklJSeoO94NR45PPw4cPIy8vD9OnT4eDg4OwtG7dGkOHDsWePXsgkUiwefNm/Pnnnxg+fDguX76MR48eISIiAvPnzy8160J2djaysrKQlJSEwMBA9OnTBz169MCUKVPKjcPS0hI+Pj5KLyQBwJIlSxASEoKFCxciPj4e9+7dw2+//SaU29nZISoqChcvXiy1LWOMMcYqpqCgAFlZWcjIyEBsbCy+++47/Pjjj9iyZQvMzc0REBAAT09PNGvWTClfmDlzJogIu3btqvCx0tLSkJiYKCzJycnV2LJaSK3v2leB/v3706hRo8osO3fuHAGgvXv3EtGL8TB79uxJxsbGpKOjQ40aNSIPDw+6dOkSEf3fUEsli0QiodatW5Ovr2+pccBsbGxo27ZtSusKCgqoRYsWpYZaOnDgALVu3ZrEYjGZm5tTnz59hLKnT59S3759qU6dOkpDNjFWUfiAhmT5kNpaWRU9V3xOWW3QuXNn4XdZJBKRiYkJ9enTh/766y8iIrp69SoBoLi4uDK3//zzz6lly5ZEVLGhll5dGjduXC3tqq1ERNyRkLGarORN0A/hT/lDamtlVfRc8Tll6vLw4UOcPn0ajo6OlRoKkdU8Nf6x+4coJycHLVq0wNixY8utIxKJlIaJ2Lx5s1C2bt061K9fH1KpFDKZDL6+vkrburi4wMzMTJgb9+rVq0rl69atg6WlJczMzN65Hy1jjLH3y/r162Fvbw+pVAonJyecOnXqtfVPnDgBR0dHSKVSODs7486dO0JZ3759la5B+vr6aNSokVA+b948fPrpp5gwYYIwBufL+DpTy6nztit7N56enmRnZ0eenp7l1nndjzYhIYHy8vKIiCg4OJhEIpEw6xIR0a1bt4iISKFQ0ODBg2nEiBFC2Z9//kk2NjZ0//59SktLo1atWtHOnTsr2SJWGfiAHpt+SG2trIqeKz6nrERAQADJ5XIqLi6mTZs2kZGRET179qzMuvn5+WRmZkZXr16loqIimjVr1munsJ4xYwbNmzdP+FyyXxsbGwoMDFSqy9eZ2o/vfNYw/v7+kMvlmDt37jvvQyaTQUdHB1lZWYiKikKvXr0gkUiEcnt7exCR0Il6wIABQpmfnx+mTJmChg0bom7dupg1axbWr19fqTYxxhhTv9GjR8Pa2hoikQhjx45FdnY27t27V2bdZ8+eoaioCC1atICGhgacnZ1LjYNdIiYmBqGhoVi4cKGwTk9Pr9w4+DpT+3HyWYPcuHEDK1euRGBg4Btna9LQ0ICVlRV69+6NS5culSq3srKCsbExzp07h+3btyuVhYaGQiwWo1mzZhgwYADc3d2FsqioKLRs2VL47OjoiOjoaO4vxhhjtUhERAQMDAxga2tbZrmxsTG8vLzg4eGBlJQUhISEYOnSpWXW9fb2xurVq1GnTp0KHZuvM7UfJ581RE5ODjw8PODv7w9zc/M31i8qKkJsbCy6d++OLl26KPXFAV7M+JCUlAQ7Ozu4uLgoTRvap08f5OTk4Pz589i2bRuWLFkilKWlpQkzQwCAoaEhFAoFsrOzq6CVjDHG1C01NRVffvkltm7d+tppn21tbdG6dWvMmTMHKSkpZU4xvXv3bjx//hyDBw+u8PH5OvMBUOcz/8ePH5O2tjZ169ZNaX3JUAb79+9/p/16enoK/Zi0tbWpWbNmpfqLdO7c+bV9JomITE1NafHixe8Uw+scPXqU3NzcSCqVklgspnr16lGXLl3o5MmT5W6zY8cO0tbWJgsLC7KwsCBDQ0PS1dWlQYMGvfF4Xbt2pRUrVpRZlp+fT7q6unT8+PEyywMCAsjKykr4bG1tTaGhocLnS5cukY6ODhUXF78xDlY98AH12fuQ2lpZFT1XfE7ZyxISEsjBwYGCgoJeW+/o0aPk6uoqfF61ahU5ODgoDUuYm5tLDRs2pCNHjpS7n7L6fFbmOlOdeUV5wy9VlYrkJa9T0sYzZ85UqD5eGirKyMiIevXqRXfu3Hnn478Ntd75DAoKQkFBAU6fPo3U1NQq3bejoyMyMjLwzz//oH379vjiiy9w/fp1oTwkJKTUXOyqsGHDBvTp0wcdOnRAREQE4uPjsWvXLnTs2BFZWVnlbjd06FA8ePBAmJFh0qRJ6N+/P3799dc3HlNPTw/Pnz8vs0xLSwtisRgaGmX/KkgkEqWyNm3aKJ3H6OhoODk5CcO1MMYYq5nS0tLg5uaG1atXY8SIEa+tGxISAmtra+Gzt7c3bt26hdu3bwvrNm3aBLFYjJ49e75VHJW5zlRnXlHd3iYvuXXrVqluDg0bNkRmZiacnZ0rfMyVK1fi0aNH2Lt3L27duqXUza46qTX5DAgIgJubG4qKihAYGFil+9bU1ISxsTGaNWsGPz8/FBcX4+LFi0K5vr5+hfufVJX4+Hh8/fXX+Prrr7Fy5UrY29ujfv36cHV1xX//+18MGTKk3G0lEgksLS2FRV9fHxKJBCYmJoiMjISDgwMiIyMBALm5uZDL5QCAsLAwnDhxAr179xb2deLECTx58gSFhYVYvnw5dHV1hTnvs7OzcfLkSRQWFuLRo0dYvXo1+vbtK2w7Y8YMbNmyBXK5HGlpaVi7di1mzpxZHaeLMcaYCnl5ecHFxQX9+vUrVfbqdcbR0RGhoaGIiYkBEeGXX36BqampUh/Rn376CZ6enm99c6Iy15nqzCuq29vkJREREaWGoNLQ0IBUKoWWllaFjymRSGBubo6uXbti5syZuHLlCvLz898q7nehtuTz9u3biIyMhI+PD9q2bYudO3dW27HS09MBABYWFsI6V1dXpXEyFQoFvLy8YGBgAEtLS6xdu7bUfrKzs+Hu7g49PT3Y2Njgl19+gUgkgr+/v1AnPj4e3bp1g0QigaOjo9I4aX/88QcAYM6cOVXavpycHMTFxSEnJwcAkJWVBWdnZxgbG2Pq1Kn4/fff8emnnwr1Dxw4AHt7e9StWxd//vknQkJChP41CoUCX331FUxMTNC6dWs4OTkpzVfv5uaGmTNnon379mjevDmGDBmCUaNGVWl7GGOMqd7Bgwexe/dupfE5Hzx4AKD0dcbLywtTpkxBjx49YGpqij179uDIkSPCyCnx8fGIj49Hly5dyjzWjBkzhP1PmDABUqkUGRkZAN79OqPKvOJVFy9ehLOzM3R1dWFhYYGZM2ciLy9PKCci+Pj4oG7dujA2Nsa8efPQtm1bpTzk1bwkLi4OnTt3Rp06dWBsbCyMyX327FmMGzcOwIsxvUuS+8TERIhEIpw9e1bYx927dzFgwAAYGRlBV1cX9vb2ePbsWZltSE9Ph7GxMcRisbDuypUr6NSpE+rUqYOOHTsiKipKaZv9+/ejSZMmkEgkGDRoEMaNGweZTPbmE6aSh/tlWLBgAclkMiouLqY1a9YQALpx4wYRVW3fjHv37pGbmxs5Ojoq9UV5tW/FnDlzyNramsLDwyk2NpbGjRtHAJT6fI4cOZIaNWpEERERdOvWLRoyZAgBEKbZLCwspGbNmtHs2bNJLpfTjz/+SAYGBpSRkUFERIMHDyaZTPZObWKsPPiA+ux9SG2trIqeKz6nrLZQVV7xqkePHpGhoSF5e3tTQkIChYWFka2tLU2ePFmos2XLFtLV1aWgoCCSy+Xk4+NDIpFIKQ95NS9xc3OjsWPHUmpqKsXGxlJUVBQRvZjKe9OmTQSAMjMzKTMzU6mNJX0+c3JySCaTUYsWLej8+fOUkpJCx48fJ4VCQUQv/vbXrVtHBQUFdOTIETIyMqL//ve/wvGzsrLIzMyM1q1bR3K5nGbPnk0ymYwKCgqIiCgmJoY0NTVp/vz59ODBAwoKCiKpVFpqivGyqOUbp7i4mGQyGX377bdERCSXy0lDQ0P4XBW/JBoaGqSrq0sA6PPPP6fHjx8r1Xn5h5ybm0v6+vq0YcMGpTovv3CUmJhIIpFIqWP006dPlZLPvXv3Up06dZSSXCMjI+Flp65du9JHH330Tm1irDwfUvLwIbW1sjj5ZB8SVeQV5SWfCxcuJEtLSyEpI3rxsq6mpialpaUREZVKRomI2rZt+9rks02bNuTp6UmFhYWljrlt27ZSf7evJp+//vorAaArV66UGTcA0tXVJU1NTQJAvr6+SuW+vr7UtGlT4XNGRgYBoPDwcCIiGj9+PNnb2yttM2vWrAoln2p57B4eHo7ExER4eHgAAKytreHi4oJdu3ZVaByvlx8JlPV4AHgxUPrNmzcxevRo3LlzBzo6OuXuLyEhAc+ePXvt3LIl/Vo6deokrHu1H8v169eRl5eHunXrCjE9ffpU6H9paGhYqQ7QJbfXeeHl5YWxqqDu32NeeHnd8iaqyCvKExMTgxYtWij1tXRyckJRURFu3bqF58+fIz4+Xil/KPmbe52lS5ciKCgIdnZ22LJlS5lDWb1ObGwsDA0N0bZt23LrzJkzB9HR0TAxMSnV1uvXryMhIUE4FyXTo5bkNNHR0W/dphIV75VahQICAgAA7dq1E9YVFhaiqKgIYWFhaNiw4Wu3f7XPQQkrKyvh32KxGDKZDD/88APs7OywYMGCcmdI+PfffwEAurq65R4zNzcXAF7bGTg/Px8mJialBnWXSqUAgFatWuHQoUN4+PAhLC0ty90PY2/r5RfKGHsbvXv3xpEjR9QdBmOVooq84m2UJLwikahC+UNZ+vbti7i4OPj6+uKrr77Cn3/+if3791d4e01NzXJHsilhYmKC5s2bY9myZZgxYwZGjx6N9u3bA3iR0zg6OpY6ppmZGYAXedG7vrit8jufCoUCwcHBWLp0qTBsUFRUFC5fvgyJRFKhDsIymazMpaw3vCwtLbFo0SJs3LgRly9fLnN/NjY2AKA0jVhubq7SG18lb/C9XOfx48cA/i/T79SpE9LT05GRkaEUV0nyWdJh+uVB298GvegmwQsvpZbQ0NB3+p1iLDQ0VO2/v7zw8qbldVSdV7zK0dERsbGxKCwsFNb9888/0NTUhL29PczMzGBgYKCUPxQWFiIrK+uNdwptbGywYcMGbN68GQcOHMCTJ08AQJjlsKCgoNxt27dvj6ysLFy7du2NbZg8eTIcHR3h5eUl3GHt1KkTbt68CR0dHaVzUjLxgK2tbanpVx8/flyhu58qTz4PHz6MvLw8TJ8+HQ4ODsLSunVrDB06FHv27BFm20lLS0NiYqKwJCcnv9MxZ86ciaZNmyqd1JdZWFige/fu+P7773Hz5k1cvXoVQ4YMUfqhtm3bFk5OTvDx8UFCQgL++usveHp6AgC0tbUBvJgZqFOnTvDw8MCZM2eQmpqKsLAwnD9/HgBgZ2eHZcuWYcuWLZg2bRpiYmKEOt7e3vjtt9/eqX2MMcbYh0pVeUV+fr7StomJiXj+/DmmTZuG58+fY/bs2UhMTERYWBgWLVqESZMmoW7dugCAcePGYfPmzbh8+TJu3ryJYcOGISMjQ8gfyrJo0SJERkYiJSUFFy5cgKWlJYyNjQG8yCcA4Pfffy+3O9/QoUPRqlUrjB49GufPn0dKSgoOHDhQ5pjimpqa2LBhA65duyY8JR43bhysrKwwZMgQREZGIjU1FSdOnEB0dLRQfvr0aQQHB0Mul2PBggU4evToa9skIBXr378/jRo1qsyyc+fOCZ1e8dLI+yVL48aNK3SMsjoGHzt2jADQmjVriKh0x97U1FTq1asX6enpUbNmzej48eOlZjiKjY2ljh07klgsptatW9PJkycJAB08eFCok5GRQRMmTCATExPS1dUlR0dH2rt3r1Ise/fupc8++4wMDAxIIpFQkyZNyMvLi+Li4irUPsY+VOCXYyqMzxX7UKgqryhr+4CAACIiunDhAn388cckFovJ3NycZsyYQbm5ucL2T58+pWHDhpGuri41bNiQtm/fTm3atKH//Oc/Qp1X85IxY8ZQvXr1SCKR0Mcff0yXLl1Simnu3LlkZGQkvOBT1gxHSUlJNHDgQKpTpw4ZGRmRs7Oz8AI2/v/b7i8bOXIk6enpUWJiIhERPXjwgIYOHUqGhoakp6dH7dq1o7CwMKH+okWLyNjYmKRSKc2aNYtmzJhBbdq0eeP5FP3/ANg7uHLlCtq3b4/r16/D0dFR3eEwVuuVPM7hr60343PF2PuroKAAFhYWWLp0KaZPn67ucKpMv379oKOjgz179ry2nlpnOKpp9u3bh/DwcDx8+BCXL1/G9OnT4eTkpLLEc926dahfvz6kUilkMpkw4GxZTpw4AUdHR0ilUjg7O+POnTul6uTk5KBFixZKg9q+7PTp09DU1FQasDYxMVGYRaFk4f6GjDFW861fvx729vaQSqVwcnJSmiSlLH5+fpDJZDA2NsaUKVOUuqopFAqMGzcO5ubmsLS0xMqVK5W2lclkMDQ0FK4j3377rVBGRJg3bx5MTU1Rr149bN68uWobqgaRkZE4fPgw5HI57ty5gylTpkChUGDgwIHqDu2dpaWl4ffff8fdu3eRlJSETZs2ITQ0VBhx4LXeeG+UCRYtWkQNGjQgsVhM1tbWNGbMGHr06JHKjp+QkEB5eXlERBQcHEwikYhycnJK1cvPzyczMzO6evUqFRUV0axZs2jYsGGl6nl6epKdnZ3Sbf4Sqamp1KhRI2rQoIHSLfyEhIQKjeHFWHUAP0quMD5X7G0FBASQXC6n4uJi2rRpExkZGdGzZ8/KrHvo0CGSyWQkl8spOzub3NzcaMWKFUL5999/T+7u7pSfn0/x8fFkYmJCsbGxQrmNjQ0lJCSUue+ff/6Z2rVrR0+ePKF79+4JE8DUZPv376dmzZqRRCIhU1NT6tq1K129elXdYVXKnTt3qFOnTsIj+TZt2lBQUFCFtuU7n29hyZIlePDgARQKBeRyOXbs2AFzc3OVHV8mk0FHRwdZWVmIiopCr169hKnMXvbs2TMUFRWhRYsW0NDQgLOzM0xMTJTq+Pv7Qy6XY+7cuaW2Ly4uhoeHBxYuXKg0Ty9jjLHaa/To0bC2toZIJMLYsWORnZ1d6m3mEoGBgXB3d4e1tTUMDQ2xZMkS/PTTT0L5w4cP4eTkBG1tbTRq1AgymQxGRkYVisPPzw9z5syBiYkJbG1tMXHixHKHSqwpBg4ciBs3biAnJwfp6ek4efIk2rRpo+6wKqVJkyaIiIhAdnY2nj17hqtXr2LEiBEV2paTzxrGysoKxsbGOHfuHLZv315mHWNjY3h5ecHDwwMpKSkICQnB0qVLhfIbN25g5cqVCAwMFIZreNnSpUtha2srzB37quTkZNjY2GD48OG4fft21TSMMcbYeyMiIgIGBgbl3oB4dThCc3NzJCcn4/nz5wAAb29vbNu2DUePHsW+ffvg6emJ+vXrC/U1NTXRoUMHuLq64vjx48L6goIC3LhxAy1bthTWOTo6ljsOJ6uZOPmsYVJSUpCUlAQ7Ozu4uLgIw0e8ytbWFq1bt8acOXOQkpIiDDGVk5MDDw8P+Pv7l3nX9vTp0zhy5Ag2btxY5n5lMhkKCgoQGRkJW1tbuLq6CuOOMcYYq/lSU1Px5ZdfYuvWrcKYjq/q168fdu3ahbi4ODx79gyrVq0C8H8Tsujq6qJjx45ISUnBd999B0NDQ6Xt7927h4SEBEyaNAmDBg1CWFgYACA9PR3FxcVK9Q0NDZGWllYdTWXqUs1dAlg1yc/PJ11dXTp+/HipsqNHj5Krq6vwedWqVeTg4ED5+fm0Y8cO0tbWJgsLC7KwsCBDQ0PS1dWlQYMGERFRly5dyNDQUCjX1tYmY2PjcvtxNG7cmP7444/qaSRjrwD3Y6wwPlfsXSQkJJCDg8Mb++4VFxeTj48PWVtbU/PmzcnPz4/q1KkjlH/00Ud09uxZIiJKSUkhW1tb2rFjR5n7mjBhAk2aNImIXlzbNDQ0lPqHBgcHk52dXWWbxt4jfOezAlxdXYX5ZUve9P7oo4/w66+/CnXOnj0LkUhUoUcDiYmJEIlEOHDgwDvHpKWlBbFYXObUWSEhIbC2thY+e3t749atW7h9+zaGDh2KBw8eCDNATJo0Cf379xfaEhwcjLi4OKHcwsICv/76K/r3719mHHp6esJjFsYYYzVXWloa3NzcsHr16jf23ROJRFi8eDHkcjliY2MhFovx2WefAXhx9zIiIkK4DtWrVw9DhgzBoUOHytzXy9cRbW1ttGjRAtevXxfKo6Oj0bp16wq1IT09HWKxGN27d1daX9nr7tixY+Hq6qq07ptvvoGdnZ0wRbePjw80NDRw4cKFUtuLRCKlkWMA4NixY+jWrRuMjY2ho6MDKysrdO3a9Y2jDNQGnHxWUO/evZGZmYmUlBScOnUKzs7O8PLywuzZs1UWw4kTJ/DkyRMUFhZi+fLl0NXVRYcOHRAZGQkHBwdERkYCeNE/JjQ0FDExMSAi/PLLLzA1NYWtrS0kEgksLS2FRV9fHxKJRHghycTERKlcU1MTJiYmwotNmZmZSE9PBxEhODgYd+/eRZcuXVR2DhhjjFUPLy8vuLi4oF+/fqXKXr3OZGdnC1NMX716FStWrMDChQsBvLiO1KtXD2vXrkVBQYHw7kHHjh2F/ZW8LxAbG4vAwED07dtXKJsxYwbWrFmDjIwM3L17F7/99htmzJhRoTYEBQWhoKAAp0+fLnfmn6oQGhoKPz8/BAcHw8DAQFhPRJg+fTqKi4tfu/2GDRvQp08fdOjQAREREYiPj8euXbvQsWPHMmcgqm3ePGkpA/Dif2Mlc7RbWlqiXbt20NbWxvfff1+xMa2qwIEDB+Du7i68yR4SEgJDQ0Pk5OQgLi4OOTk5AF58gcjlcvTo0QO5ublo0aIFjhw5Uuab8W/r3r176N+/PxQKBZo0aYKDBw+icePGld4vY4wx9Tp48CAkEgn2798vrIuOjkbDhg1LXWfi4+MxePBgPHnyBA0aNMCPP/6ITz75BACgoaGBkJAQfPXVVzA3N4e+vj48PDwwa9YsYb+9evXCkydPYG5ujgULFsDd3V0omzBhAu7evYsmTZpAV1cXixYtwqefflqhNgQEBMDNzQ0nT55EYGCg0jGryv379/HFF19g/fr1cHJyUiozMTHB1atX8fPPP2PKlCllbh8fH4+vv/4aX3/9tdL4p/Xr1y91d7XWUvNj/xqhc+fONGDAgFLr09PTSVtbm+bOnUtnzpwhAHTt2jWh/NKlS9SlSxeqU6cOSSQS6tSpExH93xRY+/fvV00DGKslwP0YK4zPFfvQxMXFEQAKDw+ntm3bKk3zWNnrrqenJ3Xu3Jny8/OpU6dO5OHhUarO4sWLqXPnzjRy5EgyNjYWprEkIqVpL5cuXUpaWlqUlpb2TrHUBvzYvRJMTU3RsGFD3Lhxo1TZo0eP0LVrVxQUFOD8+fO4ffs2li1bpoYoGWOMsdovICAAMpkMn3zyCUaNGoVr167h5s2bVXqM2bNnIysrC1u2bCm3zpo1a1BQUKA0a9PLoqKiYG1tjbp161ZpbDUJP3avJDMzszKHO9q4cSMUCgV2796NevXqAYDSS0DvomSuZsYYqyj+3mC1ARG9sXznzp1wd3eHSCTCiBEjMHfuXAQEBJSa2vNdPX78GD///DMmTpxY7hBUwIvH54sWLcI333yDSZMmKfV1BV70l7W0tKySmGoqvvNZSSkpKTAzMyu1PjY2Fvb29kLiyRirGr1791Z3CDUCnyf2IQkPD0diYqLwDoa1tTVcXFywa9euNyauAIQ55l9dHjx4INSpW7cu/Pz8sGnTJgQFBb12f1999RXs7e0xbdq0Ui8fGRoaVuvLUDUB3/mshNTUVKSkpJT6Xw3wYvaGqr7jUJE/IMYYA168jcvYhyIgIAAA0K5dO2FdYWEhioqKEBYWhoYNG752+/KGSbSyslL6PGnSJFy6dAnjx4+Hvb19uVNkamtrY+PGjXBzc1MalhEAWrVqhUOHDuHhw4cf7B1QvvNZCWvXroWOjg5GjRpVqqx9+/a4desWHj58qIbIGGOMsQ+DQqFAcHAwli5dKoxRHRUVhcuXL0MikWDnzp1v3IdMJitz0dIqfY9u48aNaNWqFQYOHPjamZe6du2KYcOG4bvvvlNaX5IzLFmy5C1bWntw8llBBQUFyMrKQkZGBmJjY/Hdd9/hxx9/xJYtW8qcpnLq1KkwNjbG8OHDce3aNcjl8lJ/AGlpaUhMTBSW5ORkVTWHMcYYqxUOHz6MvLw8TJ8+HQ4ODsLSunVrDB06FHv27BHezaiK665YLMbevXuhUCgwdOhQFBQUlFvX19cXeXl5Suvs7OywbNkybNmyBdOmTUNMTAxSU1MRFhYGb29v/Pbbb28dU03DyWcFHTlyBMbGxjAzM8Nnn32G6OhonD59GmPGjCmzvoGBAU6dOgVtbW18/PHHaNOmDbZv365UZ/LkyWjUqJGwdO7cWRVNYYwxxmqNgIAADB48GMbGxqXKJk6ciMzMTKEbSlVdd+vXr4///e9/uHDhAry9vcut16BBAyxYsKDU+m+//RZ79+5FTEwMPvnkEzRu3Bjjx49Hfn4+XFxc3immmkRE3JGQMcYYY4ypCN/5ZIwxxhhjKsPJJ2OMMcYYUxlOPhljjDHGmMpw8skYY4wxxlSGk0/GGGOMMaYynHwyxhhjjDGV4eSTMcYYY4ypDCefjDHGGGNMZTj5ZIwxxhhjKsPJJ2OMMcYYUxlOPhljjDHGmMpw8skYY4wxxlSGk0/GGGOMMaYynHwyxhhjjDGV4eSTMcYYY4ypDCefjDHGGGNMZTj5ZIwxxhhjKvP/AEGer6GupyNdAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 648x126 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.read_csv('csv_xls/microal_us8k_1k_run.csv',index_col=False)\n",
    "cols = df.columns.tolist();\n",
    "classifiers = [cls for c in cols for cls in [c]*1000 ];\n",
    "datasets = ['Dataset_{}'.format(i) for c in cols for i in range(1,1001)];\n",
    "accuracy = [a for cls in cols for a in list(df[cls])];\n",
    "df_perf = pd.DataFrame([classifiers, datasets, accuracy]).T;\n",
    "df_perf.columns = ['classifier_name', 'dataset_name', 'accuracy'];\n",
    "draw_cd_diagram(df_perf=df_perf, title='Accuracy', labels=True, diagram_name='micro_us8k_sig_diag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ACDNet' 'DeepIcL' 'DeepFeatAL' 'AL-KNC' 'AL-LogisticReg' 'AL-RidgeC']\n",
      "ACDNet              9.0\n",
      "AL-KNC              1.0\n",
      "AL-LogisticReg     37.0\n",
      "AL-RidgeC          18.0\n",
      "DeepFeatAL        794.0\n",
      "DeepIcL           138.0\n",
      "dtype: float64\n",
      "AL-KNC            4.8605\n",
      "ACDNet            4.4595\n",
      "AL-RidgeC         4.2190\n",
      "AL-LogisticReg    3.5450\n",
      "DeepIcL           2.6645\n",
      "DeepFeatAL        1.2515\n",
      "dtype: float64\n",
      "('AL-KNC', 'DeepFeatAL', 4.883546895236033e-165, True)\n",
      "('ACDNet', 'DeepFeatAL', 1.7001020467115837e-164, True)\n",
      "('AL-RidgeC', 'DeepFeatAL', 1.3659775531215002e-163, True)\n",
      "('AL-LogisticReg', 'DeepFeatAL', 1.1016214043891834e-157, True)\n",
      "('AL-KNC', 'DeepIcL', 3.476488939307429e-139, True)\n",
      "('DeepFeatAL', 'DeepIcL', 1.372610759617015e-125, True)\n",
      "('ACDNet', 'DeepIcL', 2.673260346118747e-116, True)\n",
      "('AL-RidgeC', 'DeepIcL', 7.189877417507319e-96, True)\n",
      "('AL-KNC', 'AL-LogisticReg', 1.1042175156398618e-81, True)\n",
      "('ACDNet', 'AL-LogisticReg', 5.128632345437056e-48, True)\n",
      "('AL-LogisticReg', 'DeepIcL', 2.9895233952349087e-43, True)\n",
      "('AL-LogisticReg', 'AL-RidgeC', 6.320597434485881e-28, True)\n",
      "('AL-KNC', 'AL-RidgeC', 1.0767352813270272e-24, True)\n",
      "('ACDNet', 'AL-KNC', 1.281208979207127e-10, True)\n",
      "('ACDNet', 'AL-RidgeC', 2.954088089684417e-05, True)\n",
      "Index(['AL-KNC', 'ACDNet', 'AL-RidgeC', 'AL-LogisticReg', 'DeepIcL',\n",
      "       'DeepFeatAL'],\n",
      "      dtype='object')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x126 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.read_csv('csv_xls/microal_iwingbeat_1k_run.csv',index_col=False)\n",
    "cols = df.columns.tolist();\n",
    "classifiers = [cls for c in cols for cls in [c]*1000 ];\n",
    "datasets = ['Dataset_{}'.format(i) for c in cols for i in range(1,1001)];\n",
    "accuracy = [a for cls in cols for a in list(df[cls])];\n",
    "df_perf = pd.DataFrame([classifiers, datasets, accuracy]).T;\n",
    "df_perf.columns = ['classifier_name', 'dataset_name', 'accuracy'];\n",
    "draw_cd_diagram(df_perf=df_perf, title='Accuracy', labels=True, diagram_name='micro_iwingbeat_sig_diag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func1(a, b):\n",
    "    return a*b;\n",
    "\n",
    "def func2(a, b):\n",
    "    return a+b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "a = 20; b = 20;\n",
    "f = func1;\n",
    "if a > 10:\n",
    "    f = func2;\n",
    "\n",
    "print(f(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}