PTAB_xgboost_github.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bahrad/PTAB/blob/master/PTAB_xgboost_github.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KxKMLWEKr-KV"
      },
      "source": [
        "#Initialization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SO6irSSWsgw0"
      },
      "outputs": [],
      "source": [
        "%tensorflow_version 2.x\n",
        "\n",
        "%xmode Context\n",
        "# Verbose\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import numpy as np\n",
        "!pip install xlrd==2.0.1\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import pickle\n",
        "import os\n",
        "import itertools\n",
        "\n",
        "from collections import Counter, defaultdict\n",
        "import random\n",
        "from pandas import DataFrame\n",
        "import datetime\n",
        "from datetime import datetime\n",
        "import dateutil\n",
        "from dateutil.parser import parse as dateparse\n",
        "from tqdm.notebook import tqdm\n",
        "import time\n",
        "\n",
        "import sklearn as sk\n",
        "from sklearn.preprocessing import MultiLabelBinarizer, QuantileTransformer, OneHotEncoder, StandardScaler, OrdinalEncoder\n",
        "from sklearn.model_selection import train_test_split, StratifiedKFold, RandomizedSearchCV\n",
        "from sklearn.model_selection import KFold, StratifiedShuffleSplit, ShuffleSplit\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "import sklearn.metrics\n",
        "from sklearn.metrics import accuracy_score,classification_report, make_scorer, balanced_accuracy_score, f1_score, coverage_error, roc_auc_score, confusion_matrix, plot_confusion_matrix\n",
        "from sklearn.cluster import KMeans\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.utils import resample, shuffle\n",
        "from sklearn.base import BaseEstimator, ClassifierMixin, TransformerMixin\n",
        "from sklearn.neighbors import NearestNeighbors\n",
        "from sklearn.manifold import TSNE\n",
        "from sklearn.utils import class_weight\n",
        "\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "import xgboost as xgb\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "from imblearn.over_sampling import SMOTE, RandomOverSampler, ADASYN, BorderlineSMOTE\n",
        "from imblearn.under_sampling import RandomUnderSampler, EditedNearestNeighbours, CondensedNearestNeighbour, AllKNN\n",
        "from imblearn.combine import SMOTEENN, SMOTETomek\n",
        "from imblearn.pipeline import make_pipeline,Pipeline\n",
        "\n",
        "from tensorflow.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "import string\n",
        "import re\n",
        "import ast\n",
        "# import unicodedata\n",
        "\n",
        "import nltk\n",
        "nltk.download('stopwords')\n",
        "from nltk.corpus import stopwords\n",
        "STOPWORDS = set(stopwords.words('english'))\n",
        "\n",
        "nltk.download('averaged_perceptron_tagger')\n",
        "nltk.download('wordnet')\n",
        "nltk.download('punkt')\n",
        "\n",
        "!pip install lime\n",
        "import lime\n",
        "from lime import lime_text\n",
        "from lime.lime_text import LimeTextExplainer\n",
        "from lime.explanation import Explanation\n",
        "\n",
        "!pip install shap\n",
        "import shap"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8KTO164A7t1G"
      },
      "outputs": [],
      "source": [
        "# COMMENT OUT FOR PUBLIC CODE\n",
        "from google.colab import drive, files\n",
        "# drive.mount('/content/drive')\n",
        "\n",
        "FILELOC = \"DATA/\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "meLd62MmSiZn"
      },
      "source": [
        "#Pre-Processing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m55MrI8lPFhv"
      },
      "outputs": [],
      "source": [
        "ptab = pd.read_csv(FILELOC + 'PTAB_Institution_Proceedings_to_20211231.tsv', sep='\\t')\n",
        "print(len(ptab))\n",
        "ptab.drop_duplicates('Proceeding', inplace=True)\n",
        "print(len(ptab))\n",
        "ptab['date'] = ptab['Case Filing Date'].apply(dateparse)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9RkTxlgRPFhy"
      },
      "outputs": [],
      "source": [
        "with open(FILELOC + 'IPR_Proceeding_PartyNames_12312022.txt', 'r', encoding=\"ISO-8859-1\") as f:\n",
        "    outfile = [line.rstrip('\\n') for line in f]\n",
        "case = []; number = []\n",
        "for k in range(0,len(outfile),2):\n",
        "    case.append(outfile[k])\n",
        "    number.append(outfile[k+1])\n",
        "casedf = pd.DataFrame.from_dict({'case':case, 'proc':number})\n",
        "casedf.drop_duplicates('proc', inplace=True)\n",
        "casedf['proc'] = casedf['proc'].apply(lambda x: x.split('(')[0].strip())\n",
        "casedf['name'] = casedf['case'].apply(lambda x: x.strip(\"\\\"\"))\n",
        "casedf[casedf.name.str.contains('Petition')].to_csv('a.csv')\n",
        "\n",
        "common_names = set(['business', 'doing', 'company', 'corporation', 'formerly', 'et', 'al'])\n",
        "\n",
        "def f(x):\n",
        "    y = x\n",
        "    if 'Petition' in x:\n",
        "        if 'Covered' in x:\n",
        "            y = x.replace(\"Petition for Covered Business Method Patent Review by\",\"\")\n",
        "        elif 'Inter' in x:\n",
        "            y = x.replace(\"Petition for Inter Partes Review by\", \"\")\n",
        "    y = y.translate(str.maketrans('', '', string.punctuation))\n",
        "    if 'v' in y:\n",
        "        y = y.replace(\"v\", \"\")\n",
        "    y = [s.strip() for s in y.strip().split(' ') if s != \"\" and s not in STOPWORDS|common_names]\n",
        "    return y\n",
        "casedf['party_names'] = casedf['name'].apply(f)\n",
        "\n",
        "ptdf = pd.merge(ptab,casedf,left_on='Proceeding',right_on='proc',how='inner')\n",
        "print(len(ptab), len(casedf), len(ptdf))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YxdJ9pvjXJSk"
      },
      "outputs": [],
      "source": [
        "# DOCTYPE = 'Responses'\n",
        "DOCTYPE = 'Decisions'\n",
        "# DOCTYPE = 'Petitions'\n",
        "\n",
        "ptdf.drop(columns=list({'Petitions','Responses','Decisions'}-{DOCTYPE}), inplace=True)\n",
        "ptdf.drop(columns=['case','proc'], inplace=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o4QcepJBau6N",
        "outputId": "60cac29e-999f-4be5-ae39-5c118eb34448"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10462\n",
            "9296\n",
            "9079\n"
          ]
        }
      ],
      "source": [
        "# Drop error messages and duplicates\n",
        "\n",
        "ptdf[DOCTYPE] = ptdf[DOCTYPE].fillna('NA')\n",
        "\n",
        "# clean up texts by removing (cid:##) which is likely an artifact of the PDF reading process\n",
        "cid_str = re.compile(\"\\(cid:\\d+\\)\")\n",
        "def f(x):\n",
        "    return re.sub(cid_str, \"\", x)\n",
        "ptdf[DOCTYPE] = ptdf[DOCTYPE].apply(f)\n",
        "\n",
        "def get_word_count(text):\n",
        "    return len(text.split())\n",
        "ptdf[f'{DOCTYPE}_Len'] = ptdf[DOCTYPE].apply(get_word_count)\n",
        "MIN_LENGTH = 50\n",
        "\n",
        "print(len(ptdf))\n",
        "ptdf.drop(ptdf[ptdf[f'{DOCTYPE}_Len'] < MIN_LENGTH].index, inplace=True)\n",
        "print(len(ptdf))\n",
        "ptdf.drop_duplicates(DOCTYPE, keep=False, inplace=True)\n",
        "print(len(ptdf))\n",
        "\n",
        "ptdf.reset_index(inplace=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Outcome Statistics"
      ],
      "metadata": {
        "id": "wMmkiANFUsQ6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Years = [2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021]\n",
        "granted = np.array([len(ptdf[(ptdf.Decision=='Granted') & (ptdf.date.dt.year==yr)]) for yr in Years])\n",
        "denied = np.array([len(ptdf[(ptdf.Decision=='Denied') & (ptdf.date.dt.year==yr)]) for yr in Years])\n",
        "mixed = np.array([len(ptdf[(ptdf.Decision=='Mixed') & (ptdf.date.dt.year==yr)]) for yr in Years])\n",
        "print(granted, denied, mixed)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E1TQELftdKIn",
        "outputId": "8edda5a1-bb30-4559-8889-99cd48297555"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 39 212 439 442 468 553 708 542 612 237] [ 11 153 395 420 430 481 461 381 389 183] [ 50 281 401 290 225 181   1   0   0   0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "granted/(denied+granted+mixed)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pesoo-b4sFGM",
        "outputId": "fc026ec6-b79a-4b73-e9c2-7e6b62e046ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.39      , 0.32817337, 0.35546559, 0.38368056, 0.41674087,\n",
              "       0.45514403, 0.60512821, 0.5872156 , 0.61138861, 0.56428571])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nbars = len(Years)\n",
        "x_pos = np.linspace(0,nbars-1,nbars)\n",
        "width = 0.5\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "fig.set_size_inches(10,6)\n",
        "\n",
        "ax.bar(x_pos, granted, label='Granted', color='blue')\n",
        "ax.bar(x_pos, mixed, bottom=granted, label='Mixed', color='brown')\n",
        "ax.bar(x_pos, denied, bottom=granted+mixed, label='Denied', color='orange')\n",
        "\n",
        "ax.set_xticks(x_pos)\n",
        "ax.set_xticklabels(Years, rotation=45, ha='right', fontsize=14, fontweight='bold')\n",
        "# ax.set_ylim([0.4,1.0])\n",
        "plt.yticks(fontsize=14)\n",
        "ax.set_ylabel('Number of Petitions', fontsize=18, fontweight='bold')\n",
        "ax.yaxis.grid(True)\n",
        "ax.spines['top'].set_visible(False)\n",
        "ax.spines['right'].set_visible(False)\n",
        "ax.legend(framealpha=1.0, fontsize=14, loc='upper right', bbox_to_anchor=(1.1, 1))\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 441
        },
        "id": "Mpc64FQkdVWK",
        "outputId": "7cd04609-c0ee-42fd-c354-1927e8492517"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAGoCAYAAACwgKiyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdebxVVd348c8XBARxAEQQFBVnVFKgDNJES+WXQ+XTo09YiUOYpTlAmkNKmmRO6dOD85T24FBWj0M5FmrOoJnilCaOoKJm4YRy1++PvS8cDvfcew+cyxn4vF+v/dpnr732Pt91z7nnfu86a68dKSUkSZIkLalTtQOQJEmSapXJsiRJklSCybIkSZJUgsmyJEmSVILJsiRJklTCStUOoJaNGTMm3XLLLdUOQ5IkqRZFtQNYHuxZbsXcuXOrHYIkSZKqyGRZkiRJKsFkWZIkSSrBZFmSJEkqwWRZkiRJKsFkWZIkSSrBqeMkSZI6yNtvv82rr77K/Pnzqx1KR0jVDqACmjp37nzfggULvjh8+PCPWqpgsixJktQB3n77bV5++WU23HBDevToQadOfqFfa5qamjo9//zzw+bNm3cKcHRLdXzVJEmSOsCrr77KhhtuSM+ePU2Ua1SnTp0YNGhQD2B8yTrLMR5JkqQVxvz58+nRo0e1w1AbunbtSlNT02ql9pssS5IkdRB7lGtfREArt+72FZQkSZJKMFmWJEmSSjBZliRJWo4ilu+yojv00EMZPXr0Uh9vsixJkqTFvP766xx55JFsvPHGrLzyyqy11lqMGjWKX/ziF8ybN6/Dn3/06NEceuihHf487eE8y5IkSVpo1qxZfO5zn2O11VbjlFNOYejQoXTv3p2ZM2dyySWX0KdPH8aOHbvEcfPnz6dr165ViLhj2bMsSZKkhQ455BA6derE9OnT+a//+i+GDBnCBhtswO67787vf/97vv71rwPZLBJTpkxhr732YpVVVuG4445jwYIFHHjggWywwQZ0796djTfemNNPP52mpqaF5x83bhy777475557LgMHDqRXr17sv//+vP/++wv333XXXUyZMoWIICKYNWsWAE8++SS77bYbq666KmuttRZf//rXmTNnzsJzL1iwgIkTJ9KrVy969erFEUccwYIFC5bp52HPsrS0ptbRQLCxjXBHUklSR3vrrbe49dZbmTx5MqusskqLdaJgIPSPf/xjJk+ezJlnnklE0NTUxMCBA7nuuuvo27cvDz30EOPHj6dPnz4ceOCBC4+75557WHvttbnjjjt4+eWX2Xvvvdlkk0049thjOffcc3n22WfZbLPNmDx5MgB9+/Zl9uzZfP7zn+fAAw/kzDPP5OOPP+b444/ny1/+Mvfffz+dOnXirLPO4uKLL+biiy9m6NChTJkyhf/93/9l2LBhS/0zMVmWJEkSAM899xwpJTbddNPFytdZZx3++c9/AvCNb3yDCy64AIB99tmHgw46aLG6J5988sLH66+/Po888ghXX331YsnyaqutxgUXXEDnzp3ZfPPN+c///E/uvPNOjj32WFZffXW6du1Kjx496N+//8Jjzj//fD71qU/xs5/9bGHZlVdeSe/evZk+fTqf+cxnOOecczj66KPZe++9ATj33HO59dZbl+lnYrIsSZKkVt1zzz0sWLCA8ePH8+GHHy4sHzFixBJ1L7jgAi655BJefPFFPvjgAz7++GPWW2+9xeoMGTKEzp07L9weMGAADz74YKsxzJgxg7vvvpuePXsuse/5559n0003Zfbs2YwcOXJheadOndh22215+eWX293WYibLkiRJAmCjjTYiInj66acXK99ggw0Alrh9d/FQjWuvvZYjjjiCM888k1GjRrHaaqsxZcoUfve73y1Wr0uXLottNw/haE1TUxO77bYbZ5555hL7+vXr1+bxS8tkWZIkSQD06dOHXXbZhf/5n//hsMMOa7EXtzV/+ctf2HbbbReb9u35558vO46uXbsucWHesGHDuO6661hvvfWWSLabrb322jzwwAPstNNOAKSUeOihh1h77bXLjqGZybIk1TsvNpVUQeeddx6f+9znGD58OJMmTeJTn/oUK620EjNmzOCxxx5jl112KXnsJptswhVXXMEf//hHNtpoI6655hruuusuevXqVVYM66+/Pg899BCzZs2iZ8+e9O7dm+9973tcfPHF7LPPPhxzzDH07duXf/zjH1x33XWcddZZrLrqqhx++OH89Kc/ZZNNNmGrrbbivPPOY/bs2cuULFd16riI+HxE3BARr0ZEiohxBfu6RMTPIuJvEfFeRMyOiKkRMajoHN0i4hcRMTevd0NErFNUZ1BE3JjvnxsR/x0RjTcRoCRJqnkpLd+lXIMHD+bRRx9lzJgx/OhHP2KbbbZh2LBhnH322Xz3u9/lnHPOKXnswQcfzN57783YsWP59Kc/zaxZs5gwYULZMUycOJGuXbsyZMgQ+vbty0svvcSAAQO499576dSpE2PGjGGLLbbge9/7Ht26daNbt24ATJgwgf3335+DDjqIbbfdlqamJvbdd9/yfwgFIi3NT7FCIuJLwHbAI8CVwHdTSlfk+1YHfgNcAvwVWB04C+gDDE0pfZLXOx/4MrAf8BZwNrAGMDyltCAiOufHvwUclR//S+D6lNJhrcU3YsSINH369Eo2WY3E3jzVCt+LUk2aMWMGw4cPr3YYaof8tWrxw7SqwzBSSn8A/gAQEVcU7XsX2LmwLCIOBmYCmwOP5wn1gcD+KaXb8zrfBF4EvgjcCuwCbAGsl1J6Oa9zNHBJRByfUvpXhzVQkiRJda3e7uC3Wr5+J18PB7oAtzVXyBPip4BRedFI4KnmRDl3K9AtP16SJElqUd1c4JePMT4LuDGl9Epe3B9YAMwtqv56vq+5zutF++fmx/UvKicixgPjIZuGZNq0aZUIX41o5SWnrqlZvo8bm+9FqSatuuqq1Q5BFVAXyXJErAT8imws8p4d+VwppYuAiyAbszx69OiOfDrVs6k7VjuC9hvtONGG5ntRqkkzZsyodgiqgJofhpEnylcDQ4EvpJTeKtg9B+gMrFl0WL98X3OdfkX718yPm4MkSZJUQk0nyxHRBbiWLFHeMaVUnNzOAD6m4ELAfNq4zYH78qL7gc2LppPbGfgoP16SJElqUVWHYURET2CjfLMTMCgitgbeBl4Dfg18GtgDSBHRPMb43ZTSBymldyPiUuD0iHiDRVPH/Q24I697G9kMGldGxASyqePOAC52JgxJkiS1pto9yyOAR/OlO/Dj/PHJwDpk8ycPIOsBnl2w7FNwjiOA35H1QN8LzAP2SCktAMjXuwHv5/uvBa4HJnZs0yRJklTvqj3P8jSgtdn025xpP6X0EXBYvpSq8xKwe7nxSZIkacVWF7NhSJIkNYqpW2yxXJ9v7MyZHXbuSZMm8Zvf/IYnnniiw55j7ty59O3blz//+c9UY5Yyk2VJUm3yNt5SVYwbN45f/vKXHHDAAVx66aWL7TvmmGM4/fTT2W233bjpppuYOHEihx1W8sv9hlDtMcuSJEmqMeuuuy7XXXcd77333sKyTz75hCuvvJJBgwYtLOvZsyd9+vSpRojLjcmyJEmSFjN06FA23nhjrrvuuoVlN998MyuvvPJiQyEmTZrElltuCcCHH37Illtuyf77779w/2uvvcaaa67JGWecAUBKidNPP50NN9yQ7t27s9VWW/GrX/1qsed++OGHGT58OCuvvDLbbLMNDz74YAe2tG0my5IkSVrCgQceyGWXXbZw+7LLLmP//fcnouUhUiuvvDJTp07l6quv5te//jUpJb71rW/xqU99iokTs0nITjjhBC699FKmTJnCk08+ybHHHsvBBx/MzTffDMC8efPYbbfdGDx4MNOnT+e0005beGy1mCxLkiRpCWPHjmX69On8/e9/Z86cOdxyyy2MGzeu1WOGDh3KaaedxsEHH8yECRN49NFHufLKK4kI3nvvPc4++2wuueQSxowZwwYbbMDYsWP59re/zZQpUwCYOnUq8+fP5/LLL2fLLbdk11135fjjj18OrS3NC/wkLc6LqiRJQK9evfjqV7/KZZddxhprrMHo0aMXG69cyuGHH84NN9zAz3/+c6677joGDhwIwJNPPsmHH37ImDFjFuud/vjjj1l//fUBeOqppxg6dCg9e/ZcuH/kyJGVbViZTJYlSZLUogMOOID99tuPnj17cvLJJ7frmLlz5/Lkk0/SuXNnnnvuuYXlTU1NANx4441LJN1dunSpXNAV5jAMSZIktegLX/gCXbt2Ze7cuXzlK19p1zEHHnggG220Eddeey0nnXQSM2bMAGDIkCF069aNF198kY022mixZb311gNg88035/HHH19sFo4HHnig8g0rgz3LkiRJalFE8Le//Y2UEt26dWuz/gUXXMBdd93FY489xvrrr8+4cePYd999eeSRR1h11VWZOHEiEydOJKXE5z//eebNm8cDDzxAp06dGD9+PGPHjuX444/ngAMO4MQTT+S1117j1FNPXQ4tLc1kWZIkaTnqyDvqdYRVV121XfWeeeYZJkyYwPnnn79wDPI555zDsGHDOPLII7nwwgs55ZRT6NevH2eeeSaHHHIIq622GltvvTVHH300kM3bfNNNN3HIIYcwbNgwNttsM372s5+x5557dlTz2hQpeYFMKSNGjEjTp0+vdhiqVY16IVyjtquRNepr1qjt0gpjxowZDB8+vNphqB3y16rFDx3HLEuSJEklmCxLkiRJJThmWdKKoZ6+0ge/1pekGmHPsiRJklSCybIkSZJUgsmyJEmSVILJsiRJklSCybIkSZJUgsmyJEmSVIJTx0mSJC1Py3sqyxqeinLatGnsuOOOvPnmm6y55ppLfZ7dd9+dNddckyuuuKJyweXsWZYkSdJC48aNIyKICLp06cJaa63FjjvuyJQpU/j4448r+lyjRo1i9uzZ9OnTp6LnrSSTZUmSJC3mi1/8IrNnz2bWrFncdttt7LHHHpx00klsv/32vPfeexV7nq5du9K/f38iavfGUSbLkiRJWky3bt3o378/AwcOZOutt+aoo45i2rRpPPLII5x++ukAzJ8/n2OOOYZ11lmHHj168OlPf5pbb7114TmmTZtGRHDnnXey7bbb0qNHD0aMGMEjjzyyRJ25c+cuLLvvvvvYYYcd6NGjBwMHDuSQQw7hX//618L977//PuPGjaNnz57069ePyZMnd+jPwmRZkiRJbdpyyy0ZM2YM119/PQD7778/d911F1OnTuWJJ55gv/32Y4899uCxxx5b7Lhjjz2W0047jUceeYQ+ffqw7777klLL46gff/xxdtllF/bcc08ee+wxfvvb3/LXv/6VAw44YGGdiRMncvvtt3P99ddz55138uijj3L33Xd3WLu9wE+SJEntMmTIEO644w6ef/55rr76ambNmsWgQYMAOPTQQ7njjju48MILOe+88xYec8opp7DjjjsCcOKJJ7Lddtvx6quvss466yxx/jPOOIN99tmHCRMmLCw7//zz2WabbXjjjTfo0aMHl156KZdddhm77rorAJdffnmL56oUk2VJkiS1S0qJiOCRRx4hpcSQIUMW2//RRx+x0047LVY2dOjQhY8HDBgAwBtvvNFigjtjxgyee+45rr322sWeE+D555+nR48ezJ8/n5EjRy7c37NnT7baaqtlb1wJJsuSJElqlyeffJLBgwfT1NRERPDwww/TpUuXxep07959se3C/c0X8jU1NbV4/qamJg466CCOPPLIJfYNHDiQZ599dlmbUDaTZUmSJLXpiSee4JZbbuGEE05gm222IaXEnDlzFg6xqIRhw4Yxc+ZMNtpooxb3b7jhhnTp0oUHHniAwYMHA/Dee+/xxBNPsOGGG1YsjkImy5IkSVrMRx99xJw5c2hqauLNN9/kzjvvZPLkyQwfPpyJEyeyyiqrsO+++zJu3DjOOusshg0bxttvv820adMYPHgwe+2111I97zHHHMNnP/tZvvOd73DwwQez6qqr8vTTT3PjjTdy4YUX0rNnTw488ECOOeYY+vbty4ABAzj55JNZsGBBhX8Ci5gsS5IkLU81fEe9ZnfccQdrr702nTt3Zo011mDLLbdk0qRJjB8/nq5duwLZhXWnnnoqRx99NK+88gq9e/fmM5/5zDL1NA8dOpS7776bE044gR122IEFCxYwePBgvvrVry6sc+aZZ/Lee+/x1a9+lR49enDYYYdVdO7nYlFq6g7BiBEj0vTp06sdhmrV8r5d6bIo54PZdtWGRm2b7dIKZMaMGQwfPrzaYagd8teqxQ8d51mWJEmSSjBZliRJkkowWZYkSZJKMFmWJEmSSjBZliRJ6iClbr6h2pFPdlHyKl2TZUmSpA7QtWtX3n///WqHoTbMnz+fTp06/avUfpNlSZKkDjBw4ECef/555s2bZw9zjWpqauKll156P6V0Uak63pREkiSpA/Tu3RuAF154gfnz51c5GpXQ1Llz50dSSj8qVcFkWZIkqYP07t17YdLcgOrozkFLz2EYkiRJUgkmy5IkSVIJJsuSJElSCVVNliPi8xFxQ0S8GhEpIsYV7Y+ImBQRr0XEBxExLSK2KKrTKyKuioh38+WqiFijqM5WEXFXfo5XI+LEiFghxtlIkiRp6VW7Z7kn8ARwOPBBC/uPBiYAhwGfBt4Abo+IVQvqTAWGAWPyZRhwVfPOiFgNuB14PT/H4cAPgKMq3BZJkiQ1mKrOhpFS+gPwB4CIuKJwX97zewRwWkrp+rxsP7KEeSxwYURsTpYgb5dSuj+vczBwT0RsmlJ6BtgX6AHsl1L6AHgiIjYDjoqIs1N+2xZJkiSpWLV7lluzAdAfuK25IE927wZG5UUjgXnAfQXH3Qu8V1TnnvzYZrcCA4D1OyJwSZIkNYZ29yxHxMrAakBKKb2Zl+0BfB1YGfhlSun/Khhb/3z9elH568DAgjpvFvYOp5RSRLxRcHx/4JUWztG874XCHRExHhgP0K9fP6ZNm7YMTVBDW/nMakfQfuW8j21XbWjUttmuxvX2jGpHUJ7ew6sdQd0bPXp0tUNYLsoZhnEy2fjhx4GtI2IX4P+A5kT1yxHx/1JKt5U6QT3Ib3d4EcCIESPSivJG0FKYumO1I2i/0WWMNrJdtaFR22a7Glc9vV7ga6Z2K2cYxmfI7tTyh3x7/3wdBcvhlQuNOfm6X1F5v4J9c4C+hTNb5I/XKqrT0jkKn0OSJElaQjnJ8sZkvciP59vb5ts/AG7Myyr5ncYLZMnszs0F+VCQ7Vk0Rvl+shk1RhYcNxJYpajO9vmxzXYGXgNmVTBeSZIkNZhykuU++Xp2RHQDBgEfppTOAs7P95V18/OI6BkRW0fE1nksg/LtQfk45HOAYyJir4jYEriC7IK+qQAppaeAW8hmxhgZESOBC4Gb8pkwyOu+D1wREVtGxF7ADwFnwpAkSVKrykmWm/L1msCQ/Njn8rIF+bqluZJbMwJ4NF+6Az/OH5+c7z8d+DkwBZgOrA3sklL6d8E5xgKPkc1wcWv++JvNO1NK75L1JA/IzzEFOAs4u8xYJUmStIIp5wK/F4FNgDOBf5INwXgi3zcgX88t58lTStPIxjqX2p+ASflSqs47wDfaeJ7Hgc+XE5skSZJUTs/yzWSJ7brAVnnZTfm6eazy3yoUlyRJklR15STLpwD3kCXMTcDlwDX5vt2Aj4BplQxOkiRJqqZ2D8PIx/7uEBF9gHkppY8K9m3YEcFJkiRJ1VTOmGUAUkpvdUQgkiRJUq0pK1mOiFXIZp/YhGyauOKL81JK6cAKxSZJkiRVVbuT5YgYTnb3vjXbqGqyLEmSpIZQTs/yz4G+bdTxJh+SJElqGOUkyyPIkuF/AVcDbwGfdERQkiRJUi0oJ1l+H+gGHJ5SurKD4pEkSZJqRjnzLP8xX3/YEYFIkiRJtaacZPk44E1gckQM66B4JEmSpJpRzjCMu8iGYawFPBwR/wbeLqqTvEGJJEmSGkU5yfL6ZBf4JbL5lVcDVi3YHzgbhiRJkhpIuXfwK74JSfG2JEmS1DDKSZZ37LAoJEmSpBrU7mQ5pXRXRwYiSdIKYWqdfSk71hGWWrGVOwyDiOgOfAnYLC96GvhDSumDSgYmSZIkVVtZyXJE7AT8L9mMGIXeiIh9U0p/qlhkkiRJUpW1e57liNgIuIEsUY6CBaAf8H95HUmSJKkhlHNTkqOBHmQJ8gfAX/Ol+Y5+PYAfVDQ6SZIkqYrKSZa/QDaP8j3AoJTSsJTSMGAQcDdZEv3FyocoSZIkVUc5yfLAfH1mSumt5sL88Vn55oBKBSZJkiRVWznJ8vx83auFfb3z9SfLFo4kSZJUO8qZDePvwDbAaRHxLnBvXv45YDLZEI1nKxueJEmSVD3lJMu/J0uW+wG/LdoXZMny7yoUlyRJklR15QzD+DnwHIumiyucOg6ynudzKhSXJEmSVHXtTpZTSvOA7cl6mAvvfdnco7xDXkeSJElqCGXdwS+l9DqwV0SsAWycF/89pfTPikcmSZIkVVlZyXKzPDl+uMKxSJIkSTWlZLIcESfmDy9LKb1SsN2qlNLJFYlMkiRJqrLWepYnkY1HvgN4pWC7LSbLkiRJagjlDsOINva3J5mWJEmS6kJryfKVZMnv60XbkiRJ0gqhZLKcUhrX2rYkSZLU6No9DCO/wC8Bl6eUXina1xMYCpBSuq+iEUqSJElVUs6Y5UlkyfKdZBf8FfoUcA/QVOY5JUmSpJpVzu2uW9OcILd1AaAkSZJUN1rtBY6IQcD6RcXbREThcZ2A/fLHXgAoSZKkhtHWkIn9gcKbkQTw363Uf3OZI5LqxNRTh1Q7hHYbO7baEUiSVJ/aM764eGhFa0MtfrcMsUiSJEk1pa1k+Z/Ai/nj9Vg07/JHBXWagLeA24GfVDpASZIkqVpaTZZTSucC5wJERFNe/DWnh5MkSdKKoJxp3k4m61l+qYNikSRJkmpKu5PllNKkDoxDkiRJqjklk+WI+BNZT/L3U0oz8+22pJTSFyoWnSRJklRFrfUsjyZLllcv2i4l2tgvSZIk1ZVy7+AXrSwVFxGdI+KUiHghIj7M1z8pvClKZCZFxGsR8UFETIuILYrO0ysiroqId/PlqohYoyNiliRJUuNorWd5/3z9bNH28nQM8D2yOwQ+DgwFfkk2dd0peZ2jgQnAOOAZspuo3B4Rm6aU/p3XmQoMAsbk25cAVwF7dHwTJEmSVK9KJssppV+2tr2cjAJuTCndmG/PiogbgG0h61UGjgBOSyldn5ftB7wBjAUujIjNyZLk7VJK9+d1DgbuyRPqZ5ZriyRJklQ32j0MIyL+FBF3Fg9xyPetExHHRcSxlQ2PvwA7RsRm+fMMAXYC/pDv3wDoD9zWfEBK6QPgbrJEG2AkMA8onBv6XuC9gjqSJEnSEiKl9l2Tl9+UJAHbF9+UJCI+B9xDNhtG54oFl/Uc/wQ4FlhA1hN+akrphHz/KLLEd72U0ksFx10GDEwp7RoRxwEHpZQGF537H8DFKaWfFpWPB8YD9OvXb/g111xTqeaowbw9c2a1Q2i33lss8T9uaW/P6LhAKq338PbXrad2QeO2zXbVV7ug/W1r1HappNGjR3fINWu1ppybkrSmR4XOU2wf4FtkQypmAlsD50bECymlSzviCVNKFwEXAYwYMSKNHj26I55GDWDq975X7RDabXQ5if3UHTsukEobXcYEPPXULmjcttmu+moXtL9tjdourfBaTZYjYgdgh6LiAyLiiwXbnYAv5Y8XVDA2gDOAM1NKzd27j0fEemQ9zZcCc/Lyfix+Z8F+BfvmAH0jIlLejZ73WK9VUEeSJElaQls9y6PJZpdoFpSeFSMBs5Y9pMX0YMkEfAGLxlq/QJbw7gw8DBARKwPbAz/I69wP9CQbu9w8fGQksAqLj2OWJEmSFtOeYRjF41FaG58yZRliacmNwA8j4gWyYRjbAEcBV0I2QDoizgGOi4inyaa5O4Hsgr6peZ2nIuIWspkxxufnvRC4yZkwJEmS1Jq2kuW/ks1rDNlcxwm4hWxqtmZNwFvA7Sml2ysc32Fk8ymfRzZsYjZwMXByQZ3Tge5kiXov4EFgl4I5liEb8/wL4NZ8+wbg0ArHKkmSpAbTarKcUvo/4P9g4fzFkM1GsVyGL+QJ7xH5UqpOAiblS6k67wDfqHB4kiRJanDlzIbRfJnr4x0RiCRJklRr2p0sp5TuAoiI1SPi28CWZBfJHQwMzKu9nNo7cbMkSZJU48qaZzkidgOuAlYnu9AvAd8BpgO9gd1YNC5YkiRJqmvl3O56K+A3LEqUAUgpfUI2a0UnYM9KByhJkiRVS7uTZbIbgXTLHz9atO/hfD1qmSOSJEmSakQ5yfJosmEXPwG+X7Tv5Xw9oAIxSZIkSTWhnGS5T76+q4V98/P1GssWjiRJklQ7ykmW/5WvN25h36fz9TvLFo4kSZJUO8pJlh8hu7DvZGCP5sKIOAj4IdkQjRkVjU6SJEmqonKS5cvy9ZrAD8iSY4ALgZ5FdSRJkqS61+5kOaV0LXA1We9yFOxqfnx1Sun6CsYmSZIkVVVZNyUBvgH8BTgAGJKXPQVcClxQwbgkSe009dQhbVeqEWPHVjsCSSpPWclyfivr8/NFUgMy8ZIkaZF2Jcv53ft2BLoCj6aU7uzQqCRJkqQa0GayHBFnAEcVlf0Z2DOl9H5HBSZJkiRVW6sX+EXEl4EJLHlB347AKR0YlyRJklR1bc2GcXDB48JZMAI4ICJiyUMkSZKkxtBWsjyMbD7lB4HBQG+ymS8AVgM26rjQJEmSpOpqa8xyn3x9WkppFkBE/BA4MC/v3UFxSZJWcM7MIqkWtJUsdybrWX6zuSCl9FbB6IvOHRSXJGkFt++TM6sdQruZK0uNq73zLPeLiEHtKU8pvbTsYUmSJEnV195k+TctlEUL5amMc0qSJEk1rb2JbfGsF6lEuSRJktQw2pMst5QQmyRLqiv1dLEYeMGYJNWKtpLlHZdLFJIkSVINajVZTindtbwCkSRJkmpNWzclkSRJklZYJsuSJElSCSbLkiRJUgkmy5IkSVIJJsuSJElSCSbLktztdB0AACAASURBVCRJUgklk+WIaIqITyJiVL79p4i4MyK2WH7hSZIkSdXT1k1JgkV36xtNdpvr1TsyIEmSJKlWtJYszwe6ADtHxCsF5f0jYlCpg1JKL1UqOEmSJKmaWkuWXwYGAz/Kl5SX/7qVY1Ib55QkSZLqRmuJ7W+AY8gS4GilHu2soxXR1Dp7W4xNbdeRJEkrjNaS5ZOBVYCvAAMLylvKfuosI5IkSZLaVnI2jJTSByml76eUBqWUOrMoId4updSpxNJ5+YQtSZIkdbxyxhdfSTbc4vUOikWSJEmqKe1OllNK45ofR8SawKb55jMppbkVjkuSJEmqurLu4BcRa0fEjcAc4O58mRMRN0TEgI4IUJIkSaqWdifLEbE68BfgS/lxzTcs6QTsBtwVEat1RJCSJElSNZTTs3wUsEGJfUE2J/NRyxyRJEmSVCPKSZa/nK9fBXYH1siX3YFXyBLmr1Q0OkmSJKmKykmWNySbDePYlNIfUkr/ypc/AMfldTaqdID5OOlfRsSbEfFhRDwZETsU7I+ImBQRr0XEBxExLSK2KDpHr4i4KiLezZerImKNSscqSZKkxlLO1HHNdee1sO/f+bqi8yznCe29ZGOldwPeJBvu8UZBtaOBCcA44BngROD2iNg0pdQc11RgEDAm374EuArYo5LxSpK0oop96+sOqGlstSNQvSgnWX6FLFH9YUTcn1J6AyAi1iK7LXZznUo6GpidUvpWQdkLzQ8iIoAjgNNSStfnZfuRJdNjgQsjYnOyJHm7lNL9eZ2DgXvyhPqZCscsSZKkBlHOMIw7yMYlfwZ4MSKeiIgngBeBbcmGaNxe4fi+AjwYEddGxBsR8deIODRPkiG74LA/cFvzASmlD8imtBuVF40k6w2/r+C89wLvFdSRJEmSlhApte9rk4jYAHgMWIUsaW4+sDlx/TewdUrphRYOX7rgIj7MH/4cuA7YGvgF8MOU0v9ExCiyxHe9lNJLBcddBgxMKe0aEccBB6WUBhed+x/AxSmlnxaVjwfGA/Tr12/4NddcU6nmrJjenlHtCMrTe3i7q749c2YHBlJZvbfYou1KOdtVGxq1beW0a0YdfXwMb/9HR8N+LtbT6wVlvmZq0ejRo6PtWvWv3ckyQH5h3VRg7aJdrwFjU0p3VzA2ImI+MD2lNKqgbDLw1ZTS5h2RLBcaMWJEmj59eiWbtOKZWme/R2Pb//swtYw/+tU2toxkynbVhkZtWzntijr6+CjjT2nDfi7W0+sFZb5mKqXOXvWlU86YZVJKd0XEYGAXYLO8+GngtpTSR5UODpgNPFlU9hRweP54Tr7uB7xUUKdfwb45QN+IiJT/Z5AP41iroI4kSZK0hLKSZYA8Kb4xXzravcCmRWWbkI2ThuxivznAzsDDABGxMrA98IO8zv1AT7Kxy83jlkeSDScpHMcsSZIkLabsZHk5+zlwX0QcD1wLbAN8n3xe55RSiohzgOMi4mngWeAEsgv6puZ1noqIW8hmxhifn/dC4CZnwpAkSVJrajpZTik9HBFfASYDPyIbavEj4LyCaqcD3YEpQC/gQWCXgjmWIZtG7hfArfn2DcChHRu9JEmS6l1NJ8sAKaWbgZtb2Z+ASflSqs47wDcqHZskSZIaWznzLEuSJEkrFJNlSZIkqYR2DcOIiB7AQfnmjJTSvR0XkiRJklQb2pUsp5Tej4izyHqi9+7YkCRJkqTaUM4wjJfz9fsdEYgkSZJUa8pJlq8iu63hXh0UiyRJklRTypk67i/A34EDImJ14Ldkt6Ne7O7qKaW7KxeeJKkt+z45s9ohtNvYagcgSWUqJ1m+lSwxDuA/8qVYKvOckiRJUs1amsS2uSc5KhmIJEmSVGvKSZZfomjIhSRJKk/sW19/SpNjZ7SCa3eynFJavwPjkCRJkmqOd/CTJEmSSih7zHJEbATsD2wJrAJ8CfhsvvuBlNL8yoUnSZIkVU9ZyXJEjAd+kR8XQEopzY+IXwEDga8Bv6t4lJIkSVIVtHsYRkRsB5zHokS50A152Z6VC02SJEmqrnLGLP8grz8f+EPRvsfy9YhKBCVJkiTVgnKS5ZFkU8cdC/y0aN9L+XrtSgQlSZIk1YJykuXV8/XfWjlPz2ULR5IkSaod5STLb+frrVvY9/l8PXfZwpEkSZJqRznJ8oNkF/GdDHy7uTAifgJMIBui8UBFo5MkSZKqqJxk+bx83R34JotufX0si6agO79CcUmSJElV1+5kOaV0G3A6We9y4dRxzY9PTyndWcHYJEmSpKoq66YkKaUfRsRdwAHAkLz4KeDSlNIfKx2cJEmSVE1l3+46T4pNjNUuU08d0nalGjJ2bLUjkCRJtaTsZDki1gX2AjbOi54DfptSeqn0UZIkSVL9KStZjohjyGbDKD7u9Ig4KaVUfLMSSZIkqW61+wK/iDiA7M59XVh0kV/zshLwk4g4sCOClCRJkqqhnKnjjip4/CZwS768kZcFcGSF4pIkSZKqrpxhGBuSza18M7B3SulDgIjoBvwa2D2vI0mSJDWEcnqW5+TrC5oTZYCU0kfABfnmG0scJUmSJNWpcnqWrwJOAAa1sK+57NpljkiSOsC+T86sdghlcRZDSaoNJZPliChOin8F7AZMjogE3JuXfw44lezmJJd3RJCSJElSNbTWszyLbIxysQDOa6GsF/B4G+eUJEmS6kZ7xiwXThEHixLoUmWSJElSQ2irF7g4+W0pGTZBliRJUkMqmSynlMqZKUOSJElqOCbEkiRJUglLdTFeRKwC9KaFIRgppZeWNShJkiSpFrQ7WY6IAH4AHA70L1EtlXNOSbWnnuYjdi5iSVJHKyex/Qnww/xxcY9yaqFMamgmlZIkNb5ykuX9KJ0QmyhLkiSp4ZRzgV9vsh7ki4C+KaVOLSydOyZMSZIkafkrJ1l+PF/fkFJ6qyOCkSRJkmpJOcnySfn68IhYoyOCkSRJkmpJu8csp5RuiYgTgVOAVyPiGeCfS1ZLX6hkgJIkSVU1tY4uzRqbqh1Bwyln6ridgBPJxi13Bz5VXCXfJ0mSJDWEcoZh/BToUrAdRUuHi4hjIyJFxP8UlEVETIqI1yLig4iYFhFbFB3XKyKuioh38+Uqh5JIkiSpLeVMHbcVWc/x08DlwFtAU0cE1ZKI+CwwHvhb0a6jgQnAOOAZst7v2yNi05TSv/M6U4FBwJh8+xLgKmCPDg5bkiRJdaycZHkOsB4wIaV0SwfF06KIWB34X+AAFl1o2HxXwSOA01JK1+dl+wFvkN2H4cKI2JwsSd4upXR/Xudg4J48oX5mebZFkiRJ9aOcYRhTyIZbfLqDYmnNRcBvUkp/LirfgOzW27c1F6SUPgDuBkblRSOBecB9BcfdC7xXUEeSJElaQqTUvmvyImIc2e2uNwR+Q5Z8vltcL6V0ZQXjIyK+DXwH+GxK6eOImAY8kVI6NCJGkSW+66WUXio45jJgYEpp14g4DjgopTS46Lz/AC5OKf20qHw82XAP+vXrN/yaa66pZHNWOG/PrJ9bQgP03mKLtivlZszowEAqbPjw9te1XbWhUdtmu+qrXdD+tjVquwB4u44a17uchi2b0aNH19E0IUuvnGS5iWzMcmuzXqSUUjlDO9p6zk2Bv5ANoXgmL5tGBybLhUaMGJGmT59eqeaskKaWkXzWgrFlJPdRRx8R7fw1B2xXrWjUttmu+moXtL9tjdouwKnjSqujH8zSK2cYRqHimTA6alaMkcCawMyI+CQiPgF2AL6bP26+k2C/ouP6kY2xJl/3zcc3Z8Fnj9cqqCNJkiQtoZxe4LtZ/vMo/x4o7tq9HPg7MBl4lizh3Rl4GCAiVga2B36Q178f6EmWeDePWx4JrMLi45glSZKkxZRzB7/RHRhHqef8J0V3CYyI94C3U0pP5NvnAMdFxNNkyfMJZBf0Tc3P8VRE3EI2M8b4/DQXAjc5E4YkSZJaU7HxxVV0OtkdBacAvYAHgV0K5liGbBq5XwC35ts3AIcuzyAlSZJUf8q53fXn21MvpXT30ofTrvOPLtpOwKR8KXXMO8A3OjIuSZIkNZ5yepan0faY5VTmOSVJkqSatTSJ7QoxTYgkSZJUTrL8Ekv2LK9JNqtEIrtByRI3KZEkSZLqVTmzYazfUnlE7ARcC7xPNiWbJEmS1BCW9qYkC6WU/gScAawLlLwbniRJklRvljlZzq2cr3ev0PkkSZKkqitn6rgTSxy/DvD1fHuVSgQlSZIk1YJyLvCbROmp4yLf9/CyBiRJkiTVinKnjmtt2ri3gQnLEIskSZJUU8pJln/ZQlkC3gGeBaYW3WJakiRJqmvlTB23f0cGIkmSJNWaSs2GIUmSJDWcVnuWI2J8uSdMKV209OFIkiRJtaOtYRgXUHoGjFJMliVJktQQ2jtmubVZMAqVm1hLkiRJNautZPklWk+AuwJr53Xam1BLkiRJdaHVZDmltH5L5RHRCfgWcBKLJ8o3VTI4SZIkqZrKng0jIr4GPAFcCgwiS5T/DIxKKX25suFJkiRJ1dPueZYj4v8BPwG2ZlFP8kPA8SmlOzsgNkmSJKmq2kyWI2J7YDIwikVJ8uPAj1JKN3RgbJIkSVJVtTXP8i3Azs2bwN+Bk1JK13R0YJIkSVK1tdWzvAuLLuBLQC/g7Ig4u0T9lFIaWMH4JEmSpKpp75jl5unj+uTr4mniChNqSZIkqSG0J1luz/zJzrEsSZKkhtNWsrz/colCkiRJqkFt3ZTkl8srEEmSJKnWlH1TEkmSJGlFYbIsSZIklWCyLEmSJJVgsixJkiSVYLIsSZIklWCyLEmSJJVgsixJkiSVYLIsSZIklWCyLEmSJJVgsixJkiSVYLIsSZIklWCyLEmSJJVgsixJkiSVsFK1A5AkSaplsW+qdgjtlsZWO4LGY8+yJEmSVILJsiRJklSCybIkSZJUgsmyJEmSVILJsiRJklRCTSfLEXFsRDwcEf+KiDcj4saI2LKoTkTEpIh4LSI+iIhpEbFFUZ1eEXFVRLybL1dFxBrLtzWSJEmqN7U+ddxo4DzgYSCAk4E7ImJISuntvM7RwARgHPAMcCJwe0RsmlL6d15nKjAIGJNvXwJcBeyxHNqwQtv3yZnVDqEszrgjSZIK1XSynFLatXA7Ir4JvAt8DrgxIgI4AjgtpXR9Xmc/4A2yvOfCiNicLEneLqV0f17nYOCePKF+Zrk1SJIkSXWlpodhtGBVspjfybc3APoDtzVXSCl9ANwNjMqLRgLzgPsKznMv8F5BHUmSJGkJkVL93JUmIq4DNgZGpJQWRMQossR3vZTSSwX1LgMGppR2jYjjgINSSoOLzvUP4OKU0k+LyscD4wH69es3/JprrunYRjW4GTOqHUF5hg9vf916apvtqq92QeO2zXbVV7ug/W1r1HZBfbWtnHYtq9GjR8fye7bqqZtkOSLOBv6LbDjFP/KyiifLhUaMGJGmT5/eAa1ZcUSd/RqV8+tQT22zXfXVLmjcttmu+moXtL9tjdouqK+2Lee0ro5+MkuvLoZhRMTPga8DOzUnyrk5+bpf0SH9CvbNAfrm45ubzxfAWgV1JEmSpCXUfLIcEeeyKFF+umj3C2QJ784F9VcGtmfRGOX7gZ5kY5ebjQRWYfFxzJIkSdJiano2jIiYAnwT+ArwTkT0z3fNSynNSymliDgHOC4ingaeBU4gu6BvKkBK6amIuIVsZozx+fEXAjc5E4YkSZJaU9PJMvDdfH1nUfmPgUn549OB7sAUoBfwILBLwRzLkE0j9wvg1nz7BuDQDohXkiRJDaRuLvCrBi/wW3b1dFEEeMEH2K5a0ahts1311S7wAj+or7Z5gV/l1fyYZUmSJKlaTJYlSZKkEkyWJUmSpBJMliVJkqQSTJYlSZKkEkyWJUmSpBJMliVJkqQSTJYlSZKkEkyWJUmSpBJMliVJkqQSTJYlSZKkEkyWJUmSpBJMliVJkqQSTJYlSZKkEkyWJUmSpBJMliVJkqQSTJYlSZKkEkyWJUmSpBJMliVJkqQSTJYlSZKkEkyWJUmSpBJWqnYAyk2NakfQfmNTtSOQJElaLuxZliRJkkowWZYkSZJKcBhGjZh66pBqh9BuY8dWOwJJkqTlw55lSZIkqQSTZUmSJKkEk2VJkiSpBJNlSZIkqQSTZUmSJKkEk2VJkiSpBJNlSZIkqQSTZUmSJKkEk2VJkiSpBJNlSZIkqQSTZUmSJKkEk2VJkiSpBJNlSZIkqYSVqh2AMvs+ObPaIbTb2GoHIEmStJzYsyxJkiSVYLIsSZIklWCyLEmSJJVgsixJkiSVYLIsSZIklWCyLEmSJJVgsixJkiSVsEIlyxHx3Yh4ISI+jIgZEbF9tWOSJElS7VphkuWI2Ac4F5gMbAPcB/wxIgZVNTBJkiTVrBUmWQaOAq5IKV2cUnoqpXQYMBs4pMpxSZIkqUatELe7joiuwHDgzKJdtwGjiuqOB8bnm/Mi4pmOj7BDrQnMreQJIyp5tqVW8XZBTbStUdsFvhfLUgNta9R2ge/FstRA22xXGZZzu25JKY1Zrs9YBStEskz2huwMvF5U/jrwxcKClNJFwEXLKa4OFxHTU0ojqh1Hpdmu+tOobbNd9adR22a76kujtqsRrUjDMCRJkqSyrCjJ8lxgAdCvqLwfMGf5hyNJkqR6sEIkyyml+cAMYOeiXTuTzYrRyBpmSEkR21V/GrVttqv+NGrbbFd9adR2NZxIKVU7huUinzruKuC7wL3Ad4ADgS1SSi9WMzZJkiTVphXlAj9SStdGRB/gBGBt4AngSybKkiRJKmWF6VmWJEmSyrVCjFmWJEmSlobJsiRJklSCybK0HESEv2uquojoUe0YOkpEDdyPTVJD8g+4akKjJpMRMSAieqeUmhqpjRGxYUR8ttpxVFpE9I+I3SNig2rHUmkRsQlwa0TsWe1YKikiekZET2BAtWPR0muwz8eGaYsyK8xsGPUuItYBvgZsAzwC3JNSeqS6UVVGRKwLHBARWwB3AX9MKf2jymEts4jYDLgTeDoi9k4pvRURnVNKC6od27LIk66ngH9GxPCU0qwqh1QREbEx8FtgC+DQiLgIWJBSShERqY6vho6ITcmmzOwNzIyIm4GUUmqqbmTLJv+n5gxgg3z7mJTSHdWNatlFxEDgC8BWZPcI+EdK6aF8X72/F9cF9iT7PZsJPJ1SurMB3ovrAlumlP6Yd47U9eukxZks14GI2Ai4nuyDE+CrZD1E308pza5eZMuuKEEB+CLQBJxftaAqICL6A38hS056AxdHxLfzhLlTvf5hyJOuvwABXNhAifIGwJ+AgcCUlNJ5eXkP4P16TpiLEmWA3YFTUkqvVi+qZZd/Lt4BDMqLPgE2ycvqVv6ZeCNZWwA+AN6KiJNSSpfX+XtxY+CPwOC86GOgS0QcmVI6N69Td23LO0buAt6MiJVSSjfW8+ukJflVQY2LiPWB28kS5ceBZ4GewP8j+8NetyJiMFmCsgVwC1kvwxrAZhHRuZqxVcBmZMnJXLI/CF8BLomInnmvw8pVjW4p5EnX3UAf4Gjg+IjYMyJOjYgJETG6qgEupfwr/NPIfp9+klI6LCKOjojfA7+OiP0g64att3GxBf/c9AYuB54nG66wT76/Lv8G5L14N5Ilyj8DfkXW+TM8Ij4dEdsV1K2b1yzvUW5OlK8GrgW6A+sAl0bEtyF7L1YtyKWUdyDcQJYoXwf8Bngl3/3ziDgW6u/3LP8bfSvQF9gQ+EFEfBnqry1qRUrJpUYXssTxt2Q9raeRfWiuBjyUl/1HtWNchrb1Av6ct+NooAvZkIUmsp6HO4AzgZ2rHetStm9VssTkIeAesl6vBcA1wC+AS4DVqx1nGe0ZCLyXvz7/nZf9Mt9uyts3B9i72rEuRdtWA/4GPEeWVF5X0K7m5Zhqx7kU7doCmJ3HfwqwOnBTvn1NteNbhnYFMClvx6/zsv/Ot+cAb+WPD612rEvRtgmF7crL/kbWu9wEvA/sUu04l7JtuwEfAbcWlI0DphX8nu1X7TjLbNMqBZ8X9xV8Ft4NfLnEMVHtuF3KX+qyV2EFsiUwCrgrpfTDlNIHKaV/AY/m+7s0V8zHNNeTdcn+Gbg6pXQ6cCqwIzAPGA7sBBwCnJT3QNeNvCfh43z5G9kt1ps/SP8D+B5wANCzjnr21gceyx9vFxF3AN8kS8aeABKwFvDDenov5q/VYLLftfXI/in9Gtk/bmeQ/SEH+GlEbFuNGJdG3q7zgX5kQy5+lFJ6l6y3EuA/IuKLVQtwGaQs42geUjIyIm4ADiVLlGcA7+T7/jsixlQhxGWxcb5+NyL6RMSuedkjZN8qdgN2gbr8VmBdsr9Z/SNiw7zsl8CFwP359iER0bulg2tUd7I2TUspjQLOJvvGfhQwISL2aq4YESOgPr8VkMMwat3DZGOVLwKIiG55efNY81fy8hPJvuL/zHKPcOk9CRwHfCP/Gmsi8G+yZHIH4GayD6JRQP/qhLjUIqX0IfBXsp7xx4FvkyWWncl6Hv6SUno11c/Y5fuBH5INCdqa7J+ZG4ERwDCyr/gBPsWiRKbm5X+4niX7ZybIEpF3gP9MKR0D/Bz4e169b1WCXAp5u3YHvp9SOgkgIrqQJV3Pk7V107y8br4mjhzwOtnnxQCydn4AjEwp7Qb8GHgtP6RuZjXJ29XcAfIlss/A35IlyJPJfvcC2CkiViL7B7XmFST1c/L1AGCviOifv09/TfZZAtnnx+rLOcRl8RZwPPCfACmliWTfHDYnzIdFNrvO2cBDEfG1qkWqZVPtrm2XlhegS77uCvQu2nct2R+HzYBjyXosZwPrVjvuctpWuE32B2+dgrJRZL3MrwJbVDvmdrarU9H2JOBtYGXgCBZ91fh+vr4KWKnacbejXSs1tw/4PNnFYm8AAwvqbAX8C3gBGFDtmMt5vcj++fwFi75CXWyIE1mC+W9gRLVjLqNt3Yq2Oxc8viRv49+B/tWOtcx2dc7X3cmSlJPIkq13gW3zfUH2z/iHwFeqHXM729X8OzYAeLrgs+JfwJH5vq/nZTdXO952tqn596t7vu5J9u1UE1lHz+HAoIJ9rwAvA2tXO/Z2tqtHwfstCv+uFX2ezMofvwNsWu34XZZucTaMGpJfKTw8pXRNSunj/Kra+WQJF/n2J2QfqN2A08mSzLeBL6aUXq5W7G1poW0LZ4RIKX1MNpay0DigB1liVrNX7Re1q3ku5ZSyT8yZZGOXbyLriQU4jGwIxrrA5Pz1rDlF7fqk+b0XEX8BjgHmp8VnUziY7A/ePWSJZU1q4fVqbtexwGfJhgABXBERA8j+Id2a7FueF6oTdfsUte2jot+xBQXbvya74LQ72fCaOSVPWgOK2rUgIrqmlD4gG7pFRFxA9nv2vYhYFdiV7HX7K/BAteJuSwu/Y11SSq/lFyceRNY7/nJK6c/5IV/O10/nF0A35Z8zNSciBgHfzi8wnRcRV6aUpkXEwWSdBBuSXauyaUT8luyC9QFknx/vVSvutrTQrsvS/2/v/ELtKO44/pkbvTF6oyJYRQhJtIot9MEqFDTxqiC2fRAVH6JWa6lQCkXyoGJBRB+kYKFWEFF8CdraIn1on/rSF8VaWisqopJqamNbk1qNVVET/5zpw2+WnZ7eg+eeu5uZ/Z3vB37sObMT+H2ye/bOzs7Mxvhk2v1JSEuDRpsk/CnphgD7G709xri7UOpirZRurSsssEeib2F3oNdm5SH7vID1Uu6h7Xl4B/hy6fxndBvviW16je5Ndd8ATiud/wxejcepWAOrOVbfSOVnAVtK5z+DV9P7FdJ2AzZOeVeq+3fg1NL5z+C1mLYbsYk5h7Jj1nidUTr/Gd0WVqh7Mm3v5QOlc5/Ra112Hv4o7T9IOxFub83H7PPOxbG6RwP3Z15bSuf/OW5fxNZhzyf/7gG+lPZfAuxO+z6hfZqzr/JjtpLXq43XCvV/kuq9PamOYjhRPAFFBLvzbBpVn2F31tdl+xeyz+uAP2Y/wtobyqtx20F7I/DXmi8wU3g1DcsrU2Prsub4lc59jV754/wdWO/5CJtYVe0jxim81qft0VjP+S+wZQ3vo+IbtindFsY/YxMZ91PxEKdpz0XsJucPqfGyD5uceXrp/Ds6XluBh1Ld14AzS+c/hdsrKd/HseVOD6W4Mqu3GXvC8Uy6hjw2gGO2ktfB3Cur/23azqxq/44pVnEOlE5g3iP9cf55+mH9DmskjvIL6NjF80hs0sfe2n+EM7gtYest/wrYWjr/LrywMecnNmVUvGzQDMdrAzYu+xYqHqc8rdf4sSGNRSydf5fHLPt3F1H3U4Bpj9lCVv9ibOz8CaXy7vp4YZ0j3wRup/4e5Y3Y0pgj4O5UtpQ8R8CtuV9yOy7F+hI5d+T1f8tKYk8OHsDe6FfcQdHBeVA6AUUEeBh4On3eOXYBvT6rtz1tNwAnlc67Y7fltF0Eji2dd4de55bOtSev89N2gbEJmzXGKry2lc61R7fzSufak9dy6Vx78mqu94FhTAQ+E/gz8OxY+Y3Jb2dWVu2N2hq9tmTHrPrromIV50HpBOY5+N9H2l9I2yOwnrpmOMIHwLdoxz/dUDrvHt2+Wzrvjr3uSd+vL513T8frO6Xz7smr+uPl2U1ew/qNZU5LqQG5I31vVnS6I7lck77fha2ms710zj15LZfOWdHDeVA6gXkM2vGRG8fKF7PPt2KTB5oL6AibvFL7GGWXbvKSVy3h1U1ew/Iaczuu+Q4sjdVpJmxfRLvU6XvUPZnPpZdiDedE6QTmLbAJG49gkwR2Y2uFbsv252s13gT8m3YyX+2TO1y6yUtetYRXN3kNy2uC221kw85oV5l5hHaMdvUT0716KdZ4XpROYJ4CW3rmH7S9BiPgY2x1i6tXqH9v9iOsfTKfSzd5yauW8Oomr2F5TeF2VVZvEVuOcZTiAHWvwOLSS9HBuVE6gXkJ4Hhsl0DMgQAAA4tJREFUSaMR9naf82ln2H6KvXHqiqx+87amtwZw4XTpJi951RJe3eQ1LK9VuF2e1f8NA+h59eql6Oj8KJ3AvAT2pqzXsbfRbcrKm96Ej7El007J9v0U+Erp3OfVTV7yqiW8uslrWF6rdNuEjfW9DXuTYtUNSq9eio7Oj9IJzEsAX8PuTt8Fvj6270Haxz6DmCE8D27yklct4dVNXsPyWqXbcio7Bji+dN7z6qXoJhYQvRJCCOnjc8DvsQXOd4UQzmjqxBi/BzyF3a2eM/bvqsWrm7zkVQte3eQ1LC+Yye3sVPZBjPE/hzndqfHqJbrliNIJeCWEsAn4PnBOCGEP8GvgUey1mZuBJ0IIF8cYX0j/ZIS9+vRvADHarWuNeHWTl7xqwaubvIblBWtye61EvtPi1Uv0ROmubY8BnA68TDtTdoS9onobcD+wL5W9iS1k/rP0/SUqfm2wZzd5yauW8Oomr2F5eXbz6qXo8ZwpnYC3wO5K/5J+WE8Bv81+jJcCpwB3Z3WaeJ3619V06SYvedUSXt3kNSwvz25evRQ9nzelE/AUwLG0d6A/TmXHALtS2Q+yel/FZj8/CNwObC6d/zy6yUtetYRXN3kNy8uzm1cvRf+hMcvdchRwIfB0jPFmsEkAIYR/pv2Lqey9EMKBGOPOQnnOglc3ecmrFry6yWtYXuDXzauX6BmthtEhMcY3gcuBxwBCCBvSrvVp+69UfhfwyxDCpel79TOhvbrJS1614NVNXsPyAr9uXr1E/6hnuWNijH8KITyfPn+UipeAQ8D+EMLNwA+BD4GmXrUzoXO8uslLXrXg1U1ew/ICv25evUS/qLHcAzHGQwAhhIUY4wg4ATgSe+PPMvZ6zAtijHvLZTkbXt3kJa9a8Oomr2F5gV83r16iPzQMo19iCGEdsBX7v17G3g50QYzxxaKZrR2vbvIaFl69wK+bvIaHVzevXqJj1FjukWh8Bryfig4A53n4EXp1k9ew8OoFft3kNTy8unn1Et2jxvLh4U5gP7A9xvhS6WQ6xqubvIaFVy/w6yav4eHVzauX6IigceuHhxDCUTHGg6Xz6AOvbvIaFl69wK+bvIaHVzevXqIb1FgWQgghhBBiAhqGIYQQQgghxATUWBZCCCGEEGICaiwLIYQQQggxATWWhRBCCCGEmIAay0IIIYQQQkxAjWUhhBBCCCEmoMayEEIIIYQQE/gvoQop6r0RM8sAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Tokenize"
      ],
      "metadata": {
        "id": "csv_PV5kUi4R"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HaMewizibi7j"
      },
      "outputs": [],
      "source": [
        "Params = {}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pUFUMGsMiLmt"
      },
      "outputs": [],
      "source": [
        "Params['remove_stop_words'] = True\n",
        "Params['remove_alphanumeric'] = True\n",
        "Params['remove_punctuation'] = True\n",
        "Params['remove_shortword_size'] = 3\n",
        "Params['remove_propernouns'] = True\n",
        "Params['keep_case_names'] = False\n",
        "\n",
        "Params['clean_all'] = True\n",
        "Params['remove_shortword_size'] = 3\n",
        "\n",
        "Params['use_lowercase'] = True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LkiSq11eoXag"
      },
      "outputs": [],
      "source": [
        "if Params['remove_propernouns'] or Params['clean_all']:\n",
        "    def f(x):\n",
        "        if 'v.' not in x:\n",
        "            return 'NO_PARTY'\n",
        "        else:\n",
        "            y = x.split('v.')\n",
        "            petitioner = y[0].split()[0].strip().replace(',', '')\n",
        "            patentowner = y[1].split()[0].strip().replace(',', '')\n",
        "            return [petitioner, patentowner]\n",
        "\n",
        "parties_first = casedf['name'].apply(f).values\n",
        "CASENAMES = set(itertools.chain.from_iterable(parties_first))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6eR0nIlGtQvs"
      },
      "outputs": [],
      "source": [
        "docs = ptdf[DOCTYPE].values\n",
        "partyname_list = ptdf['party_names'].tolist()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_7WJ3Cqxbb5j"
      },
      "outputs": [],
      "source": [
        "if Params['clean_all']:\n",
        "    remove_shortword_size = Params['remove_shortword_size']\n",
        "    def process_docs(x):\n",
        "        doc = x\n",
        "        t = nltk.tokenize.word_tokenize(doc)\n",
        "        PUNCT = string.punctuation + u\"‘’´“”–-\"\n",
        "        propernouns = set([a for a,b in nltk.tag.pos_tag(t) if b=='NNP'])\n",
        "        shortwords = set([tt for tt in t if len(tt) <= remove_shortword_size])\n",
        "        reject_list = set(PUNCT)|propernouns|STOPWORDS|shortwords\n",
        "\n",
        "        proct = [tt for tt in t if tt.isalpha() and tt not in reject_list]\n",
        "        return proct\n",
        "\n",
        "else:\n",
        "    remove_punct = Params['remove_punctuation']\n",
        "    remove_stopwords = Params['remove_stop_words']\n",
        "    remove_alphanumeric = Params['remove_alphanumeric']\n",
        "    # set to False or None if not used otherwise remove this length or less\n",
        "    remove_shortword_size = Params['remove_shortword_size']\n",
        "    remove_proper = Params['remove_propernouns']\n",
        "\n",
        "    def process_docs(x):\n",
        "        doc, partynames = x\n",
        "        t = nltk.tokenize.word_tokenize(doc)\n",
        "        PUNCT = string.punctuation + u\"‘’´“”–-\"\n",
        "        if remove_punct:\n",
        "            proct = [tt for tt in t if tt not in set(PUNCT)]\n",
        "        if remove_stopwords:\n",
        "            proct = [tt for tt in proct if tt not in STOPWORDS]\n",
        "        if remove_alphanumeric:\n",
        "            proct = [tt for tt in proct if tt.isalpha()]\n",
        "        if remove_shortword_size:\n",
        "            proct = [tt for tt in proct if len(tt) > remove_shortword_size]\n",
        "        propernouns = set([a for a,b in nltk.tag.pos_tag(proct) if b=='NNP'])\n",
        "        if Params['keep_case_names']:\n",
        "            propernouns = propernouns - (CASENAMES - set(partynames))\n",
        "        if remove_proper:\n",
        "            proct = [tt for tt in proct if tt not in propernouns]\n",
        "        return proct\n",
        "\n",
        "if Params['clean_all']:\n",
        "    tokdocs = ptdf[DOCTYPE].apply(process_docs)\n",
        "else:\n",
        "    tokdocs = [process_docs([docs[ind], partyname_list[ind]]) for ind in tqdm(ptdf.index)]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7dmQLyRM1hd"
      },
      "source": [
        "##Missing words in pre-trained embeddings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lYh-xEb9ehz1"
      },
      "outputs": [],
      "source": [
        "with open(FILELOC + 'Tokenized_Responses_noproper_20220131.pkl', 'rb') as f:\n",
        "    _, t1 = pickle.load(f)\n",
        "with open(FILELOC + 'Tokenized_Decisions_noproper_20220131.pkl', 'rb') as f:\n",
        "    _, t2 = pickle.load(f)\n",
        "with open(FILELOC + 'Tokenized_Petitions_noproper_20220131.pkl', 'rb') as f:\n",
        "    _, t3 = pickle.load(f)\n",
        "\n",
        "t1 = [t for t in t1]\n",
        "t2 = [t for t in t2]\n",
        "t3 = [t for t in t3]\n",
        "\n",
        "tokdocs = t1 + t2 + t3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Na9ZyOf3mkf1"
      },
      "outputs": [],
      "source": [
        "wordcount = Counter(itertools.chain.from_iterable([[t.lower() for t in doc] for doc in tokdocs]))\n",
        "vocabsize = len(wordcount)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 66,
          "referenced_widgets": [
            "e25001286f6a472f9eeb81781bf096f4",
            "f6424274b9d34ac6a53c73f4a817dab1",
            "2c6b85e1b64e42e9ad63f1f1e07fe62a",
            "c02a86138788487bad802b41687d1cc4",
            "feec8e5c4f2c4b4291d79c5914789a35",
            "2a0eba30a22f4378aafec0be7ce3810c",
            "add4245050924296b45c05f1da684446",
            "afd6311ea23b403ebc36aafc243ceda1",
            "0156ba14f4f44fc884c622344cd5a943",
            "83a8e24763764e22ace8482ff5f582a0",
            "8d8a1e80d5d74866b80a7b995dc36c3b"
          ]
        },
        "id": "SiI6wu4_C5-P",
        "outputId": "2a00267e-c6dc-40dd-f71c-84dba4a54631"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "e25001286f6a472f9eeb81781bf096f4",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "0it [00:00, ?it/s]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 400000 word vectors.\n"
          ]
        }
      ],
      "source": [
        "embedding_dim = 200\n",
        "PRETRAINED_EMBEDDINGS_FILE = FILELOC + f\"glove.6B.{embedding_dim}d.txt\"\n",
        "# embedding_dim = 200\n",
        "# PRETRAINED_EMBEDDINGS_FILE = FILELOC + f\"Law2Vec.{embedding_dim}d.txt\"\n",
        "\n",
        "embedindex = {}\n",
        "with open(PRETRAINED_EMBEDDINGS_FILE) as f:\n",
        "    for line in tqdm(f):\n",
        "        word, coefs = line.split(maxsplit=1)\n",
        "        coefs = np.fromstring(coefs, \"f\", sep=\" \")\n",
        "        embedindex[word] = coefs\n",
        "\n",
        "print(\"Found %s word vectors.\" % len(embedindex))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GtNqwafscmeQ",
        "outputId": "3a0c596b-3a2b-4693-dec4-897bc0736e75"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Converted 40479 words (119248 misses)\n"
          ]
        }
      ],
      "source": [
        "hits = 0; misses = 0\n",
        "# Prepare embedding matrix\n",
        "for word in wordcount.keys():\n",
        "    embedding_vector = embedindex.get(word)\n",
        "    if embedding_vector is not None:\n",
        "        # Words not found in embedding index will be all-zeros.\n",
        "        # This includes the representation for \"padding\" and \"OOV\"\n",
        "        hits += 1\n",
        "    else:\n",
        "        misses += 1\n",
        "print(\"Converted %d words (%d misses)\" % (hits, misses))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "60bSujwLDnhd"
      },
      "outputs": [],
      "source": [
        "missingwords = list(set(wordcount.keys()) - set(embedindex.keys()))\n",
        "df = pd.DataFrame.from_dict({'words':[m for m in missingwords],'count':[wordcount[m] for m in missingwords]})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "20qaC2xOnY30"
      },
      "outputs": [],
      "source": [
        "# Converted 24723 words (27096 misses)\n",
        "law2vec_missing_df = df.copy()\n",
        "law2vec_missing_df.sort_values(by='count', ascending=False).head(50)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V4vGFUXsnSJO"
      },
      "outputs": [],
      "source": [
        "# Converted 29951 words (21868 misses)\n",
        "glove_missing_df = df.copy()\n",
        "glove_missing_df.sort_values(by='count', ascending=False).head(50)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s_fdzeRaPFh3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "211653ae-b3c1-4081-b648-7a14ec3e3a76"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9079\n",
            "8985\n"
          ]
        }
      ],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Oh33URDEUto3"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1O5NNIHB5GCp"
      },
      "source": [
        "#XGBoost"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ySPIrSCX3YzA"
      },
      "source": [
        "##Data Preparation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VU6Ium3c4YKX"
      },
      "outputs": [],
      "source": [
        "# take a list of tokenized documents (i.e. list of lists) and derive an integer\n",
        "# mapping dictionary (0 = not used, 1 = out of vocabular, 2+ are tokens) for the\n",
        "# all (if num_words=None) or num_words most common words\n",
        "# It will generate a 2D array of truncated / padded document vectors (vec_len)\n",
        "# If lowercase set to True then converts all tokens to lowercase\n",
        "# Out of vocabulary string is \"oov_str\" (default '<OOV>')\n",
        "\n",
        "class Token2Int(BaseEstimator,TransformerMixin):\n",
        "    def __init__(self, vec_len, num_words=None, oov_str='<OOV>', lowercase=True):\n",
        "        self.vec_len = vec_len\n",
        "        self.num_words = num_words\n",
        "        self.oov_str = oov_str\n",
        "        self.lowercase = lowercase\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        if type(X[0]) is not list:\n",
        "            X = [X] # only a single document was passed\n",
        "        if self.lowercase:\n",
        "            X = [[d.lower() for d in doc] for doc in X]\n",
        "        wc = Counter(itertools.chain.from_iterable(X))\n",
        "        self.word_count = wc\n",
        "        vocab = [w for w,c in wc.most_common(self.num_words)]\n",
        "        vocab.insert(0, self.oov_str)       # assign 1 to OOV\n",
        "        self.vocab = vocab\n",
        "        self.vocab_size = len(vocab)\n",
        "        wordmap = {n:m+1 for m,n in enumerate(vocab)}\n",
        "        self.word_index = wordmap\n",
        "        self.index_word = {n:m for m,n in wordmap.items()}\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        if type(X[0]) is not list:\n",
        "            X = [X] # only a single document was passed\n",
        "        # X = np.array(list(itertools.zip_longest(*X, fillvalue=0))).T\n",
        "        if self.lowercase:\n",
        "            # X = np.vectorize(str.lower)(X)\n",
        "            X = [[d.lower() for d in doc] for doc in X]\n",
        "        wordmap = self.word_index\n",
        "        vocab = self.vocab\n",
        "        veclen = self.vec_len\n",
        "        numdocs = len(X)\n",
        "        # wordmap['0'] = 0\n",
        "        # # textpad = np.array([t[:veclen] if len(t) >= veclen else t + ['0']*(veclen-len(t)) for t in X]).astype(str)\n",
        "        # X = [[wordmap.get(x, 1) for x in t] for t in X]\n",
        "        # return pad_sequences(X, maxlen=veclen, padding='post', truncating='post')\n",
        "        textpad = np.zeros((numdocs, veclen))\n",
        "        for d in tqdm(range(numdocs)):\n",
        "            doc = X[d]\n",
        "            doclen = min(len(doc), veclen)\n",
        "            textpad[d,:doclen] = [wordmap.get(word, 1) for word in doc[:doclen]]\n",
        "            # textpad[d,:doclen] = [wordmap[word] if word in vocab else 1 for word in doc[:doclen]]\n",
        "        return textpad\n",
        "\n",
        "    def reverse(self, textpad):\n",
        "        texts = []\n",
        "        for row in textpad:\n",
        "            int2text = ['' if w==0 else self.index_word[w] for w in row]\n",
        "            texts.append(' '.join(int2text).strip())\n",
        "        return texts"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UxxwuzHA3Yon"
      },
      "outputs": [],
      "source": [
        "with open(FILELOC + 'Tokenized_Responses_noproper_20220131.pkl', 'rb') as f:\n",
        "    ptdf, tokdocs = pickle.load(f)\n",
        "\n",
        "# with open(FILELOC + 'Tokenized_Decisions_noproper_20220131.pkl', 'rb') as f:\n",
        "#     ptdf, tokdocs = pickle.load(f)\n",
        "\n",
        "# with open(FILELOC + 'Tokenized_Petitions_noproper_20220131.pkl', 'rb') as f:\n",
        "#     ptdf, tokdocs = pickle.load(f)\n",
        "\n",
        "# with open(FILELOC + 'Tokenized_Responses_20220212.pkl', 'rb') as f:\n",
        "#     ptdf, tokdocs = pickle.load(f)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j0mgqy-c5-kP",
        "outputId": "73927061-1523-44f2-a628-b112dd4ff572"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9283\n",
            "7843\n"
          ]
        }
      ],
      "source": [
        "map_outcome2unpat = {'Denied': 0,\n",
        "                     'Denied on Rehearing': -1,\n",
        "                    #  'Mixed': 0,\n",
        "                     'Mixed': -1,\n",
        "                     'Granted': 1,\n",
        "                     'Granted on Rehearing': -1,\n",
        "                     'Indefinite': -1,\n",
        "                     }\n",
        "ptdf['Unpatentable'] = ptdf['Decision'].map(map_outcome2unpat)\n",
        "\n",
        "selind = ptdf[ptdf['Unpatentable'] != -1].index\n",
        "\n",
        "print(len(ptdf))\n",
        "ptdf.drop(ptdf[ptdf['Unpatentable'] == -1].index, inplace=True)\n",
        "print(len(ptdf))\n",
        "ptdf.reset_index(inplace=True)\n",
        "tokdocs = [tokdocs[ind] for ind in range(len(tokdocs)) if ind in selind]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "STcP1HIJ6GPL"
      },
      "outputs": [],
      "source": [
        "# trainindex = ptdf[ptdf.date.between(pd.Timestamp(2018,7,1), pd.Timestamp(2020,11,30))].index\n",
        "# testindex = ptdf[ptdf.date.between(pd.Timestamp(2020,12,1),pd.Timestamp(2021,3,31))].index\n",
        "\n",
        "trainindex = ptdf[ptdf.date < pd.Timestamp(2017,12,31)].index\n",
        "testindex = ptdf[ptdf.date > pd.Timestamp(2019,1,1)].index\n",
        "\n",
        "print(len(trainindex), len(testindex))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ytrain = ptdf.loc[trainindex, 'Unpatentable'].values\n",
        "ytest = ptdf.loc[testindex, 'Unpatentable'].values"
      ],
      "metadata": {
        "id": "FMTI0cnZLYef"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Params = {}\n",
        "Params['num_words_to_use'] = 20000\n",
        "Params['text_length'] = 8000\n",
        "\n",
        "trainindex = ptdf[ptdf.date.between(pd.Timestamp(2018,7,1), pd.Timestamp(2020,11,30))].index\n",
        "testindex = ptdf[ptdf.date >= pd.Timestamp(2020,12,1)].index\n",
        "\n",
        "ytrain = ptdf.loc[trainindex, 'Unpatentable'].values\n",
        "ytest = ptdf.loc[testindex, 'Unpatentable'].values\n",
        "\n",
        "tdocs = [t if len(t) < Params['text_length'] else t[:Params['text_length']] for t in tokdocs]\n",
        "tdocs = [[t.lower() for t in doc] for doc in tdocs]\n",
        "\n",
        "toktrain = [tdocs[ind] for ind in range(len(tdocs)) if ind in trainindex]\n",
        "toktest = [tdocs[ind] for ind in range(len(tdocs)) if ind in testindex]"
      ],
      "metadata": {
        "id": "10kXEym3HSiS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Params = {}\n",
        "# Params['num_words_to_use'] = None\n",
        "# Params['text_length'] = 4000\n",
        "\n",
        "# trainindex = ptdf[ptdf.date.between(pd.Timestamp(2018,7,1), pd.Timestamp(2020,11,30))].index\n",
        "# testindex = ptdf[ptdf.date >= pd.Timestamp(2020,12,1)].index\n",
        "\n",
        "# ytrain = ptdf.loc[trainindex, 'Unpatentable'].values\n",
        "# ytest = ptdf.loc[testindex, 'Unpatentable'].values\n",
        "\n",
        "# tdocs = [t if len(t) < Params['text_length'] else t[:Params['text_length']] for t in tokdocs]\n",
        "# tdocs = [[t.lower() for t in doc] for doc in tdocs]\n",
        "\n",
        "# toktrain = [tdocs[ind] for ind in range(len(tdocs)) if ind in trainindex]\n",
        "# toktest = [tdocs[ind] for ind in range(len(tdocs)) if ind in testindex]"
      ],
      "metadata": {
        "id": "g3Ba4ja8k63p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uDabtFQy3WZp"
      },
      "source": [
        "##Model Fitting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kFokRMfE5V7-"
      },
      "outputs": [],
      "source": [
        "def set_model(random_state=2856):\n",
        "    return xgb.XGBClassifier(\n",
        "        objective= \"binary:logistic\",\n",
        "\n",
        "        booster='dart',  # rate_drop, skip_drop', and 'sample_type' are for dart booster\n",
        "        rate_drop= 0.1, # 0.1,\n",
        "        skip_drop= 0.5, # 0.5,\n",
        "        sample_type='weighted',\n",
        "\n",
        "        random_state=random_state,\n",
        "        subsample=0.8,          # typically 0.5-1, lower values = more conservative\n",
        "        reg_lambda=2.0,         # L2 regularization, default 1 (reg_alpha default 0 is L1)\n",
        "        max_depth=15,           # 8\n",
        "        learning_rate=0.1,   # 0.001\n",
        "        gamma=0,                # makes model more conservative\n",
        "        colsample_bytree=0.8,   # typically 0.5-1, fraction of columns to be randomly sampled / tree\n",
        "        n_jobs=-1,\n",
        "        eval_metric = 'auc',\n",
        "        # predictor = \"cpu_predictor\",\n",
        "        predictor = \"gpu_predictor\",\n",
        "        n_estimators = 1200,\n",
        "        )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lMxwBxUiFXDZ"
      },
      "outputs": [],
      "source": [
        "def dummy_fun(doc):\n",
        "    return doc\n",
        "def return_tfidf(max_features, vocabulary=None):\n",
        "    tfidf = TfidfVectorizer(analyzer='word', tokenizer=dummy_fun, preprocessor=dummy_fun,\n",
        "                            token_pattern=None, max_features=max_features, vocabulary=vocabulary)  \n",
        "    return tfidf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3d6aCY9xAk_I"
      },
      "outputs": [],
      "source": [
        "vectorizer = return_tfidf(max_features=Params['num_words_to_use'])\n",
        "\n",
        "vectorizer.fit(toktrain)\n",
        "xtrain = vectorizer.transform(toktrain)\n",
        "xtest = vectorizer.transform(toktest)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eCoVPE4nAk8F",
        "outputId": "ec07dcec-34f5-4d72-9313-a983017106cf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1.0693121693121692, 0.9391263940520446]\n"
          ]
        }
      ],
      "source": [
        "class_weights = list(class_weight.compute_class_weight(class_weight='balanced',\n",
        "                                                    classes=np.unique(ytrain), y=ytrain))\n",
        "sample_weights = np.array([class_weights[y] for y in ytrain])\n",
        "print(class_weights)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cKpI0KcBJkSr"
      },
      "source": [
        "###Responses - Outcomes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w0xcDlxfIkrn"
      },
      "outputs": [],
      "source": [
        "vectorizer = return_tfidf(max_features=Params['num_words_to_use'])\n",
        "vectorizer.fit(toktrain)\n",
        "xtrain = vectorizer.transform(toktrain)\n",
        "xtest = vectorizer.transform(toktest)\n",
        "\n",
        "class_weights = list(class_weight.compute_class_weight(class_weight='balanced',\n",
        "                                                    classes=np.unique(ytrain), y=ytrain))\n",
        "sample_weights = np.array([class_weights[y] for y in ytrain])\n",
        "print(class_weights)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "RANDSTATE_LIST = [10666, 559, 1024, 6, 39842]\n",
        "results_test = {}; results_val = {}; results_paper = {}\n",
        "results_cleantest = {}; results_cleanval = {}; results_cleanpaper = {}\n",
        "\n",
        "for RANDSTATE in RANDSTATE_LIST:\n",
        "    print(\"training...\")\n",
        "    model_tfidf = set_model(RANDSTATE)\n",
        "    model_tfidf.fit(xtrain, ytrain,\n",
        "                    sample_weight=sample_weights,\n",
        "                    verbose=False,\n",
        "                    )\n",
        "    pred_train = model_tfidf.predict(xtrain)\n",
        "    pred_test = model_tfidf.predict(xtest)\n",
        "\n",
        "    print(confusion_matrix(ytest,np.round(pred_test)))"
      ],
      "metadata": {
        "id": "o2-AgstVErZM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_tfidf_booster = model_tfidf.get_booster()\n",
        "\n",
        "feature_names = vectorizer.get_feature_names_out()\n",
        "\n",
        "fs_dict = model_tfidf_booster.get_fscore()\n",
        "fsdf = pd.DataFrame.from_dict({'feature':fs_dict.keys(),\n",
        "                               'score':fs_dict.values()}).sort_values(by='score', ascending=False)\n",
        "def f(x):\n",
        "    feature_id = int(x[1:])\n",
        "    return feature_names[feature_id]\n",
        "\n",
        "fsdf['feature_name'] = fsdf.feature.apply(f)"
      ],
      "metadata": {
        "id": "yIFdT1-kkV0i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "shap_pred_raw = model_tfidf_booster.predict(xgb.DMatrix(xtest, ytest), pred_contribs=True)\n",
        "shap_pred = shap_pred_raw[:,:-1]\n",
        "shap.summary_plot(shap_pred, xtest, feature_names=feature_names)"
      ],
      "metadata": {
        "id": "VQYhw5NYExQq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 585
        },
        "outputId": "a45c93a9-e2f8-4110-c5cd-876bf1ce7d9b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x684 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-4nryQZTJr-0"
      },
      "source": [
        "###Decisions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d5ANtstDZuFW"
      },
      "outputs": [],
      "source": [
        "RANDSTATE_LIST = [10935, 432, 978]\n",
        "\n",
        "for RANDSTATE in RANDSTATE_LIST:\n",
        "    print(\"training...\")\n",
        "    model_tfidf = set_model(RANDSTATE)\n",
        "    model_tfidf.fit(xtrain, ytrain,\n",
        "                    sample_weight=sample_weights,\n",
        "                    verbose=False,\n",
        "                    )\n",
        "    pred_test_cont = model_tfidf.predict(xtest)\n",
        "    pred_test = np.round(pred_test_cont)\n",
        "    print(\"Classification Report: \"); print(classification_report(np.array(ytest), pred_test))\n",
        "    print(confusion_matrix(ytest,pred_test))\n",
        "    "
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "machine_shape": "hm",
      "name": "PTAB_xgboost_github.ipynb",
      "provenance": [],
      "toc_visible": true,
      "mount_file_id": "1fElvudNKO69ttwo8qNl20HLGxLqUZr3w",
      "authorship_tag": "ABX9TyOG/jvmCFI+MWmp9koFMFFW",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "e25001286f6a472f9eeb81781bf096f4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "HBoxView",
            "_dom_classes": [],
            "_model_name": "HBoxModel",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_f6424274b9d34ac6a53c73f4a817dab1",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_2c6b85e1b64e42e9ad63f1f1e07fe62a",
              "IPY_MODEL_c02a86138788487bad802b41687d1cc4",
              "IPY_MODEL_feec8e5c4f2c4b4291d79c5914789a35"
            ]
          }
        },
        "f6424274b9d34ac6a53c73f4a817dab1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "2c6b85e1b64e42e9ad63f1f1e07fe62a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_2a0eba30a22f4378aafec0be7ce3810c",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": "",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_add4245050924296b45c05f1da684446"
          }
        },
        "c02a86138788487bad802b41687d1cc4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_afd6311ea23b403ebc36aafc243ceda1",
            "_dom_classes": [],
            "description": "",
            "_model_name": "FloatProgressModel",
            "bar_style": "success",
            "max": 1,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 1,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_0156ba14f4f44fc884c622344cd5a943"
          }
        },
        "feec8e5c4f2c4b4291d79c5914789a35": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_83a8e24763764e22ace8482ff5f582a0",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 400000/? [00:15&lt;00:00, 28509.58it/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_8d8a1e80d5d74866b80a7b995dc36c3b"
          }
        },
        "2a0eba30a22f4378aafec0be7ce3810c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "add4245050924296b45c05f1da684446": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "afd6311ea23b403ebc36aafc243ceda1": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "bar_color": null,
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "0156ba14f4f44fc884c622344cd5a943": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": "20px",
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "83a8e24763764e22ace8482ff5f582a0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "8d8a1e80d5d74866b80a7b995dc36c3b": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}