MIMICS_Characteristics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "ILQk_GWVEomi",
        "ufMZnAupEm03",
        "EU1NprGn09km",
        "azyO1gxSRLXt",
        "eg-r3ZgyDNzr",
        "EBgEECuDxfgA",
        "9A-LqOchXBS4",
        "LLj7p3ItruOm"
      ],
      "authorship_tag": "ABX9TyN20vmqneERjYc0q/59Cq3l",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rahmanidashti/CQSatisfaction/blob/main/MIMICS_Characteristics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Analysis"
      ],
      "metadata": {
        "id": "IvklLH8E2XpP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Install and Import"
      ],
      "metadata": {
        "id": "iaAIojWbQJZe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install rouge"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3lUvYMkKLxub",
        "outputId": "d7231074-5b89-45a0-807a-52d7885f77ed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting rouge\n",
            "  Downloading rouge-1.0.1-py3-none-any.whl (13 kB)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from rouge) (1.16.0)\n",
            "Installing collected packages: rouge\n",
            "Successfully installed rouge-1.0.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# import\n",
        "import re\n",
        "import copy\n",
        "import pandas as pd\n",
        "from rouge import Rouge\n",
        "from tqdm import tqdm\n",
        "import numpy as np\n",
        "from scipy import stats\n",
        "from textblob import TextBlob\n",
        "import collections\n",
        "import random\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "sns.set_theme()"
      ],
      "metadata": {
        "id": "Na3sXvQg2Nsn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data Loading"
      ],
      "metadata": {
        "id": "i5ceSPyUC_Vw"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CsaXgQ5y2EAM"
      },
      "outputs": [],
      "source": [
        "DATASET = \"MIMICS\"\n",
        "# load dataset in a pandas dataframe\n",
        "if DATASET == \"MIMICS\":\n",
        "  dataset_df = pd.read_csv(f\"https://raw.githubusercontent.com/microsoft/MIMICS/master/data/MIMICS-Manual.tsv\", sep='\\t')\n",
        "elif DATASET == \"MIMICS-Duo\":\n",
        "  dataset_df = pd.read_csv(f\"https://raw.githubusercontent.com/Leila-Ta/MIMICS-Duo/main/Data/Task2-QualityLabelling.tsv\", sep='\\t')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if DATASET == \"MIMICS-Duo\":\n",
        "    target = 'OverallClarificationPaneQuality'\n",
        "    dataset_df.loc[dataset_df[target] == 2, target] = 1\n",
        "    dataset_df.loc[dataset_df[target] == 3, target] = 2\n",
        "    dataset_df.loc[dataset_df[target] == 4, target] = 3\n",
        "    dataset_df.loc[dataset_df[target] == 5, target] = 3"
      ],
      "metadata": {
        "id": "jAjVgf-RfSw-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Labels in MIMICS-Manual: 2 (Good), 1 (Fair), or 0 (Bad)"
      ],
      "metadata": {
        "id": "2VlkBsy9GJRz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset_df.head(1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        },
        "id": "nEboClMiMHLU",
        "outputId": "63bd289e-c1ed-47e9-f02f-35a9a83faf7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                   query                          question  \\\n",
              "0  caesars atlantic city  Select one to refine your search   \n",
              "\n",
              "                       option_1                    option_2  \\\n",
              "0  caesars atlantic city events  caesars atlantic city jobs   \n",
              "\n",
              "                        option_3 option_4 option_5  question_label  \\\n",
              "0  caesars atlantic city parking      NaN      NaN             NaN   \n",
              "\n",
              "   options_overall_label  option_label_1  option_label_2  option_label_3  \\\n",
              "0                      1               2               2             2.0   \n",
              "\n",
              "   option_label_4  option_label_5  \n",
              "0             NaN             NaN  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-42448a0b-21fa-4cc4-889d-2de26c4dd7d5\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>query</th>\n",
              "      <th>question</th>\n",
              "      <th>option_1</th>\n",
              "      <th>option_2</th>\n",
              "      <th>option_3</th>\n",
              "      <th>option_4</th>\n",
              "      <th>option_5</th>\n",
              "      <th>question_label</th>\n",
              "      <th>options_overall_label</th>\n",
              "      <th>option_label_1</th>\n",
              "      <th>option_label_2</th>\n",
              "      <th>option_label_3</th>\n",
              "      <th>option_label_4</th>\n",
              "      <th>option_label_5</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>caesars atlantic city</td>\n",
              "      <td>Select one to refine your search</td>\n",
              "      <td>caesars atlantic city events</td>\n",
              "      <td>caesars atlantic city jobs</td>\n",
              "      <td>caesars atlantic city parking</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>2</td>\n",
              "      <td>2.0</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-42448a0b-21fa-4cc4-889d-2de26c4dd7d5')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-42448a0b-21fa-4cc4-889d-2de26c4dd7d5 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-42448a0b-21fa-4cc4-889d-2de26c4dd7d5');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dataset Statistics"
      ],
      "metadata": {
        "id": "SOJpIRwX2S1E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"The number of samples: {dataset_df.shape}\")\n",
        "print(f\"The number of Nan in 'question_label': {dataset_df['question_label'].isna().sum()} - ({dataset_df.shape[0] - dataset_df['question_label'].isna().sum()})\")\n",
        "print(f\"The number of Nan in 'options_overall_label': {dataset_df['options_overall_label'].isna().sum()}\") #\n",
        "\n",
        "num_question_label = dataset_df.shape[0] - dataset_df['question_label'].isna().sum()\n",
        "num_option_label = dataset_df.shape[0] - dataset_df['options_overall_label'].isna().sum()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eiCMwqfDNsam",
        "outputId": "4d6ecc6f-ed79-4337-cfa0-7224579c3e12"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number of samples: (2832, 14)\n",
            "The number of Nan in 'question_label': 2257 - (575)\n",
            "The number of Nan in 'options_overall_label': 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Clarification Questions Templates"
      ],
      "metadata": {
        "id": "ggRb13dl2bjA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cq_to_count = dict()\n",
        "for cq in dataset_df.itertuples(index=True):\n",
        "  if cq.question not in cq_to_count.keys():\n",
        "    cq_to_count[cq.question] = 1\n",
        "  else:\n",
        "    cq_to_count[cq.question] += 1"
      ],
      "metadata": {
        "id": "jsm46qCl2Px8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"The numebr of unique CQ: {len(cq_to_count)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-O4sLj0i25Lu",
        "outputId": "3a57f4db-438c-473f-9e4b-04163700eca6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The numebr of unique CQ: 252\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# cq_to_count"
      ],
      "metadata": {
        "id": "oeGJ6gkZiNI1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## CQ Quality Analysis"
      ],
      "metadata": {
        "id": "7ehmuSq6QPL0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "def add_template_to_dict(cq_template, cq_count, cq_label, ca_label):\n",
        "    if cq_template not in template_cq_to_count.keys():\n",
        "      template_cq_to_count[cq_template] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "      template_cq_to_count[cq_template]['count'] = cq_count\n",
        "      if not math.isnan(cq_label):\n",
        "        if cq_label == 0:\n",
        "          template_cq_to_count[cq_template]['cqBad'] = 1\n",
        "        elif cq_label == 1:\n",
        "          template_cq_to_count[cq_template]['cqFair'] = 1\n",
        "        elif cq_label == 2:\n",
        "          template_cq_to_count[cq_template]['cqGood'] = 1\n",
        "      #\n",
        "      if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          template_cq_to_count[cq_template]['caBad'] = 1\n",
        "        elif ca_label == 1:\n",
        "          template_cq_to_count[cq_template]['caFair'] = 1\n",
        "        elif ca_label == 2:\n",
        "          template_cq_to_count[cq_template]['caGood'] = 1\n",
        "    else:\n",
        "      template_cq_to_count[cq_template]['count'] += cq_count\n",
        "      if not cq_label == None:\n",
        "        if cq_label == 0:\n",
        "          template_cq_to_count[cq_template]['cqBad'] += 1\n",
        "        elif cq_label == 1:\n",
        "          template_cq_to_count[cq_template]['cqFair'] += 1\n",
        "        elif cq_label == 2:\n",
        "          template_cq_to_count[cq_template]['cqGood'] += 1\n",
        "      #\n",
        "      if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          template_cq_to_count[cq_template]['caBad'] += 1\n",
        "        elif ca_label == 1:\n",
        "          template_cq_to_count[cq_template]['caFair'] += 1\n",
        "        elif ca_label == 2:\n",
        "          template_cq_to_count[cq_template]['caGood'] += 1"
      ],
      "metadata": {
        "id": "eeyWdZtX7RZl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Here we create a dictionary that the key is the len of non-nan options generate for each clarification question\n",
        "# and the values are the number of options with respect to key and the number of lables for CQ and Overal Candidate Answers\n",
        "def candidate_answers(option_1, option_2, option_3, option_4, option_5, cq_label, ca_label):\n",
        "  options = [option_1, option_2, option_3, option_4, option_5]\n",
        "  # the number of non-nan candidate answers (or options)\n",
        "  non_nan_options = len([option for option in options if option is not np.nan])\n",
        "\n",
        "  if non_nan_options not in answers_count_to_labels.keys():\n",
        "    answers_count_to_labels[non_nan_options] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "    answers_count_to_labels[non_nan_options]['count'] = 1\n",
        "    if not math.isnan(cq_label):\n",
        "      if cq_label == 0:\n",
        "        answers_count_to_labels[non_nan_options]['cqBad'] = 1\n",
        "      elif cq_label == 1:\n",
        "        answers_count_to_labels[non_nan_options]['cqFair'] = 1\n",
        "      elif cq_label == 2:\n",
        "        answers_count_to_labels[non_nan_options]['cqGood'] = 1\n",
        "    #\n",
        "    if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          answers_count_to_labels[non_nan_options]['caBad'] = 1\n",
        "        elif ca_label == 1:\n",
        "          answers_count_to_labels[non_nan_options]['caFair'] = 1\n",
        "        elif ca_label == 2:\n",
        "          answers_count_to_labels[non_nan_options]['caGood'] = 1\n",
        "  else:\n",
        "      answers_count_to_labels[non_nan_options]['count'] += 1\n",
        "      if not math.isnan(ca_label):\n",
        "        if cq_label == 0:\n",
        "          answers_count_to_labels[non_nan_options]['cqBad'] += 1\n",
        "        elif cq_label == 1:\n",
        "          answers_count_to_labels[non_nan_options]['cqFair'] += 1\n",
        "        elif cq_label == 2:\n",
        "          answers_count_to_labels[non_nan_options]['cqGood'] += 1\n",
        "      #\n",
        "      if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          answers_count_to_labels[non_nan_options]['caBad'] += 1\n",
        "        elif ca_label == 1:\n",
        "          answers_count_to_labels[non_nan_options]['caFair'] += 1\n",
        "        elif ca_label == 2:\n",
        "          answers_count_to_labels[non_nan_options]['caGood'] += 1\n"
      ],
      "metadata": {
        "id": "3CfLV2pZpFD7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "def query_length(query, cq_label, ca_label):\n",
        "  q_len = len(query.split(' '))\n",
        "\n",
        "  if q_len not in query_len_to_labels.keys():\n",
        "    query_len_to_labels[q_len] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "    query_len_to_labels[q_len]['count'] = 1\n",
        "    if not math.isnan(cq_label):\n",
        "      if cq_label == 0:\n",
        "        query_len_to_labels[q_len]['cqBad'] = 1\n",
        "      elif cq_label == 1:\n",
        "        query_len_to_labels[q_len]['cqFair'] = 1\n",
        "      elif cq_label == 2:\n",
        "        query_len_to_labels[q_len]['cqGood'] = 1\n",
        "    #\n",
        "    if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          query_len_to_labels[q_len]['caBad'] = 1\n",
        "        elif ca_label == 1:\n",
        "          query_len_to_labels[q_len]['caFair'] = 1\n",
        "        elif ca_label == 2:\n",
        "          query_len_to_labels[q_len]['caGood'] = 1\n",
        "  else:\n",
        "      query_len_to_labels[q_len]['count'] += 1\n",
        "      if not math.isnan(ca_label):\n",
        "        if cq_label == 0:\n",
        "          query_len_to_labels[q_len]['cqBad'] += 1\n",
        "        elif cq_label == 1:\n",
        "          query_len_to_labels[q_len]['cqFair'] += 1\n",
        "        elif cq_label == 2:\n",
        "          query_len_to_labels[q_len]['cqGood'] += 1\n",
        "      #\n",
        "      if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          query_len_to_labels[q_len]['caBad'] += 1\n",
        "        elif ca_label == 1:\n",
        "          query_len_to_labels[q_len]['caFair'] += 1\n",
        "        elif ca_label == 2:\n",
        "          query_len_to_labels[q_len]['caGood'] += 1"
      ],
      "metadata": {
        "id": "Y-pxNC_-WoFG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "def qeustion_length(question, cq_label, ca_label):\n",
        "  q_len = len(question.split(' '))\n",
        "\n",
        "  if q_len not in question_len_to_labels.keys():\n",
        "    question_len_to_labels[q_len] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "    question_len_to_labels[q_len]['count'] = 1\n",
        "    if not math.isnan(cq_label):\n",
        "      if cq_label == 0:\n",
        "        question_len_to_labels[q_len]['cqBad'] = 1\n",
        "      elif cq_label == 1:\n",
        "        question_len_to_labels[q_len]['cqFair'] = 1\n",
        "      elif cq_label == 2:\n",
        "        question_len_to_labels[q_len]['cqGood'] = 1\n",
        "    #\n",
        "    if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          question_len_to_labels[q_len]['caBad'] = 1\n",
        "        elif ca_label == 1:\n",
        "          question_len_to_labels[q_len]['caFair'] = 1\n",
        "        elif ca_label == 2:\n",
        "          question_len_to_labels[q_len]['caGood'] = 1\n",
        "  else:\n",
        "      question_len_to_labels[q_len]['count'] += 1\n",
        "      if not math.isnan(ca_label):\n",
        "        if cq_label == 0:\n",
        "          question_len_to_labels[q_len]['cqBad'] += 1\n",
        "        elif cq_label == 1:\n",
        "          question_len_to_labels[q_len]['cqFair'] += 1\n",
        "        elif cq_label == 2:\n",
        "          question_len_to_labels[q_len]['cqGood'] += 1\n",
        "      #\n",
        "      if not math.isnan(ca_label):\n",
        "        if ca_label == 0:\n",
        "          question_len_to_labels[q_len]['caBad'] += 1\n",
        "        elif ca_label == 1:\n",
        "          question_len_to_labels[q_len]['caFair'] += 1\n",
        "        elif ca_label == 2:\n",
        "          question_len_to_labels[q_len]['caGood'] += 1"
      ],
      "metadata": {
        "id": "9Fe6DPWib92P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "template_cq_to_count = dict()\n",
        "query_len_to_labels = dict()\n",
        "question_len_to_labels = dict()\n",
        "answers_count_to_labels = dict()\n",
        "\n",
        "for eachline in dataset_df.itertuples(index=True):\n",
        "\n",
        "  #\n",
        "  query_length(eachline.query, eachline.question_label, eachline.options_overall_label)\n",
        "  #\n",
        "  qeustion_length(eachline.question, eachline.question_label, eachline.options_overall_label)\n",
        "  # canidate answers\n",
        "  candidate_answers(eachline.option_1, eachline.option_2, eachline.option_3, eachline.option_4, eachline.option_5, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  cq_count = 1\n",
        "  cq = eachline.question\n",
        "  # T0: Select one to refine your search\n",
        "  # if bool(re.match(r'Select one to refine your search', cq)):\n",
        "  #   template = 'Select one to refine your search'\n",
        "  #   add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T1: What (would you like | do you want) to know about _____?\n",
        "  if bool(re.match(r'What (would you like|do you want) to know about [a-z]+?', cq)):\n",
        "    template = 'What (would you like|do you want) to know about [a-z]+?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T2: (Which | What) _____ do you mean?\n",
        "  elif bool(re.match(r'(Which|What) \"\"[a-z]+\"\" do you mean?', cq)):\n",
        "    template = '(Which|What) \"\"[a-z]+\"\" do you mean?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T3: (Which | What) _____ are you looking for?\n",
        "  elif bool(re.match(r'(Which|What) [a-zA-Z ]+ are you looking for?', cq)):\n",
        "    template = '(Which|What) [a-zA-Z ]+ are you looking for?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T4: What (would you like | do you want) to do with _____?\n",
        "  elif bool(re.match(r'What (would you like|do you want) to do with [a-z]+?', cq)):\n",
        "    template = 'What (would you like|do you want) to do with [a-z]+?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T5: Who are you shopping for?\n",
        "  elif bool(re.match(r'Who are you shopping for?', cq)):\n",
        "    template = 'Who are you shopping for?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T6: What are you trying to do?\n",
        "  elif bool(re.match(r'What are you trying to do?', cq)):\n",
        "    template = 'What are you trying to do?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T7: Do you have _____ in mind?\n",
        "  elif bool(re.match(r'Do you have [a-z]+ in mind?', cq)):\n",
        "    template = 'Do you have [a-z]+ in mind?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T8: Refine your search by interest\n",
        "  elif bool(re.match(r'Do you have any specific product in mind?', cq)):\n",
        "    template = 'Do you have any specific product in mind?'\n",
        "    add_template_to_dict(template, cq_count, eachline.question_label, eachline.options_overall_label)\n",
        "\n",
        "  # T9: else\n",
        "  # else:\n",
        "    # add_template_to_dict(\"XXX: \"+cq, cq_count, eachline.question_label, eachline.options_overall_label)\n"
      ],
      "metadata": {
        "id": "SineG_QV4eqD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Normalizer"
      ],
      "metadata": {
        "id": "9craCWn4VNGn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def _normalizer(analysis_dict):\n",
        "  # zi = (xi – min(x)) / (max(x) – min(x))\n",
        "  for key, statistics in analysis_dict.items():\n",
        "    # analysis_dict[key]['count'] = round(analysis_dict[key]['count'] / dataset_df.shape[0], 4)\n",
        "    analysis_dict[key]['cqBad'] = analysis_dict[key]['cqBad'] / (1.0 * analysis_dict[key]['count'])\n",
        "    analysis_dict[key]['cqFair'] = analysis_dict[key]['cqFair'] / (1.0 * analysis_dict[key]['count'])\n",
        "    analysis_dict[key]['cqGood'] = analysis_dict[key]['cqGood'] / (1.0 * analysis_dict[key]['count'])\n",
        "    analysis_dict[key]['caBad'] = analysis_dict[key]['caBad'] / (1.0 * analysis_dict[key]['count'])\n",
        "    analysis_dict[key]['caFair'] = analysis_dict[key]['caFair'] / (1.0 * analysis_dict[key]['count'])\n",
        "    analysis_dict[key]['caGood'] = analysis_dict[key]['caGood'] / (1.0 * analysis_dict[key]['count'])"
      ],
      "metadata": {
        "id": "VdM2M4Ns8ev5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def count_remover(input_dict):\n",
        "  copied_input_dict = copy.deepcopy(input_dict)\n",
        "  for key, value in copied_input_dict.items():\n",
        "    value.pop('count', None)\n",
        "  return copied_input_dict"
      ],
      "metadata": {
        "id": "lMBgKbxpbzTj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Template to Count Plots"
      ],
      "metadata": {
        "id": "rHnS0Knkctkc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "_normalizer(template_cq_to_count)\n",
        "copied_template_cq_to_count = count_remover(input_dict=template_cq_to_count)\n",
        "sorted_template_cq_to_count = collections.OrderedDict(sorted(copied_template_cq_to_count.items()))\n",
        "\n",
        "pd.DataFrame(sorted_template_cq_to_count).plot(kind='bar', width=0.7)\n",
        "# Put a legend to the right of the current axis\n",
        "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "plt.savefig(f'{DATASET}_templates_to_count.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "Gf2__51MmyES",
        "outputId": "258fc8f7-099e-4826-b512-45f8abdcb05f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuMAAAEbCAYAAABwVIpNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xN9//A8Vdys0guIlK1xaiGWIkQ21dtIbGDUlS0Zq2qHVtTNFpqNEUkYjYtEmmoaqlRZJhRM2aMiNAMcrN+f+Tn1JWbRdJrvJ+PRx7JPedzPud9xuV9P/dzPh+DjIyMDIQQQgghhBD/OUN9ByCEEEIIIcTbSpJxIYQQQggh9ESScSGEEEIIIfREknEhhBBCCCH0RJJxIYQQQggh9ESScSGEEEIIIfREknEhhBBCCCH0xEjfATwrLi6R9HT9DHtuZWVBbGyCXvZdmOS4Xi9yXK8XfR+XoaEBlpbmetu/EEKIl/dKJePp6Rl6S8af7v9NJMf1epHjer28qcclhBDivyHdVIQQQgghhNATScaFEEIIIYTQE0nGhRBCCCGE0BNJxoUQQgghhNCTXJNxT09PWrduTY0aNbhw4YLOMmlpacyePZs2bdrQtm1btm3bVuCBCiGEEEII8abJNRn/4IMP8Pf3p1y5ctmWCQwM5Pr16+zZs4ctW7awbNkybt68WaCBCiGEEEII8abJNRlv0KABZcqUybFMcHAwvXr1wtDQkJIlS9KmTRtCQkIKLEghhBBCCCHeRAUyzvjt27cpW7as8rpMmTLcuXMn3/VYWVkURDgvzNpardf9F5bcjis1JQUjY+NclxUETUoaJsaqXJdlJ12jwdDEBPj3uJ5d9iaQ+zDnZa+aN/V6CSGE+G+8UpP+xMYm6G0CDWtrNTEx8XrZd2HKy3FZW6tZPmWw1rJRC9cVyvmwtlbTZcIOrWWBS1zyvC9razWHXHpoLWu6I+CNuXZyH/4392FB0ff1MjQ00HsjhhBCiJdTIKOplClThujoaOX17du3effddwuiaiGEEEIIId5YBZKMd+jQgW3btpGens6DBw/Yu3cv7du3L4iqhRBCCCGEeGPlmozPmzePFi1acOfOHQYPHkznzp0BcHd35/Tp0wC4uLhQvnx52rVrR+/evRk5ciQVKlQo3MiFEEIIIYR4zeXaZ3z69OlMnz49y3Jvb2/lb5VKxezZsws2MiGEEEIIId5wMgOnEEIIIYQQeiLJuBBCCCGEEHoiybgQQgghhBB6Ism4EEIIIYQQeiLJuBBCCCGEEHoiybgQQgghhBB6Ism4EEIIIYQQepLrOONCvOpSU9KwtlZnWa5JTuXRP4/1EJEQQgghRN5IMi5ee0bGKuZMCMqyfOYSZz1E82ZRFyuCman2PxNPklOJlw85QgghRIGQZFwIkS0zUyO6TNihtSxwiQvxeopHCCGEeNNIn3EhhBBCCCH0RJJxIYQQQggh9ESScSGEEEIIIfREknEhhBBCCCH0RJJxIYQQQggh9ESScSGEEEIIIfREknEhhBBCCCH0RJJxIYQQQggh9EQm/RFCFBpLtQlGZqYAWFurAUh9kkxcvEafYQkhhBCvDEnGhRCFxsjMlEMuPbSWNd0RAJKMCyGEEIB0UxFCCCGEEEJvJBkXQgghhBBCTyQZF0IIIYQQQk8kGRdCCCGEEEJP5AFOIcQrKz01XRmF5alUTSpxjx7rKSIhhBCiYEkyLoR4ZRkaGXJx8UGtZdUnNtNTNEIIIUTBk24qQgghhBBC6Ikk40IIIYQQQuiJJONCCCGEEELoifQZF0K8NHUJU8yMTfQdhhBCCPHakWRcCPHSzIxN6L1leJblW/us1EM0QgghxOtDuqkIIYQQQgihJ3lqGY+KimLy5Mk8fPiQEiVK4OnpSeXKlbXKxMbGMmXKFG7fvk1qaiqNGjVi+vTpGBlJ47sQQgghhBC65Kll3MPDg379+rF792769evHzJkzs5RZtWoVVatWJTAwkJ07d3L27Fn27NlT4AELIYQQQgjxpsg1GY+NjSUyMhJnZ2cAnJ2diYyM5MGDB1rlDAwMSExMJD09HY1GQ0pKCqVLly6cqIUQQgghhHgD5JqM3759m9KlS6NSqQBQqVS888473L59W6vciBEjiIqKolmzZsqPg4ND4UQthBBCCCHEG6DAOnSHhIRQo0YN1q9fT2JiIu7u7oSEhNChQ4c812FlZVFQ4bwQa2u1XvdfWF70uP7L81FY+3odr+nrEPPLxqjv7QvSqxTLU+np6dy/f58HD+JIS0vTdzhCCPFWK1LEjAoVKmBsbKxzfa7JeJkyZbh79y5paWmoVCrS0tK4d+8eZcqU0Sq3YcMGFixYgKGhIWq1mtatW3P06NF8JeOxsQmkp2fkuXxBsrZWExMTr5d9F6a8HFd2yURhnI+X3Vd+E5/X7Zq+avdhXq9XQVyX/NTxqpwjfV8vQ0MDnY0YN27cIDU1HSur0qhURhgYGOghOiGEEBkZGcTHP+LGjRtUqVJFZ5lcu6lYWVlha2tLUFAQAEFBQdja2lKyZEmtcuXLl+fAgQMAaDQajhw5QvXq1V/2GIQQQuRTYmIilpalMDIylkRcCCH0yMDAALW6OI8fP8m2TJ5GU5k1axYbNmygffv2bNiwgdmzZwPg7u7O6dOnAZg6dSphYWF06dIFV1dXKleuTO/evQvgMIQQQuRHRgYYGMg0EkII8SrIrVEkT33Gq1atyrZt27Is9/b2Vv6uWLEi69aty2d4Qggh/gtFippiZlrw8z48SU7lcVJygdcrhBBvC2k6EUKIt4CZqRFdJuwo8J/8JPiTJ08kMvIsN25cp3XrZqSmpgKZfSo7dvyAZcu8lLL79u3lk0+GADB8uDsHDx7QWef8+XM4cSI8x/16e6/i22+9dK6Ljo5m+HB3AHbs+JmxY0cp6y5fvoSTkz2HDv2pLFu8+EtWr14BgJOTPUlJSbkddpb9bd8eoLVs+PChREffyjG+Z+MMCwtlzhwP5TdAUNBO2rRpgbv7oHzFk5N9+/bi5taD9u1b52s7V9fOWr91HUNucrrmb6Pt2wPo3783bm49mDBhDImJifoOSRQgScaFEEIUujNnTvP4cRI1a9aiQoWKWFio+fvvcwBERV2hTJmyREREKOXDw0Oxt2+Qa73Tps2kXj37AonRwaEBp06dVD4kRESEUauWHeHhoc/EFYa9/YsP23v7djTbt/+ktczNrT8//LD6het8ytGxEd7ePi9dz1OtW7fh66+XZbv+abItCt+775Zh7Vo/Nm8OwMysCDt2/KzvkEQBkrnqhRBCFLodO36iXbuOymt7ewfCw8Ows6tNeHgYrVq1Zu/ePSQmJmBubkF4eBjjx3+ulI+ICMPX14f792P44IO2jBw5BshsQe3ffwDNmrUgISGepUuXcO5cJAYGBtSrV5+JEycDEBNzj3HjRhMdfYty5cqzYIEnZmZFtGIsX74CanXmhwQ7u9pERIQzePBQ1q79AYC4uDhu3bpJ7dp1lW22bt3E/v2/8+jRI0aNGkvr1h8AMHPmNK5fv0pKSgrly1dg2jQPihUrxuLFXxIdHc2AAW6UL1+BhQsX0bRpM778ch6JiYmYm5trxaRSGVKsWDHlN4CxsTEWFhbK7+xkF8Pz1qz5nj/+2AdASkoKV69GsXfvfiwsXmzYTktLS63fuo7heVFRV5g7dxaPHydRtWo1NJp/uz7duHEdT8/5xMXFoVIZMXz4SBo3bqq1fXJyMt27d2H9en9KlbIGYMmSr7CysmLQoI85cuQQK1cuJy0tDUtLS774YhoVKlQkKGgnhw79ycKFiwCyvH6Wq2tnOnToRGjoMWJiYhgxYjRxcQ/YsyeEf/55xLRpHtSvn/lB7fDhg6xbtwaNJhljY2PGjp2AnV0dYmPvM2PGVBITE9BoNDRp0ozRo8cCmd/gXL9+jYSEhCz3qZNTEyWOJ0+eYGws6dubRFrGhRBCFLrw8MxW5qccHBooLc4REWHUr29P7dp1OHEiQkl67ezqKOXv3LnDqlU/4Ou7kZ07t3P9+vUs+/DyWoyZWRH8/DazYcMWhg79RFl37lwkc+YsYPPmAFJTUwkJ+UVnnE8/JAD8/fc5nJyaoNEkk5iYQEREGLa2NTEzM1PKm5ubs27dBjw85uLl9ZWyfPz4ifj4+OPvvxUbmyr4+fkAMHHiZGxsbPDz26wkfEZGxlSpUpVTp05kiad06Xfx9Fyi/AaoU6cu48d/rvzOTnYxPO/jj4fh57cZP7/N1KjxPm5u/V44EQdYt26D1m9dx/C8WbOm06NHLzZt+hE3t36cOxeprPPwmE67dh3x99/K7NnzmDVrBnFxcVrbm5qa0qmTs/KtQ1JSEnv37qZr1248ePCA2bNnMHv2fPz9t9KuXUc8PKa/0LGlpGj44Yf1LFy4iIUL52JkZMTatX58+ukoVq78DoCbN2+wdq03S5cuY/36jUydOpNp0zI/FFpYqFm8eCnr12/Ez28Tf/8dyZEjh5T6c7tPfX3Xcf9+DM7OLi8Uv3g1yUcrIYQQhe7evbuULGmlvLa3b4CX1xJSU1P5++9z2NrW4u7du4SHh5KcnEzNmrW0kt4PPmiLoaEhFhZqKleuzK1bN6hYsaLWPg4d+hMfH38MDTPbmUqUsFTWOTk1Rq3OTDBr1bLj1q2bOuO0t3fgt9/20rx5C8qXL4+RkRF16tTjxIkIwsNDcXDQ7jrTtm17AOzsahMTE0NycjKmpqYEB+9i9+5gUlNTefz4cZZYn2dlVYp79+7ldhrzJb8xrF69gidPnjBmzPhsywwa1F+ZSOr+/RgGDHADMhPuxYuXvlCciYkJXLlymY4dM7u92NnVoWrVav+/LpGLF8/j7NwVABubKlSv/h5nzpyiefOWWvX07NmbTz75mEGDPiYkJJiGDZ0oWbIkf/65n2rV3sPGJnOMZ2fnrixatPCF+l23aZN5vWvUeJ8nT57Qpk07AN5/35abN28A8NdfR7h16yaffjpU2S4tLZXY2FiKFi3KsmVLOX36JBkZGTx4EMvFixeUlv6c7tPLly+xdesmfH03U6SI9rc64vUmybgQQohCZ2pqqtX1oFy58hQrpmb37l8oVy4z6a1f356NG/1ITk7O0i/bxMRE+dvQUJXvmUVNTEyf2d4w2+0dHBzx8lpCaOgxpctB/fr2hIeHEh4exoQJk3TWq1KpAEhLS+PEiXB++mkb3t4+WFpasnv3L1n6iT/vaRJfUHKKYdGihZw6dRKAefO+pFKlygQGbufYsb/47rvvlQ8zuvj4+Ct/u7p2xs9vc4HF/LJKl34XW9uaHDiwn4CArUyePC3XbVQqFenp6cprjUaTY/mn9+HT6/30+mvfkxk4OTXBw2Nulu3XrvUmPv4f1qzxxdTUlIUL55Kc/O/7Iqf79MKF89SqVTvLPC/i9SfdVIQQQhS6qlWrce3aNa1l9vYN8PFZoyTeVlalSEpK4vDhQ9jbO+Z7H02bNmfDBl8yMjJncn74MC6XLbIqW7YcxYoVY+vWzcoDpPXq2bN//x/cunVLq+tMduLj47GwsKB48eJoNBoCA3co68zNzUlISMiyzdWrUVSv/l6+432RGD7/fIrSLaVSpcocO3YUP7/1LFq0VOvbiP+KubkFVatWY/fuzC4ZZ8+e4fLlS/+/zpzq1WsQHBwIZPYtv3TpQrbXoVcvN5YuXYxKZaT07bezq8OlSxe4ejUKgODgQN57rwbm5uZUqFCBy5cvotFoSElJYd++vS99PA0bNuavvw5z5cplZVlk5Fkg87qUKlUKU1NT7t27x4ED+/Ncb9269ejXb8BLxydePdIyLoQQb4EnyakELin4fqZPklPzVK5Vq9YcPXpEq5uHvX0DgoODlBZogDp16hESsgs7u9r5jmXs2Il4eS2mX79eqFQq6td3yNKSnRf29g3Yt+9XatasCYC1deYDgTVr1spT63Xjxk0ICQmmd29XihcvQb169koyVq1adSpVqkS/fr2oVKkyCxcu4vbtaACla0ZByCmG5/n4rOHx4yQ++2yEsmzVqjVZHiYtTB4ec5k7dxZ+fj5UrVoNW9uayrrZs+fh6TmfTZv8UamM8PCYqzwc+jx7ewdMTEzo0aOXsszS0hIPj7nMnDmNtLRULC0tmTVrHpCZqDs6NqJfv56UKmVNtWrvERt7/6WOpWLFisyaNY/582eTnJxMSkoKderUo2bNWvTu7ca0aV/Qr18v3nnnHRwdG+a53kuXLnHyZDh169Z7qfjEq8cg42kTwisgNjaB9HT9hGNtrSYmJl4v+y5MeTkua2s1y6cM1lo2auG6Qjkf1tZqukzYobUscIlLnvdlba3mkEsPrWVNdwQwZ0JQlrIzlzi/dtf0VbsP83q9rK3V9N4yPMv2W/us1Hm9dB1jdvfhxcUHtZZVn9jslTlH+r5ehoYGWFllHU3j7NlIypatpIeIspeYmMCwYUNYs8ZXL62v2YmOjmbuXA9WrvTOvXAhWbFiGeXLV6BrV9cXriOnUUBeRnR0NIMHf8ju3fsKtN7CEh19i2HDBvPjjzuyjJYjhD5FR1+jVq2aOtdJNxUhhBCFztzcgjFjxiutwOJf1tbWygOKL8rU1JRz5yILfNKfzz8f+9r0Uf7++5V88snHjBkzXhJx8VqRbipCCCH+E40aOek7hCzUajWdO3fRawy9erm9dB1t27ZXRnYpKK1bt6F16zYFWmdhGjZsOMOGZf2GTohXnbSMCyGEeGup1eqXbpUWQoiXIcm4EEIIIYQQeiLdVIQQ/6nUlDSsrV98dj8hhBDiTSLJuBDiP2VkrMp29BshhBDibSPJuBBCvAWKmRuhMim4GR6fStMk809i3sYaF0IIkZUk40II8RZQmZhyZX6P3AvmU5VpAZDHZHzy5IkMHDgYtVrNRx/1Y8+ePzAyMiIjI4NOndrQqZMzo0ePAzKH1duyZSOrV69l+HB3+vcfQLNmLbLUOX/+HDp3dqZePfts9+vtvYrHjx8zZsy4LOueHWd8x46f+f3331i6dDkAly9fon//3ixZ8g1NmzYHYPHiL1Gri/HJJyNwcrJn376DFC1aNE/H/3R/x44dwdX132sxfPhQZsyYTdmy5XSW79XLhSpVqjJnzgJsbKrkeV+5OXz4EOPHj+bLLxfTqlVrnWUOHNiPt/dKrWUPHjwgIyOD4OBfs5QfNepTLlz4G3f3TwtklJjXhatrZ5Ys+eaFJ24KCwtl2TIvfHz8s6wbN240EyZMonz5Ci8bpmLVqu/4/fffKFGiBKtXr83zdhqNhlmzpnPt2lWePHlC79596dOnb4HF9baSBziFEEIUujNnTvP4cRI1a9aiQoWKWFio+fvvc0DmFOdlypQlIiJCKR8eHqpMR5+TadNm5piI54eDQwNOnTpJamrmh4uIiDBq1bIjPDz0mbjCsLd3yK6KXN2+Hc327T9pLXNz688PP6zOdhsLCzV+fpsLNBEHCAraQYMGjgQG7si2TIsWLfHz26z8LFu2EmNjI8aP/1xn+eXLV9GsWUud67y9VxEUtLNAYgdIS0srsLpeZV5eywo0EQfYtGkDq1atyVcinp6eTnp6Oi4u3fD338oPP6xn9ervePgwrkBjextJy7gQQohCt2PHT7Rr11F5bW/vQHh4GHZ2tQkPD6NVq9bs3buHxMQEzM0tCA8P00r4IiLC8PX14f79GD74oC0jR44B0Go1T0iIZ+nSJZw7F4mBgQH16tVn4sTJAMTE3GPcuNFER9+iXLnyLFjgmWVimPLlK6BWZ35IsLOrTUREOIMHD2Xt2h8AiIuL49atm9SuXVfZZuvWTezf/zuPHj1i1KixtG79AQAzZ07j+vWrpKSkUL58BaZN86BYsWIsXvwl0dHRDBjgRvnyFVi4cBFNmzbjyy/nkZiYmKcp6P39/di7dzdpaWmYmJgwadJU3nuvRpZyhw8fZOXK5crrqKgrLFjwFS1atOLRo4eEhh5j06YA+vbtSWzsfaysSuW437S0NKZPn0zr1m1p06ZdrnG+qOzOXVhYKF9//RXvv2/LhQvn+eSTEVSoUBEvr8U8evSQlJQU3Nz64ezsolVfcnIy3bt3Yf16f0qVsgZgyZKvsLKyYtCgjzly5BArVy4nLS0NS0tLvvhiGhUqVMwyq2leZzm9ceM6np7ziYuLQ6UyYvjwkTRu3BQg2309Kz4+nsmTJ9CsWQv69v1Qq9V9+HB3atasyenTp7O8F6KirjB37iyePHlM9ervcfPmDQYPHprlG6VPPhlCcnIyo0Z9gpNTY0aPHoevrw8hIbsAsLWtyYQJX1C0aFG8vVcRFXWFhIQE7t69g7e3D40aNQYgLS2V9PR0VCpJJV+WtIwLvUtP1WBtrdb6sSxuou+wRDZ0XS8hchMentnK/JSDQwOlxTkiIoz69e2pXbsOJ05EKEmvnV0dpfydO3dYteoHfH03snPndq5fv55lH15eizEzK4Kf32Y2bNjC0KGfKOvOnYtkzpwFbN4cQGpqKiEhv+iM8+mHBIC//z6Hk1MTNJpkEhMTiIgIw9a2JmZmZkp5c3Nz1q3bgIfHXLy8vlKWjx8/ER8ff/z9t2JjUwU/Px8AJk6cjI2NDX5+m5WkzsjImCpVqnLq1Ik8nctOnZxZt24Dvr6bGDZsBJ6e83WWa9KkmdKi3aNHb2xtayqJVEhIME2bNsfKyopWrVqza1fWh6qft2LFMjIyMpTkr7Bkd+4gM+F0de2On99mnJyaMHPmVMaOncC6dRtYvXotvr4+XL0apVWfqakpnTo5K99IJCUlsXfvbrp27caDBw+YPXsGs2fPx99/K+3adcTDY/pLxe/hMZ127Tri77+V2bPnMWvWDOLi4vK0r9u3oxk16hN69OhN374f6qw/u/fCrFnT6dWrDxs3bsPNrT/nzkXq3P5pa7i3tw+jR4/j8OFDhITswtt7Hf7+W0lPT2ftWm+l/NmzZ5gzZz5btvxEsWLFlHP4+efjGDLEHbVa/g94WfJxRuidoZFJlr6sVaYFABr9BCRylP31EiJ79+7dpWRJK+W1vX0DvLyWkJqayt9/n8PWthZ3794lPDyU5ORkataspZX0fvBBWwwNDbGwUFO5cmVu3bpBxYraLYqHDv2Jj48/hoaZ7UwlSlgq65ycGitJQ61adty6dVNnnPb2Dvz2216aN29B+fLlMTIyok6depw4EUF4eCgODtpdZ57OemlnV5uYmBiSk5MxNTUlOHgXu3cHk5qayuPHj7PE+jwrq1Lcu3cvt9MIwN9/R7J+/Vr++ecfDAwMuHEj6weTZ/3112E2bdrA6tVrMDXNfIg3KGgnn302HoDOnbuwYMEcBg4clG0d+/btZe/ePaxbtwGVSpWnOAF27PiZH3/cAkBsbCzGxsZs2bIRgOHDR9GkSbMs2+R07ipUqKh8M3HjxnWuXr3KjBlTlPUajYarV6OoXNlGq86ePXvzyScfM2jQx4SEBNOwoRMlS5bkzz/3U63ae0oXIGfnrixatJDExMQ8H+OzEhMTuXjxvDKRlI1NFapXf48zZ04B5Liv2Nj7jBz5CTNnzqFevfrZ7kPXe8HKqiRXrlymffvMb59sbWtSrVr1PMV8/PhR2rRpj7m5BQAuLt3x8vq39b9Jk6Za7yWANWtWU7VqNQYOHJynfYicSTIuhBCi0JmamqLRJCuvy5UrT7Fianbv/oVy5TKT3vr17dm40Y/k5OQs/bJNTP79tszQUJXv/sImz4wkY2homO32Dg6OeHktITT0GPXrZ8ZQv7494eGhhIeHMWHCJJ31Pk1Q09LSOHEinJ9+2oa3tw+Wlpbs3v1Lln7iz3uaxOcmJSWFqVMnsXLlD7z/vi0xMTF06ZL5gSAoaAdbtmwCoH//gXTo0ImLFy/g6bmAb775Tkmo/v47kitXrjBv3myl3vv3Yzh58gQ3blzLUkdU1BU8PRfw9dffUrJkyVxjfJaLSzdcXLoBmX3Gy5Qpm+OMp7mduyJF/u1alJGRQYkSJfDz25xrHKVLv4utbU0OHNhPQMBWJk+elus2KpWK9PR05bVGU7gNRGp1Md55pzRHjhzMMRnP6b1gYGBQ4HEVKZL1AeXz58/Tu7c8uFlQpJuKEEKIQle1ajWuXbumtczevgE+PmuUxNvKqhRJSUkcPnwIe3vHfO+jadPmbNjgS0ZGBsALPVhWtmw5ihUrxtatm5UHSOvVs2f//j+4deuWVteZ7MTHx2NhYUHx4sXRaDRaD0iam5uTkJCQZZurV6OoXv29XOvWaJJJS0ujdOl3AQgI2Kqsc3Z2UbqldOjQiXv37jFlykRmzZpHxYqVlHKBgTsYMOAjtm/fpfy4u39KUNCOLHUkJiYyefJEhg8fqdXNqLDkdO6eV7FiJczMzPjll3+72Fy9GkViYtbzC9CrlxtLly5GpTJSWtft7Opw6dIFpWtLcHAg771XA3NzcypUqMDlyxfRaDSkpKSwb9/eXOM3NzenevUaBAcHApndai5duoCdXZ0c9wWZSfaiRV5ERUXx9deLlPs4L8zNLbCxqcqePSFAZhery5cv5WlbR8dG/PbbHhITE8nIyGDnzu00bOiU4zaDBg3B1rZmnuMTOZOWcSGEeAukaZILpTtR2jOt3Tlp1ao1R48e0ermYW/fgODgIKUFGqBOnXqEhOzCzq52vmMZO3YiXl6L6devFyqVivr1HbK0ZOeFvX0D9u37lZo1M5MNa+vMh/5q1qyVp9brxo2bEBISTO/erhQvXoJ69eyJjDwLQLVq1alUqRL9+vWiUqXKLFy4iNu3owHyNCyeubkF7u6fMnjwhxQvXpzWrdtkW3bnzp+Ji3vI4sVfKsuGDx/Nr7/uzjKKRrt2HfjwQzfGj5+k1focELCVmzdvEBCwjYCAbVrbrFq1Jk8PnOZHTufueUZGRixatJSlSxezYYMv6enplCxZkvnzPXWWt7d3wMTEhB49einLLC0t8fCYy8yZ00hLS8XS0pJZs+YBmYm6o2Mj+vXrSalS1lSr9h6xsfdzPYbZs+fh6TmfTZv8UamM8PCYi6Vl5rcS2e3rKWNjYxYs+IpZs6azcOG8PLXgP+XhMYf582fj67uOqlWrUbVqNSwsLHLdrkmTpnf6wHwAACAASURBVFy6dBF390EAvP9+TQYPHprjNrt3h9C5s7Py3hAvxyAjPx+9CllsbALp6foJx9paTUxMvF72XZjyclzW1mqWT9Hu9zVq4bpCOR/W1mq6TNBu6Qhc4qKzD7Ku/Vtbqznkol226Y6AbGd0fN2u6at2H+bnevXeMjzL9lv7rMzX9dJ1H15cfFBrWfWJzV6Zc6Tv62VoaICVVdb/bM+ejaRs2Uo6ttCfxMQEhg0bwpo1vlp9wfXt2XHG9WXFisyh67p2dc2yLjo6msGDP2T37n16iOzFzJnjga2t7Ss3znh09C2GDRvMjz/uyDKSzpsgKSmJIkWKYGBgQFTUFUaMcGfLlp+Vhy6FfkVHX6NWLd3fJkjLuBBCiEJnbm7BmDHjuX07usDHy37dWVtbZ9uPWqUyxNjYiAED3Ap80p/CMGrUp9y6dRN7+4IZ+72gfP/9SgIDdzBmzPg3MhEHOH36JMuWLVW6t0yZMkMS8deEJONCCCH+E40a5dwPVR/UajWdO3fRaww5tSCXLv0uQUF7/sNoXs7y5av0HYJOw4YNZ9iwrN/evUkaNWqsDF0pXi/yAKcQQoi3llqtznF0DyGEKGySjAshhBBCCKEnkowLIYQQQgihJ5KMCyGEEEIIoSfyAKcQQrwFiloYY2psknvBfEpO0ZCUkJJrOVfXzpiammJsbMyTJ4+xsanKgAGDqFOnboHH9DJe1WH5Xhc//fQjyclP6Nv3QwDmzvUgMvIsVapUpX37Tpw8Gc7o0eP0HGXmbKCPHz9mzJgXiyUsLJTU1JRsH5j8/vuV2NhUoW3b9i8TZrbOnYtk0yZ/5syZn6/tnh0q8+rVKDw95/PPP/+Qnp7OxImTteYBEP+dPCXjUVFRTJ48mYcPH1KiRAk8PT2pXLlylnLBwcGsXLmSjIwMDAwMWLduHaVKlSromIUQQuSTqbGJzrHgX9bWPitJIvdkHGDBgq+UiW1+//03xo8fzdKl373QBD/i1dS9e0/l79jYWH7/fR979+7H0DDzi/gWLVoWyn5TU1MxMvrv2hfDw0N5/Phxtsl4YY/cYmtbM9+J+PMyMjKYMmUGFStW4tChP/n666/w99+a+4aiwOXpzvXw8KBfv364uLiwY8cOZs6cia+vr1aZ06dPs3z5ctavX4+1tTXx8fGYmBR8K4wQQojX3//+9wGRkWfZuNGPBQu+IikpiSVLPDl3LhKAjh07M2DAoCzbjR8/hs6du/DBB22BzKT+558D+PbbFdy4cR1Pz/nExcWhUhkxfPhIGjdummXinNwm0rly5TIjRw7j7t271K5dh5kz52BgYMDu3b+wZcsmUlMzP3yMHj0WR8dG/PLLLv74Yx+enkuAzMTQ1bUT33+/jrJly+Hr68Mff/xGamoa1tbWTJ06AyurrA1VM2dO4/r1q6SkpFC+fAWmTfOgWLFihIWFsnTpYmrVsuP06VMYGBgwd+5CbGyq5Hg+nnXt2lXmzvXgyZMnpKen07lzF/r3H4i39yquXo3i4cM47t+/j41NFaZP98DCQk1KSgqrVi0nIiIcjUZDtWrVmTRpKkWLFiUhIZ6lS5dw7lwkBgYG1KtXn4kTJystzh9/PIyRI4eRnPyEjz7qR6dOzqjVxTh06E8WLlwEQGDgdrZs2QRkzjy5ePE3WFlZacU9Z44HRkZGREVd5uHDh9Sv78Dnn0/G2NiYOXM8UKlUXL9+laSkJPz8NuPr60NIyC4gM2GdMOELJd758+dw5cplSpa0onTp0pQsaaXs49lvQ559res4XV178PPPAWRkpHP8+FHatm3PwIGDs8T9tA5v71Vcv36NhIQEoqNvUa5ceRYs8NQ53rmTkz2ffDKCAwf+4NGjR0yZMp3jx4/x11+HSU1NZf58T2xsqhAWFsqyZV74+Pgr97Ora3eOHDnEkydPmDp1JvXq1Qfgxx+3sHmzP0WLWtC0aTNlX8+OWZ+crMHY2Fjn+0EUvlz7jMfGxhIZGYmzszMAzs7OREZG8uDBA61yPj4+DBkyRJkaVa1W52naYCGEEG+nWrXsuHLlMgBr13qTkZGBv/9WvL3XERwcxOHDh7Js06tXH61p2QMCttKzZ28APDym065dR/z9tzJ79jxmzZpBXFxcvuO6fPkyX3+9jE2bfuTvv89x7NhRAJycGrNmzXp8fTcxd+5C5szxAOB//2vNiRMRPHyYua8jRw5RqVJlypYtxy+/7OLWrRv88MN6fH030qRJM775xkvnfsePn4iPjz/+/luxsamCn5+Psu7KlSt069YTf/+tfPBBW9atW5Pr+XhWQMA2mjdvyYYNW9i4cRtduvw72+eJExHMmbOQLVt+wsLCgrVrfwDAz2895uZq1q71Y8OGLZQqZc369WsB8PJajJlZEfz8NrNhwxaGDv1Ea3/m5uZ8/fUyLCzU+PltVrqtPBUWFsr69Wv55pvv2LBhC9999322U7efPXuab75ZwaZNP3Lnzm22bw9Q1l28eJ6lS7/Dz28zhw8fIiRkF97e6/D330p6ejpr12bOrLpmjTfm5uZs2fITCxd+RUREuM59PU/XcVarVp1u3XrQsaMzfn6bsyTiupw7F8mcOQvYvDmA1NRUQkJ+ybasWq1m3boNjBw5hkmTxlOnTl18fTfRsWNnfHzW6Nzm0aOH1K5dB1/fTQwZ4s533337/+fnAj4+a1i9eh2+vht59OhRlm2joq7w9deejBkzPk/nRBS8XJPx27dvU7p0aVQqFQAqlYp33nmH27dva5W7fPkyN27coH///nTr1o0VK1Yos0AJIYQQz3v2/4jjx4/StWs3DAwMMDe3oG3bDhw/fjTLNk5OTYiNvU9U1BWioq5w8+ZNmjZtTmJiIhcvnlfGDLexqUL16u9x5sypfMfVsmUrpX97jRrvc+vWTQBu3rzJZ5+NpG/fnkyfPpkHD2KJjb2PmVkRWrRoxe7dIQDs2hVI586ZcRw8eIDjx4/x0Uf9GDDAjYCArdy+Ha1zv8HBu/joo37079+bPXtCuHjxvLKuUqVK1KjxPgB2drW5detGjufjefXq2bNz53ZWr15BaOgx1Gq1sq5p0+ZKi3SXLq6Ehh7//9j3s3t3MAMGuDFggBt//rlfOReHDv3Jhx8OVLqflChhma9zfPjwn3Ts6Kx8Q1C0aNFsG/DatGlH0aJFMTIyolMnZyU+gNat21CkSGYL8/HjR2nTpj3m5hYYGBjg4tJduYfCwkKVDyAlSljSqtX/8hTnyx7nU05OjVGr1RgYGFCrlp1yHrM7XoAaNd7HwMCAZs1aAPD++7bcvHlD5zZFixZVymXeH5n1h4eH0aTJv9fX1bV7lm3nzJnJiBFjsLd3eKFjEy+vwDpYpaWlcf78edatW4dGo2Ho0KGULVsWV1fX3Df+f1ZWuj8V/1esrdW5F3oNvehx6ft8FMT+9X0ML+J1jPm/9iqdo1cpltfNuXORSh/yvDIwMKBnz95Ka3C3bj2UxqLsGBmpyMhIV15rNMk5ln+2i6WhoYq0tFQAZs6cypgx42jZ8n+kp6fTqlUTkpM1AHTu3AUvr0V06NCRiIhwZs2aC2R+4Bg8+GOtlmhdTpwI56eftuHt7YOlpSW7d//C9u0/5RBTWr7OR+vWH1C7dh2OHj2Cr68PgYE7mD075z7HGRkZfP75ZBo0aJhjOX16moi/DJVKRXr6vx8Mc7s/XoSJyb8fNAwNDZXrl1NZQ0MVxsa6r/vz8lpOlwsXztOyZas8lxcFL9dkvEyZMty9e5e0tDRUqswLfO/ePcqUKaNVrmzZsnTo0AETExNMTEz44IMPOHXqVL6S8djYBK03xH/J2lpNTEy8XvZdmPJyXNklE4VxPvKTuOjaf34Tn9ftmr5q9+Grmmi+KudI39fL0NBA740YL+rAgT/46adtLF36HQCOjo0IDNxO3br1SEpKYu/e3YwePVbntp06daFv356kpGjYuPFHILNbRPXqNQgODsTZ2YWoqCtcunQBO7s6qNVqUlNTuXHjOhUqVGTPnpAXijk+Pp6yZcsBEBi4A41Go6yrV68+iYmJrFixjBYtWin9gZs3b8GWLZto2bI1xYoVQ6PRcO3aVapXfy9L3RYWFhQvXhyNRkNg4I48x6XrfDzvxo3rlCtXHmfnrlSoUJF582Yp6w4f/pO4uDgsLS0JCtpJgwaO/x97SzZt2oCdXR3MzMxITEzk3r272NhUoWnT5mzY4MuECZMwMDDg4cO4fLUaN2nSnIUL5+Dq2gMrKyuSkpJQqVQ6W8f37duLm1t/jI2NCQnZpbPlHzLvoe+++4Y+ffpStGhRdu7cTsOGTgA0aOBIUNBO6tatx6NHD9m//3dat87sZ1+hQgXOnTsLwP37MYSFhVK3bj2AbI/T3NyCmJiYPB+vvtjbO7Bhgw8PHjygZMmS7Ny5PUuZWbPmYWpqpofoxFO5JuNWVlbY2toSFBSEi4sLQUFB2NraUrJkSa1yzs7O7N+/HxcXF1JTU/nrr79o375whvQRQgjx+pk6dZIytGHlylX4+utlykgqQ4a4s3ixJ/37Z/Z37tChM40bN9VZj7m5OU5OTUhOfoKl5b8J4OzZ8/D0nM+mTf6oVEZ4eMxV1o8bN5ExY0ZgaWlJkybNdNabm3HjJjBp0njU6mI0btyY4sVLaK3v1KkL33+/glWr/u3X27GjMw8fPmT48KFAZmtz9+69siTjjRs3ISQkmN69XSlevAT16tkTGXk2T3Fldz6e9dtvv7J79y///5CeAePGfa6sq1u3PjNmTCYmJobKlW347LPM4f4GDhyEt/dqhgwZgIGBAQYGBnz88TBsbKowduxEvLwW069fL1QqFfXrOzBhwqQ8xQvg4NCAgQOHMGbMcAwMDDAxMWHRoqU6k3Fb21qMGTOCuLgH2Ns3wNW1h846mzRpyqVLF3F3HwTA++/XZPDgzPM+ZMhQ5s2bTZ8+3SlZ0op69eyV7VxcujFlyiTc3HpQsWIlatWyU9Zld5ytWv2PL74IYsAAN50PcL4qqld/j48+GsKwYYMxNzfXee/7+q6jefOW/+loNEKbQUYeOnZfvnyZyZMn888//1CsWDE8PT2pUqUK7u7ujBkzhtq1a5Oeno6npycHDhzA0NCQZs2a8cUXXyj9rPJCWsYLXl5bxpdP0f6HZNTCdYXWMt5lgnaLT+ASF67M1/7Htcq0gGxbxg+5aJdtuiOAOROCspSducT5tbumr9p9mJ/rpWvYvK19Vubreum6Dy8uPqi1rPrEZq/MOdL39cquZfzs2UjKlq2ktUzf44wXpNTUVD78sA8zZ86hZs1a/+m+X0Uvcz5edrztwibjvos3RXT0NWrVqqlzXZ4+BlWtWpVt27ZlWe7t7a38bWhoyJQpU5gyZcoLhimEEKKwJCWk5Hk88FfZgQP7+fprT1q2/J8k4sj5EOJNIN9JCCGEeG20aNGy0CaOeR297Plwd/+0AKMpeDNnztZ3CEIUOknGxVvFsngRjEy0b/tUTSpxjx7rKSIhhBBCvM0kGRdvFSMTI519kIUQQggh9CHvT1cKIYQQQgghCpQk40IIIYQQQuiJJONCCCGEEELoiSTjQgjxFlAXMcLS0rzAf9RFcn/0aNWq7/D0XKC8PnjwAE5O9ly5cllZNmHCGHbu3E50dDTt27fO9/FduHCevXv35Frm888Lfzxtb+9VfPutl851QUE7mTLlc53rClNYWCiDBvUHICYmhhEjhinrnJzsSUpKyld9w4e7Ex0drXNdTsf/Jtq82Z8HDx4orwMCtuHjsybb8kFBO7l+/dpL7/dF3yt5MW7caG7evAFkjTc/97Cra2f69OlOcHDWuSVe1KhRn9KuXSu2bduc5222bw+gf//euLn1YMKEMSQmJhZYPAVBHuAUQoi3gJGZaZYJmApC0x0B8Dg1xzIODg1YvNhTeR0REUatWnaEh4dSpUpV0tLSOHnyhNaskPl14cJ5Dh36kzZt2mVbZsWKZXz8sfsL7+NNYW1tzYoV3+s7jDfG5s0bcXRspMxM7uLiSp8+PejVqw/m5lkn5dq1K5ASJUpQsWKlLOteFV5ey5S/XzbeBQu+omrVagUVGsuXr2LOHA+d67y9V1GmTFmcnbtqLX/33TKsXeuHqakp06Z9wY4dP9Ov34cFFtPLkpZxIYQQhap27brcvh1NbGwsABER4QwZ4k54eBiQmUibm1tQvnwFZZuVK5czcGBfevfuxokTEUDmTJOffTaCQYP607dvT+bO9SAlJYVHjx7i7b2K48ePMmCAG0uWfJUlhjt3bnP9+jVq164LZCbmGzasB2Dv3j00buygtG6OGzeao0ePABAcHET//r3p3783X3wxQSnzfOtvdq3BKSkpfPnlPHr2dGHo0I+yneL+t99+Zfz4McprjUZD587tuHPnNmlpaXz7rRf9+vWiX79efPutF2lpaUBmC/XBgweU7Z5/rUt2Larp6eksXbqYGTOmoNFoOHPmNCNGDOOjj/rx0Uf9OHToT531JSTEM2XK5/Tp053hw925deumsi4pKYm5cz2U2P38fHTWMX78GH777Vfl9e+//8aYMSMAuHHjOqNGfUL//r0ZOLAfR44c0nkc2R1XUlIS7du3Vs6Zm1sPFi1aCMDZs2dwdx8EwO7dvzBkyEAGDuzLwIF9OX78qFKHq2tnvv9+JUOHfoSra2elVXbduh+4fz+GqVMnMWCAG1FRVzAyMqZhQyd+/TXrNzVBQTv4++9Ivv56EQMGuHHs2NEcr+/zfvxxCz17dmXgwH4EBm7XWpfdvfqsv/46rNxnDx48oHFjB+W8+/n5sHLlMuV4L1++pDNegMTERKZN+4K+fXvi7j6Y2Nj7OuN93vHjRxk69CMGDuxL//69+fXX3TrLPXjwgAED3JSfdu1asXTp4jztQxcnpyaYmpoC8OTJE4yNX622aEnGhRBCFCozMzNq1qxFeHgoiYmJPH78GCenJly4cB6A8PBQ7O0dlPKPHj2kdu06+PpuYsgQd7777lsAVCoVc+YswMfHn40bt5Genk5g4A6KFy+Bu/unODo2ws9vMxMmTMoSQ0REmNYMlQ0aNCQ09BgAoaHHsLOrTVjYcVJTUzh79gx169bj8uVLrFjxLd988x3+/lupUqUqS5Z4Zqk7Jz//HEB0dDSbN//I8uWriIw8o7Ncy5b/48qVS0RH3wLgt9/2YGdXm3ffLcP27T9x4cJ51q/fyPr1G7lw4W+2b/8pX3HkRqNJZtq0L5RznJyczFdfLWDOnPmsX7+RJUu+4csv5xMfH59l2zVrvDE3N2fLlp9YuPArIiLClXVr13qTkZGBv/9WvL3XERwcxOHDh7LU0atXHwIC/p3pOyBgKz179gbAw2M67dp1xN9/K7Nnz2PWrBnExcXl+diKFi1KpUqVOXfuLPfvx2BmZsbJkyeAzGvfoEFDAJycGrNmzXp8fTcxd+7CLK2vT5484Ycf1rNihTcrViwjKSmJwYOHUqqUNQsWfIWf32ZsbKoAULt2HeX+epazswvvv1+T8eM/x89vMw0bNsrz9b148QI+PmtYvXodvr4befTokbIur/dqvXr1OXPmNKmpKcp9/+z74Om5yClegHPnzjJmzDg2bfoRG5sqbN2aty4jNWrYsnr1Wnx9N/Httyv59lsv/vnnnyzlSpYsiZ/fZvz8NjN9+iwsLNT07NknT/vIia/vOu7fj8HZ2eWl6ypIkowLIYQodPb2DQgPD+PkyRPUrVsPlUpFhQoVuXLlMuHhoTg4NFDKFi1alGbNWgBgZ1dbaWlNT0/H39+PAQPc+PDDPoSGHufixfN52v+9e/coWdJKeV2nTl0iIyNJSUnh1KmTDBnizrFjRzlz5jRVq1bFzKwIYWGhNG7cjFKlrAHo1q0Hx49nTbByEhZ2nE6dnDEyMsbMrAgdOnTSWc7IyAhX1x789NOPAPz441Z69MhMRo8fP0rnzl0wNjbG2NiYzp27arXaFoSxY0dhZ1eb0aPHYWBgwOnTJ4mOvsW4caMZMMCNceNGY2BgoPQj1j7GULp0cQWgRAlLWrX6n7Lu+PGjdO3aDQMDA8zNLWjbtoPO2J2cmhAbe5+oqCtERV3h5s2bNG3anMTERC5ePK90O7CxqUL16u9x5sypfB2fo6Mjx44d4/jxozRr1gK1uhj37t3l+PGjNGjgCMDNmzf57LOR9O3bk+nTJ/PgQaxWi2/btu0BKFu2rLJ9dqysrLh3716eYsvr9Q0PD6NJk+ZYWWXex66u3ZV1eb1XzcyKULVqVc6cOcPx40cZMsSdU6dOotFoOHcukjp16uUp5jp16lK69LuA9ns0Nw8fxjF16iT69evF2LEj+eeff7h+/Wq25e/evcPUqZOYPXue1jdnz9qx42elBf3nnwPw9l6lvD58+N95RS5fvsTWrZvw8lpOkSJF8hTvf+XVaqcXQgjxRnJwaMBXXy3EwsKC+vUzW8Hr17fn+PFjnDx5ggkTvlDKGhubKH8bGqqUr+z37PmFkycjWLVqDebm5vj4rOH69et52r+pqSkaTbLy2szMjGrVqrNnTwhWVqVwcHDk22+9eOedd7K0DuqiUhmRnp6uvNZoNHmKIyeurt0ZOLAfzZu3JCEhAUfHvMShIj0945k4knMonT17+wYcOXKYHj16YWZWhIyMDKpVq86qVdk/iFiQDAwM6Nmzt9I63q1bD1QqVY7bGBmpyMh49hpkf+wODg354YfVvPtuGbp2dcXQ0JCDB//kwoXzStelmTOnMmbMOFq2/B/p6em0atWE5OR/r6uJybP3pWG2XUkAkpM1SreIV42DgyOhocc4c+Y0kyZNxdKyJL/+upvq1d/Lc8wmJv+Wy+1cPOurrxbQvHlLvvxyMQYGBvTq5UpysoZLly4ye/aM/4+vAWPHTiQxMYEJEz5j5MgxyjXSxcWlGy4u3YDs+4xDZne4WrVqK337XyXSMi6EEKLQ2dnV4c6d2/z++2/Y22e2gterZ8+PP27BwkJN2bLlcq0jPj6BEiUsMTc3JyEhnj17QpR1mcsSst22atVqXLumPYJFgwYN8fZehaNjQ0xMTHjnnXfYtStQScYdHBpw5MhBpXV0x46flK/pK1SowPnz50hPTycxMTHb/tQNGjgSErKL1NRUnjx5ohXz80qUsMTRsSEzZkyhe/deGBgYAODo2Ijg4CBSU1NITU0hODiIhg2dlDjOncvshx4VdYWLFy/keA6zM3ToJzRs6MRnn40kMTGB2rXrcuPGDcLCjitlIiPPkpGRkWXbBg0cCQraCWR2Mdq//3dlnaNjIwIDt5ORkUFiYiJ79+5WzuHzOnXqwoEDf/Dbb3vo2jUzuTI3N6d69RoEBwcqx3jp0gXs7OpQsqQVqamp3LiR+YEsp3Nbu3YdLl26wOnTJ7Gzs8PRsSG+vuuoUcNWSbLj4+OV+zAwcEeeP2DpuveuXo2ievX38lQ+p+v7LHt7B44cOaj0Bd+5898+4zndq89r0KAhQUE7KV26NMbGxjg6Zr4PsvsQmtt7Kz/i4+MpU6YsBgYGHD36l/JNS7Vq1ZVuKWPHTiQ1NZUpUybRsWNnWrduUyD7rlu3Hv36DSiQugqatIwLIcRbIPVJcubIJ4VQb16YmppSs6YdMTH3sLbO/Cq9Zs2axMTco3Xrtnmqo1Onzhw48Ad9+nTH0tKSunXrk5ycuX9Hx4Zs3OjHhx/2oX59hyz9xuvWrc/t27dISIjHwkL9/9s48v33K5QkpEGDhpw+fYpatTL7lletWo0RI8YoDxKWK1eeL76YBkCrVq3Zu3cPbm49KF36Xd5/31ZnzK6uPbh06SJubj0oUaIEtrY1dT5Y91TXrt3Yt28vnTs7P1NHd27evMHAgf0AaNSosdIS+OGHHzF16iQOHPiDGjXe5733auTpXOoycOAgTE1NGT16OF5ey1m0yItly5bi5bWYlJQUypUrz+LFS5UPCU8NGTKUefNm06dPd0qWtKJePftn1rmzeLEn/ftndrnp0KEzjRs31bl/c3NznJyakJz8BEtLS2X57Nnz8PScz6ZN/qhURnh4zFXWjxs3kTFjRmBpaUmTJs2yPTZjY2NsbWuiUhlhZGSMrW0t4uPjlS4qmXVNYNKk8ajVxWjcuDHFi5fI03nr3bsv8+bNwszMjDlzFmBjU4WjRw/z6acjdZZ3de3Ot9964e/vy+jR43K8vs+qXv09PvpoCMOGDcbc3FzreHO6V59nZ2fHo0cPte77lSuXa52LnOJ9GSNGjGHRooV4e6/C1rYW1apV11nu1KmThIYeIy7uASEhwQC0b9+RDz/86IX3fenSJU6eDKdu3bx1xfkvGWTo+pirJ7GxCVpft/2XrK3VxMRkfTDldZeX47K2VrN8ymCtZaMWriuU82FtrabLhB1aywKXuHBlvvaQa1WmBejcv7W1OsvwbE13BDBnQtYxTGcucc5Sh7W1mouLD2otqz6x2Stz7V+1+zA/16v3luFZtt/aZ2W+rpeu+1CuV/YMDQ2wsso6dNrZs5GULfvqDpumL+vXr8XExIS+fV+dIc2et3btD8TGxvD551P0HUqOhg93Z8aM2ZQtW7bA6kxNTeXDD/swc+YcrYdtXzdXr0bh6TmflSt/0Hcoeufq2pklS74p0KENAebM8cDW1pZevdwKtN7CFB19jVq1aupcJ91UhBBCvBX69v0QU1MzfYeRrb59e7Jv368MGfL2jYV+4MB+evbsSqNGTq91Ig5w9+5dJk2aqu8wXgmWlpbMmDGlwCf9iYgIe+UewnwZ0k3lNacuYYrZMw87PfUkRUP8wxd7kOdVoElLwdpare8whBBvEBMTE7p376nvMLK1adOP+g4hzzp37oJaXXD/Rrdo0ZIWLVoWWH361KhR1v7eb6t16zYUeJ3Ll68q8Dr1TZLx15yZsUm23QPieX2TcROVcbbHJYQQQr90jVYhhHgx0k1FCCGEEEIIPZFkQ/ExKAAAIABJREFUXAghhBBCCD2RZFwIIYQQQgg9kWRcCCGEEEIIPZFkXAgh3gLmRU2xtDQv8B/zorlPn71q1Xd4ei5QXh88eAAnJ3uuXLmsLJswYQw7d24nOjqa9u1b5/v4Llw4z969e3It8/nnLzdpSV54e6/i22+9dK4LCtrJlCmfF3oMzwsLC2XQoP4AxMTEMGLEMGWdk5M9SUlJ+apv+HB3oqOjda7L6fjfRJs3+2tN5BQQsA0fnzXZlg8K2sn169eyXZ+dF31v/FeGD3fn4MEDBVZffHw8fn4+2a4PCwulZcsmDBjgRnx8wcz3cOrUSQYMcMvXe0Kj0TB16iT69+9Njx5d2bJlU773K6OpCCHEW8DE1EjnZEsva+YSZxKTch65ycGhAYsXeyqvIyLCqFXLjvDwUKpUqUpaWhonT55g3LgXT1IvXDjPoUN/0qZNu2zLrFixjI8/fvvG8H6etbU1K1Z8r+8w3hibN2/E0bERJUuWBMDFxZU+fXrQq1cfzM2zTsq1a1cgJUqUoGJFmZgrJ/Hx8WzY4MuAAYOyLWNjY4OPj3+B7bNOnbr4+W3Gycle53pX185s375La1l6ejouLt1o1KgxcXFx9OjRhfbtO1CihKXOOnSRlnEhhBCFqnbtuty+HU1sbCwAERHhDBniTnh4GJCZSJubW1C+fAVlm5UrlzNwYF969+7GiRMRQOYMjZ99NoJBg/rTt29P5s71ICUlhUePHuLtvYrjx48yYIAbS5Z8lSWGO3duc/36NWrXrgtkJuYbNqwHYO/ePTRu7KC0bo4bN5qjR48AEBwcRP/+venfvzdffDFBKfN86292rcEpKSl8+eU8evZ0YejQj4iMPKvzHP3226+MHz9Gea3RaOjcuR137tzm/9q787Coqv+B4+9h2MEVMcFdNANxY1NMy0xzQyVccE9N7KuVhea+oLjlbu7lguG+76aW9rU0vspiZrkv5QIpoiIgss38/uDH5MSqoNcZPq/n6Xnm3nvmzOfce8PPnDn3nIyMDBYunE/Pnl3p2bMrCxfOJyMjA8jeG1mQ3sncelg1Gg0LFsxhwoQxpKam8vvvZxkyZBAffNCTDz7oyYkTP+dYX2JiAmPGjMDf34/BgwO4ffuW7tjjx4+ZMiVIF3tuPZ3Dhg3lyJHvdds//nhEt7T7zZs3+OSTj+jVqxt9+/YkLOxEju3IrV2PHz+mdesWunPWvXtnZs+eAcAff/xOQEA/AA4d+o4BA/rSt28P+vbtQXj4SV0dvr7t+eabZQwc+AG+vu3ZunUTACEhK7l3L5axY0fSp093rl+/hqmpGV5ejfn+++y/1Ozbt5sLF84xb95s+vTpzqlTJ/O8vrlJTU1l3LhRfPXVPLRaLYMHB7Bo0XwGDRqAn18HlixZqCub2/nbuXOb3nlo3NhNd3/OmjWDXbu2Z/vc8PCTDBz4AX379qBXr258//2hbMcHDOhDly4dWbZsUb4x5HUN58z5ksTEBPr06a67RvlZuHA+/fv3pndvfz755CNiYnL+9Wb37p306dOdPn2607u3P40bu3H58qUCfca/WVpa0qiRNwAZGeloNBrU6mfr65ZkXAghxAtlaWmJi0sdoqIiSEpKIjk5mcaNm3Dp0kUAoqIicHNz15WPj39I3br1CA3dyIABAbrEQq1WExw8nTVr1rNhw1Y0Gg179+6mVKnSBAT8B0/PRqxdu4nhw0dmi+H06Ui9lR09PLyIiDgFQETEKVxd6xIZGU56ehp//PE79es34OrVKyxdupCvvlrC+vVbqFHDiblzZ2arOy87d24nOjqaTZu2sXjxcs6d+z3Hcm+//Q7Xrl0hOvo2AEeOHMbVtS4VKjiwa9cOLl26yLffbuDbbzdw6dIFdu3a8Uxx5Cc1NYVx40bpznFKSgqzZk0nOHga3367gblzv+LLL6flOBxg1aoV2NjYsHnzDmbMmMXp01G6Y6tXr0Cr1bJ+/RZWrAjhwIF9/PLLiWx1dO3qz/btW3Xb27dvoUuXbgAEBY3nvffasn79FiZPnsqkSRN48OBBgdtmbW1N1arVOH/+D+7di8XS0pIzZ34FMq+9h4cXAI0be7Nq1beEhm5kypQZBAcH6dXz5MkTVq78lqVLV7B06SIeP35M//4DKVfOnunTZ7F27SaqV68BQN269XT319N8fDrxxhsuDBs2grVrN+Hl1eiZr298fDyfffYx9eo14LPPhqFSqQD4+++/Wb58JaGhG9izZxc3btzI8/xl/j8QrjsPT8f89Hl5Wu3aznz99WpCQzeycOEyFi6cz6NHj3THr1+/zjffhBAauonjx3/WfTF8nmv4xRejsbUtwdq1m1ixYk2eZbP07duPkJB1rFu3mVat2uh9KXlap07vs3btJtau3cSbbzajefMWODnVLNBn5Obx48eMGBHIgAEBz7wglgxTEUII8cK5uXkQFRWJjY0t9es3QK1WU7lyFa5du0pUVATvvPOurqy1tTVNm74FgKtrXV2Ps0ajYf36tYSFnUCj0fDo0SMsLQu2vP3du3cpW9ZOt12vXn3Gjz9HWloav/12hk8//ZyjR49gb2+Pk5MTlpZWREZG4O3dlHLl7AF4//3O9O7d/ZnaHRkZTrt2PpiammFqakabNu10ieDTTE1N8fXtzI4d2/jkk8/Ytm0LH330MZDZ29i+fQfMzMwAaN++I8eO/Ujnzl2fKZa8fP75J7Rq1ZpevfoCcPbsGaKjbxMY+KmujEql4tatmzg7u/yrjRG6L0ClS5ehefN3dMfCw08SGDgClUqFjY0trVq1ITz8JE2avKlXR+PGTViwYC7Xr18D4NatW7z5ZjOSkpK4fPmibpGh6tVrUKvW6/z++284OdUqcPs8PT05deoUDg4VaNr0LSIjI7h79w7h4Sfp33+g7jO//nossbF3MTU15f79OOLi7mFnVw6AVq1aA+Do6EiJEiW5e/cO1apVz/Hz7OzsuHv3boFie5brm5qawkcfDSAg4D+8+24rvWPvvtsKExMTbG1LUK1aNW7fvomdnV2u569Zs7dJSXny/+fhFP/5zyesWbOK1q3bkpqaqvdLVZaHDx8wbdpkbt68gVqt5tGjR9y48SeurvUA/v9eN8XU1JSWLd8jIiKchg3di+QaFkRY2Am2bdtCcnJyvr8uAOzZs4vIyHAWL/4aE5Oc+6e/+OJz7tz5G4B792Lp0yfzb4BardYbIrNq1dc4OdWkb9/+zxy3JONCCCFeOHd3D2bNmoGtrS0NG2b2gjds6EZ4+CnOnPmV4cNH6cqamZnrXpuYqHX/qB4+/B1nzpxm+fJV2NjYsGbNKl3vX34sLCxITf1nbLulpSU1a9bi8OGD2NmVw93dk4UL51O+fPkcewT/Ta02RaPR6LZTU1MLFEdefH396Nu3J82avU1iYiKengWJQ41Go30qjudbednNzYOwsF/o3LkrlpZWaLVaatasxfLluT+IWJRUKhVdunTT9Y6//35n1Gp1nu8xNVWj1T59DXJvu7u7FytXfk2FCg507OiLiYkJx4//zKVLF3VDlyZOHMvQoYG8/fY7aDQamjdvQkrKP9fV3Pzp+9Ikz2QvJSUVC4v8H25+VmZmZri61uXnn4/RvHkLvXOkH5+6QMmou7snx4//zIMH93F392Du3JmcOHEcDw/PHMvPmjWdZs3e5ssv56BSqeja1VfvHD2rZ7mG+YmJiWbBgnmEhKzF0bEiv/12hokTxwKZw4mOHv0BgM8/H467uycnT4axfn0oy5evyvNL/Zw5C3SvfX3bs3btphzLXbx4kW7dejxX7DJMRQghxAvn6lqPv/+O4ccfj+Dm5gFAgwZubNu2GVvbEjg6Vsy3joSEREqXLoONjQ2JiQkcPnxQdyxzX2Ku73Vyqslff+nPYOHh4cWKFcvx9PTC3Nyc8uXLs3//Xl0y7u7uQVjYceLi7gGwe/cOvLwaAVC5cmUuXjyPRqMhKSkp1/HUHh6eHDy4n/T0dJ48eaIX87+VLl0GT08vJkwYg59fV93wA0/PRhw4sI/09DTS09M4cGAfXl6NdXGcP585zvf69WvPPe514MCP8PJqzGeffUxSUiJ169bn5s2bREaG68qcO/cHWq0223s9PDzZt28PkDnE6NixH3XHPD0bsXfvLrRaLUlJSfzwwyHdOfy3du068NNP/+XIkcN07Pg+kHlda9WqzYEDe3VtvHLlEq6u9Shb1o709HRu3sz8QpbXua1btx5Xrlzi7NkzuLq64unpRWhoCLVrO+uS2ISEBN19uHfv7gJ/wcrp3vvzz+vUqvV6gcrndX3/TaUyYdy4IGxsbBg/fjTp6Wn5xpbb+YPM/wdCQ0OoVy/zC0m9evUJDQ3J9QtpQkICDg6OqFQqTp78H7du3dQ7fvDgAdLT00lOTubIke/x8PB87mtoY2PDkydPSE9Pz7ONWZKSkjAzM6VsWTs0Gg07d27THevff6BuWIq7uydXrlzmyy+nMXv2fMqUKfiDlnnp129Atl+NCkp6xoUQohhITUln4lyfF1JvQVhYWODi4kps7F3s7TOHfbi4uBAbe5cWLVrl8+5M7dq156ef/ou/vx9lypShfv2GpKRk9qR5enqxYcNaevf2p2FD92zjxuvXb0hMzG0SExOwtS3x/+/x5JtvluoSDw8PL86e/Y06dTLHljs51WTIkKG6BwkrVqzEqFHjAGjevAU//HCY7t0789prFXjjDeccY/b17cyVK5fp3r0zpUuXxtnZRW8avH/r2PF9jh79gfbtfZ6qw49bt27St29PABo18qZTp8xktXfvDxg7diQ//fRfatd+g9dfr12gc5mTvn37YWFhwaefDmb+/MXMnj2fRYsWMH/+HNLS0qhYsRJz5izQfUnIMmDAQKZOnYy/vx9ly9rRoIHbU8cCmDNnJr16ZY7/btOmPd7e+kNUstjY2NC4cRNSUp7oJUiTJ09l5sxpbNy4HrXalKCgKbrjgYFfMHToEMqUKUOTJk1zbZuZmRnOzi6o1aaYmprh7FyHhIQEvR7gwMDhjBw5jBIlSuLt7U2pUqULdN66devB1KmTsLS0JDh4OtWr1+DkyV/4z38+zrG8r68fCxfOZ/36UD79NDDP65sTlUrFiBFjWLhwPiNHDmfGjNl5xpfX+fPw8GLy5Al6/w/s2rUj157xIUOGMnv2DFasWI6zcx1q1tQfZlKtWjUGDerPo0fxvPtuK91ws+e5hqVKlaJ167b06tWNkiVL5jtuvGbNWrRo0YoePbpQunRpmjR5U+/5hadt3LiO5OTHjBv3zy9yU6d+SdWq1fL8jLwcOnSQ9u19dH/fnoVKm9PXXIXExSXq/dz2MtnblyA2tmjmqXyZ7O1L0G3z4Gz7t/gvIzY2oUDtsrcvweIx+mOchkxZhYmp/g8n6anpPIhPLnS8HYbv1tu3d24nrk3rrLevxrjtubbrRCf9sm/u3p7jlG0T5/pka7u9fQkuzzmut6/WF01fmWv/qt2HL/t6/fs+/GRGiFyvPJiYqLCzyz512h9/nMPRUaZN+7dvv12Nubk5PXr0VjqUXK1evZK4uFhGjBijdCh5Gjw4gAkTJuPo6Fhkdaanp9O7tz8TJwbrPWxraP788zozZ05j2bKVSodi1CIjI1i0aH6RTm2YpXFjN44ePY61tXWR1Rkd/Rd16uTccy7DVESOTExNuDznuN5/pubyQ4oQwnD16NEbC4uCPfCphB49unD06PcMGFD85kL/6adjdOnSkUaNGht0Ig5w584dRo4cq3QYRs/MzIz79++/kEV/ypa1w8RElf8biohkV0IIIYoFc3Nz/Py6KB1GrjZu3JZ/oVdE+/Ydnnn6try89dbbvPXW20VWn5IaNcp5vLcoWvXq1WfPnu+KvM7cHtB8kQrUM379+nX8/f1p3bo1/v7+/Pnnn7mWvXbtGvXr12fmzGebi1UIIYQQhsHHp2ORJuNCFGcFSsaDgoLo2bMnhw4domfPnkycODHHchkZGQQFBdGyZcsiDVIIIYQQQghjlG8yHhcXx7lz5/DxyXyy28fHh3PnzuX4NPg333xD8+bNqVatWpEHKoQQQgghhLHJd8x4TEwMr732mm5iebVaTfny5YmJiaFs2bK6chcuXOD48eOEhoaydOnS5womp1kBXiZ7e+P6yS2rPUXZLkM7RwWN91Vq16sUy6vqVTpHr1IsQgghDE+RPMCZlpbGhAkTmDFjRr4rZuVFpjZ8dnklAs8ytWFBFfYcvezEJaepDQtSTimv2n34qiaar8o5Uvp65Ta1oRBCCMORbzLu4ODAnTt3yMjIQK3OXF717t27ODg46MrExsZy48YNBg0aBMCjR4/QarUkJiYyZcqUFxe9EEKIArG1McXMvOiX505LTSExKe+Ff5YvX0J8fDyjRmVO93b8+E988cXnbNiwlRo1nAAYPnwob7/dAg8PL/r3782hQ0efKY5Lly5y48ZftGz53vM15BVU2DYFBn7K8OEjqVSpcpHEEx0dzalTYfj6ds6/cD6Cg4Nwdnama9fuuZZJTU1l0qTx/PXXnzx58oRu3Xrg7/98y40L8SrLNxm3s7PD2dmZffv20alTJ/bt24ezs7PeEBVHR0dOnjyp2160aBGPHz9m1KhROVUphBDiJTMzt8i2qFJR+GRGCOSTjLu7ezBnzj8zbJ0+HUmdOq5ERUVQo4YTGRkZnDnzK4GBI547jkuXLnLixM+FTsbT09MxNX01Zv3Nr035xTp//qIijScmJppdu3YUSTJeEBqNhk6d3qdRI28ePHhA584daN26DaVLF83y5UK8Kgr0F2fSpEmMHj2apUuXUrJkSd20hQEBAQwdOpS6deu+0CCFEEIYrrp16xMTE01cXBx2dnacPh3Fhx8OYv/+vXTp4s+lSxexsbGlUqXKREdHA7Bs2WLCwk7w5MkTxo6dSIMGDUlPT2f48KHEx8eTkpKCi0sdRo8ez+PHSaxYsZykpET69OlOgwZuDB8+Ui+G8PCTfP31UlJTU8nIyKBfvw9p1ao1kLma5Ouvv87vv5+lZMlSzJ+/iNDQNfz3v0dIT8/A3t6esWMnYGdXTq/Odeu+JSYmWrdaZlxcHL17+7Nz5140Gi1z587k/PlzALRt254+ffoB4Ovbnrlzv8LJqWaO2wDx8Q9zbFPjxm58+OEgfvnlOI0bN+HYsR8ZP36SbqGcDRvW8ddf1xkzZoJevYMHB+Di4sLZs2e5dy+Wd99txccfDwXg+vVrTJkyiSdPkqlV63Vu3bpJ//4DdUuZZ5kz50uio6Pp06c7lSpVZsaM2Zw79wfz5s0iOTkZKysrhg0bmeOiPXfv3iU4eAL37t3DwcFRb0GVuLg4Zs2azq1bNwHo1asv7dr5YGlpSaNG3gBkZKSj0WhQq1+NL0pCFKUC3dVOTk5s3bo12/4VK1bkWP7TTz8tXFRCCCGMhqWlJS4udYiKiqBJk6YkJyfTuHET5s+fA0BUVARubu668vHxD6lbtx6DB3/CwYMHWLJkIStWhKBWqwkOnk6pUqXRarUEB09k797d+Pl1ISDgP5w48TMzZszOMYbatZ35+uvVqNVq4uLi6NevF40aeVOyZEkAbt++zddfr8bU1JTvvtvP7ds3WbnyW0xMTNi+fStffTWf4OBpenV26OBLjx5d+Pjjz7C2tmb37h20bt0GS0srFi/+Cq1Wy/r1W3j8OImBA/vh5FSLJk3eLNA5K1WqdK5tsrCwJCRkHQD29uXZvn0LLi6T0Wq17NixNddz8Pfff7N8+UoeP06ic+dOdOjgS5UqVZg0aTzdu/eibdv2nD9/jg8/7Jvj+7/4YrTe8uNpaWmMGTOC8eOD8PRsxKlTJxkzZgTbtu3GzMxM773z5s2iQQM3Bg78iNu3b9GnT3caN26iO1ajhhMzZ87l3r1Y+vXrRe3ab+i+nDx+/JgRIwIZMCBA5jYXRkm+YgohhHjh3Nw8iIqKxMbGlvr1G6BWq6lcuQrXrl0lKiqCd955V1fW2tpa1yvr6lqXhQvnA5nDFtavX0tY2Ak0Gg2PHj3C0rJgy9s/fPiAadMmc/PmDdRqNY8ePeLGjT9xda0HQOvWbXVDPo4f/4nz58/xwQc9gcw1NGxssj8oW6pUKZo1e4vvvttPp07vs3v3ThYtWg5k9sQHBo5ApVJhY2NLq1ZtCA8/WeBkPC/t2/voXrdt257Vq78hPj6ec+d+p2xZO2rVej3H9737bitMTEywtS1BtWrVuH37JnZ2Zbl27SqtW7cFwNnZhZo1axUojr/++hMzM1M8PRsB4OXVCDMzU/76689sdURFRTBsWOavFRUrVsLDw0t3LDz8FJ99NgyAcuXs8fZuSmRkhC4ZX7Xqa5ycatK3b9EPsxLiVSDJuBBCiBfO3d2DWbNmYGtrS8OGmb3gDRu6ER5+ijNnfmX48H+eMTIzM9e9NjHJnDgA4PDh7zhz5jTLl6/CxsaGNWtWcePGjQJ9/qxZ02nW7G2+/HIOKpWKrl19SUlJ1R23srLSvdZqtfTv/yEdOvjmW2/Xrt0JChpHmTJlqVatGlWqVMn3PaamajQajW47NTU1j9LZWVlZ68X93ntt2bdvD1FREXTp0i3X95mb53xeAVQqVU5veSVcvHiRbt3kwU1hvAq0AqcQQghRGK6u9fj77xh+/PEIbm4eADRo4Ma2bZuxtS2Bo2PFfOtISEikdOky2NjYkJiYwOHDB3XHMvcl5vHeBBwcHFGpVJw8+T/d+OScNGv2Ftu3b+XRo0dAZrJ8+fKlHMvWrFmLUqVKs2DBHDp39tft9/RsxN69u9BqtSQlJfHDD4fw8srsQa5UqbJuLHl4+Enu34/Lse782pSlS5dubN68gYsXz+v9wlAQNja2VK/upDuXFy6c5+rVKwWKp2rVaqSlpRMZGQ5ARMQp0tPTqVq1Wrb3urt7sm/fHgCio28TEXFKd8zT04vdu3cAEBd3j7Cw43h4eOqO9+s3AGdnl2dqlxCGRHrGhRCiGEhLTcmc+eQF1FsQFhYWuLi4Eht7F3t7ewBcXFyIjb1LixatClRHu3bt+emn/+Lv70eZMmWoX78hKSmZn+/p6cWGDWvp3dufhg3dsz3AOWTIUGbPnsGKFctxdq6T51CMtm19ePjwIYMHDwQye8r9/LrmOvyjY0dfli9fTNOmzXT7BgwIYM6cmfTqldlT3aZNe7y9M4eoDBo0hODgiWzdugl3d08qVKiQY735tSmLo2NFqlatRp06rtnGahdEUFAw06ZNJjQ0BCenmjg51cTWNvuwnJo1a1G1alV69uxK1arVmDFjNjNmzNZ7gHP69Nk5xhAYOILg4AkcPvwdjo4Vdb+OAAwbNpKZM6fpztWQIUN1U14CHDp0kPbtfXT3jRDGRpJxIYQoBhKT0vOdgvBFW7ZM/6F/U1Mz/vvfX/T2OTo66s0x/vS2rW0JFi9enmPdtrYlWLFiTa6f3ahRY7Zt212guAB69OhNjx69c63vaZGREXTp4o+JyT8/NltbWzNx4uQcy7u41GHTpu267c8/H55juZza9L//RWUrl5SUyPXrV5kwQf/zdu3ar3v97zY+ve3g4MiqVaGoVCquX7/GkCEB1KhRk38zNTVl7tyF2dqycuW3Ocb/tPLly7N48dc5HrOzs2PWrHm5vnfcuIn51i+EIZNkXAghhHgOsbGxfPzxIOzs7Bg+/PnnSC+MHTu2ERKykh49+lC+fPnnquPs2TMsWrQArTZzBewxYyboZpkRQrx4kowLIYQQz8He3p4tW3YqGoOfXxf8/LoUqo5Gjbx183kLIV4+eYBTCCGEEEIIhUgyLoQQQgghhEIkGRdCCCGEEEIhkowLIYQQQgihEEnGDUiZUubY25fQ+08IIQqipI0lZcrYFPl/JW3yX45++fIlzJw5Xbd9/PhPNG7sxrVrV3X7hg8fyp49u4iOjqZ16xYv5BwYqsaN3Xj8+PFL+azz588xceK4Iq0zPv4hAQH96NOnO+vW5T8N4tPOnPmVAQP60qtXN/r27cmVK5eLNDYhXgUym4oBMTW34Nq0znr7aozbnktpIYT4h9pczeU5x4u83lpfNIWkvMu4u3swZ85M3fbp05HUqeNKVFQENWo4kZGRwZkzvxIY+PKnB0xPT8fUVP4pzOLs7EJw8LQirfPUqZOUKFEyz3ngc5Keno6ZmRkzZ87F3t6ebds2s3z5EubMWVCk8QmhNPkLJIQQ4oWqW7c+MTHRxMXFYWdnx+nTUXz44SD2799Lly7+XLp0ERsbWypVqkx0dDQAy5YtJizsBE+ePGHs2Ik0aNAQgAMH9rF+fSiQuaz8qFHjKFu2bLbPXLhwPqdPR5KWlkbp0qUZNy4IBwdHoqOj6d+/N+3bdyAiIhxfXz/eeutt5s6dxZ07f5OSkkKrVq3p1+/DbHX27NmV8eMn4eJSB4ANG9bx11/XGTNmAufO/aG3EuWwYSNxcalDZGQEixbNZ82a9QDZtp+2cuXXfP/9IczNzVGpVCxZ8g0lSmT+Arply0aOHfuR+Ph4Pvnkc1q0yFz2PizsBMuWLSYjI4MyZcowatQ4KleuQmRkBPPnz6ZWrde5cOE8VlZWTJgwmerVa+R7LCu+rHPl6+uX47XYunUTmzdvpESJEjRp8ibbtm3VW7Aps73hLF78FUlJifTp053hw0dSuXJVZs2azq1bNwHo1asv7dr5AODr255WrVoTGRmOk1NNxo0L0tWVkpL6XCuMCvGqk2EqQgghXihLS0tcXOoQFRVBUlISycnJNG7chEuXLgIQFRWBm9s/y6PHxz+kbt16hIZuZMCAAJYsyVz18erVKyxdupCvvlrC+vVbqFHDiblzZ+b4mX379iMkZB3r1m2mVas2ujqy6nd2diE0dAN+fl2YPHki3bp1Z/XqtaxZs56wsBOcPPm/bHV26eLP9u1bANBqtezYsZUuXfxJS0tjzJgRfPTRENav38LVfWjdAAAblElEQVSgQUMYM2YEaWlpBT5H8fHxbNq0nm+/3cDatZtYtmwlVlZWuuM2NjaEhKwjKGgK8+fPAuD+/ftMnjyByZOnsX79Ft57ry1BQeN177ly5TIdOviyceM2OnfuxuTJEwp0TD+unK/F5cuXCA0NYcWKNYSErCMhITHH97u7exIQ8B88PRuxdu0mGjRwY968WdSo4cT69Vv46qslLF26kKtXr+jek5SUxOrVa/US8cjICDZuXMugQYMLfE6FMBSSjAshhHjh3Nw8iIqK5MyZX6lfvwFqtZrKlatw7dpVoqIicHf30JW1tramadO3AHB1rcvt27eAzITM27sp5crZA/D++50JDz+V4+eFhZ3gww/70rNnVzZsWMvly5d0xywsLGjZ8j0AkpOTiYqKZN682fTp050BA/pw7949/vzzerY627Ztz8mTYcTHx/O///1C2bJ21Kr1On/99SdmZqZ4ejYCwMurEWZmpvz1158FPj+2tpm/DAQHT2TXrh0kJz/WGz7TqlVr3fmIjY0lJSWFP/44S82ar1O9eg0AfHw6cvnyRZKSMscNVapUWfclp23b9ly9eoWkpMR8jz0tt2sRFRWJt3dTypQpA0CHDp0K3Nbw8FO8/37mkMty5ezx9m5KZGSE7ni7du31yms0GiZMGMOUKTN0bRXCmMgwFSGEEC+cu7sHs2bNwNbWloYNM5PAhg3dCA8/xZkzvzJ8+ChdWTMzc91rExM1GRkZz/RZMTHRLFgwj5CQtTg6VuS3384wceJY3XFLSytUKhWQmeipVBASshZT07yHQFhZWfHee23Zt28PUVERdOnSLd9Y1Go1Go1Wt52ampJruZUrv+W3384QGXmKfv16MX/+YmrVeh0Ac3MLXTngmc/J8yrstXgeVlbWetv37sWSnp6mu2+EMDbSMy6EEOKFc3Wtx99/x/Djj0dwc8vsBW/QwI1t2zZja1sCR8eK+dbh7u5BWNhx4uLuAbB79w68vBplK5eUlISZmSlly9qh0WjYuXNbrnXa2NjQoEFDQkPX6PbdufO37jP+rUuXbmzevIGLF8/zzjuZ47arVq1GWlo6kZHhAEREnCI9PZ2qVatRsWIloqNv8ejRI7RaLd9/fyjHepOSknj48AFubu4EBAymRo2aerPN5MTVtR5XrlzS9eIfOLCX11+vjY2NDQC3b9/i11+jADh06DucnGpiY2Ob77GCcHNzJyzsBA8fPgBg//69BX6vp6cXu3fvACAu7h5hYcfx8PDMtXyJEiUZO3ZigesXwtBIz7gQQogXzsLCAhcXV2Jj72JvnznMxMXFhdjYu7Ro0apAdTg51WTIkKEMHToEgIoVKzFqVPZp+GrWrEWLFq3o0aMLpUuXpkmTNzl9OirXeidPnsaCBXPp1Suzp9va2ppx44KwsyuXrayjY0WqVq1GnTquuocJzczMmDFjtt4DnNOnz8bMzAx7e3t69uxDv369KFu2LA0buueYZCclJTJ69AhSUp6g1WqpXfsNmjfPe4rHMmXKEBQ0hYkTx5GRkU6ZMmWYNGmq3vnas2cXs2bNwNLSkqCgKQU6VhC1ar1O794fMHBgP2xsbPDw8MLWtmDJ/LBhI5k5c5rufA8ZMpQaNZxyLZ+YmMiWLZvyPR9CGCpJxoUQohjISM3InIbwBdRbUMuWrdDbNjU147///UVvn6Ojo96MHP/ebtfORzfzRl6GDRvBsGH/TJUYEDA4x/oA7OzKMWXKjAK1ISkpkevXrzJhwmS9/S4udVi5Muc5tAcMCGDAgIA86y1f/jVWrw7N8dj//heV67a395t4e7+Z4/tMTU2ZODH4mY65u3voZnrJ71r4+HTE378HACtWLMfVtW6On+Xj0xEfn466bTs7O2bNmpdj2V279mfbZ29vz9Kl3+RYXghjIMm4EEIUA4+SnuQ7H7jI244d2wgJWUmPHn0oX7680uEobunShfz22xnS0tKoWLEio0fnPCOLECJvkowLIUQRKFXSCnOL7H9SU1PSiX+UrEBEoqj5+XXBz6+L0mEUyNM93M9y7FmMGDGm0HUIISQZF0KIImFuYUrw8H3Z9k+cm/+QCiGEEMWXzKYihBBGRqUCrVajdBhCCCHIXCQsL5KMCyGEkbGxseH+/Xukp6fl+4+AEEKIF0er1ZKQEI+VlWWuZWSYihBCGJnKlStz79497t+/Q3r6y1kcRgghRM6srCypXLlyrsclGRdCCCNjYmJC+fLlZcYPIYQwADJMRQghhBBCCIVIMi6EEEIIIYRCJBkXQgghhBBCITJmXAghgDKlzDE1t9Dbl56awoP4VIUiEkIIURxIMi6EEICpuQXXpnXW21dj3HZAknEhhBAvToGS8evXrzN69GgePnxI6dKlmTlzJtWqVdMrs2TJEg4cOICJiQlmZmYEBgbSrFmzFxGzEEIIIYQQRqFAyXhQUBA9e/akU6dO7N69m4kTJxIaGqpXpl69egwYMAArKysuXLhA7969OX78OJaWuU9yLoQQQgghRHGW7wOccXFxnDt3Dh8fHwB8fHw4d+4c9+/f1yvXrFkzrKysAKhduzZarZaHDx++gJCFEEIIIYQwDvkm4zExMbz22muo1WoA1Go15cuXJyYmJtf37Nq1iypVqlChQoWii1QIIYQQQggjU+QPcJ46dYqvvvqK1atXP/N77exsizqcZ2JvX0LRzy9qWe0pynYZ2jkqaLyvUrtepVheVS/zHOX3WQWJRa6pEEKI3OSbjDs4OHDnzh0yMjJQq9VkZGRw9+5dHBwcspU9ffo0I0aMYOnSpdSoUeOZg4mLS0Sj0T7z+4qCvX0JYmMTFPnsgnrWf9BjYxMK1K5nqbew5+hlJyX/jje3z39Vrv2rdh++qknkizhHz3NvPH298jpXL+qampioFO/EEEIIUTj5DlOxs7PD2dmZffv2AbBv3z6cnZ0pW7asXrnffvuNwMBAFi5cSJ06dV5MtEIIIYQQQhiRAq3AOWnSJNatW0fr1q1Zt24dkydPBiAgIICzZ88CMHnyZJ48ecLEiRPp1KkTnTp14uLFiy8uciGEEEIIIQxcgcaMOzk5sXXr1mz7V6xYoXu9ffv2ootKCCGEEEKIYqBAPeNCCCGEEEKIoifJuBBCCCGEEAop8qkNhRC5K1HaAksz82z7n6SlkvAwRYGIhBBCCKEkScaFeIkszczptnlwtv1b/JeRgCTjQgghRHEjw1SEEEIIIYRQiCTjQgghhBBCKESScSGEEEIIIRQiY8aFEOIlK1PKClNz/T+/6anpPIhPVigiIYQQSpFkXAghXjJTc1Muzzmut6/WF00VikYIIYSSZJiKEEIIIYQQCpFkXAghhBBCCIVIMi6EEEIIIYRCZMy4EEI8ozIlzDG1tADA3r6EwtEIIYQwZJKMCyHEMzK1tOBEp856+97cvV2haIQQQhgyGaYihBBCCCGEQiQZF0IIIYQQQiGSjAshhBBCCKEQGTMuxAtSppQ5puYWSochhBBCiFeYJONCvCCm5hZcm6b/kF+NcfKQnxBCCCH+IcNUhBBCCCGEUIgk40IIIYQQQihEknEhhBBCCCEUIsm4EEIIIYQQCpEHOIuRUiWtMLeQS/4ilChphaWcWyGEEEI8I8keihFzC1OCh+/Ltn/iXB8FojEulhamdBi+W2/f3rmdFIpGCCGEEIZChqkIIYQQQgihEEnGhRBCCCGEUIgk40IIIYQQQihEknEhhBBCCCEUIsm4EEIIIYQQCpFkXAghhBBCCIVIMi6EEEIIIYRCZJ5xIV5RuS3SlJqSTvyjZAUiEkIIIURRK1Ayfv36dUaPHs3Dhw8pXbo0M2fOpFq1anplMjIymDp1Kj///DMqlYpBgwbRtWvXFxGzEMWCLNIkhBBCGL8CDVMJCgqiZ8+eHDp0iJ49ezJx4sRsZfbu3cuNGzc4fPgwmzdvZtGiRdy6davIAxZCCCGEEMJY5NszHhcXx7lz5wgJCQHAx8eHKVOmcP/+fcqWLasrd+DAAbp27YqJiQlly5alZcuWHDx4kIEDBxY4GBMT1XM0oego/fkFYVrKPts+e+uyOZT8pz1Pt6tUGascy5YobZf9s0pa5FpnYZTPIYZnaZdF+exlc2tXTvG+qu16luv1Mu/Vl3m9XuZ9mJOc2pXbZ70K96Eh/M0SQgiRN5VWq9XmVeD3339n1KhR7N+/X7evXbt2zJ49mzp16uj2dejQgWnTplGvXj0AVqxYwZ07dxg/fvwLCl0IIYQQQgjDJrOpCCGEEEIIoZB8k3EHBwfu3LlDRkYGkPmg5t27d3FwcMhWLjo6WrcdExNDhQoVijhcIYQQQgghjEe+ybidnR3Ozs7s25c5q8O+fftwdnbWGy8O0KZNG7Zu3YpGo+H+/fv88MMPtG7d+sVELYQQQgghhBHId8w4wNWrVxk9ejSPHj2iZMmSzJw5kxo1ahAQEMDQoUOpW7cuGRkZBAcHc+LECQACAgLw9/d/4Q0QQgghhBDCUBUoGRdCCCGEEEIUPXmAUwghhBBCCIVIMi6EEEIIIYRCJBkXQgghhBBCIZKMCyGEEEIIoRBJxoUQQgghhFCIJONCCCGEEEIoxFTpAETRysjIoEuXLuzcuVPpUIrMlStX8jxes2bNlxRJ0TLWdkHmfRgUFMTUqVOVDkUIIYR4pRXLZHz9+vV5Hu/Vq9dLiqToqdVqrK2tSUlJwcLCQulwisSgQYNQqVRotVpiYmKwtbVFpVKRkJCAg4MDR48eVTrE52Ks7YLM+/DixYtKh1GkGjdujEqlyvV4WFjYS4xGCCGEsSiWyfjvv/8OwIMHDzh16hTe3t5A5j+mjRo1MuhkHKB69er06tWL1q1bY21trdtvqO3KSkqnTJmCh4cHbdu2BeDgwYNEREQoGVqhGGu7sjRu3Jjg4GB8fX317kND7fHfvn07ANu2bePhw4f4+/uj1WrZtm0bpUqVUjg6IYQQhqpYr8A5aNAgJkyYQOXKlQG4efMm06ZNY/ny5QpHVjhjxozJcf+MGTNeciRFq2PHjuzZs0dvX6dOndi9e7dCERUNY21XixYtsu1TqVQcOXJEgWiKjp+fHzt27NDb17lzZ12yLoQQQjyLYtkzniU6OlqXiANUrlyZW7duKRhR0TD0pDs3Wq2WiIgIPDw8AIiMjESj0SgcVeEZa7sMeZhNXhITE7l//z5ly5YF4P79+yQmJioclRBCCENVrJPxcuXKsWTJErp27Qpk/gxdrlw5haN6fpGRkbi7u3Ps2LEcj7/99tsvOaKiFRQUxLBhw7CysgIgJSWFuXPnKhxV4Rlbu1JTUzE3Nyc5OTnH41ntNFQffPABvr6+NG/eHIBjx47x0UcfKRuUEEIIg1Wsh6ncuXOHadOmcfLkSSBzjOvYsWN57bXXFI7s+YwfP56pU6fSp0+fbMdUKhWhoaEKRFW0UlNTuX79OpA5Nt7c3FzhiIqGMbXr/fffZ+fOnbzxxhu6B1SzqFQqzp8/r2B0RePChQuEh4cD4OXlRe3atRWOSAghhKEq1sm4MDxXrlzR+/Lk5OSkcERFJy4ujpSUFN22o6OjgtGIvKSnp+t9eTI1LdY/MgohhCiEYp+MX7t2jQsXLpCamqrb5+vrq2BERSMhIYHr16/rJXeenp4KRlR4u3btYu7cubrhNj/99BNffPEFHTt2VDiywgkLC2P06NHExcVhYmJCWloapUuXlqnyXlFnz55l6NChmJubo9VqSU9PZ9GiRdSpU0fp0IQQQhigYt2dExoayubNm4mNjaVu3bpERETg6elp8Mn4gQMHmDlzJo8ePaJ8+fLcuHGDN954w+AXAlq9ejU7duzA3t4egNjYWD788EODT8Znz57NmjVrCAwMZOfOnWzbts0oHiS+cOECQUFB2b7sGvowlWnTpjF9+nS9KVGnTJnCpk2bFI5MCCGEITJROgAlbdmyha1bt+Lg4MCqVavYunUrNjY2SodVaMuXL2fHjh1UrVqVQ4cOsXLlSurWrat0WEUiKxH/92tDV716ddLT01GpVHTt2pWff/5Z6ZAKbdKkSXz++edUrVqVY8eOMWjQIAIDA5UOq9CSk5N1iTiAt7d3rg+rCiGEEPkp1sm4ubk51tbWaDQatFotr7/+On/++afSYRWaqakpdnZ2ZGRkAPDmm29y9uxZhaMqvCpVqrBw4ULu3LnDnTt3WLx4sd7UlIYqa7zxa6+9xtGjR7l48SLx8fEKR1V4qampeHt7o9VqKV++PIGBgRw6dEjpsArNyspK99wCwKlTpwx+hhghhBDKKdbDVKysrEhLS+ONN95g9uzZODg4GMX8zlljWatWrcratWupWLEijx8/VjqsQps8eTJTp07VDUt58803CQ4OVjiqwuvbty/x8fF89tlnDB8+nISEBMaOHat0WIWmVqsBKFWqFBcuXOC1117jwYMHCkdVeGPHjuWzzz7TGzO+cOFCpcMSQghhoIr1A5yXLl2iUqVKJCcnM2/ePBISEhg8eDDOzs5Kh1YoYWFhuLq6EhcXx6RJk0hISGD48OE0adJE6dBEMRISEoKvry9nz57ls88+Q6PRMHToUD788EOlQyu0tLQ0vdlUzMzMFI5ICCGEoSrWybixGTZsGPPmzQNg586dvP/++wpHVLS0Wi2bN2/ml19+AaBp06Z07doVlUqlcGTP77fffqNkyZJUq1aNI0eO8Msvv1C9enW6d+9usNPlrV69mgEDBgBw+fJlatWqRVpaGikpKdja2iocXdEw5ik2hRBCvFzFcsx4YmIiK1euZOvWraSlpTF9+nQ6dOjA0KFDiYmJUTq853bt2jXda2NY4OffZs2axcGDB2nZsiUtW7bk4MGDzJ49W+mwntuCBQv4/PPP6devHzNnzmTJkiVYWVnx3XffMXXqVKXDe2579+7VvR45ciQAZmZmRpOI79q1i/79+3P+/HnOnz9P//792bNnj9JhCSGEMFCG2fVWSGPHjkWtVpOcnMz27dupVasWI0aM4OTJkwQFBfHNN98oHeJzMeQe4oI4fvw4O3fu1PUYt23bFj8/P13CZ2gOHz7Md999R1JSEi1atOD48ePY2tqSmppq0NNrPv1jmzH+8GasU2wKIYRQRrFMxq9evcr+/ftJS0ujadOmbNy4EZVKxVtvvYWPj4/S4T23hIQEjh07BmT2/me9zpK1WI4he/oLh6F/+TA3N8fCwgILCwuqVKmi6zk2NzfH3Nxc4eien1ar5cmTJ2i1Wr3XWYxh5hFjnWJTCCHEy1csk/GsRMfMzAwHBwe9pM6QH8RycHBg5cqVAFSoUEH3GjITV0NPxps2bUpAQIBuLPyuXbto2rSpwlE9v6xEVaPRoFKp9JJWQ+5RvnjxIg0bNtS1oUGDBqhUKrRaLSqVyuAX/cmaYtPf3x+ArVu3GsUUm0IIIZRRLJPxp3uQk5KS9HqQExMTlQqr0NauXat0CC/UiBEj2Lx5M99//z0ALVu21CVEhii/pNVQXbhwQekQXihjnWJTCCGEMorlbCp9+vTJ87ihJ7VXrlzJ83jNmjVfUiRCCCGEECIvxTIZN3YtWrQgJiYGW1tbVCoVCQkJODg4AJnDVY4cOaJwhM/m119/5dq1a/j5+QEwdOhQHj58CMAnn3yCl5eXkuGJXMTExDB79mwuXLhASkqKbr+h3X9Z7ty5w+3bt3FzcwMy51FPSkoCoFOnTjJURQghxHMplsNUshhrD/I777yDh4cHbdu2BeDgwYNEREQwfvx4hSN7PkuWLOHjjz/WbV+5coWRI0fy+PFjVq9ebfDJuLElrVnGjh1Lu3btuHDhAnPmzGHjxo1UqVJF6bCe24IFC/D29tYl4xs2bKBly5Y8efKE5cuXM23aNIUjFEIIYYiKdTI+aNAgo+pBzhIeHs6ECRN0223atGHZsmUKRlQ4cXFxNGjQQLdtbm5O8+bNAVi/fr1CURUdY0taszx48ICuXbsSGhpKw4YNqV+/Pv7+/nzyySdKh/Zczp07x/Tp03XbNjY2jBo1CoCePXsqFZYQQggDVywX/cnyzjvvMG/ePMLDwzl16hTz58+nRYsWHD161GATcciciSMiIkK3HRkZiUajUTCiwnny5Ine9tNj+h88ePCywylyWUmrWq2mYcOGfPnll9mmpTREWTMTWVtbEx0dTXp6Ovfv31c4quf37wdrsxJxQDdcRQghhHhWxbpn3Nh6kLMEBQUxbNgw3XzOKSkpzJ07V+Gonp9arSY2NlY3n3OJEiUAuHv3LiYmhv998t9Ja7ly5Qw6ac3i4eHBw4cP6dGjB35+fpibm9OmTRulw3puT548ITU1VTc1qre3NwCpqak8fvxYydCEEEIYsGKdjGf1IHt4eACG34OcJTU1lZ07d3Lv3j0AypUrx6VLlxSO6vl169aNwMBApk2bRtWqVQG4ceMG48aNo1u3bgpHV3jGlrRmadasGWq1Gl9fX7y8vIiOjiYtLU3psJ7b22+/zZdffsm4ceNQq9UAaDQaZs2aZfBz+AshhFBOsZ5NJSIiIsceZHd3d4UjKxxfX1927typ+0ldo9HQuXNndu7cqXBkz2/+/PmEhIRgaWkJZF6rfv36ERgYqHBkhffLL79Qt25dSpQoQXR0tC5pzep5NVTGdh8mJSXx0UcfER0djYuLC5A5jrxChQqsWLECGxsbhSMUQghhiIp1z7ix9SBn+ffYVhMTEzIyMhSMqPACAwP56KOPdDPg1KxZE2tra4WjKhqzZs3SJaiOjo5UqFDBoJPWLMZ2H9rY2LBu3TrCwsL4448/gMwHN5s0aaJwZEIIIQxZsU7Gs5IgOzs74J+fnA09CbKxseHMmTPUr18fgDNnzhhF4hodHa1rR3R0dLbjhjoVpbElrVmM9T709vY2+F8thBBCvDqKdTJurEnQiBEj+Pjjj3XJ6ZUrV1i8eLHCURWesU5FaaxJq7Heh8Y6L7wQQghlFOtk3FiToIYNG7J//35+/fVXABo0aECpUqUUjqrwjG0xoyzGmrQa632YNS/8+fPnjWpeeCGEEMoo1g9wnj59mk8//TRbEvT0AjPi1dGxY0f27Nmjt69Tp07s3r1boYiKTnx8vNElrcbK19eXXbt20aFDB/bu3YtGo8Hf35+tW7cqHZoQQggDVKx7xo21585YGetUlAClSpWS6fEMhLHOCy+EEEIZxToZB0mCDImxLWYkDJOxzgsvhBBCGcU+GReGw1inohSGxdgWMxJCCKGsYj1mXBgWY1tERhgmuQ+FEEIUJROlAxCioIx1KkphWOQ+FEIIUZQkGRcGI2sqyizGMhWlMCxyHwohhChKMkxFGAyZilK8CuQ+FEIIUZQkGRcGRebjFq8CuQ+FEEIUFUnGhRBCCCGEUIiMGRdCCCGEEEIhkowLIYQQQgihEEnGhRBCCCGEUIgk40IIIYQQQihEknEhhBBCCCEU8n+RveZkXYbmqgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# sorted_template_cq_to_count"
      ],
      "metadata": {
        "id": "ale2v_6emPNg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "_normalizer(answers_count_to_labels)\n",
        "copied_answers_count_to_labels = count_remover(input_dict=answers_count_to_labels)\n",
        "sorted_answers_count_to_labels = collections.OrderedDict(sorted(copied_answers_count_to_labels.items()))\n",
        "\n",
        "pd.DataFrame(sorted_answers_count_to_labels).plot(kind='bar')\n",
        "# Put a legend to the right of the current axis\n",
        "# plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "plt.savefig(f'{DATASET}_answers_count_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "UO1RIbrNHanx",
        "outputId": "b8758167-e30b-41fc-beb2-1918c2423afd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# sorted_answers_count_to_labels"
      ],
      "metadata": {
        "id": "_on2V8VFX7yR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "_normalizer(query_len_to_labels)\n",
        "copied_query_len_to_labels = count_remover(input_dict=query_len_to_labels)\n",
        "sorted_query_len_to_labels = collections.OrderedDict(sorted(copied_query_len_to_labels.items()))"
      ],
      "metadata": {
        "id": "yUliSdkoIp6a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(sorted_query_len_to_labels).plot(kind='bar', width=0.8)\n",
        "# Put a legend to the right of the current axis\n",
        "# plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "plt.savefig(f'{DATASET}_query_len_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "Xt16SzwwZnEn",
        "outputId": "2a48bc0e-bdce-4b71-d25b-1e3b4e210ca2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sorted_query_len_to_labels_df = pd.DataFrame(sorted_query_len_to_labels)\n",
        "sorted_query_len_to_labels_df.loc[['cqFair', 'cqGood']].T.plot(kind='bar', width=0.7)\n",
        "plt.legend(labels = ['Fair', 'Good'], prop={'size': 16})\n",
        "locs, labels = plt.xticks()\n",
        "plt.xticks(fontsize=16, rotation=0)\n",
        "# plt.xticks(locs, labels=['Fair', 'Good'], fontsize=16, rotation=0)\n",
        "plt.savefig(f'{DATASET}_query_len_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "UVA0MqzXIoZy",
        "outputId": "bddf45a2-e71c-4f7e-84a0-adfc09455ea3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# line plot\n",
        "# pd.DataFrame(sorted_query_len_to_labels).T.plot(kind='line')"
      ],
      "metadata": {
        "id": "_nLZv59ia1Bu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "_normalizer(question_len_to_labels)\n",
        "copied_question_len_to_labels = count_remover(input_dict=question_len_to_labels)\n",
        "sorted_question_len_to_labels = collections.OrderedDict(sorted(copied_question_len_to_labels.items()))"
      ],
      "metadata": {
        "id": "lu0vcjejKZRn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sorted_question_len_to_labels_df = pd.DataFrame(sorted_question_len_to_labels)\n",
        "sorted_question_len_to_labels_df.loc[['cqFair', 'cqGood']].T.plot(kind='bar', width=0.7)\n",
        "plt.legend(labels = ['Fair', 'Good'], prop={'size': 16})\n",
        "locs, labels = plt.xticks()\n",
        "plt.xticks(fontsize=16, rotation=0)\n",
        "# plt.xticks(locs, labels=['Fair', 'Good'], fontsize=16, rotation=0)\n",
        "plt.savefig(f'{DATASET}_question_len_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "ALwFIM2cKbUF",
        "outputId": "02a1eae4-2081-454e-fd67-87d977e430db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(sorted_question_len_to_labels).plot(kind='bar', width=0.8)\n",
        "# Put a legend to the right of the current axis\n",
        "# plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "plt.savefig(f'{DATASET}_question_len_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "v12_-UB-bU6q",
        "outputId": "d7f718d4-202f-4edb-ab26-3cb0006908ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# line plot\n",
        "pd.DataFrame(sorted_question_len_to_labels).T.plot(kind='line')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "MfXRmJjrd3Qe",
        "outputId": "7f86999a-e063-4c79-b431-1ed93b86b1fc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f5bff76d340>"
            ]
          },
          "metadata": {},
          "execution_count": 36
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Faceted vs. Ambiguous"
      ],
      "metadata": {
        "id": "ILQk_GWVEomi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_query_model(query_type, cq_label, ca_label):\n",
        "  query_model[query_type]['count'] += 1\n",
        "  if not math.isnan(cq_label):\n",
        "    if cq_label == 0:\n",
        "      query_model[query_type]['cqBad'] += 1\n",
        "    elif cq_label == 1:\n",
        "      query_model[query_type]['cqFair'] += 1\n",
        "    elif cq_label == 2:\n",
        "      query_model[query_type]['cqGood'] += 1\n",
        "  if not math.isnan(ca_label):\n",
        "      if ca_label == 0:\n",
        "        query_model[query_type]['caBad'] += 1\n",
        "      elif ca_label == 1:\n",
        "        query_model[query_type]['caFair'] += 1\n",
        "      elif ca_label == 2:\n",
        "        query_model[query_type]['caGood'] += 1"
      ],
      "metadata": {
        "id": "6WpjqR-6-Xxb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# analysis of generated CQs for faceted and non-faceted query\n",
        "query_model = dict()\n",
        "query_model['faceted'] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "query_model['ambiguous'] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "\n",
        "for eachline in dataset_df.itertuples(index=True):\n",
        "  # Faceted query\n",
        "  # T2: (Which | What) _____ do you mean?\n",
        "  if bool(re.match(r'(Which|What) \"\"[a-z]+\"\" do you mean?', eachline.question)):\n",
        "    add_query_model('ambiguous', eachline.question_label, eachline.options_overall_label)\n",
        "  # Non-faceted Query\n",
        "  else:\n",
        "    add_query_model('faceted', eachline.question_label, eachline.options_overall_label)"
      ],
      "metadata": {
        "id": "ZOEEhtX49gbn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "_normalizer(query_model)\n",
        "copied_query_model = count_remover(query_model)\n",
        "sorted_query_model = collections.OrderedDict(sorted(copied_query_model.items()))"
      ],
      "metadata": {
        "id": "JswpHUrfDb2D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sorted_query_model_df = pd.DataFrame(sorted_query_model)\n",
        "sorted_query_model_df.loc[['cqBad', 'cqFair', 'cqGood']].plot(kind='bar', width=0.7)\n",
        "plt.legend(prop={'size': 16})\n",
        "locs, labels = plt.xticks()\n",
        "plt.xticks(locs, labels=['Bad', 'Fair', 'Good'], fontsize=16, rotation=0)\n",
        "plt.savefig(f'{DATASET}_query_model_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "HrtIFdCjDe_p",
        "outputId": "7952fbce-3148-4f8f-860e-8c59200e8446"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxTZb7H8U+TLlQoLS3dkH0RiqCIIDKA8CpLAYsFpBYLo8hQxgGVARFRkYKMMKggSkUEZKn1KlQFpCBy3a4iggtcQbjgjBapQ0pLVwpd09w/GDLG0g1a0p5+368XL8jJc578wpN8c/Kck3NcbDabDRERMRyTswsQEZHaoYAXETEoBbyIiEEp4EVEDEoBLyJiUAp4ERGDUsCLiBiUq7ML+K2srPOUlja8w/L9/JqQkZHn7DKkHBqfuq+hjpHJ5EKzZo3Lvb9OBXxpqa1BBjzQYJ93faHxqfs0RmVpikZExKAU8CIiBqWAFxExKAW8iIhBVRrwS5cuJTQ0lM6dO/Pjjz9eto3VamXhwoUMGTKEoUOHkpiYWOOFiohI9VR6FM3gwYO57777mDBhQrltduzYwalTp9izZw/Z2dmMHj2avn370rJlyxotNj//PHl52VitJTXar7OlpZkoLS11dhmGZjKZcXV1x8vLBzc3d2eXI3JNVBrwvXr1qrSTXbt2ERkZiclkwtfXlyFDhrB7926mTJlSI0XCxXA/dy4LHx9/3NzccXFxqbG+nc3V1URJiQK+tthsNkpLrRQW5pOVlYaXVzM8Pcs/dljEKGrkOHiLxUKLFi3st4ODg0lNTa12P35+Tcq978cfU/HzC8DDo9EV1VjXubpqd0jtMuPh4Y6Hhwd5eVm0bh1UrbX9/b1qqa76p6jYirub2dllOCgqtmqMLqNO/dApIyOv3B8rFBYWYjK5GXJLV1vw147J5EZ+fgHp6eeqvI6/v1e12hudv78Xox7d7uwyHOxYFtEgx8hkcqlww7hGNhuDg4M5ffq0/bbFYiEoqHpbSFVhpGkZcQ69hqQhqZGAHz58OImJiZSWlpKZmclHH31EWFhYTXQtIiJXqNKA/9vf/sYdd9xBamoqDzzwAHfeeScAMTExHDlyBICIiAhatmzJsGHDuOeee5g+fTqtWrWq3cpFRKRCLjabrc6coaeiOfjU1F8ICmpTZrlXU08aeThvV0JBYQnncvOvqo/anIPv378X9903malTp1XY7qGHpgIQF7emVuqoS8p7LZVHc/CONAdfd1Q2B1+ndrJeiUYerk59se1YFoERXlaPPjrX2SWISA2r9wEvNaNdu/bOLkFEapgOvnaSX39NYdGip4mMvIuBA/sSGRnBCy8sITc316Hds88uYMyYkRw/fowHH5xMaGg/7r13LPv27QXg7bcTGDduFMOGDWTu3FlkZWWVeSybzcamTa8zZsxIQkP7MX16DP/4xwmHNg89NNU+TXPJiRPHmTZtCqGh/Rg79k7i49fz+uuv0b//f378ZrGcpn//XuzatcNh3YMHv6V//14cPPitQx2bN7/JvfeOZdCg24mICGP58qWcP593Rf0dOPAVDz44mbCwgQwdOoB77x3Lhg1rK/x/F2lItAXvJGfPphMQEMQjjwzGx8eblJRfiY/fwD/+MYPXXtvg0Pb8+fP87W+xjB8/kebN/YmPX8+8eXMYMyaSlJRTzJr1OJmZGbz88nKWL1/KokV/d1j/ww93ERgYyMyZcyguLmLdutXMmDGNt99+j6ZNvS9bX3Z2NjNm/IXmzf156qkFuLm5sWXLf2GxnL5s+6pYs2YVb7yxgbFjI+nX7w5OnvyZdetW889//oO4uDWYTFXf3vjXv35l7txZDBo0mEmTpuDm5kZKyilOn/7XFdcnYjQKeCfp0aMnPXr0BC7uZA0J6c7117di+vQp/PjjcW64oYu97YUL55k9+wl7++bN/Zk06V727fuChIREzOaLvypMTv6Jd97ZjNVqtS8DKCwsYPnyV/D09ASga9dujB8/hs2b/4uYmL9ctr7Nm9/893orCQgIBKBPn9sZN+6uK3q+ubk5vP12AiNGhDNr1uP/7q8vPj7NWLRoPvv2fUH//gOr3N+PPx6nuLiY2bPn0rjxxZ1Mt97a+4pqEzEqTdE4SXFxMfHx64mOvpuBA/syaNDtTJ9+8dw9p0794tDW09PTHu4Abdq0BaBXrz4OQd66dVusVisZGWcd1r/99n72cAcIDm7BjTd254cfjpRb39GjR7jxxu72cAfw8GhE3779qv9k/91fcXExw4aNcFg+ePAwzGYzhw4drFZ/nTp1xtXVldjYJ/n004/Iysq8orpEjExb8E6yenUc7767mUmTptCjRw88PDxJS0vjqaceo6ioyKFtkyaO59hwc3MDwMvr8st/v76vr1+Zx/f19SU5+edy68vIOEu7dh0us17Zvqri0r4FP7/mDstdXV3x9vbh3Lncy61WrpYtW7F8eRwJCZtYtCiW4uIiQkJu5C9/eZhbbrn1imoUMRoFvJN8/PEehg+/k0mTptiPg8/Pv7rj6cuTmZlxmWWZNG8eUO46fn7Nyc4uu8P29325u1889W5xcbHD8tzcHIfbTZs2ta/fvv1/PjhKSkrIycnGy6tptfoD6NmzFz179qKoqIgjR75n3brVzJnzVxITd+Dj41PucxNpKDRF4yQFBQW4ujp+vu7c+X6tPNb+/V86fHhYLKc5evQI3bp1L3edi1M4h0lLO2NfVlhYwFdffenQztfXD3d3d5KTf3JYfukon9/25+bmxscf73FY/skn/43VarVvdVe1v99yd3fn1lt7M2HCfeTn52OxaEerCGgL3mn69OnLBx8k0b59R9q0ac0nn3zMDz8crpXH8vBoxKxZ07n33vsoLi7i9ddfo3HjJkRFRZe7TlTUBLZufYdZsx7mgQdicHd3Y/Pm/8LNzc3hhF0uLi6Ehg4lKWk7rVq1pnXrNuzb92WZOfWmTb0ZP34ib7yxgUaNPOnbtx8nTyazdu2r3HRTD/7wh/7V6m/btnf43/89RN++/QgICCQnJ5s33thI8+b+Dt8QRBqyeh/wBYUl7FgW4dTHvxIzZ84BbKxZswoXl4s7QhcseJaYmPtrtkAgLGwknp6evPjic+TkZNOlS1cWLlxc7iGSAD4+Prz00qusWPE8zz4bS9Om3owefTfZ2dns3r3Toe2MGbOx2UpZv34NpaU2QkOHMHPmY8yZ81eHdlOnTsPHx4dt295l69ZEvL29GT78Th58cLrDIZJV6a9jxxvYv38fr732CllZmTRt2pTu3XsQG7vIsNcMEKmuen8uGiOoL+eDt1qtTJ480R7+9ZXORXN1dC6ausPw56KR2rN27au0bNmKwMAgcnNz2LFjOz/99A+ef/4lZ5cmIlWggJdyubi4sGHDWs6ePYuLC3To0IklS1644mPhReTaUsBLuaZMeZApUx50dhkicoV0mKSIiEEp4EVEDEoBLyJiUAp4ERGDUsCLiBiUAl5ExKAU8CIiBlXvj4Nv5u2Oq7uH0x6/pKiQrJyiyhuWIylpOwkJG0lNtdCoUSN27/6s5oqrgoMHv+XQoe944IGYal0yrzKvv/4aGzasZe/ebytvLCK1ot4HvKu7Bz8/e7fTHr/9U+8CVxbwZ8+m8/zziwkLG8ETT8Ti4eFes8VVwaFD37Fhw1ruv/9PNRrwIuJ89T7g67OUlFNYrVZGjgzn5pt7OLscETEYBbyTPPvsAj74IAmAhx66eDqAESPC6dOnL++/v5Wff/4nhYWFtGzZinvuiWbEiHCH9UtKSnj77QR2797J6dP/4rrrruOGG0KYMeNR+zVbs7KyWLfuVb788gtycrIJDm5BVNQEIiLGAv+ZRgEYNOh2e9+XplUKCgpYv34Nn376Eenpafj7BxAeHsEf//iAw9b+jz8eZ8WKFzh+/Jj9tMIi4nwKeCeZNGkKnTt3YcWKF5g9ey4dO3amWbNmfPzxHgYNGszEiZNwcXHh++8P8fe/L6KwsIDRo8fZ11+w4Em++OJ/iIy8l169bqOoqIjvvz9IRsZZ2rRpy/nzeUyb9icKCwuZPHkqwcEt+Prr/Sxb9neKi4sYN248o0aNJj09jaSk7axatQ6T6T8X8C4pKWHWrIc4eTKZSZP+RPv2HTl69AibNr1Obm4uDz88E4Ds7GweeeQv+Pn58dRTC3Bzc+ett+I5c+ZMmecsIteWAt5Jrr++JW3atAOgXbv29svn3XffZHub0tJSbrnlVjIyzrJ167v2gP/uu2/47LNPmDFjNpGR4+3t77hjkP3fiYlvc+ZMKps2vU2rVq0B6N27D3l559iwYS2jR48jICAQf/+L12Xt2rWbwyUEP/roQw4f/l/i4tbQo0dPAHr1ug2ADRvWMnHi/TRr5svmzW9SUJDP8uVxBAYG2R9n3DjHbxwicu1pr1odk5JyitjYJxk9egSDBt3OoEG3s2PHNlJSfrG3+frr/bi4uHDXXaPL7efAgX107dqN4OAWlJSU2P/cdtvt5OTkcPJkcoV1HDjwFUFBwXTrdlOZ9UtKSjh69AgAR48e4cYbu9vDHcDT05N+/e64yv8JEbla2oKvQy5cuMDMmdNp1KgRDz74ENdf3xI3Nze2bn3H4YLcubk5NG3atMJL02VlZfHrrykOc+u/lZubU2EtWVmZpKZayl0/J+fi+hkZZ2nXruw1UJs1862wfxGpfQr4OuTo0cOkplp45ZV1DkfVWK1Wh3be3j7k5uZSWFhQbsg3bepN9+7NmDFj9mXvb9264kvWeXt7Exx8PYsWLbns/UFBLQDw82tOVlZmmfsvt0xEri0FfB1SUFAA4DAXnpuby969/+PQ7rbbbichYSM7dmxj3LjxXE6fPn15990tBAYGVbg17e5+8dj7oqJCh8ft0+cPfPbZJ3h6Xmc/KudybryxO2+99QZnzqTap2ny8/P58svPK36yIlLrqhTwycnJzJ07l+zsbHx8fFi6dClt27Z1aJORkcETTzyBxWKhpKSEPn36MG/ePIfQkIp163YzjRs3ZvnypfzpT38mPz+f+PjX8fb2IS8vz96uZ89eDBoUysqVL5KWdoaePXtTUlLC998fom/ffvTs2YuoqAl88sl/M23aFKKiomndui35+fn88stJDh8+xN//vhyAtm0v7uh9660Ebr+9H2aziS5dujJs2Ah27drBjBl/Yfz4CXTseAPFxcWcPv0re/d+zpIly2jUqBFRURPYuvUdZs16iMmTp9qPorn4zaLiaSARqV1VSt/Y2Fiio6OJiIhg+/btzJ8/n/j4eIc2q1evpkOHDqxZs4bi4mKio6PZs2cPI0eOrJXCLykpKvz3r0mdo6SosMb6atasGYsXv0Bc3IvMm/c4zZs3JzLyXnJzc+zHq1+yYMFi3nxzEx98sJMtW96iSZMmdOnSlVGjIgBo0qQJr766no0b1/Lmm/Gkp6fRpIkXrVu3YdCgUHs/f/jDAMaMiWTr1nfYuHEdNpuNvXu/xdXVlWXLVpKQsJH339+KxXKaRo08uf76lvTt28/+we3j48NLL73KSy+9wLPPLrAfB2+1WsvULCLXlovNZrNV1CAjI4OwsDAOHDiA2WzGarXSp08f9uzZg6/vf776L168mIKCAhYsWEB+fj4TJkzg6aef5tZbb61yMRkZeZSWXr6c1NRfCAqqeN64vnJ1NVFSUursMhqM6r6W/P29SE8/V4sV1S/+/l6MenS7s8twsGNZRIMcI5PJBT+/JuXfX1kHFouFwMBAzOaLP4Ixm80EBARgsVgc2k2bNo3k5GT69+9v/1OdcBcRkZpVYxPku3fvpnPnzmzatInz588TExPD7t27GT58eJX7qOiTKC3NhKurcQ/bN/Jzq2tMJhP+/l7VWqe67eXa0xiVVWnABwcHc+bMGaxWq32KJi0tjeDgYId2CQkJLF68GJPJhJeXF6GhoRw4cKBaAV/RFE1paalhpzE0RXNtlZaWVuvrvKZoHNXVIG2IY3TVUzR+fn6EhISQlHTxxFhJSUmEhIQ4zL8DtGzZks8/v3hoXFFREV999RWdOnW6mtpFROQqVGleYMGCBSQkJBAWFkZCQgILFy4EICYmhiNHLv5k/cknn+S7775j1KhRjB49mrZt23LPPffUaLGV7A8WqZReQ9KQVGkOvkOHDiQmJpZZvnbtfw6Da926NRs2bKi5yn7HZDJTWmrFbNZx9XLlrFarw1kzRYys3uzZc3V1p7Aw39llSD1XUHAeDw9PZ5chck3Um4D38vIhLy+HoqICfc2WarHZbJSUlJCXl8OFC+do3Lips0sSuSbqzXyHm5s7Xl7NyM3NpKSk2Nnl1CiTyURpqY6iqU0mkxkPD098fQNxdXVzdjki10S9CXgAT8/GeHo2dnYZNU6H4YlIbag3UzQiIlI9CngREYNSwIuIGJQCXkTEoBTwIiIGpYAXETEoBbyIiEEp4EVEDEoBLyJiUAp4ERGDUsCLiBiUAl5ExKAU8CIiBqWAFxExKAW8iIhBKeBFRAxKAS8iYlAKeBERg1LAi4gYlAJeRMSgFPAiIgalgBcRMSgFvIiIQSngRUQMSgEvImJQCngREYNSwIuIGJQCXkTEoKoU8MnJyURFRREWFkZUVBQnT568bLtdu3YxatQowsPDGTVqFGfPnq3JWkVEpBpcq9IoNjaW6OhoIiIi2L59O/Pnzyc+Pt6hzZEjR4iLi2PTpk34+/tz7tw53N3da6VoERGpXKVb8BkZGRw7dozw8HAAwsPDOXbsGJmZmQ7tNm7cyOTJk/H39wfAy8sLDw+PWihZRESqotKAt1gsBAYGYjabATCbzQQEBGCxWBza/fTTT6SkpDBhwgTGjBnDqlWrsNlstVO1iIhUqkpTNFVhtVo5ceIEGzZsoKioiClTptCiRQtGjx5d5T78/JrUVDn1jr+/l7NLkApofOo+jVFZlQZ8cHAwZ86cwWq1YjabsVqtpKWlERwc7NCuRYsWDB8+HHd3d9zd3Rk8eDCHDx+uVsBnZORRWtrwtvr9/b1ITz/n7DKkHBofR3U1SBviGJlMLhVuGFc6RePn50dISAhJSUkAJCUlERISgq+vr0O78PBw9u7di81mo7i4mP3799OlS5erLF9ERK5UlQ6TXLBgAQkJCYSFhZGQkMDChQsBiImJ4ciRIwDceeed+Pn5MXLkSEaPHk3Hjh0ZN25c7VUuIiIVcrHVoT2hmqKRukjj48jf34tRj253dhkOdiyLaJBjdNVTNCIiUj8p4EVEDEoBLyJiUAp4ERGDUsCLiBiUAl5ExKAU8CIiBqWAFxExKAW8iIhBKeBFRAxKAS8iYlAKeBERg1LAi4gYlAJeRMSgFPAiIgalgBcRMSgFvIiIQSngRUQMSgEvImJQCngREYNSwIuIGJQCXkTEoBTwIiIGpYAXETEoBbyIiEEp4EVEDEoBLyJiUAp4ERGDUsCLiBiUAl5ExKAU8CIiBqWAFxExKAW8iIhBVSngk5OTiYqKIiwsjKioKE6ePFlu259//pmbb76ZpUuX1lSNIiJyBaoU8LGxsURHR/Phhx8SHR3N/PnzL9vOarUSGxvLkCFDarRIERGpvkoDPiMjg2PHjhEeHg5AeHg4x44dIzMzs0zbNWvWMGjQINq2bVvjhYqISPW4VtbAYrEQGBiI2WwGwGw2ExAQgMViwdfX197u+PHj7N27l/j4eFatWnVFxfj5Nbmi9YzA39/L2SVIBTQ+dZ/GqKxKA74qiouLefrpp1myZIn9g+BKZGTkUVpqq4mS6hV/fy/S0885uwwph8bHUV0N0oY4RiaTS4UbxpUGfHBwMGfOnMFqtWI2m7FaraSlpREcHGxvk56ezqlTp5g6dSoAubm52Gw28vLyWLRoUQ08DRERqa5KA97Pz4+QkBCSkpKIiIggKSmJkJAQh+mZFi1acODAAfvtlStXcuHCBR5//PHaqVpERCpVpaNoFixYQEJCAmFhYSQkJLBw4UIAYmJiOHLkSK0WKCIiV8bFZrPVmUlvzcFLXaTxceTv78WoR7c7uwwHO5ZFNMgxqmwOXr9kFRExKAW8iIhBKeBFRAxKAS8iYlAKeBERg1LAi4gYlAJeRMSgFPAiIgalgBcRMSgFvIiIQSngRUQMSgEvImJQCngREYNSwIuIGJQCXkTEoBTwIiIGpYAXETEoBbyIiEEp4EVEDEoBLyJiUAp4ERGDUsCLiBiUAl5ExKAU8CIiBqWAFxExKAW8iIhBKeBFRAxKAS8iYlAKeBERg1LAi4gYlAJeRMSgFPAiIgblWpVGycnJzJ07l+zsbHx8fFi6dClt27Z1aPPKK6+wa9cuTCYTbm5uzJw5kwEDBtRGzSIiUgVVCvjY2Fiio6OJiIhg+/btzJ8/n/j4eIc2N910E5MnT8bT05Pjx48zceJE9u7dS6NGjWqlcBERqVilUzQZGRkcO3aM8PBwAMLDwzl27BiZmZkO7QYMGICnpycAnTt3xmazkZ2dXQsli4hIVVQa8BaLhcDAQMxmMwBms5mAgAAsFku562zbto3WrVsTFBRUc5WKiEi1VGmKpjq+/vprXnrpJdavX1/tdf38mtR0OfWGv7+Xs0uQCmh86j6NUVmVBnxwcDBnzpzBarViNpuxWq2kpaURHBxcpu2hQ4d47LHHWLVqFe3bt692MRkZeZSW2qq9Xn3n7+9Fevo5Z5ch5dD4OKqrQdoQx8hkcqlww7jSKRo/Pz9CQkJISkoCICkpiZCQEHx9fR3aHT58mJkzZ/Lyyy9z4403XmXZIiJytap0HPyCBQtISEggLCyMhIQEFi5cCEBMTAxHjhwBYOHChRQUFDB//nwiIiKIiIjgxIkTtVe5iIhUqEpz8B06dCAxMbHM8rVr19r//e6779ZcVSIictX0S1YREYNSwIuIGJQCXkTEoBTwIiIGpYAXETEoBbyIiEEp4EVEDEoBLyJiUAp4ERGDUsCLiBiUAl5ExKAU8CIiBqWAFxExKAW8iIhBKeBFRAxKAS8iYlAKeBERg6rSFZ1EGrLSkqI6d6HpkqJCsnKKnF2G1HEKeJFKmFzd+fnZu51dhoP2T70LKOClYgp4Ean39C3r8hTwIlLv6VvW5Wknq4iIQSngRUQMSgEvImJQCngREYNSwIuIGJQCXkTEoBTwIiIGpYAXETEoBbyIiEEp4EVEDEoBLyJiUAp4ERGDqlLAJycnExUVRVhYGFFRUZw8ebJMG6vVysKFCxkyZAhDhw4lMTGxpmsVEZFqqFLAx8bGEh0dzYcffkh0dDTz588v02bHjh2cOnWKPXv2sHnzZlauXMmvv/5a4wWLiEjVVHq64IyMDI4dO8aGDRsACA8PZ9GiRWRmZuLr62tvt2vXLiIjIzGZTPj6+jJkyBB2797NlClTqlyMyeRyBU/BGBryc68PXL39nV1CGc58zQQ083TaY5enIY5RZf1XGvAWi4XAwEDMZjMAZrOZgIAALBaLQ8BbLBZatGhhvx0cHExqamq1im3WrHG12huJn18TZ5cgFWj90Gpnl1CGM18zr88b5rTHLo/GqCztZBURMahKAz44OJgzZ85gtVqBiztT09LSCA4OLtPu9OnT9tsWi4WgoKAaLldERKqq0oD38/MjJCSEpKQkAJKSkggJCXGYngEYPnw4iYmJlJaWkpmZyUcffURYWFjtVC0iIpVysdlstsoa/fTTT8ydO5fc3FyaNm3K0qVLad++PTExMTzyyCN0794dq9XKM888w5dffglATEwMUVFRtf4ERETk8qoU8CIiUv9oJ6uIiEEp4EVEDEoBLyJiUAp4ERGDUsDXoPfee4/OnTvb/4SEhDBgwABmzJjBzz//XGOPExoayty5c2usv4bm9+P02z/79u2rUh8ag5pz6NAhZs6cyR133EG3bt3o2bMnd999NytWrCAtLe2a1mK0ca30VAVSfS+99BJBQUFYrVZSUlJYtWoVkyZNYufOnXh5eTm7PPm3S+P0Wx07dqzSunFxcTRpotNLXK3169fz3HPP0adPH/7617/SqlUrLly4wMGDB9myZQs//PAD69atc3aZ9ZYCvhaEhITQpk0bAG699VYCAgJ44IEHOHjwIAMHDnRydXLJb8epurp27Vppm6KiItzd3a+o/4Zg//79PPfcc9x33308+eSTDvcNHDiQP//5z+zevdtJ1RmDpmiugUtbeiUlJQD88ssvPPbYY4SGhnLTTTcxePBgYmNjycnJKbPupk2bCA0NpXv37owdO5Zvv/32mtbe0Ozdu5eYmBj69+/PzTffTHh4OOvXr7efquOS33+VvzTt88033/DII4/Qq1cvIiMjr3X59cratWtp1qwZs2fPvuz91113HWPHjrXfTktLY86cOfTp04du3boxatQotm/fXma9w4cPM2nSJG655RZ69OjB/fffz+HDh8u0awjvLW3B1wKr1UpJSQmlpaWkpKSwfPly/Pz86NOnD4D9XD5PPvkk3t7epKSk8NprrzF16lQ2b95s7ycxMZHFixczduxYRowYwalTp5g1axbnz5931lMzlEvjdImLiwspKSn07duXiRMn4uHhwQ8//MDKlSvJzMwsN4h+a/bs2dx55528/PLLDn2Lo5KSEr755huGDh1apW85Fy5c4I9//CM5OTnMmjWLoKAg3n//febMmUNBQYH9V/PHjx9n4sSJdOzYkSVLluDi4sKaNWuYOHEiW7ZsoUuXLkDDeW8p4GvBiBEjHG4HBASwevVq+5Z879696d27t/3+W265hdatWzNhwgSOHTtG165dKS0tJS4ujv79+7NkyRJ7W19fX2bOnHltnojB/X6cevbsyVtvvWW/bbPZ6NWrF8XFxaxfv55Zs2ZhMlX8pTcsLIw5c+bUSr1Gkp2dTWFhocMpxi/5/Qejq6sr7733HidPniQ+Pt6+oTRw4EAyMjJYsWIF48aNw2w2s2rVKtzd3dm4cSNNmzYFoF+/foSGhhIXF0dcXFyDem8p4GvBK6+8QmBgIDabjbS0NN58802mTp3Km2++SYcOHSgqKmL9+vVs27aN06dPU1hYaF83OTmZrl27kpqaSmpqKg8//LBD38OGDcPVVcNWEy6N0yWNGzcmLS2NuLg4vg7XCM0AAAPWSURBVPjiC9LS0hzCJiMjA3//ii8qMXTo0FqrtyFIT0+nf//+DsuOHj3KN998Q2BgoD3cL7nrrrt44okn+Oc//2mfIhs0aJA93OHiFGloaCiffvopQIN6bxnr2dQRnTp1cth5179/fwYOHMjKlStZsWIFy5cvJyEhgWnTpnHLLbfQuHFjzpw5w0MPPWQP+/T0dACaN2/u0Lerqys+Pj7X7skY2O/HqbS0lMjISNLS0nj44Ydp3749Hh4efPTRR6xevdrhg7g8lX0AyEU+Pj54eHg4nGIcoFmzZrzzzjsAbNmyhS1btgCQk5Nz2f/bS++PS/uvKmp3qU1Dem8p4K+BRo0a0apVK06cOAHAzp07iYiIYNq0afY2+/fvd1jn0ov07NmzDstLSkrIzs6u5YobplOnTvHDDz/w3HPPERERYV9+acuvKlxcdOnFqnB1daV3797s27fP4WgjV1dXunfvDsBnn31mb+/t7U1ycnKZfi69P7y9ve1///49c6ndpTYN6b2lo2iugfz8fFJSUuzn0C8oKCjzVfC9995zuB0UFERwcDAffPCBw/I9e/Zo510tKSgoAMDNzc2+rLi4mB07djirJEObMmUKWVlZvPDCC5W2ve2220hNTeW7775zWJ6UlISfn5/99wu9e/fm888/Jy8vz94mLy+PTz/9lNtuuw1oWO8tbcHXgv/7v/8jKysLm81Geno6CQkJZGdnM3HiRAAGDBjAtm3buOGGG2jTpg179uzh0KFDDn2YTCamT5/OvHnzeOKJJxg5ciSnTp1izZo1+oFNLWnfvj3XX389L774IiaTCVdXVzZt2uTssgyrb9++PProoyxbtowTJ04wevRoWrZsSWFhISdPnmTnzp1cd911uLi4MGbMGOLj43n44YeZOXMmgYGB7Nixgy+//JJnnnnGfs3oadOm8dlnnzFp0iRiYmJwcXFh7dq15OfnM336dKBhvbcU8LVgxowZ9n/7+vrSqVMn1q1bx4ABAwCYN28eNpuNFStWAHDHHXewbNmyMsdNR0ZGcuHCBTZu3EhSUhKdOnVi2bJlOkqjlri7u/PKK6/wzDPP8Pjjj+Pt7c3dd99NixYtmDdvnrPLM6SYmBh69uxJfHw8y5cvJysrC3d3d9q1a8fIkSMZP348ZrOZ6667jjfeeIPnn3+eF154gfPnz9OuXbsy02ldunThjTfe4MUXX2Tu3LnYbDZuvvlmEhIS7IdIQsN5b+mCHyIiBqU5eBERg1LAi4gYlAJeRMSgFPAiIgalgBcRMSgFvIiIQSngRUQMSgEvImJQCngREYP6fxz46f3fDlctAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# pd.DataFrame(sorted_query_model).plot(kind='bar', width=0.7)\n",
        "# # Put a legend to the right of the current axis\n",
        "# # plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "# plt.savefig(f'{DATASET}_query_model_label.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "rTd9mZdv-1Fz",
        "outputId": "4d66a68c-677f-4dbb-d348-407479283eb3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Rouge"
      ],
      "metadata": {
        "id": "ufMZnAupEm03"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Should we include the \"select to refine the query\" clarification questions in this analysis?\n",
        "# most of them are zero\n",
        "\n",
        "rouge = Rouge()\n",
        "\n",
        "rouge1_fmeasure, rouge1_precision, rouge1_recall = [], [], []\n",
        "rouge2_fmeasure, rouge2_precision, rouge2_recall = [], [], []\n",
        "rougeL_fmeasure, rougeL_precision, rougeL_recall = [], [], []\n",
        "\n",
        "nonnan_dataset_df = dataset_df[~dataset_df['question_label'].isna()]\n",
        "\n",
        "for eachline in tqdm(nonnan_dataset_df.itertuples(index=True)):\n",
        "  preds = eachline.query\n",
        "  target = eachline.question\n",
        "  eval = rouge.get_scores(preds, target)\n",
        "\n",
        "  rouge1_fmeasure.append(eval[0]['rouge-1']['f'])\n",
        "  rouge1_precision.append(eval[0]['rouge-1']['p'])\n",
        "  rouge1_recall.append(eval[0]['rouge-1']['r'])\n",
        "\n",
        "  rouge2_fmeasure.append(eval[0]['rouge-2']['f'])\n",
        "  rouge2_precision.append(eval[0]['rouge-2']['p'])\n",
        "  rouge2_recall.append(eval[0]['rouge-2']['r'])\n",
        "\n",
        "  rougeL_fmeasure.append(eval[0]['rouge-l']['f'])\n",
        "  rougeL_precision.append(eval[0]['rouge-l']['p'])\n",
        "  rougeL_recall.append(eval[0]['rouge-l']['r'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rf-0zBOkBlDA",
        "outputId": "f8011127-a32b-4467-d29e-a5ed0acf13a1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "575it [00:00, 1297.14it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Rouge-1 (F1, Pre, Rec):\", round(np.mean(rouge1_fmeasure), 4), round(np.mean(rouge1_precision), 4), round(np.mean(rouge1_recall), 4))\n",
        "print(\"Rouge-2 (F1, Pre, Rec):\", round(np.mean(rouge2_fmeasure), 4), round(np.mean(rouge2_precision), 4), round(np.mean(rouge2_recall), 4))\n",
        "print(\"Rouge-L (F1, Pre, Rec):\", round(np.mean(rougeL_fmeasure), 4), round(np.mean(rougeL_precision), 4), round(np.mean(rougeL_recall), 4))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WrRWjZvQEBap",
        "outputId": "c064de8a-6825-4415-c612-53400a19014d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rouge-1 (F1, Pre, Rec): 0.0408 0.0901 0.027\n",
            "Rouge-2 (F1, Pre, Rec): 0.0129 0.0328 0.0081\n",
            "Rouge-L (F1, Pre, Rec): 0.0408 0.0901 0.027\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The correlation between the rouge scores and the clarification usefulness scores"
      ],
      "metadata": {
        "id": "Q4IcPvcothDD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from scipy import stats\n",
        "for rouge_metric in [rouge1_fmeasure, rouge1_precision, rouge1_recall, rouge2_fmeasure, rouge2_precision, rouge2_recall, rougeL_fmeasure, rougeL_precision, rougeL_recall]:\n",
        "  res = stats.pearsonr(rouge_metric, dataset_df.question_label[~dataset_df.question_label.isna()])\n",
        "  print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vco429qstlYv",
        "outputId": "f55a4444-33fa-4c34-db97-7946210bf1c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0.3305695654327875, 3.9704337281077464e-16)\n",
            "(0.3626806639806858, 2.573432182428273e-19)\n",
            "(0.30757905102364885, 4.590886507739612e-14)\n",
            "(0.22382883369484785, 5.8110851244321464e-08)\n",
            "(0.23116886571184406, 2.055101810661361e-08)\n",
            "(0.22087931664922716, 8.737001664065087e-08)\n",
            "(0.3305695654327875, 3.9704337281077464e-16)\n",
            "(0.3626806639806858, 2.573432182428273e-19)\n",
            "(0.30757905102364885, 4.590886507739612e-14)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rouge_precision_corr = stats.pearsonr(rouge1_precision, dataset_df.question_label[~dataset_df.question_label.isna()])[0]\n",
        "rouge_recall_corr = stats.pearsonr(rouge1_recall, dataset_df.question_label[~dataset_df.question_label.isna()])[0]"
      ],
      "metadata": {
        "id": "LtUoYqkM40_r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Speciteller"
      ],
      "metadata": {
        "id": "EU1NprGn09km"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -U liblinear-official"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QXrsGxDI1Lcx",
        "outputId": "f1d94e9b-721e-4ec8-cd3a-9d1a50020640"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting liblinear-official\n",
            "  Downloading liblinear-official-2.46.1.tar.gz (46 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.9/46.9 KB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.8/dist-packages (from liblinear-official) (1.7.3)\n",
            "Requirement already satisfied: numpy<1.23.0,>=1.16.5 in /usr/local/lib/python3.8/dist-packages (from scipy->liblinear-official) (1.21.6)\n",
            "Building wheels for collected packages: liblinear-official\n",
            "  Building wheel for liblinear-official (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for liblinear-official: filename=liblinear_official-2.46.1-cp38-cp38-linux_x86_64.whl size=146570 sha256=b13fe3f533ebcfc2b06746b30ed0a294b0d10652b3cf71badfa03327c41ee157\n",
            "  Stored in directory: /root/.cache/pip/wheels/d8/81/b1/c41e218ccdbb56d943dfff43f4ad2071a679ecb2f93c904b49\n",
            "Successfully built liblinear-official\n",
            "Installing collected packages: liblinear-official\n",
            "Successfully installed liblinear-official-2.46.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! git clone https://github.com/rahmanidashti/CQSatisfaction.git"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ew96v8Wj4vMS",
        "outputId": "f4c9d65d-995e-485b-90d4-52efc1e9a973"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'CQSatisfaction'...\n",
            "remote: Enumerating objects: 69, done.\u001b[K\n",
            "remote: Counting objects: 100% (69/69), done.\u001b[K\n",
            "remote: Compressing objects: 100% (54/54), done.\u001b[K\n",
            "remote: Total 69 (delta 21), reused 56 (delta 11), pack-reused 0\u001b[K\n",
            "Unpacking objects: 100% (69/69), 6.58 MiB | 4.90 MiB/s, done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cd CQSatisfaction/speciteller"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NX3eYyj-ALDK",
        "outputId": "83fd50af-c97a-40bc-886d-bfed2e4d9f75"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/CQSatisfaction/speciteller/CQSatisfaction/speciteller\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# creating query and clarification question file\n",
        "queries = open('queries', 'w')\n",
        "cqs = open('cqs', 'w')\n",
        "\n",
        "for eachline in tqdm(dataset_df.itertuples(index=True)):\n",
        "  queries.write(eachline.query + \"\\n\")\n",
        "  cqs.write(eachline.question + \"\\n\")\n",
        "\n",
        "queries.close()\n",
        "cqs.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RGyF2CcuL0pR",
        "outputId": "e3da3fb8-7d3a-4f85-a2e9-d8c496389739"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "2832it [00:00, 255997.18it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! python speciteller.py --inputfile queries --outputfile queries.probs"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EOHSasjp1WD_",
        "outputId": "d1692381-d812-46f7-a416-31fd052f8c51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loading brown clusters...\n",
            "done; # words:  247339\n",
            "loading word embeddings...\n",
            "done; # words:  268810\n",
            "SPECITELLER: please make sure that your input sentences are WORD-TOKENIZED for better prediction.\n",
            "Output to queries.probs done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! python speciteller.py --inputfile cqs --outputfile cqs.probs"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wBzCGY5T_d1v",
        "outputId": "2e929856-8d1b-47be-cbeb-1841966986d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loading brown clusters...\n",
            "done; # words:  247339\n",
            "loading word embeddings...\n",
            "done; # words:  268810\n",
            "SPECITELLER: please make sure that your input sentences are WORD-TOKENIZED for better prediction.\n",
            "Output to cqs.probs done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "queries_prob = pd.read_csv(\"queries.probs\", names=['prob'])\n",
        "cqs_prob = pd.read_csv(\"cqs.probs\", names=['prob'])\n",
        "# adding cqs_prob to the queries_prob dataframe\n",
        "queries_prob['cqs_prob'] = cqs_prob['prob']\n",
        "print(queries_prob.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z0WJkYCDMgkS",
        "outputId": "f03a6e44-fee6-421f-c40b-3b80b5e4188d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2832, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Remove rows\n",
        "# queries_prob = queries_prob[queries_prob.cqs_prob <= 0.05]\n",
        "# print(queries_prob.shape)"
      ],
      "metadata": {
        "id": "oCN5yrBTdsSX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from scipy import stats\n",
        "specifity_corr = stats.pearsonr(queries_prob['prob'], cqs_prob['prob'])[0]"
      ],
      "metadata": {
        "id": "I4exSq8GM_jz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# plotting the data\n",
        "plt.scatter(queries_prob['prob'], queries_prob['cqs_prob'])\n",
        "# This will fit the best line into the graph\n",
        "# plt.plot(np.unique(queries_prob['prob']), np.poly1d(np.polyfit(queries_prob['prob'], queries_prob['cqs_prob'], 1))(np.unique(queries_prob['prob'])), color='red')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "jIfGOY_VN7Kr",
        "outputId": "eb4cdb30-2d4a-493b-e2c4-416672d0d592"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7fed02f85220>"
            ]
          },
          "metadata": {},
          "execution_count": 44
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Query refinement"
      ],
      "metadata": {
        "id": "azyO1gxSRLXt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "def query_refinem(query_type, query, cq_label, ca_label):\n",
        "\n",
        "  q_len = len(query.split(' '))\n",
        "\n",
        "  query_refinement[query_type]['count'] += 1\n",
        "  query_refinement[query_type]['sum_len'] += q_len\n",
        "  if not math.isnan(cq_label):\n",
        "    if cq_label == 0:\n",
        "      query_refinement[query_type]['cqBad'] += 1\n",
        "    elif cq_label == 1:\n",
        "      query_refinement[query_type]['cqFair'] += 1\n",
        "    elif cq_label == 2:\n",
        "      query_refinement[query_type]['cqGood'] += 1\n",
        "  #\n",
        "  if not math.isnan(ca_label):\n",
        "      if ca_label == 0:\n",
        "        query_refinement[query_type]['caBad'] += 1\n",
        "      elif ca_label == 1:\n",
        "        query_refinement[query_type]['caFair'] += 1\n",
        "      elif ca_label == 2:\n",
        "        query_refinement[query_type]['caGood'] += 1"
      ],
      "metadata": {
        "id": "LUraHR9egWYq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "query_refinement = dict()\n",
        "query_refinement['refine'] = {'count': 0, 'sum_len': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "query_refinement['non-refine'] = {'count': 0, 'sum_len': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "\n",
        "for eachline in dataset_df.itertuples(index=True):\n",
        "  if bool(re.match(r'Select one to refine your search', eachline.question)):\n",
        "    query_refinem('refine', eachline.query, eachline.question_label, eachline.options_overall_label)\n",
        "  else:\n",
        "    query_refinem('non-refine', eachline.query, eachline.question_label, eachline.options_overall_label)"
      ],
      "metadata": {
        "id": "9IlHuqp6RVAC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"> refine - count\", query_refinement['refine']['count'])\n",
        "print(\"> non-refine - count\", query_refinement['non-refine']['count'])\n",
        "print(\"\")\n",
        "\n",
        "for attribute in ['sum_len', 'cqBad', 'cqFair', 'cqGood', 'caBad', 'caFair', 'caGood']:\n",
        "  print(f\"> refine - count/{attribute}:\", round(query_refinement['refine'][attribute] / query_refinement['refine']['count'], 4))\n",
        "  print(f\"> non-refine - count/{attribute}:\", round(query_refinement['non-refine'][attribute] / query_refinement['non-refine']['count'], 4))\n",
        "  print(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FAe4W4Xiii7H",
        "outputId": "0ebb667f-8e95-49dc-c9f6-d437625c88de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> refine - count 2490\n",
            "> non-refine - count 342\n",
            "\n",
            "> refine - count/sum_len: 2.1325\n",
            "> non-refine - count/sum_len: 1.9357\n",
            "\n",
            "> refine - count/cqBad: 0.0\n",
            "> non-refine - count/cqBad: 0.0\n",
            "\n",
            "> refine - count/cqFair: 0.0932\n",
            "> non-refine - count/cqFair: 0.0906\n",
            "\n",
            "> refine - count/cqGood: 0.0004\n",
            "> non-refine - count/cqGood: 0.9094\n",
            "\n",
            "> refine - count/caBad: 0.0807\n",
            "> non-refine - count/caBad: 0.038\n",
            "\n",
            "> refine - count/caFair: 0.855\n",
            "> non-refine - count/caFair: 0.7953\n",
            "\n",
            "> refine - count/caGood: 0.0643\n",
            "> non-refine - count/caGood: 0.1667\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Query Classifier"
      ],
      "metadata": {
        "id": "eg-r3ZgyDNzr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%bash\n",
        "\n",
        "pip install --upgrade pip\n",
        "pip install git+https://github.com/deepset-ai/haystack.git#egg=farm-haystack[colab]\n",
        "\n",
        "# Install these to allow pipeline visualization\n",
        "apt install libgraphviz-dev\n",
        "pip install pygraphviz"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V7RoxMHji9sA",
        "outputId": "42ac950d-7ec6-4f3f-d809-a321c0e9da97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: pip in /usr/local/lib/python3.8/dist-packages (22.0.4)\n",
            "Collecting pip\n",
            "  Downloading pip-23.0.1-py3-none-any.whl (2.1 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.1/2.1 MB 14.8 MB/s eta 0:00:00\n",
            "Installing collected packages: pip\n",
            "  Attempting uninstall: pip\n",
            "    Found existing installation: pip 22.0.4\n",
            "    Uninstalling pip-22.0.4:\n",
            "      Successfully uninstalled pip-22.0.4\n",
            "Successfully installed pip-23.0.1\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting farm-haystack[colab]\n",
            "  Cloning https://github.com/deepset-ai/haystack.git to /tmp/pip-install-dh_lonl6/farm-haystack_9697fe58d69442519efe1989bd39224c\n",
            "  Resolved https://github.com/deepset-ai/haystack.git to commit bde01cbf1f18660f2780c181919bc54aa3c90c58\n",
            "  Installing build dependencies: started\n",
            "  Installing build dependencies: finished with status 'done'\n",
            "  Getting requirements to build wheel: started\n",
            "  Getting requirements to build wheel: finished with status 'done'\n",
            "  Preparing metadata (pyproject.toml): started\n",
            "  Preparing metadata (pyproject.toml): finished with status 'done'\n",
            "Requirement already satisfied: more-itertools in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (9.0.0)\n",
            "Requirement already satisfied: tenacity in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (8.2.1)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (3.0)\n",
            "Requirement already satisfied: protobuf<=3.20.2 in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (3.19.6)\n",
            "Collecting azure-ai-formrecognizer>=3.2.0b2\n",
            "  Downloading azure_ai_formrecognizer-3.2.0-py3-none-any.whl (228 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 228.4/228.4 kB 5.1 MB/s eta 0:00:00\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (2.25.1)\n",
            "Requirement already satisfied: dill in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (0.3.6)\n",
            "Collecting posthog\n",
            "  Downloading posthog-2.3.1-py2.py3-none-any.whl (34 kB)\n",
            "Collecting elasticsearch<8,>=7.7\n",
            "  Downloading elasticsearch-7.17.9-py2.py3-none-any.whl (385 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 386.0/386.0 kB 16.2 MB/s eta 0:00:00\n",
            "Collecting mmh3\n",
            "  Downloading mmh3-3.0.0-cp38-cp38-manylinux2010_x86_64.whl (50 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 50.0/50.0 kB 4.9 MB/s eta 0:00:00\n",
            "Collecting sentence-transformers>=2.2.0\n",
            "  Downloading sentence-transformers-2.2.2.tar.gz (85 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 86.0/86.0 kB 9.4 MB/s eta 0:00:00\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Collecting seqeval\n",
            "  Downloading seqeval-1.2.2.tar.gz (43 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 43.6/43.6 kB 4.4 MB/s eta 0:00:00\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Requirement already satisfied: scipy>=1.3.2 in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (1.7.3)\n",
            "Collecting huggingface-hub>=0.5.0\n",
            "  Downloading huggingface_hub-0.12.1-py3-none-any.whl (190 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 190.3/190.3 kB 15.9 MB/s eta 0:00:00\n",
            "Collecting quantulum3\n",
            "  Downloading quantulum3-0.8.1-py3-none-any.whl (10.7 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 10.7/10.7 MB 84.6 MB/s eta 0:00:00\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (4.64.1)\n",
            "Requirement already satisfied: scikit-learn>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (1.0.2)\n",
            "Requirement already satisfied: pydantic in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (1.10.4)\n",
            "Collecting rank-bm25\n",
            "  Downloading rank_bm25-0.2.2-py3-none-any.whl (8.6 kB)\n",
            "Requirement already satisfied: jsonschema in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (4.3.3)\n",
            "Collecting langdetect\n",
            "  Downloading langdetect-1.0.9.tar.gz (981 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 981.5/981.5 kB 54.2 MB/s eta 0:00:00\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Collecting tika\n",
            "  Downloading tika-2.6.0.tar.gz (27 kB)\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Collecting rapidfuzz<2.8.0,>=2.0.15\n",
            "  Downloading rapidfuzz-2.7.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.1/2.1 MB 53.0 MB/s eta 0:00:00\n",
            "Collecting mlflow\n",
            "  Downloading mlflow-2.1.1-py3-none-any.whl (16.7 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.7/16.7 MB 37.4 MB/s eta 0:00:00\n",
            "Requirement already satisfied: nltk in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (3.7)\n",
            "Collecting tiktoken>=0.1.2\n",
            "  Downloading tiktoken-0.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.6 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.6/1.6 MB 47.4 MB/s eta 0:00:00\n",
            "Collecting transformers[torch]==4.25.1\n",
            "  Downloading transformers-4.25.1-py3-none-any.whl (5.8 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5.8/5.8 MB 66.1 MB/s eta 0:00:00\n",
            "Collecting python-docx\n",
            "  Downloading python-docx-0.8.11.tar.gz (5.6 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5.6/5.6 MB 62.4 MB/s eta 0:00:00\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (1.3.5)\n",
            "Requirement already satisfied: pillow<=9.0.0 in /usr/local/lib/python3.8/dist-packages (from farm-haystack[colab]) (7.1.2)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from transformers[torch]==4.25.1->farm-haystack[colab]) (23.0)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.8/dist-packages (from transformers[torch]==4.25.1->farm-haystack[colab]) (1.21.6)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.8/dist-packages (from transformers[torch]==4.25.1->farm-haystack[colab]) (3.9.0)\n",
            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.8/dist-packages (from transformers[torch]==4.25.1->farm-haystack[colab]) (2022.6.2)\n",
            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.8/dist-packages (from transformers[torch]==4.25.1->farm-haystack[colab]) (6.0)\n",
            "Collecting tokenizers!=0.11.3,<0.14,>=0.11.1\n",
            "  Downloading tokenizers-0.13.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (7.6 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 7.6/7.6 MB 67.1 MB/s eta 0:00:00\n",
            "Requirement already satisfied: torch!=1.12.0,>=1.7 in /usr/local/lib/python3.8/dist-packages (from transformers[torch]==4.25.1->farm-haystack[colab]) (1.13.1+cu116)\n",
            "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.8/dist-packages (from azure-ai-formrecognizer>=3.2.0b2->farm-haystack[colab]) (4.5.0)\n",
            "Collecting msrest>=0.6.21\n",
            "  Downloading msrest-0.7.1-py3-none-any.whl (85 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 85.4/85.4 kB 8.6 MB/s eta 0:00:00\n",
            "Collecting azure-common~=1.1\n",
            "  Downloading azure_common-1.1.28-py2.py3-none-any.whl (14 kB)\n",
            "Collecting azure-core<2.0.0,>=1.23.0\n",
            "  Downloading azure_core-1.26.3-py3-none-any.whl (174 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 174.5/174.5 kB 16.9 MB/s eta 0:00:00\n",
            "Requirement already satisfied: urllib3<2,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from elasticsearch<8,>=7.7->farm-haystack[colab]) (1.24.3)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.8/dist-packages (from elasticsearch<8,>=7.7->farm-haystack[colab]) (2022.12.7)\n",
            "Collecting jarowinkler<2.0.0,>=1.2.0\n",
            "  Downloading jarowinkler-1.2.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 114.1/114.1 kB 10.4 MB/s eta 0:00:00\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.8/dist-packages (from scikit-learn>=1.0.0->farm-haystack[colab]) (1.2.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from scikit-learn>=1.0.0->farm-haystack[colab]) (3.1.0)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.8/dist-packages (from sentence-transformers>=2.2.0->farm-haystack[colab]) (0.14.1+cu116)\n",
            "Collecting sentencepiece\n",
            "  Downloading sentencepiece-0.1.97-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.3/1.3 MB 53.8 MB/s eta 0:00:00\n",
            "Collecting blobfile>=2\n",
            "  Downloading blobfile-2.0.1-py3-none-any.whl (73 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 73.5/73.5 kB 5.0 MB/s eta 0:00:00\n",
            "Collecting requests\n",
            "  Downloading requests-2.28.2-py3-none-any.whl (62 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.8/62.8 kB 6.5 MB/s eta 0:00:00\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests->farm-haystack[colab]) (2.10)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.8/dist-packages (from requests->farm-haystack[colab]) (3.0.1)\n",
            "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.8/dist-packages (from jsonschema->farm-haystack[colab]) (22.2.0)\n",
            "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.8/dist-packages (from jsonschema->farm-haystack[colab]) (0.19.3)\n",
            "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.8/dist-packages (from jsonschema->farm-haystack[colab]) (5.10.2)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.8/dist-packages (from langdetect->farm-haystack[colab]) (1.15.0)\n",
            "Requirement already satisfied: pytz<2023 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (2022.7.1)\n",
            "Collecting shap<1,>=0.40\n",
            "  Downloading shap-0.41.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (575 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 575.9/575.9 kB 28.8 MB/s eta 0:00:00\n",
            "Requirement already satisfied: sqlparse<1,>=0.4.0 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (0.4.3)\n",
            "Requirement already satisfied: sqlalchemy<2,>=1.4.0 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (1.4.46)\n",
            "Requirement already satisfied: Jinja2<4,>=2.11 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (2.11.3)\n",
            "Collecting gunicorn<21\n",
            "  Downloading gunicorn-20.1.0-py3-none-any.whl (79 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 79.5/79.5 kB 8.4 MB/s eta 0:00:00\n",
            "Requirement already satisfied: cloudpickle<3 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (2.2.1)\n",
            "Requirement already satisfied: matplotlib<4 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (3.2.2)\n",
            "Requirement already satisfied: click<9,>=7.0 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (7.1.2)\n",
            "Collecting gitpython<4,>=2.1.0\n",
            "  Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 184.3/184.3 kB 15.8 MB/s eta 0:00:00\n",
            "Collecting querystring-parser<2\n",
            "  Downloading querystring_parser-1.2.4-py2.py3-none-any.whl (7.9 kB)\n",
            "Requirement already satisfied: Flask<3 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (1.1.4)\n",
            "Requirement already satisfied: entrypoints<1 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (0.4)\n",
            "Collecting alembic<2\n",
            "  Downloading alembic-1.9.4-py3-none-any.whl (210 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 210.5/210.5 kB 18.8 MB/s eta 0:00:00\n",
            "Requirement already satisfied: markdown<4,>=3.3 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (3.4.1)\n",
            "Collecting docker<7,>=4.0.0\n",
            "  Downloading docker-6.0.1-py3-none-any.whl (147 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 147.5/147.5 kB 14.5 MB/s eta 0:00:00\n",
            "Collecting databricks-cli<1,>=0.8.7\n",
            "  Downloading databricks-cli-0.17.4.tar.gz (82 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 82.3/82.3 kB 9.0 MB/s eta 0:00:00\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Requirement already satisfied: pyarrow<11,>=4.0.0 in /usr/local/lib/python3.8/dist-packages (from mlflow->farm-haystack[colab]) (9.0.0)\n",
            "Collecting packaging>=20.0\n",
            "  Downloading packaging-22.0-py3-none-any.whl (42 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 42.6/42.6 kB 3.4 MB/s eta 0:00:00\n",
            "Collecting importlib-metadata!=4.7.0,<6,>=3.7.0\n",
            "  Downloading importlib_metadata-5.2.0-py3-none-any.whl (21 kB)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.8/dist-packages (from pandas->farm-haystack[colab]) (2.8.2)\n",
            "Collecting backoff>=1.10.0\n",
            "  Downloading backoff-2.2.1-py3-none-any.whl (15 kB)\n",
            "Collecting monotonic>=1.5\n",
            "  Downloading monotonic-1.6-py2.py3-none-any.whl (8.2 kB)\n",
            "Requirement already satisfied: lxml>=2.3.2 in /usr/local/lib/python3.8/dist-packages (from python-docx->farm-haystack[colab]) (4.9.2)\n",
            "Collecting num2words\n",
            "  Downloading num2words-0.5.12-py3-none-any.whl (125 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 125.2/125.2 kB 12.1 MB/s eta 0:00:00\n",
            "Requirement already satisfied: inflect in /usr/local/lib/python3.8/dist-packages (from quantulum3->farm-haystack[colab]) (2.1.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.8/dist-packages (from tika->farm-haystack[colab]) (57.4.0)\n",
            "Collecting Mako\n",
            "  Downloading Mako-1.2.4-py3-none-any.whl (78 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 78.7/78.7 kB 7.2 MB/s eta 0:00:00\n",
            "Collecting urllib3<2,>=1.21.1\n",
            "  Downloading urllib3-1.26.14-py2.py3-none-any.whl (140 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 140.6/140.6 kB 13.6 MB/s eta 0:00:00\n",
            "Collecting pycryptodomex~=3.8\n",
            "  Downloading pycryptodomex-3.17-cp35-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.1/2.1 MB 44.0 MB/s eta 0:00:00\n",
            "Collecting pyjwt>=1.7.0\n",
            "  Downloading PyJWT-2.6.0-py3-none-any.whl (20 kB)\n",
            "Requirement already satisfied: oauthlib>=3.1.0 in /usr/local/lib/python3.8/dist-packages (from databricks-cli<1,>=0.8.7->mlflow->farm-haystack[colab]) (3.2.2)\n",
            "Requirement already satisfied: tabulate>=0.7.7 in /usr/local/lib/python3.8/dist-packages (from databricks-cli<1,>=0.8.7->mlflow->farm-haystack[colab]) (0.8.10)\n",
            "Collecting websocket-client>=0.32.0\n",
            "  Downloading websocket_client-1.5.1-py3-none-any.whl (55 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 55.9/55.9 kB 6.6 MB/s eta 0:00:00\n",
            "Requirement already satisfied: Werkzeug<2.0,>=0.15 in /usr/local/lib/python3.8/dist-packages (from Flask<3->mlflow->farm-haystack[colab]) (1.0.1)\n",
            "Requirement already satisfied: itsdangerous<2.0,>=0.24 in /usr/local/lib/python3.8/dist-packages (from Flask<3->mlflow->farm-haystack[colab]) (1.1.0)\n",
            "Collecting gitdb<5,>=4.0.1\n",
            "  Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.7/62.7 kB 6.5 MB/s eta 0:00:00\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.8/dist-packages (from importlib-metadata!=4.7.0,<6,>=3.7.0->mlflow->farm-haystack[colab]) (3.13.0)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.8/dist-packages (from Jinja2<4,>=2.11->mlflow->farm-haystack[colab]) (2.0.1)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4->mlflow->farm-haystack[colab]) (1.4.4)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4->mlflow->farm-haystack[colab]) (0.11.0)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4->mlflow->farm-haystack[colab]) (3.0.9)\n",
            "Requirement already satisfied: requests-oauthlib>=0.5.0 in /usr/local/lib/python3.8/dist-packages (from msrest>=0.6.21->azure-ai-formrecognizer>=3.2.0b2->farm-haystack[colab]) (1.3.1)\n",
            "Collecting isodate>=0.6.0\n",
            "  Downloading isodate-0.6.1-py2.py3-none-any.whl (41 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 41.7/41.7 kB 3.8 MB/s eta 0:00:00\n",
            "Requirement already satisfied: numba in /usr/local/lib/python3.8/dist-packages (from shap<1,>=0.40->mlflow->farm-haystack[colab]) (0.56.4)\n",
            "Collecting slicer==0.0.7\n",
            "  Downloading slicer-0.0.7-py3-none-any.whl (14 kB)\n",
            "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.8/dist-packages (from sqlalchemy<2,>=1.4.0->mlflow->farm-haystack[colab]) (2.0.2)\n",
            "Collecting docopt>=0.6.2\n",
            "  Downloading docopt-0.6.2.tar.gz (25 kB)\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Collecting smmap<6,>=3.0.1\n",
            "  Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n",
            "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /usr/local/lib/python3.8/dist-packages (from numba->shap<1,>=0.40->mlflow->farm-haystack[colab]) (0.39.1)\n",
            "Building wheels for collected packages: sentence-transformers, farm-haystack, langdetect, python-docx, seqeval, tika, databricks-cli, docopt\n",
            "  Building wheel for sentence-transformers (setup.py): started\n",
            "  Building wheel for sentence-transformers (setup.py): finished with status 'done'\n",
            "  Created wheel for sentence-transformers: filename=sentence_transformers-2.2.2-py3-none-any.whl size=125938 sha256=d7517da043ff1f28474a1b3e221f0bbadc355bce8595eae62088956f20ebab64\n",
            "  Stored in directory: /root/.cache/pip/wheels/5e/6f/8c/d88aec621f3f542d26fac0342bef5e693335d125f4e54aeffe\n",
            "  Building wheel for farm-haystack (pyproject.toml): started\n",
            "  Building wheel for farm-haystack (pyproject.toml): finished with status 'done'\n",
            "  Created wheel for farm-haystack: filename=farm_haystack-1.15.0rc0-py3-none-any.whl size=640064 sha256=c1c1006632e17f434125df3dfdadc358f251edad8cf243e40b9ffe902d8b749b\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-7qraeds_/wheels/97/0d/ae/77cde17929fbf66c8320f19b30789acfe52e2312bb1d125be1\n",
            "  Building wheel for langdetect (setup.py): started\n",
            "  Building wheel for langdetect (setup.py): finished with status 'done'\n",
            "  Created wheel for langdetect: filename=langdetect-1.0.9-py3-none-any.whl size=993242 sha256=01560e049b949ef1e5fde636db679d634c92f0afdc864dd3e2a0a39478f4fc42\n",
            "  Stored in directory: /root/.cache/pip/wheels/13/c7/b0/79f66658626032e78fc1a83103690ef6797d551cb22e56e734\n",
            "  Building wheel for python-docx (setup.py): started\n",
            "  Building wheel for python-docx (setup.py): finished with status 'done'\n",
            "  Created wheel for python-docx: filename=python_docx-0.8.11-py3-none-any.whl size=184505 sha256=a370c0c94d26098a8e59c1c959b8278078fc126b530f34c58f77a2d229579ef2\n",
            "  Stored in directory: /root/.cache/pip/wheels/32/b8/b2/c4c2b95765e615fe139b0b17b5ea7c0e1b6519b0a9ec8fb34d\n",
            "  Building wheel for seqeval (setup.py): started\n",
            "  Building wheel for seqeval (setup.py): finished with status 'done'\n",
            "  Created wheel for seqeval: filename=seqeval-1.2.2-py3-none-any.whl size=16179 sha256=15b04dc63382d6488c22cbbb27f8db99ec2f51bcfe9363d3b8c3d797c4faa949\n",
            "  Stored in directory: /root/.cache/pip/wheels/ad/5c/ba/05fa33fa5855777b7d686e843ec07452f22a66a138e290e732\n",
            "  Building wheel for tika (setup.py): started\n",
            "  Building wheel for tika (setup.py): finished with status 'done'\n",
            "  Created wheel for tika: filename=tika-2.6.0-py3-none-any.whl size=32642 sha256=8ec344d950dc3e6b1324bc08f090014a4fc7f622f80836cf645a28f8d03ab301\n",
            "  Stored in directory: /root/.cache/pip/wheels/02/bd/74/313abcb9271e041e30734880e6813385150dd93627e9659de5\n",
            "  Building wheel for databricks-cli (setup.py): started\n",
            "  Building wheel for databricks-cli (setup.py): finished with status 'done'\n",
            "  Created wheel for databricks-cli: filename=databricks_cli-0.17.4-py3-none-any.whl size=142894 sha256=bf76abec1581776b6a7b05fbb5a2c6e9ef134eeef0113e4b0b0d7de3df7d13b5\n",
            "  Stored in directory: /root/.cache/pip/wheels/48/7c/6e/4bf2c1748c7ecf994ca951591de81674ed6bf633e1e337d873\n",
            "  Building wheel for docopt (setup.py): started\n",
            "  Building wheel for docopt (setup.py): finished with status 'done'\n",
            "  Created wheel for docopt: filename=docopt-0.6.2-py2.py3-none-any.whl size=13723 sha256=0c4f110f19944405a8af9319829fb48828ff06dae31a34c1b139fd1f7cc5d8d7\n",
            "  Stored in directory: /root/.cache/pip/wheels/56/ea/58/ead137b087d9e326852a851351d1debf4ada529b6ac0ec4e8c\n",
            "Successfully built sentence-transformers farm-haystack langdetect python-docx seqeval tika databricks-cli docopt\n",
            "Installing collected packages: tokenizers, sentencepiece, monotonic, mmh3, docopt, azure-common, websocket-client, urllib3, smmap, slicer, rank-bm25, querystring-parser, python-docx, pyjwt, pycryptodomex, packaging, num2words, Mako, langdetect, jarowinkler, isodate, importlib-metadata, gunicorn, backoff, requests, rapidfuzz, quantulum3, gitdb, elasticsearch, blobfile, alembic, tiktoken, tika, shap, seqeval, posthog, huggingface-hub, gitpython, docker, databricks-cli, azure-core, transformers, msrest, mlflow, sentence-transformers, azure-ai-formrecognizer, farm-haystack\n",
            "  Attempting uninstall: urllib3\n",
            "    Found existing installation: urllib3 1.24.3\n",
            "    Uninstalling urllib3-1.24.3:\n",
            "      Successfully uninstalled urllib3-1.24.3\n",
            "  Attempting uninstall: packaging\n",
            "    Found existing installation: packaging 23.0\n",
            "    Uninstalling packaging-23.0:\n",
            "      Successfully uninstalled packaging-23.0\n",
            "  Attempting uninstall: importlib-metadata\n",
            "    Found existing installation: importlib-metadata 6.0.0\n",
            "    Uninstalling importlib-metadata-6.0.0:\n",
            "      Successfully uninstalled importlib-metadata-6.0.0\n",
            "  Attempting uninstall: requests\n",
            "    Found existing installation: requests 2.25.1\n",
            "    Uninstalling requests-2.25.1:\n",
            "      Successfully uninstalled requests-2.25.1\n",
            "Successfully installed Mako-1.2.4 alembic-1.9.4 azure-ai-formrecognizer-3.2.0 azure-common-1.1.28 azure-core-1.26.3 backoff-2.2.1 blobfile-2.0.1 databricks-cli-0.17.4 docker-6.0.1 docopt-0.6.2 elasticsearch-7.17.9 farm-haystack-1.15.0rc0 gitdb-4.0.10 gitpython-3.1.31 gunicorn-20.1.0 huggingface-hub-0.12.1 importlib-metadata-5.2.0 isodate-0.6.1 jarowinkler-1.2.3 langdetect-1.0.9 mlflow-2.1.1 mmh3-3.0.0 monotonic-1.6 msrest-0.7.1 num2words-0.5.12 packaging-22.0 posthog-2.3.1 pycryptodomex-3.17 pyjwt-2.6.0 python-docx-0.8.11 quantulum3-0.8.1 querystring-parser-1.2.4 rank-bm25-0.2.2 rapidfuzz-2.7.0 requests-2.28.2 sentence-transformers-2.2.2 sentencepiece-0.1.97 seqeval-1.2.2 shap-0.41.0 slicer-0.0.7 smmap-5.0.0 tika-2.6.0 tiktoken-0.2.0 tokenizers-0.13.2 transformers-4.25.1 urllib3-1.26.14 websocket-client-1.5.1\n",
            "Reading package lists...\n",
            "Building dependency tree...\n",
            "Reading state information...\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-510\n",
            "Use 'apt autoremove' to remove it.\n",
            "The following additional packages will be installed:\n",
            "  libgail-common libgail18 libgtk2.0-0 libgtk2.0-bin libgtk2.0-common\n",
            "  libgvc6-plugins-gtk libxdot4\n",
            "Suggested packages:\n",
            "  gvfs\n",
            "The following NEW packages will be installed:\n",
            "  libgail-common libgail18 libgraphviz-dev libgtk2.0-0 libgtk2.0-bin\n",
            "  libgtk2.0-common libgvc6-plugins-gtk libxdot4\n",
            "0 upgraded, 8 newly installed, 0 to remove and 21 not upgraded.\n",
            "Need to get 2,148 kB of archives.\n",
            "After this operation, 7,427 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu focal/main amd64 libgtk2.0-common all 2.24.32-4ubuntu4 [126 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu focal/main amd64 libgtk2.0-0 amd64 2.24.32-4ubuntu4 [1,791 kB]\n",
            "Get:3 http://archive.ubuntu.com/ubuntu focal/main amd64 libgail18 amd64 2.24.32-4ubuntu4 [14.7 kB]\n",
            "Get:4 http://archive.ubuntu.com/ubuntu focal/main amd64 libgail-common amd64 2.24.32-4ubuntu4 [116 kB]\n",
            "Get:5 http://archive.ubuntu.com/ubuntu focal/universe amd64 libxdot4 amd64 2.42.2-3build2 [15.4 kB]\n",
            "Get:6 http://archive.ubuntu.com/ubuntu focal/universe amd64 libgvc6-plugins-gtk amd64 2.42.2-3build2 [20.6 kB]\n",
            "Get:7 http://archive.ubuntu.com/ubuntu focal/universe amd64 libgraphviz-dev amd64 2.42.2-3build2 [57.2 kB]\n",
            "Get:8 http://archive.ubuntu.com/ubuntu focal/main amd64 libgtk2.0-bin amd64 2.24.32-4ubuntu4 [7,728 B]\n",
            "Fetched 2,148 kB in 1s (2,090 kB/s)\n",
            "Selecting previously unselected package libgtk2.0-common.\r\n",
            "(Reading database ... \r(Reading database ... 5%\r(Reading database ... 10%\r(Reading database ... 15%\r(Reading database ... 20%\r(Reading database ... 25%\r(Reading database ... 30%\r(Reading database ... 35%\r(Reading database ... 40%\r(Reading database ... 45%\r(Reading database ... 50%\r(Reading database ... 55%\r(Reading database ... 60%\r(Reading database ... 65%\r(Reading database ... 70%\r(Reading database ... 75%\r(Reading database ... 80%\r(Reading database ... 85%\r(Reading database ... 90%\r(Reading database ... 95%\r(Reading database ... 100%\r(Reading database ... 128126 files and directories currently installed.)\r\n",
            "Preparing to unpack .../0-libgtk2.0-common_2.24.32-4ubuntu4_all.deb ...\r\n",
            "Unpacking libgtk2.0-common (2.24.32-4ubuntu4) ...\r\n",
            "Selecting previously unselected package libgtk2.0-0:amd64.\r\n",
            "Preparing to unpack .../1-libgtk2.0-0_2.24.32-4ubuntu4_amd64.deb ...\r\n",
            "Unpacking libgtk2.0-0:amd64 (2.24.32-4ubuntu4) ...\r\n",
            "Selecting previously unselected package libgail18:amd64.\r\n",
            "Preparing to unpack .../2-libgail18_2.24.32-4ubuntu4_amd64.deb ...\r\n",
            "Unpacking libgail18:amd64 (2.24.32-4ubuntu4) ...\r\n",
            "Selecting previously unselected package libgail-common:amd64.\r\n",
            "Preparing to unpack .../3-libgail-common_2.24.32-4ubuntu4_amd64.deb ...\r\n",
            "Unpacking libgail-common:amd64 (2.24.32-4ubuntu4) ...\r\n",
            "Selecting previously unselected package libxdot4:amd64.\r\n",
            "Preparing to unpack .../4-libxdot4_2.42.2-3build2_amd64.deb ...\r\n",
            "Unpacking libxdot4:amd64 (2.42.2-3build2) ...\r\n",
            "Selecting previously unselected package libgvc6-plugins-gtk.\r\n",
            "Preparing to unpack .../5-libgvc6-plugins-gtk_2.42.2-3build2_amd64.deb ...\r\n",
            "Unpacking libgvc6-plugins-gtk (2.42.2-3build2) ...\r\n",
            "Selecting previously unselected package libgraphviz-dev:amd64.\r\n",
            "Preparing to unpack .../6-libgraphviz-dev_2.42.2-3build2_amd64.deb ...\r\n",
            "Unpacking libgraphviz-dev:amd64 (2.42.2-3build2) ...\r\n",
            "Selecting previously unselected package libgtk2.0-bin.\r\n",
            "Preparing to unpack .../7-libgtk2.0-bin_2.24.32-4ubuntu4_amd64.deb ...\r\n",
            "Unpacking libgtk2.0-bin (2.24.32-4ubuntu4) ...\r\n",
            "Setting up libxdot4:amd64 (2.42.2-3build2) ...\r\n",
            "Setting up libgtk2.0-common (2.24.32-4ubuntu4) ...\r\n",
            "Setting up libgtk2.0-0:amd64 (2.24.32-4ubuntu4) ...\r\n",
            "Setting up libgvc6-plugins-gtk (2.42.2-3build2) ...\r\n",
            "Setting up libgail18:amd64 (2.24.32-4ubuntu4) ...\r\n",
            "Setting up libgtk2.0-bin (2.24.32-4ubuntu4) ...\r\n",
            "Setting up libgail-common:amd64 (2.24.32-4ubuntu4) ...\r\n",
            "Setting up libgraphviz-dev:amd64 (2.42.2-3build2) ...\r\n",
            "Processing triggers for man-db (2.9.1-1) ...\r\n",
            "Processing triggers for libc-bin (2.31-0ubuntu9.9) ...\r\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pygraphviz\n",
            "  Downloading pygraphviz-1.10.zip (120 kB)\n",
            "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 120.6/120.6 kB 3.8 MB/s eta 0:00:00\n",
            "  Preparing metadata (setup.py): started\n",
            "  Preparing metadata (setup.py): finished with status 'done'\n",
            "Building wheels for collected packages: pygraphviz\n",
            "  Building wheel for pygraphviz (setup.py): started\n",
            "  Building wheel for pygraphviz (setup.py): finished with status 'done'\n",
            "  Created wheel for pygraphviz: filename=pygraphviz-1.10-cp38-cp38-linux_x86_64.whl size=184581 sha256=32f4064105068029d97e35e573fd95758957fb5118645ee600f25a9be238cb49\n",
            "  Stored in directory: /root/.cache/pip/wheels/ac/bd/46/118c2a336c6fd8d47026854302f8fad63bb7e431e52008ea06\n",
            "Successfully built pygraphviz\n",
            "Installing collected packages: pygraphviz\n",
            "Successfully installed pygraphviz-1.10\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "DEPRECATION: git+https://github.com/deepset-ai/haystack.git#egg=farm-haystack[colab] contains an egg fragment with a non-PEP 508 name pip 25.0 will enforce this behaviour change. A possible replacement is to use the req @ url syntax, and remove the egg fragment. Discussion can be found at https://github.com/pypa/pip/issues/11617\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/deepset-ai/haystack.git /tmp/pip-install-dh_lonl6/farm-haystack_9697fe58d69442519efe1989bd39224c\n",
            "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\n",
            "\n",
            "WARNING: apt does not have a stable CLI interface. Use with caution in scripts.\n",
            "\n",
            "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(format=\"%(levelname)s - %(name)s -  %(message)s\", level=logging.WARNING)\n",
        "logging.getLogger(\"haystack\").setLevel(logging.INFO)"
      ],
      "metadata": {
        "id": "TNhChd49DSDx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Here we create the keyword vs question/statement query classifier\n",
        "from haystack.nodes import SklearnQueryClassifier\n",
        "keyword_classifier = SklearnQueryClassifier()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MrQlEL8sDV_A",
        "outputId": "85111307-4973-4e83-af2f-2d38cd5da8b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:haystack.telemetry:Haystack sends anonymous usage data to understand the actual usage and steer dev efforts towards features that are most meaningful to users. You can opt-out at anytime by calling disable_telemetry() or by manually setting the environment variable  HAYSTACK_TELEMETRY_ENABLED as described for different operating systems on the documentation page. More information at https://docs.haystack.deepset.ai/docs/telemetry\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator DummyClassifier from version 1.2.0 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator DecisionTreeRegressor from version 1.2.0 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator GradientBoostingClassifier from version 1.2.0 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator TfidfTransformer from version 1.2.0 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator TfidfVectorizer from version 1.2.0 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Here we create the question vs statement query classifier\n",
        "model_url = (\n",
        "    \"https://ext-models-haystack.s3.eu-central-1.amazonaws.com/gradboost_query_classifier_statements/model.pickle\"\n",
        ")\n",
        "vectorizer_url = (\n",
        "    \"https://ext-models-haystack.s3.eu-central-1.amazonaws.com/gradboost_query_classifier_statements/vectorizer.pickle\"\n",
        ")\n",
        "\n",
        "question_classifier = SklearnQueryClassifier(model_name_or_path=model_url, vectorizer_name_or_path=vectorizer_url)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wqhs0iFPxkt2",
        "outputId": "b4288176-12e5-4198-d0db-6676f3e57e74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator DummyClassifier from version 0.24.1 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator DecisionTreeRegressor from version 0.24.1 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator GradientBoostingClassifier from version 0.24.1 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator TfidfTransformer from version 0.24.1 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/base.py:329: UserWarning: Trying to unpickle estimator TfidfVectorizer from version 0.24.1 when using version 1.0.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def add_query_class(query_type, cq_label, ca_label):\n",
        "\n",
        "  query_class[query_type]['count'] += 1\n",
        "  if not math.isnan(cq_label):\n",
        "    if cq_label == 0:\n",
        "      query_class[query_type]['cqBad'] += 1\n",
        "    elif cq_label == 1:\n",
        "      query_class[query_type]['cqFair'] += 1\n",
        "    elif cq_label == 2:\n",
        "      query_class[query_type]['cqGood'] += 1\n",
        "  #\n",
        "  if not math.isnan(ca_label):\n",
        "      if ca_label == 0:\n",
        "        query_class[query_type]['caBad'] += 1\n",
        "      elif ca_label == 1:\n",
        "        query_class[query_type]['caFair'] += 1\n",
        "      elif ca_label == 2:\n",
        "        query_class[query_type]['caGood'] += 1"
      ],
      "metadata": {
        "id": "KbQc59ENzxrR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "query_class = dict()\n",
        "query_class['keyword'] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "query_class['statement'] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "query_class['question'] = {'count': 0, 'cqBad': 0, 'cqFair': 0, 'cqGood': 0, 'caBad': 0, 'caFair': 0, 'caGood': 0}\n",
        "\n",
        "for eachline in dataset_df.itertuples(index=True):\n",
        "    result = keyword_classifier.run(query=eachline.query)\n",
        "    if result[1] == \"output_1\":\n",
        "      # \"Question/Statement\"\n",
        "      result_QC = question_classifier.run(query=eachline.query)\n",
        "      if result_QC[1] == \"output_1\":\n",
        "        add_query_class('question', eachline.question_label, eachline.options_overall_label)\n",
        "      else:\n",
        "        add_query_class('statement', eachline.question_label, eachline.options_overall_label)\n",
        "    else:\n",
        "      add_query_class('keyword', eachline.question_label, eachline.options_overall_label)"
      ],
      "metadata": {
        "id": "Md6NbWePDaEb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "_normalizer(query_class)\n",
        "copied_query_class = count_remover(query_class)\n",
        "sorted_query_class = collections.OrderedDict(sorted(copied_query_class.items()))"
      ],
      "metadata": {
        "id": "rDUQ0ovzCtxR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sorted_query_class_df = pd.DataFrame(sorted_query_class)\n",
        "sorted_query_class_df.loc[['cqBad', 'cqFair', 'cqGood']].plot(kind='bar', width=0.7)\n",
        "plt.legend(prop={'size': 16})\n",
        "locs, labels = plt.xticks()\n",
        "plt.xticks(locs, labels=['Bad', 'Fair', 'Good'], fontsize=16, rotation=0)\n",
        "plt.savefig(f'{DATASET}_query_class_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273
        },
        "id": "XQabX015Cx7a",
        "outputId": "2e025ef3-b4ad-448c-bcc2-7364318cb15e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# pd.DataFrame(sorted_query_class).plot(kind='bar', width=0.7)\n",
        "# # Put a legend to the right of the current axis\n",
        "# # plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "# plt.savefig(f'{DATASET}_query_class_to_labels.pdf', bbox_inches='tight', pad_inches=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "TfjskVSa1E-n",
        "outputId": "0a002f9c-381e-4d35-adc7-3912ffe4ce65"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### TextBlob Sentiment: Calculating Polarity (Sentiment) and Subjectivity\n",
        "https://planspace.org/20150607-textblob_sentiment/"
      ],
      "metadata": {
        "id": "EBgEECuDxfgA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "queries_polarity = []\n",
        "cq_polarity = []\n",
        "\n",
        "queries_subjectivity = []\n",
        "cq_subjectivity = []\n",
        "\n",
        "nonnan_dataset_df = dataset_df[~dataset_df['question_label'].isna()]\n",
        "\n",
        "for eachline in nonnan_dataset_df.itertuples(index=True):\n",
        "  queries_polarity.append(TextBlob(eachline.query).sentiment[0])\n",
        "  cq_polarity.append(TextBlob(eachline.question).sentiment[0])\n",
        "  queries_subjectivity.append(TextBlob(eachline.query).sentiment[1])\n",
        "  cq_subjectivity.append(TextBlob(eachline.question).sentiment[1])"
      ],
      "metadata": {
        "id": "nS4NQMIbxhEg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# dataset_df.question_label[~dataset_df.question_label.isna()]\n",
        "nonnan_dataset_df.question_label"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ukkHA5O43hYK",
        "outputId": "be7ec39d-9619-4f0d-dd54-ed9da074df31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "720     1.0\n",
              "772     2.0\n",
              "775     2.0\n",
              "780     2.0\n",
              "781     2.0\n",
              "       ... \n",
              "2680    2.0\n",
              "2681    2.0\n",
              "2682    2.0\n",
              "2683    2.0\n",
              "2685    1.0\n",
              "Name: question_label, Length: 575, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# subjectivity\n",
        "res = stats.pearsonr(queries_subjectivity, cq_subjectivity)\n",
        "print(res)\n",
        "# res = stats.pearsonr(queries_subjectivity, dataset_df.question_label[~dataset_df.question_label.isna()])\n",
        "res = stats.pearsonr(queries_subjectivity, nonnan_dataset_df.question_label)\n",
        "print(res)\n",
        "res = stats.pearsonr(nonnan_dataset_df.question_label, cq_subjectivity)\n",
        "print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qQbg7142xmgz",
        "outputId": "ce986dbc-8853-4c5e-8c2f-a15df7a27155"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PearsonRResult(statistic=0.07007045659331715, pvalue=0.09322263147667989)\n",
            "PearsonRResult(statistic=-0.012323306425308257, pvalue=0.7680926827991115)\n",
            "PearsonRResult(statistic=0.3741760207626681, pvalue=1.5058036697072992e-20)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "subjectivity_corr = stats.pearsonr(nonnan_dataset_df.question_label, cq_subjectivity)[0]\n",
        "subjectivity_corr"
      ],
      "metadata": {
        "id": "iZ_OI4eU5JCV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f381877b-4bcb-4e85-c423-ae1267230dff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.3741760207626681"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ploarity\n",
        "res = stats.pearsonr(queries_polarity, cq_subjectivity)\n",
        "print(res)\n",
        "res = stats.pearsonr(queries_polarity, nonnan_dataset_df.question_label)\n",
        "print(res)\n",
        "res = stats.pearsonr(nonnan_dataset_df.question_label, cq_polarity)\n",
        "print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jn_csE0V1jto",
        "outputId": "74af6791-bcb9-4fdd-f285-2ede1a87989c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PearsonRResult(statistic=0.03850251528686946, pvalue=0.35674219545923835)\n",
            "PearsonRResult(statistic=-0.048278242652514555, pvalue=0.24775215393303582)\n",
            "PearsonRResult(statistic=-0.28115485187341616, pvalue=6.595164405106558e-12)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "polarity_corr = stats.pearsonr(nonnan_dataset_df.question_label, cq_polarity)[0]\n",
        "polarity_corr"
      ],
      "metadata": {
        "id": "TN4mFnAY5R8Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "edc543c2-c406-403f-c499-874fc0807b6b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-0.28115485187341616"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "sns.set_theme()\n",
        "import numpy as np\n",
        "\n",
        "metrics = ['rouge-precision', 'rouge-recall', 'polarity', 'subjectivity', 'specifity']\n",
        "values_1 = [rouge_precision_corr, polarity_corr, rouge_recall_corr, subjectivity_corr, -0.15]\n",
        "\n",
        "X_axis = np.arange(len(metrics))\n",
        "  \n",
        "plt.bar(X_axis, values_1, linestyle='--', width=0.1)\n",
        "\n",
        "plt.xticks(fontsize=18, rotation=20)\n",
        "plt.xticks(X_axis, metrics)\n",
        "\n",
        "plt.savefig('corr_featuers.pdf', bbox_inches='tight')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 325
        },
        "id": "l2Bt6TqX19q7",
        "outputId": "223ecb6d-773c-4eb4-e62d-914812a61038"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m6rJFzCJ5nnk",
        "outputId": "e9882f7d-3438-42ad-8a12-41bee4704054"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-0.0024575611466291017"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Feature Extraction"
      ],
      "metadata": {
        "id": "9A-LqOchXBS4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# clarification question template types via one-hot embeddings (e.g. [0,1,0,0,0]), question length, rouge_precisions, question subjectivity (possibly the sentiment as well)\n"
      ],
      "metadata": {
        "id": "aZ7WDcjsDIoy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "feature_data_df = pd.DataFrame(columns=['query', 'cq_vector', 'cq_length', 'rouge_precision', 'cq_polarity', 'cq_subjectivity'])\n",
        "rouge = Rouge()\n",
        "for eachline in dataset_df.itertuples(index=True):\n",
        "  cq = eachline.question\n",
        "  cq_length = len(eachline.question.split(' '))\n",
        "  eval = rouge.get_scores(eachline.query, eachline.question)\n",
        "  rouge_precision = eval[0]['rouge-2']['p']\n",
        "  cq_subjectivity = TextBlob(eachline.question).sentiment[1]\n",
        "  cq_polarity = TextBlob(eachline.question).sentiment[0]\n",
        "\n",
        "  # T0: Select one to refine your search\n",
        "  if bool(re.match(r'Select one to refine your search', cq)):\n",
        "    cq_vector = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "  # T1: What (would you like | do you want) to know about _____?\n",
        "  elif bool(re.match(r'What (would you like|do you want) to know about [a-z]+?', cq)):\n",
        "    cq_vector = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "  # T2: (Which | What) _____ do you mean?\n",
        "  elif bool(re.match(r'(Which|What) \"\"[a-z]+\"\" do you mean?', cq)):\n",
        "    cq_vector = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "  # T3: (Which | What) _____ are you looking for?\n",
        "  elif bool(re.match(r'(Which|What) [a-zA-Z ]+ are you looking for?', cq)):\n",
        "    cq_vector = [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "  # T4: What (would you like | do you want) to do with _____?\n",
        "  elif bool(re.match(r'What (would you like|do you want) to do with [a-z]+?', cq)):\n",
        "    cq_vector = [0, 0, 0, 0, 1, 0, 0, 0, 0, 0]\n",
        "\n",
        "  # T5: Who are you shopping for?\n",
        "  elif bool(re.match(r'Who are you shopping for?', cq)):\n",
        "    cq_vector = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0]\n",
        "\n",
        "  # T6: What are you trying to do?\n",
        "  elif bool(re.match(r'What are you trying to do?', cq)):\n",
        "    cq_vector = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0]\n",
        "\n",
        "  # T7: Do you have _____ in mind?\n",
        "  elif bool(re.match(r'Do you have [a-z]+ in mind?', cq)):\n",
        "    cq_vector = [0, 0, 0, 0, 0, 0, 0, 1, 0, 0]\n",
        "\n",
        "  # T8: Refine your search by interest\n",
        "  elif bool(re.match(r'Do you have any specific product in mind?', cq)):\n",
        "    cq_vector = [0, 0, 0, 0, 0, 0, 0, 0, 1, 0]\n",
        "\n",
        "  # T9: else\n",
        "  else:\n",
        "    cq_vector = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]\n",
        "\n",
        "  feature_data_df = feature_data_df.append({'query': eachline.query, 'cq_vector': cq_vector, 'cq_length': cq_length, 'rouge_precision': rouge_precision, 'cq_polarity': cq_polarity, 'cq_subjectivity': cq_subjectivity}, ignore_index=True)"
      ],
      "metadata": {
        "id": "QckBQtPBI4sT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "feature_data_df.to_csv('feature_data.csv', index=False)"
      ],
      "metadata": {
        "id": "iIbzKtUjNS1n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dataset_meta_info = dataset_df.merge(feature_data_df)"
      ],
      "metadata": {
        "id": "QcWXABPZN1mZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# This dataset will be used for evaluation of models for prediction with new features\n",
        "dataset_meta_info.to_csv('MIMICS-Manual-MetaInfo.csv', index=False)"
      ],
      "metadata": {
        "id": "ZrwsTjtpPKy-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### User Study"
      ],
      "metadata": {
        "id": "LLj7p3ItruOm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "study_dataset_df = dataset_df[~dataset_df['question_label'].isna()]"
      ],
      "metadata": {
        "id": "MqC7zEiwtVfX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sample_study_dataset_df = study_dataset_df.sample(50)"
      ],
      "metadata": {
        "id": "rHVq9PsluDNp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "user_study_df = pd.DataFrame(columns=['Query', 'Clarification Question', 'Option 1', 'Option 2', 'Option 3', 'Option 4', 'Option 5', 'Quesction Label', 'CQ Usefulness', 'Naturalness', 'Grammar', 'Fluency', 'Question Template', 'Coverage', 'Relevance', 'Novelty', 'Efficiency'])\n",
        "\n",
        "for eachline in sample_study_dataset_df.itertuples(index=True):\n",
        "  user_study_df = user_study_df.append({'Query': eachline.query, 'Clarification Question': eachline.question, 'Option 1': eachline.option_1,\n",
        "                                        'Option 2': eachline.option_2, 'Option 3': eachline.option_3, 'Option 4': eachline.option_4,\n",
        "                                        'Option 5': eachline.option_5, 'Quesction Label': eachline.question_label,\n",
        "                                        'CQ Usefulness': 0, 'Naturalness': 0, 'Grammar': 0, 'Fluency': 0, 'Question Template': 0,\n",
        "                                        'Coverage': 0, 'Relevance': 0, 'Novelty': 0, 'Efficiency': 0}, ignore_index=True)\n",
        "\n"
      ],
      "metadata": {
        "id": "4cZybTPrPU7T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "user_study_df.to_csv(\"online_user_study.csv\", index=False, sep='\\t')"
      ],
      "metadata": {
        "id": "5auzSj2CxIKw"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}