Wine_Variety_MCC.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Wine_Variety_MCC",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyMFUlkT5yu86zyFZiGdfhUQ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/abdulkk49/Multi-Class-Text-Classification-Wines-NLP/blob/master/Wine_Variety_MCC.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U2Gw1SJXWYwF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pt5rTenbWjYm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "cd /content/drive/My Drive"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O0bSrPaiZYNE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np \n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.style as style\n",
        "import seaborn as sns\n",
        "import sklearn.model_selection as sk\n",
        "import plotly.express as px\n",
        "import re\n",
        "import os\n",
        "import nltk\n",
        "nltk.download('stopwords')\n",
        "from nltk.corpus import stopwords"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sbin0CU8WzGN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Initialize, load data paths, setup and check\n",
        "sw =set(stopwords.words('english'))\n",
        "print(\"Input files:\")\n",
        "for dirname, _, filenames in os.walk('./KnightData'):\n",
        "    for filename in filenames:\n",
        "        print(os.path.join(dirname, filename))\n",
        "\n",
        "from tensorflow.compat.v1 import ConfigProto\n",
        "from tensorflow.compat.v1 import InteractiveSession\n",
        "config = ConfigProto()\n",
        "config.gpu_options.allow_growth = True\n",
        "session = InteractiveSession(config=config)\n",
        "\n",
        "print()\n",
        "print(\"TF Version: \", tf.__version__)\n",
        "print(\"Eager mode: \", tf.executing_eagerly())\n",
        "print(\"GPU is\", \"available\" if tf.config.experimental.list_physical_devices(\"GPU\") else \"NOT AVAILABLE\")\n",
        "\n",
        "if tf.test.gpu_device_name():\n",
        "    print('GPU found')\n",
        "else:\n",
        "    print(\"No GPU found\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmJlS1_vYnSB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Load train and test data\n",
        "path_to_train = './KnightData/train.csv'\n",
        "path_to_test = './KnightData/test.csv'\n",
        "winesdf = pd.read_csv(path_to_train)\n",
        "winesdf_test = pd.read_csv(path_to_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vhxh6SdB68le",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Checking data and properties \n",
        "print(winesdf.head())\n",
        "print(\"=\"*30)\n",
        "print(winesdf.info())\n",
        "print(\"=\"*30)\n",
        "print(winesdf.shape)\n",
        "print(\"=\"*30)\n",
        "print(winesdf.columns)\n",
        "print(\"=\"*30)\n",
        "winesdf.describe()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZNt29LnB_v1i",
        "colab_type": "code",
        "outputId": "71532c74-86b3-4bf6-f636-011b71ddf7be",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "#===============Actionable insights===================\n",
        "# Extracting feature : vintage\n",
        "years = []    \n",
        "for value in winesdf['review_title']:\n",
        "    regresult = re.search(r'19\\d{2}|20\\d{2}', value)\n",
        "    if regresult:\n",
        "        years.append(regresult.group())\n",
        "    else: years.append(None)\n",
        "\n",
        "winesdf['year'] = years\n",
        "print(\"We extracted %d years from the wine titles and %d did not have a year.\" %(len(winesdf[winesdf['year'].notna()]), len(winesdf[winesdf['year'].isna()].index)))\n",
        "winesdf['year'].describe()\n",
        "\n",
        "# Removing entries having no year value\n",
        "winesdf_year = winesdf\n",
        "winesdf_year = winesdf_year.dropna(subset=['year'])\n",
        "print('Removed ' + str(winesdf.shape[0]-winesdf_year.shape[0]) + ' rows with empty year values.' + \"\\n\")\n",
        "winesdf_year['year'] = winesdf_year['year'].astype(int)\n",
        "winesdf_year['year'].describe()\n",
        "\n",
        "#year insights\n",
        "dfWineYear = winesdf_year.groupby(['year']).mean()\n",
        "print(dfWineYear)\n",
        "dfWineYear = pd.DataFrame(data=dfWineYear).reset_index()\n",
        "style.use(\"dark_background\")\n",
        "plt.figure(figsize=(14,10))\n",
        "ax = sns.barplot(y=dfWineYear['points'], x=dfWineYear['year'])\n",
        "plt.title(\"Average Points vs. Year\", fontsize=14)\n",
        "plt.xlabel(\"\")\n",
        "ax.set(\n",
        "    xlim=(0, len(dfWineYear)), \n",
        "    ylim=(85, 100)\n",
        ")\n",
        "ax.set_xticklabels(\n",
        "    ax.get_xticklabels(), \n",
        "    rotation=45, \n",
        "    horizontalalignment='right',\n",
        "    fontweight='light',\n",
        "    fontsize='medium'\n",
        ")\n",
        "plt.show()\n",
        "\n",
        "#Wineyards distribution\n",
        "wine_yards = winesdf[[\"winery\", \"points\", \"price\"]].groupby(\"winery\").mean()\n",
        "points = wine_yards[\"points\"]\n",
        "prices = wine_yards[\"price\"]\n",
        "plt.plot(points, prices, \"b.\")\n",
        "plt.title(\"Points and prices in wine_yards\")\n",
        "plt.xlabel(\"Points\")\n",
        "plt.ylabel(\"Prices\")\n",
        "\n",
        "# country insights\n",
        "countries = winesdf[ [\"country\", \"winery\"] ].groupby(by=\"country\").count().sort_values(by=\"winery\")[::-1]\n",
        "print(countries)\n",
        "print( \"Number of countries: \" + str(len(countries)) )\n",
        "\n",
        "# user insights\n",
        "tasters = winesdf[ [\"user_name\", \"points\"] ].groupby(by=\"user_name\").mean()[::-1]\n",
        "print(tasters)\n",
        "\n",
        "#Variety insights\n",
        "label_freq = winesdf['variety'].apply(lambda s: str(s)).explode().value_counts().sort_values(ascending=False)\n",
        "print(label_freq)\n",
        "print(type(label_freq))\n",
        "print()\n",
        "print(list(label_freq.index))\n",
        "# Bar plot\n",
        "style.use(\"dark_background\")\n",
        "plt.figure(figsize=(12,10))\n",
        "sns.barplot(y=label_freq.index.values, x=label_freq, order=label_freq.iloc[:15].index)\n",
        "plt.title(\"Wine frequency\", fontsize=14)\n",
        "plt.xlabel(\"\")\n",
        "plt.xticks(fontsize=12)\n",
        "plt.yticks(fontsize=12)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Removed 2528 rows with empty year values.\n",
            "\n",
            "         points       price\n",
            "year                       \n",
            "1904  91.000000   40.000000\n",
            "1912  89.571429         NaN\n",
            "1919  88.000000   13.000000\n",
            "1929  87.000000   25.000000\n",
            "1945  95.000000  350.000000\n",
            "1976  88.000000  101.000000\n",
            "1985  91.333333  148.666667\n",
            "1986  86.000000  170.000000\n",
            "1988  89.600000  138.000000\n",
            "1989  86.500000   53.500000\n",
            "1990  90.250000  170.250000\n",
            "1991  88.500000   88.000000\n",
            "1992  90.692308   66.545455\n",
            "1993  93.000000   65.000000\n",
            "1994  88.466667   56.466667\n",
            "1995  89.363636   53.448276\n",
            "1996  87.850000   53.102564\n",
            "1997  88.972350   43.654028\n",
            "1998  87.555838   32.303109\n",
            "1999  87.728285   31.921114\n",
            "2000  87.397260   31.160966\n",
            "2001  87.118182   26.025761\n",
            "2002  87.873950   39.677570\n",
            "2003  88.401294   49.336879\n",
            "2004  88.826579   49.093142\n",
            "2005  88.444155   43.633663\n",
            "2006  88.264804   39.387672\n",
            "2007  88.271581   39.277649\n",
            "2008  88.307360   38.421354\n",
            "2009  88.448664   40.702643\n",
            "2010  88.351235   38.711838\n",
            "2011  88.360236   38.119823\n",
            "2012  88.861258   38.938493\n",
            "2013  89.050798   38.414446\n",
            "2014  89.014229   35.432550\n",
            "2015  88.612115   26.515325\n",
            "2016  87.590004   18.358154\n",
            "2017  85.285714   11.857143\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:4: SettingWithCopyWarning:\n",
            "\n",
            "\n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA58AAAKBCAYAAADQuh8jAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzde5jVZbn4/3sOAnIaBkwl5SAGpBBYhm4cSGCroxGg4iFCd6CWKJbmb/stD5SaWXlob0+VGYYYKol5TiQOamCChgaKKQgaAx4AkfM4aM/3D3/OV0KNaj0uGV6v63qua2bNcK97GGbs3WfNmpKISAEAAAAZlRZ7AQAAABo+8QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BoIg2bdoUhx9+eLHXAIDsxCcA2fXt2zdSSjFu3Lhir1JQS5Ysibq6uti0aVNs2rQp3njjjZg1a1Yccsgh2zxj5513jsmTJ2/T+x588MHRq1evf3Xdgtpll11i5cqVcdppp231tmHDhsXatWujXbt2RdgMgI+z5DiO4zg5z/jx49PEiRPT+vXrU4sWLYq+T6HOkiVL0ujRo+tfb9KkSTrjjDNSbW1t2meffQp+f/fcc88W91fsM3LkyPT666+nT3ziE/W3tWzZMi1fvjydeeaZRd/PcRzH+didoi/gOI7jNOBTUVGRNmzYkLp165aefPLJ9PWvf73+bbfddlsaP378Fu9/yimnpJqamlRSUpJatWqVxo8fn5YtW5bWrVuX7r///tShQ4cUEalDhw4ppZROO+20tGLFivTVr341RUT6xje+kZ5//vm0bt26tHDhwjRy5Mj62aWlpemaa65J69atS0uXLk0nnnhimjdvXn3QlZSUpO9+97tp4cKFacOGDWnu3LlpwIABH/ix/X18vnvmzZuXzjnnnBQRqVGjRumKK65IL774Ytq4cWN67LHHUp8+ferfN6WUBg4cmCIizZgxI5177rlp/Pjxac2aNWnp0qXpuOOOSxGR7r///pRSSnV1demhhx5KEZHOOeectGTJkrRhw4b0wgsvpDPOOGOrXUpKStKyZcvSSSedtMXtv/71r9Mtt9ySSkpK0uWXX56WLVuW1q9fnxYsWFB/n9typk+fvsXn8JprrkmzZ89OJSUlKSLSqFGj0jPPPJM2bNiQ/vKXv2wxu3Xr1unWW29Nr7zySnrjjTfStGnTUteuXbf4+73gggvS888/n8aOHVv0f8uO4zjOv32KvoDjOI7TgM/o0aPTk08+mSIinX322Wn27Nn1bzv66KPTqlWrUllZWf1tDzzwQPrJT36SIiLdeeed6a677kqtW7dOzZs3T2PHjk2PPvpoivh/8XnHHXekli1bpohIffr0SXV1dWm//fZLEZG+9KUvpbfeeit16dIlRUQ666yz0ooVK1L37t1TixYt0qRJk9KaNWvqA/LMM89MCxcuTF26dEnl5eXpa1/7Wlq3bl2qrKx834/tg+LzmWeeSd/61rdSRKTLLrssPf3006lTp06pUaNG6cILL0yrV69OrVq1ShFbx2dNTU067LDDUnl5efrhD3+YVq5c+b7317t377Rx48bUvXv3FBHp85//fFq1alX96+89V199dbrnnnvqX99pp53SG2+8kQYPHpyGDRuWli1bltq1a5ciIh1++OFp3bp1qXXr1tv0+e3cuXPauHFj6tevX9p///3Tpk2bUo8ePVJEpCFDhqSVK1emXr16pdLS0jRw4MBUW1ubPv3pT6eISL/85S/T9OnTU7NmzVLjxo3Tr3/96zRz5swtPt4FCxakzp07F/3fseM4jlOQU/QFHMdxnAZ85s6dm84+++wUEWm33XZLmzdvrg+kJk2apLVr19ZfXWzZsmV68803U69evdInPvGJlFJK3bp1q5/VunXr9Pbbb6cuXbrUx+fgwYO3uL+KiootXl+zZk368pe/nCIiTZkyJV1zzTX1b3t3xrtB9/TTT28Vk3/+85+3uFr73vP38dm0adN0xhlnpPXr16e99torRUR6/fXX0/Dhw+vfp6ysbIud/j4+f/vb39a/b69evVJKKe26665b3d8RRxyRNm7cmDp27Fj//u9ebfz706dPn7Rx48bUtGnT+j/7+uuvp5122imddtppaenSpalNmzb/cM4HnfPPPz8tWLAgPf744+mHP/xh/e333Xdfuvzyy7d437vvvjtdeumlKeKdq8Lv7hQR6aijjkq1tbVb/P2++39EOI7jONv/8YRDAGSz//77x2c+85m45ZZbIiLi1VdfjalTp8Ypp5wSERG1tbVx3333xZFHHhkREYMGDYqlS5fG448/Hp06dYqIiCeeeKL+CX2WLVsWb7/9drRv377+Pl566aX6l8vLy2PMmDHx0ksv1f+Zli1bRuPGjSMiom3btvHiiy9u8WdfffXV+tf33nvv+MlPflL/Zzdt2hSf/vSnP/SJc/7nf/6n/n1ramrimGOOierq6liyZEm0atUqKisrY8GCBfXv//bbb8eLL74YHTt2fN95S5YsqX9548aNEfHOkxL9vWnTpsXUqVPjueeeiwcffDDOPvvsqKysfN+ZM2fOjNdff73+WXWPPvrouPPOO2Pz5s1x2223RU1NTbz00ktx1113xamnnvq+9/dhLrvsskgpRevWreOiiy6qv33vvfeOM888c4u/z8MPPzz23HPPiIj41Kc+FXfccUesWrUqamtr47bbbqv/XL3rvZ9fALZv4hOAbL72ta9FaWlpLFy4MNatWxfr1q2LAQMGxAknnBCNGjWKiIjf/OY3MWTIkIh4J4puu+22iHjnV5BERHTo0CF23nnn+tOoUaOYOnVq/X289dZb9S9/97vfjWHDhsXQoUOjadOmsfPOO8fq1avr315aWhqbN2/eYse//e1v9S9v2rQpTjzxxC3ur3HjxjFmzJgP/Bi/9a1v1b9v69ato1+/fjFr1qyIiK1C6r1SSu97+3v3+TB1dXUxePDg6NWrV/zhD3+IkSNHxrPPPvuBUTtp0qQ48sgjo7S0NAYPHhy33nprRESsXr06evfuHYceemgsWLAgvv3tb8ef//znaNmy5TbtERGxefPmmDNnTsydOzdqa2vrb9+0aVNccMEFW/19/td//VeUlJTE/fffH6tXr4599tknmjRpEscee+xWs9/7+QVg+yY+AciiadOmMWzYsBg9enTst99+9adnz55RXl5ef7XzgQceiFatWsVBBx0U1dXV9fG5ZMmSeOutt6JHjx71M0tKSj70KuQBBxwQ9957bzzxxBORUoq99tpri6uBr732WnTo0KH+9Xbt2kXbtm3rX1+0aNEW9xcRW7z/P+u1116LtWvXxj777FN/W+PGjaNjx46xaNGif3luRERZWVlUVFTEvHnz4pJLLon99tsv1qxZE0cfffT7vv9vfvOb+OIXvxj9+vWLlFJMnz49IiIaNWoUzZs3jz/+8Y9x3nnnRffu3WP33Xf/p35dzAd5v7/Pdu3aRUlJSey2227RsWPHuPrqq+O1116LiHeulAPQcIlPALI4/vjjY/PmzXHjjTfGCy+8UH/+8pe/xG233RYnn3xyRES8+eabce+998YPf/jDWLJkSTz99NMREbFu3bq45ZZb4kc/+lG0b98+GjduHBdeeGE89NBDUVr6/v/5Wrx4cfTs2TOaNm0anTt3jiuvvDJqampijz32iIiI6dOnx7Bhw6Jr167RokWL+PGPfxxr166t//M/+9nP4rTTTouqqqooLS2NQYMGxTPPPBNdunT5l/4OUkpx8803x3e+851o3759NGnSJC666KLYuHHjNv9uz/fatGlT7L333tGyZcs455xz4qGHHqqP465du0abNm0+MGofffTR2LhxY3zve9+L22+/vf4K69VXXx133HFH7LrrrhER8dnPfjYaN24cL7zwQkRETJ06Nb7yla/8Kx9+/OxnP4tjjjkmBg8eHGVlZdG7d+946qmnon///rFixYpYt25d9O7dOxo1ahRHH310HHzwwRER8clPfvJfuj8APv6K/oOnjuM4TsM7s2bNSv/7v//7vm/r1atXeuutt1L79u1TRKTBgwenlFI6//zzt3i/ioqKNH78+LR69eq0evXqNGXKlPrfn/nukwW99wmJ9txzzzRz5sy0fv36NHfu3HTAAQekCy64IG3cuDF9/etfT02aNEkTJkxIGzduTM8//3waPHhwevHFF9Npp51WP+O73/1uqqmpSRs2bEhPPvlkGjRo0Ad+jB/0bLfvPTvvvHP6xS9+kZYuXZpWrVqVJk+eXP/suxFbP+HQe5+gp1u3bimlVP/rZc4666y0YcOGNH/+/NSoUaN07bXXpldeeSVt2LAhLVq0KP2f//N/PnSXn/zkJymllKqqqrb4O54wYUJauXJlWr9+fXrmmWfSiBEj/qmPMSLSr371q3T77bdvdfuoUaPSCy+8kDZu3JieffbZLX7ly5e//OVUU1OT1qxZk26++ebUpk2b9Kc//SmtXr06tW7depvv23Ecx9k+Tsn//wIA7BAaNWoUdXV1EfHOw3jXr18fw4YNi3vuuafImwFAw+ZhtwDsME444YRYunRpdO3aNcrLy+M73/lObN68uf4JggCAfD6S+OzWrVssWrQoRo8eHRERe+65Z8yYMSMeeeSRmDhxYv0zHn7lK1+JOXPmxGOPPRYnnXTSR7EaADuQCRMmxC9/+cuYNm1avP7663H00UfHUUcdFatWrSr2agDQ4GV/2G3Tpk3jvvvui4ULF8a8efPiuuuuixtvvDF+97vfxaRJk+IHP/hBLF26NMaPHx9z586NAw44IOrq6uLxxx+PL3zhC1s8RT4AAADbp+xXPt9888344he/GMuXL6+/rV+/fvU/W3PvvffGIYccEgceeGA8/vjjsXbt2qitrY1Zs2ZFVVVV7vUAAAD4CJTnvoO333473n777S1ua9asWf2TPbz22mvRtm3b2H333WPFihX17/Pu7e/VqFGj6NWrV7z88stbzQQAAKC4ysrKom3btvH444/XN9+7ssfnP1JSUrLNt/fq1StmzpyZeyUAAAD+DX369NnqCf2KEp/r16+PJk2aRG1tbeyxxx6xfPnyWL58eey+++7177PHHnvEY489tsWfe/nllyPinQ+kpqbmI90ZAACAD7fnnnvGzJkz69vtvYoSn1OnTo2hQ4fGhAkTYujQoTF58uSYPXt2/PKXv4yKiop46623oqqqKs4666wt/ty7D7WtqamJl156qRirAwAA8A+8349JZo/Pz33uc3HllVdGx44dY/PmzXHMMcfE8OHDY9y4cXHqqafGSy+9FDfddFO89dZb8Z3vfCcefPDBSCnFRRddFGvXrs29HgAAAB+B7L9qpZA6dOgQL774YnTs2NGVTwAAgI+ZD2u27L9qBQAAAMQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADIrrwYd1pSUhI///nPo3v37lFXVxejRo2KXXfdNS699NLYvHlzbNiwIU488cR44403irEeAAAABVaU+BwyZEhUVFREVVVVdOrUKa666qrYfffdY/jw4fH888/HueeeG6eeemr8+Mc/LsZ6AAAAFFhRHnbbuXPnmDNnTkRELF68ODp06BCrV6+ONm3aREREZWVlrFy5shirAQAAkEFR4nP+/PlRXV0dpaWl0aVLl+jUqVNccsklcdddd8Vf/vKX6Nu3b4wbN64YqwEAAJBBUeJz8uTJMWfOnHjkkUfirLPOimeffTbGjBkTRx11VHz605+OmTNnxumnn16M1QAAAMigKD/zGRExZsyY+pcXLVoU7du3j0cffTQiIn7/+9/H8OHDi7UaAAAABVaUK589evSIsWPHRkREdXV1zJ07N1555ZXYZ599IiKiV69esXDhwmKsBgAAQAZFufI5f/78KC0tjdmzZ0dtbW0MHz482rVrFzfccENs3rw5Xn/99TjppJOKsRoAAAAZFCU+U0oxcuTILW6rqamJPn36FGMdAAAAMivKw24BAADYsYhPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQXVHis6SkJK6//vqYNWtWzJgxI7p27Rrl5eUxYcKEmD17dkydOjVatWpVjNUAAADIoCjxOWTIkKioqIiqqqo4+eST44orroivfe1rsWLFijjwwANj4sSJ0bdv32KsBgAAQAblxbjTzp07x5w5cyIiYvHixdGhQ4cYNGhQfO9734uIiBtuuKEYawEAAJBJUa58zp8/P6qrq6O0tDS6dOkSnTp1io4dO8YRRxwRM2bMiFtvvTUqKyuLsRoAAAAZFCU+J0+eHHPmzIlHHnkkzjrrrHj22WejpKQknnvuuejfv388/fTTce655xZjNQAAADIoysNuIyLGjBlT//KiRYti+fLl8fDDD0dExIMPPhgXXXRRsVYDAACgwIpy5bNHjx4xduzYiIiorq6OuXPnxv333x+HH354RETsv//+8dxzzxVjNQAAADIoypXP+fPnR2lpacyePTtqa2tj+PDhsWrVqrjpppvi5JNPjvXr18dXv/rVYqwGAABABkWJz5RSjBw5cqvbjzvuuCJsAwAAQG5FedgtAAAAOxbxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB25cVegOJ5+rpBBZnTffS9BZkDAAA0XK58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJBdUeKzpKQkrr/++pg1a1bMmDEjunbtWv+2ww47LFJKxVgLAACATIoSn0OGDImKioqoqqqKk08+Oa644oqIiGjcuHGce+65sXz58mKsBQAAQCZFic/OnTvHnDlzIiJi8eLF0aFDhygtLY3zzjsvrrvuuqirqyvGWgAAAGRSlPicP39+VFdXR2lpaXTp0iU6deoUn//856Nnz54xadKkYqwEAABARuXFuNPJkydHVVVVPPLIIzFv3rx49tln49JLL42vf/3rxVgHAACAzIoSnxERY8aMqX958eLF0aZNm5gwYUJERLRt2zYeeuih6NevX5G2AwAAoJCK8rDbHj16xNixYyMiorq6Op544ono1KlT9O7dO3r37h0vv/yy8AQAAGhAinLlc/78+VFaWhqzZ8+O2traGD58eDHWAAAA4CNSlPhMKcXIkSM/8O177bXXR7gNAAAAuRXlYbcAAADsWMQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmVF3sBgO3NUXdVF2zWnUc+WLBZAAAfZ658AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANltU3w2a9YsDjnkkIiIaNGiRVx88cVx0UUXRUVFRdblAAAAaBi2KT7HjRsXffr0iYiIn/70p9G9e/fYaaedYty4cTl3AwAAoIHYpt/z2aNHjzj22GNj5513jsGDB0f79u1jzZo18fTTT+feDwAAgAZgm658/u1vf4uIiOrq6njiiSdizZo1ERFRXr5N7QoAAMAObpvq8Q9/+ENMmTIl9t133/jGN74RERHnn39+LFiwIOtyAAAANAzbFJ+jRo2K6urqWLFiRTzxxBMREVFTUxPXXntt1uUAAABoGLbpYbc333xzPPDAA/XhGRFx0003xYMPPphtMQAAABqOD73y+aUvfSkGDx4chx9+eFx//fVbvK1Vq1bxqU99KutyAAAANAwfGp+zZ8+OZs2axZFHHhnLli3b4m0vvvhiXHbZZVmXAwAAoGH40PhcsWJFTJw4MZ577rl46qmnPqqdAAAAaGC26QmHmjdvHpMnT4727dtHWVnZFm/r2rVrlsUAAABoOLYpPseNGxc/+9nPYu7cufH222/n3gkAAIAGZpvi880334wrr7wy9y4AAAA0UNv0q1buuuuuGDhwYO5dAAAAaKC26cpnv3794lvf+lasXbs21qxZs8Xb/MwnAAAA/8g2xee5556bew8AAAAasA+Nz1122SVWrlwZCxcu/Kj2AQAAoAH60Ph8+OGHo1u3blFTUxMppSgpKdni7SmlKC/fpounAAAA7MA+tBy7desWEbHV7/YEAACAf8Y2X7YcNmxYHHbYYbHrrrvGq6++Gvfdd1/89re/zbkbAAAADcQ2xefll18effv2jQkTJsTq1aujTZs2cd5550X37t3j4osvzr0jAAAA27ltis8jjjgi9t9//3jzzTfrb7vhhhtizpw54hMAAIB/qHRb3qmsrGyL8IyI2LRpU5SWbtMfBwAAYAe3TVc+H3roobjnnnviF7/4Rf3Dbk855ZSYMWNG7v0AAABoALYpPs8888w466yz4oILLoiKiopYvXp1TJo0Ka699trc+wEAANAAbFN89uzZM44//vjYb7/96m8rLS2NGTNmxJNPPpltOQAAABqGbfqhzVtvvTWuu+66aN26dZSVlUWbNm1i7NixMWnSpNz7AQAA0ABsU3xu3rw5brzxxlizZk1ERLzxxhtxww03xObNm7MuBwAAQMOwTfF53333xdChQ7e4bdCgQXH33XdnWQoAAICGZZt+5vPQQw+NM888M9atW1f/bLdNmzaNl156KY488sj69+vates23WlJSUn8/Oc/j+7du0ddXV2MGjUqNmzYEL/61a9ip512is2bN8cJJ5wQr7766r/2UQEAAPCxsk3x+c1vfrOgdzpkyJCoqKiIqqqq6NSpU1x11VWxatWq+MUvfhG33357nH766XH22WfHt7/97YLeLwAAAMWxTfH5yCOPFPROO3fuHHPmzImIiMWLF0eHDh3i+OOPj9ra2oiIWLFiRXzuc58r6H0CAABQPNv0M5+FNn/+/Kiuro7S0tLo0qVLdOrUKZo3bx5/+9vforS0NEaPHh233HJLMVYDAAAgg2268llokydPjqqqqnjkkUdi3rx58eyzz0ZJSUmUlpbGzTffHNOnT4/p06cXYzUAAAAyKEp8RkSMGTOm/uVFixbFa6+9FuPGjYuFCxfGxRdfXKy1AAAAyKAoD7vt0aNHjB07NiIiqqurY+7cuTFs2LCoq6uLCy+8sBgrAQAAkFFRrnzOnz8/SktLY/bs2VFbWxvDhw+PiRMnRpMmTWLGjBkREbFgwYIYPXp0MdYDAACgwIoSnymlGDly5Ba3VVVVFWMVAAAAPgJFedgtAAAAOxbxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAsisv9gLwz5p6wxcLMueQr/2uIHMAAIB/zJVPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiE90kpUwAACAASURBVAAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJBdebEX+Ff86ZL/ib+t2/CBb9/19BM/wm0AAAD4R1z5BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsyou9AEAO/9/t1QWbdeWxDxZsFgDAjsqVTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2ZUXewHg4+3qXx9WsFnfPGFKwWYBALB9ceUTAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyK4oz3ZbUlISP//5z6N79+5RV1cXo0aNig0bNsTNN98cZWVl8fLLL8eJJ54YdXV1xVgPAACAAivKlc8hQ4ZERUVFVFVVxcknnxxXXHFFXHzxxXHdddfFF77whVi0aFGcdNJJxVgNAACADIoSn507d445c+ZERMTixYujQ4cO0a9fv7jnnnsiIuLee++NQw45pBirAQAAkEFR4nP+/PlRXV0dpaWl0aVLl+jUqVPstdde9Q+zfe2116Jt27bFWA0AAIAMivIzn5MnT46qqqp45JFHYt68efHss89Gjx496t9eUlJSjLUAAADIpCjxGRExZsyY+pcXLVoUNTU10aRJk6itrY099tgjli9fXqzVAAAAKLCiPOy2R48eMXbs2IiIqK6ujrlz58bUqVNj6NChERExdOjQmDx5cjFWAwAAIIOiXPmcP39+lJaWxuzZs6O2tjaGDx8eb731VowfPz5OPfXUeOmll+Kmm24qxmoAAABkUJT4TCnFyJEjt7r9sMMOK8I2AAAA5FaUh90CAACwYxGfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGRXXuwFYEdx642HFWTOsJOmFGQOAAB8lFz5BAAAILsd4srnaz/7acFm7Xra6QWbBQAAsKNw5RMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgux3i93wC8I4jfnthQeY8cHRh5gAAOw5XPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgu/JiLwAAADRcL1++sCBz2p7TuSBzKB7xCQAAbJde+cmTBZmz+9mfLcgcPpyH3QIAAJCdK58AfOx98Y6fFmTO74aeXpA5AMA/z5VPAAAAshOfAAAAZCc+AQAAyM7PfAIAwA5u6eUvF2ROu3PaFmQODZMrnwAAAGTnyicAwD9wzKQ/F2zWpGN6FmwWwPbElU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7PyeTwAAgL/zyv/OLNis3c/qU7BZ2zNXPgEAAMhOfAIAAJCd+AQAACA7P/MJFM2ltx5WsFnnDZtSsFkAABSeK58AAABk58onwMfI4XeeUbBZk4+6tmCzgHxOuOPFgs369dCOBZvVkE2b8FpB5vzn8F0LMgd2FK58AgAAkJ0rnwBAg3DUpFkFm3XnMVUFmwXAO1z5BAAAIDtXPgEAoEBm3/hqQeYceNJuW9224KevFGT2vqfvXpA58M9y5RMAAIDsXPkEAOBj587frCjInKOO+0RB5gD/PvEJANBAXfLb5QWbdcHRn9zi9bF3FObhpRERJw/d+iGmQMPjYbcAAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7Iryq1aaNWsW48ePj8rKymjcuHFcdNFF0bx58/jv//7vqKuri2XLlsWIESNi8+bNxVgPAACAAitKfI4YMSKee+65OO+886Jt27Yxffr0aNGiRey7776xdu3auP766+Poo4+OiRMnFmM9AAAACqwoD7tduXJltGnTJiIiKisrY+XKlfH6669Hq1atIiKiVatWsXLlymKsBgAAQAZFufI5ceLEGDFiRCxcuDAqKytj4MCB0aRJk3jyySfjjTfeiCeffDKmTZtWjNUAAADIoCjxOXz48PjrX/8aRxxxRPTo0SN+9atfRXl5efTq1SsWL14cEydOjEGDBsW9995bjPX+KS//9MKCzWp7euFmFdsffz6wIHN6j7q/IHMAAIDiKsrDbquqquLBBx+MiIh58+bFPvvsEyUlJbF48eKIiJg2bVp8/vOfL8ZqAAAAZFCU+Fy0aFEceOCBERHRvn37qKmpicrKythll10iIqJXr16xcOHCYqwGAABABkV52O31118fN954Yzz00ENRXl4ep556arRo0SLuvffeePPNN2PJkiVx2223FWM1AAAAMihKfG7YsCGOP/74rW6/5557irANAAAAuRUlPgGAHdOQ239fsFl3H3towWYBkJ/4BKAgvnjHFQWZ87uh/12QOQDAx0tRnnAIAACAHYv4BAAAIDvxCQAAQHZ+5hMAMhl4+68LMuf+Y08oyBwAKCZXPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsPNstAADAR+jVq6cUbNZu3zysYLNyE58A7NAGThpbkDn3H3NyQeYAQEPlYbcAAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAdp7tFgC2QwN/c3tB5tx/3LEFmQMA/4grnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADIrrzYCwAAHy+Dbr+3IHPuPXZQQeYA0DC48gkAAEB24hMAAIDsxCcAAADZiU8AAACy84RDH3N/vfrEgsxp/82bCzIHAADgX+HKJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACA78QkAAEB24hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAsisv9gLAv2/suEMLNuvkEb8v2CwAAHiXK58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANkVJT6bNWsWd9xxR0yfPj1mzZoVhx12WLRs2TJ+97vfxWOPPRZ33HFHNGrUqBirAQAAkEFR4nPEiBHx3HPPxYABA+KYY46Jq666Ks4///yYMmVK/Md//Ec89dRT0bNnz2KsBgAAQAblxbjTlStXRo8ePSIiorKyMlauXBmDBg2Kgw8+OCIivv/97xdjLQAAADIpSnxOnDgxRowYEQsXLozKysoYOHBgPPDAAzFq1Kg49NBDY8GCBfHNb34z6urqirEeO7B7xh5ekDmDT55ckDkAANBQFOVht8OHD4+//vWv0blz5xgwYEBce+210aRJk/j9738fX/jCF6K0tDROOeWUYqwGAABABkWJz6qqqnjwwQcjImLevHnxyU9+MmpqauKxxx6LiIgpU6ZEt27dirEaAAAAGRQlPhctWhQHHnhgRES0b98+1q9fH9OmTYt+/fpFRMT+++8fzz33XDFWAwAAIIOi/Mzn9ddfHzfeeGM89NBDUV5eHqNGjYr58+fHhAkT4uKLL45XX33Vkw4BAAA0IEWJzw0bNsTxxx+/1e3V1dVF2AYAAIDcivKwWwAAAHYs4hMAAIDsxCcAAADZiU8AAACyE58AAABkJz4BAADITnwCAACQnfgEAAAgO/EJAABAduITAACA7MQnAAAA2YlPAAAAshOfAAAAZCc+AQAAyE58AgAAkJ34BAAAIDvxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMiuvNgLAAAAUBivXntXwWbtdsaRBZsV4conAAAAHwHxCQAAQHbiEwAAgOzEJwAAANmJTwAAALITnwAAAGQnPgEAAMhOfAIAAJCd+AQAACC78mIv8M8oKyuLiIjSZk0/9P06dOiwxeulLVoUbIe/n13WoiLb7Hfm75Jt9k4tds02u3HzfLObZJy9c8bZzZrvlm1282aFmf1+81tknF2RcXZl03yzP7Fzvtm7Nm2dbfY78wvzPev9Z7fMOLsw38fff3bzjLObZZz94f8t/Pdm75xxdpOCzH6/+Z9o2jjj7J2yzd6laVm22RUZZzdvWrhrGO/3b6Vpgea/7/+WaJZvdqPm+Wbv1CLf7LKWhfm38v6zC5Mc7ze7tGWjfLNb5PueUtoi3/fC0haF+R7+frO3xZ577hkR/6/d3qskItK/u9RHpaqqKmbOnFnsNQAAAPgQffr0iVmzZm1x23YVn40aNYpevXrFyy+/HG+//Xax1wEAAOA9ysrKom3btvH4449HXV3dFm/bruITAACA7ZMnHAIAACA78bkDa9y4cD9E/VErL9+unisLPja216/7li0L82RG8HHlaxM+nnxtFlZZRFxY7CUiIvr27Rvt27ePZcuWRUqFfSTwfvvtF506dYqWLVvGihUrCjq7a9euUVZWFq1atYp169ZtN7P79u0bxx57bDz++OMF//nZbt26RdOmTWOnnXaKjRs3FnR2RMRBBx0U/fr1i6effrrg/1Zy7r7PPvtEs2bNokWLFrF27dqCzt5rr72irq4umjdvHrW1tQWdve+++0azZs2ioqIi1qxZU9DZjRs3zvbz2zm/7nv27Bnt27ePFi1axKpVqwo6O+f3wpxf9z179ow999wzdtppp4L/O+nfv3/cfffdMW3atFi5cmVBZ3/mM5+JPfbYI1q2bFnwz2XO7+Hb69dlhK/ND5rta3NLvja35r+ZW8v5dfnufF+bhZc+DufOO+9MM2fOTFVVValJkyYFm9u/f/80b9689P3vfz8tXbo09e3bt6CzZ8+enS644II0ZcqU1L9//xQRqaSk5GM/e9q0aal3794F/zz+53/+Z3r++efTD37wg3TwwQcXfH7//v3Tww8/nA444IDtavf+/funxx57LF122WVpwoQJaffddy/Y7AEDBqSHH344XXLJJenGG28s6Oe1f//+6amnnko/+tGP0p/+9Kd06KGHFnT22LFj07777pvl30mur/t+/fqlJ554Il166aXp0UcfTR07dizo7jm/F+b6uh8wYEBasmRJGjNmTBo8eHDBP5cPPPBAuuqqq1KvXr1SRGG+D777uZwzZ076/ve/nx577LG09957F3TvnN/Dt8evy3fn+9rc+u/E1+bWn0tfm1vP9t/MrU+ur8t3/158bWY5RV8gRUQaPXp0mjNnTvrRj35UsP/h37x583T33XenAQMGpIhII0aMSNdcc01BPgmVlZVpypQp9bsOHDgwrVmzpiC7t27dOtvsz372s2nZsmX13xB32WWX1K5du7TXXnv927ObNGmSbr755nT44YfXv96sWbO06667FuTzecABB6Tnn3++/j8UlZWVqbKyMu22227/9uymTZum8ePHZ9m9Xbt26Y9//GM66KCDUllZWfrxj3+cKisrC/JNcrfddkszZ85MBx10UIqIdNxxx6U///nP9a//O6eioiL93/bOPKqqev3/73MQgUQEBZVJQBCZDiAoMhQYk3oAGRQFFBmcrVZKg+Y1TUUw0TLF26osu9XN4Yotp4XdEpQIRSCcRSbxMEpomAwC4vP7w9/ZF/na9ezNOSS3z3utvVJivXp69vPe+9l7f4bjx4/TlClTCABJpVKSyWQklUqVcj4XLFhAFy5coKSkJLK1tVUKE1Ct70eOHEk5OTmcFzdv3kxGRkY0YsQIpfAB1VwLnZ2dVeb7QYMG0datWyk0NJTL/6hRo7gGoy85cXd3pzNnztCkSZNo2rRp9O233yqtTkaPHv3EuVy3bh1ZWlqSnp5en9mqvD8MVF/Ka0NV3hw1ahTzZq9Dld708PAYkN5UZX81UL3J7plPPwaqN1V531TW8dwMu7137x40NDQgk8ng4+MDMzMzWFpa4urVq4KZnZ2d8PDwQHl5OSorK/HCCy/A19cXhw4d6nO8Dx48gEQiQX19PcrLy1FaWgpHR0csWbIEly9fxq1btwSz29vbIZFI0NDQoHT2mDFjoKenh6amJrS1tWHPnj2QSCRITU1FSUkJysvLBXGHDRuG1tZWuLi4QE1NDbdv38bBgwfh7u6OpUuX4ubNm32KG3i8V9CQIUOQl5cHdXV17NmzB5MnT0ZSUhIqKytx8+ZNweyuri6VxS4SiWBra4t9+/Zh5MiR2L59O6ysrDBr1izU1taipqZGMLu1tRXOzs7Izs7G3bt3IZPJ4OrqisTERBQVFaGurk4wu6OjAxKJBPfv30dpaSlu3LiB0tJSfPrpp7h8+TIqKysFswHAwcEBjY2NMDIywtixY3H79m1uaIhYLBY8fKazsxMvvvgiSktLle771tZW2NjY4NChQxg6dCj27t0LXV1dbNy4EZWVlYL901PNzc3Q1NRU6rXQ0tISOjo6aGpqQnt7u9J8DwCPHj2Cm5sb7O3tUVJSggMHDsDR0REbN27sM9vT0xMHDhxAYWEhysvL4ebmBplMppRhW21tbZBIJLh8+TI0NDSQnp6O0aNHIykpCVVVVX2q7wcPHsDZ2Rm1tbWoqKhQ6jW8o6MDDg4OA86XwH+8WVZWhoqKCqV7c/z48cjIyFCZN1XRp4wdOxbDhg3DnTt3lHpPBv7jTQcHB6V708PDQ2XebG1thUQiwZUrV5Tuzfb2dpV6087ODvfv30dZWZnSvWlra8t509LSUqn3TFX1yh0dHRg7diwyMjKgo6Ojsnumsn0JADY2NtDS0lKZN11dXSGRSJTuTR8fH3z99dcoKipSujeVqT/lqdfS0pLc3d25vxsZGdF3331HACg5OZnu3btHSUlJgtja2trcmwMXFxfu5+bm5pSRkcH93cDAoE/spKQk2r59O61atYref/99euuttyg0NJQOHjxIw4YN4812dHSkWbNmkYGBAb3xxhuUlpamNLarqyslJCQQAPLy8qKPPvqICgoKKDExkYDHb/9qa2vJ2tqaNzswMJB++OEH0tTUpGnTptGOHTto3bp1FBcXRyKRiKKioigvL4+MjY0FnU87Ozvy9vYmHR0diomJofT0dMrKyqL4+HgCQOHh4VRcXEwmJia82ba2tjR9+nTS0tKi6dOn086dO5UWu62tLQUEBNCwYcPok08+oY8++ohqampo5cqVNHz4cIqLi6Njx44J+rpqa2tLU6dOpaFDh9LWrVtp165dFBERQSkpKfTKK6/Q3LlzKTU1lQYPHsz7DZqZmRlJJBICQImJiZScnPxEbkNDQyknJ0fQF2czMzNycHAg4PHXZgA0YsQI2r17N23YsIEbTqSrqyuILY9b/k9AOb7vGbd8+I1EIqH58+cTAAoJCaHa2loaN25cn9gAyMTERGnXQnNzc87TPj4+3FAwZfi+Z77t7e0pJSWFtm3bxrFnzJhBMplMENvc3Pz/DLMbPHgwpaam0rJlywTl4mn5XrNmDW3atIlu3LhBb775JgGgsLAwunr1qqChYT1z8tprr9GWLVto9erVSrmGW1paciMaFi5cSBs3blSaLy0tLbm6lt/j9PX1leLLnrGLRCJycnJ64jz31ZvyXkIsFnP5UZY3VdmnWFlZkYuLC4nFYnr55ZcpJSVFad7seT4lEgklJycrzZtWVlbk7Oz8xM80NDSU4k15vtXU1Gjt2rW0ceNGpXlTnhORSESvv/46paSkKM2bcs8AoCVLltDWrVvJyMiI+1lfvNmTLY9t+PDhlJ6e3mdv9kevrKamxg3hdXBwUIove+ZELBaThYUFHT58mIC++xIADR06lGP7+/vTBx98oLR+uWfszs7OlJaWRmlpaUrxpjzunrlRV1enlJSUPntT2cef8uVTKpUiPT0d9vb2mD17Nu7fv4/i4mLo6+vD1tYW4eHhyMzMxOjRo3H37l1UV1crzH7xxRexY8cO1NTU4NatW6ivr+f+3fDhwxEZGYmvvvoKcXFxWL9+PTIyMvDw4UNB7MLCQgwbNgza2toQiURIS0vDtWvX4Ofnh2PHjvGamCyVSrFt2zYYGRnB398fBw8exN27d2FgYAAi6hNbTU0NycnJmDNnDtra2nD06FH8/vvvaG9vx9GjR3Hv3j2UlZXB1NQUv/zyC6+JyT4+Pli9ejXU1dXR1dWFI0eOICgoCC4uLsjMzERlZSWuXLkCJycn5Obm8p7YP3XqVHz44YdwcHBAdHQ01q1bxy0Q8M9//hNtbW0oKSmBRCLB6dOn0dLSwpttZWWFuLg4pKamws/PD25ubsjMzERFRYXg2OVsGxsbzJw5EwkJCThx4gRGjhyJvXv3orGxESUlJXB3d0dWVhba29t5s62trREZGYlXX30V1tbWMDMzw9ChQ7F582Y0NjZi+vTpOHLkiMJc4HEd7tq1C7a2tvDx8UFhYSF8fX1hbW2N0tJStLW14fr163BxccGpU6d4xd2TPW3aNNy5cwdNTU24d+8eLl68iMDAQIwYMQI+Pj54/fXXcfjwYYXrvCfb398f5eXlqKurw6NHjzBixIg++V7OtrOzg6+vL65du4b6+nrU19fj4sWLAIDS0lKYmZmhuLiY10INcraNjQ2kUil+++03XLlyBaNGjcL48eP7dC2USqXYuXMnJBIJfH19cf36dTQ0NODWrVv4/vvv0dzcLNj3PeP29/eHTCaDsbExrK2tUV1djUuXLuHatWswNjbGpUuXeOdEHrdUKkVzczN+/fVXdHR0oKqqClu2bMHt27dRUlKiMLN33Pb29vDy8sKpU6ewd+9eaGho4OLFi6isrERJSQmsra2Rn5+P5uZm3mxbW1u89NJLyMvLQ1dXF4DHi4Rs3bq1T/cH+T0zKCgIFy5cgL+/P8zMzFBWVtZnX6anp8PBwQGRkZFobm7G3bt3cefOnT77sjc/LCwMN2/eRH19PTo7O5XizfT0dEgkEoSEhKCsrAwNDQ2orq5WijdV1afIa8XZ2ZmLu7GxEaWlpfj3v//dZ2/K8x0eHo66ujqYmprCzMwMNTU1ffamPO7Zs2ejpaUFTU1NaGlpUYo35edy6tSpOHPmDL744guIxWJcunSpz96Us6dPn47z58+ju7sbHR0d0NTU7JM35X1hdXU1ZDIZrly5gtmzZ8PV1RVXrlxBe3u7YG/K2TKZDDKZDB0dHVBTU0NbWxuKi4sxdepUwd7sr165qqoKMpkMANDY2NhnX/bOCRGhubkZY8aMgaWlJSIiIgT78mmxV1VVobu7G01NTTh+/Hif+uXesTc1NWHChAmYMGECKisr++TN3nUoV3d3N27evIn3339fsDdVpX592tXU1KQ9e/Zwbz8XL15MH374ISUmJtLu3bvp6tWr5O3tTcDjry58F2ZZunQpffPNN7R//36OIz/GjBlD+/bto8jISDp+/DjZ2NgIZsvnHfY8XF1dKT4+nnJzc0lfX19h7qBBg+izzz7j3mClpaXRV199pRS2/JBKpZSenk4pKSm0YsUKAh6/rQQez0mMioqic+fO8frC5+npSQUFBSSRSMjQ0JBWrlzJcXfv3k2bN28mqVRKMTExVFhYyPtcjho1io4cOcK9Adq/fz9NmjSJRCIR94ZHXV2dZs2aRbm5ubz4vdkHDhwgJycnGjx4MO3YsYPee+89wbE/LW55LX7yySe0fft20tLSopkzZ9KZM2d4ffl8Wtw931gCIENDQ5o3bx5lZmbyehuqra1NX3/9NVeHK1asoMOHD1NMTAzt37+fUlNTafHixTR37lzKz8/n9Ra3N/u1116jU6dOUXh4OOno6HC/l5ubS8XFxby8+TR2VlYWhYeH05AhQ8jIyEiw7/8be/jw4WRjY0MTJ06k6OhoKiws5PX1/Wns06dPU0REBO3cuZOuX78u+FrYm/3666/TyZMnaebMmVy9mZiYCPL90+rk6NGjNGfOHNqwYQOtX7+ekpKSaP78+XT58uU+sZ9WJwEBAZSRkfHEFymhOcnOzqaIiAhKTU2ltLQ0cnJyojlz5lBeXh4ZGhr2KScnTpyg8PBw7ncmTpwo6Bre+565fPlyWrt2LS1btowOHTpEycnJgn3Zm71kyRLatm0bxcfH0/Dhwwl4/FVEiC+fxl+8eDHH19HRoVGjRgn25tPY27dvp/j4eBo5ciRZW1sL9qYq+5Te7KVLl1JKSgolJiZyNSf0ntybvWzZMtqwYQMtXryYNm/eTGvXrhXszT86lwkJCVytBAYGCvLm0+L+4IMPKCEhgdLS0mjLli3k7OwsyJtP809ycjI3Eqwv3pSfP3lfKJ8zqampSZ9//jmlpaUJ9mZvds9+Vk1NjfuzUG/2V6/ck62hoUEODg7k6uoqyJf/jZ2amkplZWXcV1Yhzw+9+fK5uyKRiBupJfS+2Zstf4ZQV1ent99+mzZu3EgrV64U5E1FaiUgIIAOHz7M25uqOv6UL5/z58+HSCRCfn4+ioqKoKenB0tLS+Tk5ODTTz9FYWEhAKC4uJjXlywACAwMRElJCa5fv47Y2Fjcvn2bG8N/7949xMbGYsaMGVi0aBFu3LghmD1v3jw0NjZybHt7e4SFhUEqlWL58uVPvHl4lsRiMZKSklBeXo6SkhKcP38eQUFB+O677wCAe8saFBSEZcuW8WLLZWpqCn9/f/zjH/+Am5sbAgMDYWFhAX19fcyfPx/BwcFITExEVVWVwkxLS0scPHgQly5dgr6+PtavX4/y8nJUVFTgxx9/xMiRI2FqagovLy+sXLmS91yKR48eITQ0FB0dHSgvL8eWLVtgbm6OmJgYlJaWYsqUKVi8eDEiZhajvAAADy5JREFUIiKQmJjIi9+bnZqaCisrK0ilUuzbtw+dnZ0wMzODp6cn79ifFreRkRFCQkLw7bffYtq0afDy8kJwcDAWLVrE63w+LW5zc3PExcWhsrISY8eORUJCAsLDw7F8+XLe80kTEhLQ1dWFgoICnDt3DjExMWhpacH+/ftx7949WFlZwc3NDStWrOBdhz3Z58+fR2hoKF544QXU1taioaEBLi4uCA4ORmxsLO+3c73ZM2bM4Njl5eVYsGABpk+fjsWLF/P2/dPYWlpaqKurg6enJ4KDg+Ht7Y1Fixbxnnf8NPbDhw9x5MgR7N27F7/88gsAYdfCnuz8/HxERERAU1MTt27dgo2NDRITEwX5vjf73LlzmDNnDrq6upCZmYmrV6/CyMgIVlZWeOedd/rEflqdPHjwAN3d3SgoKEBra6tgdn5+PkJDQ9Hd3Y3MzExYWVlh8uTJ8Pf3x5IlS3hfr3rnZNasWdDW1savv/4KLS0tzJ07F4GBgbzvDwAQGxvL3TMLCgpgYmICU1NTZGZm4tdff4WlpaVgX/ZkFxUVQVdXFy4uLmhra0NlZSUmTJiAkJAQQb78I76rqytaW1tx+fJlJCYmCvbmf4t90qRJkEqlgr3Zm63MPqUnu7CwEAYGBnBycsLvv/+OsWPHIi4uDiEhIYK82Zstn7t79uxZXLhwAaNHjxbszWfVSltbm2Bv9o5bT08P48aNw9mzZ2Fubg5XV1cEBAQI8mZv/xgYGGDixIl4+PAh1NTUEBUVJdibgYGBuHHjBq5du4a5c+fizp07KCsrw8mTJ6GnpwdjY2N4enoK8mZPds9+Vj63Uz6aQIg3/4gNKKdX/qO4Y2Ji4OvrC19fXyxcuJC3L3uz5X14bm4usrKycP78eQDCfNmbL+/zq6qq0NXVhenTpyMqKgphYWGCvNmb3dTUhIqKCuTn56O1tRW6urqwsbHB6tWr+8R+Wq3It/cT4k1VSITHT6Eql729PUQiEcrLy2FlZYXly5fjxIkTOHHiBADgzTffhKenJyIiIgSxAUAmk6GlpQVEBD09PYSHh3NDuHJycmBkZISgoCB8//33Cl8E+LDr6uqgpaWl8LAKeU4qKiqgpqbGGcXExATffvstpkyZgkePHmHMmDGQyWS82fLhCPJFZzZt2oR3330X8fHx2LZtGz7//HOsWrUKwOONaBXde9Le3h7d3d24f/8+amtruZ/PnDkTRkZG+OKLL54obg0NDXR0dCjElvPFYjEaGxsxduxYvPHGG9DR0cEPP/yAtLQ0vPPOO3B0dMTChQvR3d0NLS0t/Pbbb0phr127Fvb29oiPj0dHRwev2J/Ffvfdd2FhYYHXXnsNHR0dGDJkiML7OimSkwkTJiAuLg7t7e0YOnSowsOE5XVYVVWF8ePHY/Xq1SgtLUVXVxcMDAxQV1cHe3t7xMTEAOB3Pp/FlslkcHd3R3h4OCQSCe7cuaPwIkmKsD08PLibc05OjsJNy7PYNTU1sLOzQ2xsLADghRdeUHhf2Gex6+vr4ejoiNmzZyvE45sTZ2dnREdHA+Dv+//Grq2thZOTE+bMmQMAGDRokMLDtPjUCfB4KoGiw8sUqe9x48YhPj4eAKCtra1w06JI3K6urty55FMnzs7OGDRoEMrLy2FsbIzly5cjMzMTx48fBwC88cYbmDx5Msfm48tnsVesWAE/Pz+EhITAwcEBd+/e5bV4mSJ8f39/BAcHY+7cucjNzVXYm89ir1y5Em5ublyNKzPnfelTFMmJl5cXIiMjAfDzpiK14unpiZkzZwLg500+tQLw86Yi+XZ2dsa8efMA8POmInF7e3tz55JvnYjFYlRXV3NDI3v2hX//+9+RlZUFQ0ND1NfXY/Dgwejs7FQKu2fPaWJigurq6ieGzCqLzbdXfhZ7165dOHPmDExMTFBTU8Orn1U03/Khtormmm9eTExM0NjYCA0NDYX7q2exd+/ejezsbIwePRoNDQ28/aNI3HK2WCzGo0ePeOVGVeqXL58BAQHYtGkTzM3NMXnyZNjY2KCwsBAeHh7Q0NBAaWkp8vLyMHv2bFy4cIHXiky92fb29sjPz8eDBw+4m2V4eDg8PT3h7u6O9PR0hcdoK8r28PCAv78/Tp8+rbCZerLd3d0xbtw45OfnAwD09fURGRmJPXv2IDo6GomJicjKylL4wihnW1hYwNHRERKJBPn5+ZgxYwa8vLwQHh6Ojz/+GMbGxrCwsMD58+cVbloCAgKQnJwMCwsLSCQSODg4cHHr6ekhODgYhYWFaG5uxqBBg/Do0SNe8yfksZuZmcHR0RGamppYtWoV7O3t0dDQgKKiIuTm5iIuLg4lJSW4desWHjx4oDR2Tk4OYmNjUVFRgZqaGoVjV5S9YMEClJSUoLq6mlfOFcnJvHnzUFpaitraWoUvvj3rcOLEiTA0NOTm9Ny/fx9r167FTz/9hKioKJw5cwatra28c/Lf2D///DNmzZqFH374ATKZTOELOh/2iRMnUFhYqPCDviJseb6zs7PR1tbGze1TBjsnJweRkZG85wIrmpPo6GjuesK3Bp9VJ3PmzMHp06fR1tam8E1O0bhnzpzJsRVd1VHRuOfNm8flRJne+fnnn7mctLa28qqT1NRUWFpaYsqUKbCzs8PZs2fh7u4OLS0tlJaW4uzZs4iJicHFixfR1NTEy5fPYp87d47bVP3GjRu85rvz4efl5SE3N5eXNxVhx8bGori4GHfu3FFqzvvSpygS99y5c7m4+XhTkVqJioriaoWPNxU9l/Kc8PGmIvmeP38+lxM+3lQk7p454VsnVlZW8PHxgUQiQW5u7hN9YWho6BN9IZ8e5Vlsec/p7e2N/fv3K/ziXVG20F75WeywsDB4enri5ZdfRnZ2Nq9eWZF8T548GX5+fsjKylL4XPLNy5QpU5CVlaXwl0MhtcK3xp8Vt7u7O292f0ml43o1NTXp6NGj3PjmSZMm0fHjx2nnzp00e/Zs+vzzz2nVqlUUHh5OeXl53NwBoewff/yR3nrrrSd+77PPPqOysjJeG/PyZfPZc+mP2PIV3YDH8z7Dw8Pp+++/5z0Ppjc7Ozubli1bRgEBAfTTTz+Rn58fAY/nOfCdH/SsnKxZs4bKy8tJS0tLKbWSnZ1Nr7zyCnl4eNBHH31E0dHR3P8Hn7mSjK0YOysri5YuXcr9jre3N0VGRlJhYeETczOVzeazwuDzxB6oOVFl3IzdN7a6ujplZGRQUFAQAY9XQf/mm29o3759NGvWLNqzZw+tXr1a0D1TlWwhfPlef3927IzN2ELZhw4doq1btz7xe0L6wueJzadXfp7i5rv36UCNXdV56Y9DpV8+xWIxurq64O3tjYKCAm7OjrOzM0aOHInW1lZ8+eWXCAsLw4gRI7Bp0yaFP/E/jV1fXw8HBwdIJBIMGzYMv/zyC/z8/Lg5cIqOiRfCVnRMvKLs3bt3QyqVIioqCqWlpX1i29nZwcnJCbq6uli3bh03j6yurk7hNzjPiltXVxdFRUX46aefYGhoiBs3bvBaje5ZsWtrayM/Px/R0dFwcHDA22+/rfCYeMZWjN3Q0AA7OztMnDgROjo6KCkpQXJyMkxNTbFmzRqFV40Twu6L7/9M9kDNiSrjZmzhbCMjI+jq6kJXVxfXrl1DbW0tGhsbuVWn1dXV8fHHHyMsLAwGBgbYuHGjwnWiSrZQvqJDbQdqXhj7f5t9+/Ztbs67mZkZ8vLy4Ovri8TERF594fPGVrRXft7i5jM3daDGruq89KdU8lTr7e1NCxcuJHV1dYqLi6OioiJKSEigXbt20Y4dO8jPz49SUlIIeLwXjVgsVgr7ww8/JF9fX0pOTiYApKenx2tPqD+bvWXLFgJAkydPJisrK6Xme8OGDSQSiXjv+6hoTuSrgamiVt577z0SiUSkrq5OQ4YMYWwVseXnMzU1lYDHKzEPHjyYsRmbsVXMlkqllJeXR9999x11d3fT6dOnuZEMampq5OHhQbt37yY1NTXe90xVsgdy7IzN2H1li8Vi8vDwoF27dpGOjg7vvpCx+5c9kGNXdV76+VAN+NChQ3TgwAFu49SQkBB69dVXae3atdzvHDt2jPcyy3zYY8aMGZBsvkss82H33Pj4eWDz4ZuamjJ2P7JV6U3GZmzG/s9hbGxMJ0+e5F44Hj16lG7fvk3Xr1/n7gcikYj+9a9/0fjx458b9kCOnbEZW9lsvsMbGbt/2QM5dlXnpb+PQVCR2tvbuVUbFy5ciP3793OrlI0bNw5+fn4YPHiwwhOxhbAVXaDneWLzXRmWb9xCJhyrks2Hz2fxFcbuO1uV3mRsxmbs/6izsxOamprcCqRffvklvv76a+jr6+PkyZNYs2YNDA0Noaurq/AKqP3BHsixMzZjK5vNZ6oRY/c/eyDHruq89LdUNuezsLAQGRkZUFdXh5ubG4yMjHDr1i1oa2tjwYIFcHd3x5o1a3jvZfO/zhay99bzELdQ9kCOnbEZm7EZWxnszs5O3Lx5ExcuXAAAODo6Ijg4GH/729/Q0NAACwsLODs74913332u2AM5dsZmbMb+a7EHcuyqzkt/S2VfPuWb2x87dgzq6urw8vLClClTuE23o6KiFN5nirH/d9kDOXbGZmzGZmxlsB8+fIjs7Gzu7y0tLRCLxQAe78l4//59LFq0SFDMqmQP5NgZm7EZ+6/FHsixqzovf4b6ZXzvSy+9RKdOnaILFy7wWsaZsf9a7IEcO2MzNmMztjKOSZMm0apVq8jd3Z1+/PHHAcMeyLEzNmMz9l+LPZBjV3Ve+uHon/9QUFAQXb16laytrRmbsf8nY2dsxmZsxlbGMWbMGGppaaGCgoIBxR7IsTM2YzP2X4s9kGNXdV764VD9f0QsFlNQUBCvrUMY+6/HHsixMzZjMzZjK+sQiUS0fv16srS0HFDsgRw7YzM2Y/+12AM5dlXnRdWH6P//gYmJiYmJiek5kZqaGrq7uwccW9V8xmZsxmbsgcIfqGxViz18MjExMTExMTExMTExMalc4j87ACYmJiYmJiYmJiYmJqb/fbGHTyYmJiYmJiYmJiYmJiaViz18MjExMTExMTExMTExMalc7OGTiYmJiYmJiYmJiYmJSeViD59MTExMTExMTExMTExMKhd7+GRiYmJiYmJiYmJiYmJSudjDJxMTExMTExMTExMTE5PK9f8A5xsEDFJzyj4AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 1008x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "                winery\n",
            "country               \n",
            "US               38573\n",
            "France           15948\n",
            "Italy             9112\n",
            "Portugal          3197\n",
            "Chile             2891\n",
            "Spain             2755\n",
            "Argentina         2570\n",
            "Austria           1892\n",
            "Germany           1573\n",
            "New Zealand       1121\n",
            "Australia         1028\n",
            "South Africa       727\n",
            "Israel             320\n",
            "Canada             176\n",
            "Greece             139\n",
            "Bulgaria            93\n",
            "Romania             80\n",
            "England             62\n",
            "Slovenia            42\n",
            "Mexico              38\n",
            "Hungary             35\n",
            "Moldova             35\n",
            "Uruguay             33\n",
            "Turkey              33\n",
            "Lebanon             28\n",
            "Brazil              28\n",
            "Morocco             21\n",
            "Georgia             12\n",
            "Croatia             12\n",
            "Ukraine             11\n",
            "Peru                 8\n",
            "Cyprus               6\n",
            "Macedonia            5\n",
            "Luxembourg           5\n",
            "Switzerland          5\n",
            "Serbia               4\n",
            "Czech Republic       3\n",
            "India                1\n",
            "Number of countries: 38\n",
            "                     points\n",
            "user_name                  \n",
            "@worldwineguys    88.681909\n",
            "@winewchristina   86.250000\n",
            "@wineschach       86.837981\n",
            "@wawinereport     88.747335\n",
            "@vossroger        88.709333\n",
            "@vboone           89.324406\n",
            "@suskostrzewa     86.146771\n",
            "@paulgwine        89.107855\n",
            "@mattkettmann     90.094230\n",
            "@laurbuzz         87.756398\n",
            "@kerinokeefe      89.169868\n",
            "@gordone_cellars  88.569725\n",
            "@bkfiona          86.750000\n",
            "@JoeCz            88.292076\n",
            "@AnneInVino       90.779170\n",
            "Pinot Noir                    10587\n",
            "Chardonnay                     9403\n",
            "Cabernet Sauvignon             7552\n",
            "Red Blend                      7166\n",
            "Bordeaux-style Red Blend       5497\n",
            "Riesling                       4148\n",
            "Sauvignon Blanc                4011\n",
            "Syrah                          3316\n",
            "Rosé                           2831\n",
            "Merlot                         2471\n",
            "Nebbiolo                       2242\n",
            "Zinfandel                      2209\n",
            "Sangiovese                     2165\n",
            "Malbec                         2119\n",
            "Portuguese Red                 1969\n",
            "White Blend                    1896\n",
            "Sparkling Blend                1739\n",
            "Tempranillo                    1448\n",
            "Rhône-style Red Blend          1182\n",
            "Pinot Gris                     1148\n",
            "Champagne Blend                1133\n",
            "Cabernet Franc                 1095\n",
            "Grüner Veltliner               1055\n",
            "Portuguese White                896\n",
            "Pinot Grigio                    873\n",
            "Bordeaux-style White Blend      850\n",
            "Gewürztraminer                  840\n",
            "Gamay                           816\n",
            "Name: variety, dtype: int64\n",
            "<class 'pandas.core.series.Series'>\n",
            "\n",
            "['Pinot Noir', 'Chardonnay', 'Cabernet Sauvignon', 'Red Blend', 'Bordeaux-style Red Blend', 'Riesling', 'Sauvignon Blanc', 'Syrah', 'Rosé', 'Merlot', 'Nebbiolo', 'Zinfandel', 'Sangiovese', 'Malbec', 'Portuguese Red', 'White Blend', 'Sparkling Blend', 'Tempranillo', 'Rhône-style Red Blend', 'Pinot Gris', 'Champagne Blend', 'Cabernet Franc', 'Grüner Veltliner', 'Portuguese White', 'Pinot Grigio', 'Bordeaux-style White Blend', 'Gewürztraminer', 'Gamay']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Zpv4D3Qxron",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Preprocessing to remove useless entries\n",
        "processor = winesdf[[ 'review_description', 'year', 'variety', 'province' ]]\n",
        "print(processor.isnull().sum())\n",
        "print()\n",
        "print(processor[processor['variety'].isna()].head(10))\n",
        "processor = processor.dropna(subset=['review_description', 'variety'])\n",
        "print('Removed ' + str(winesdf.shape[0]-processor.shape[0]) + ' rows with empty values.' + \"\\n\")\n",
        "\n",
        "for i in range(1,5):\n",
        "    print(processor['variety'].iloc[i])\n",
        "    print(processor['review_description'].iloc[i])\n",
        "    print()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lmb5VYdcP7pF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "input_data_train = processor['review_description'].str.lower()\n",
        "input_data_test = winesdf_test['review_description'].str.lower()\n",
        "list_train = []\n",
        "list_test = []\n",
        "# Remove stopwords\n",
        "for phase_word in input_data_train:\n",
        "    list_train.append(' '.join([re.sub('[0-9\\W_]', '', word) for word in phase_word.split() if not word in sw]))\n",
        "for phase_word in input_data_test:\n",
        "    list_test.append(' '.join([re.sub('[0-9\\W_]', '', word) for word in phase_word.split() if not word in sw]))\n",
        "\n",
        "# train and test list\n",
        "input_data_train = list_train\n",
        "input_data_test = list_test\n",
        "list_test = []\n",
        "list_train = []\n",
        "\n",
        "print(\"Input Data Characeristics:\\n\")\n",
        "print(input_data_train[3], type(input_data_train), len(input_data_train))\n",
        "maxLen = len(max(input_data_train, key=len).split())\n",
        "print(\"Maximum Length of a review: \" + str(maxLen))\n",
        "\n",
        "uniqueWords = list(set(\" \".join(input_data_train).lower().split(\" \")))\n",
        "count = len(uniqueWords)\n",
        "print(\"Count of unique words in reviews: \" + str(count))\n",
        "\n",
        "label_words = list(label_freq.index)\n",
        "num_labels = len(label_words)\n",
        "print(\"There are total \"  + str(num_labels) + \" different categories.\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UnwFLIYyhM0M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# length of dictionary\n",
        "VOCAB_LEN = count\n",
        "# Length of each review\n",
        "SEQ_LEN = maxLen"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IcsBJLCwBkZK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Tokenize input data\n",
        "def tokenise_data(input_data):\n",
        "\n",
        "  tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words = VOCAB_LEN, oov_token='<UNK>')\n",
        "  tokenizer.fit_on_texts(input_data)\n",
        "  #word_index = tokenizer.word_index\n",
        "  #print(dict(list(word_index.items())[0:10]))\n",
        "  wine_seqs = tokenizer.texts_to_sequences(input_data)\n",
        "  wine_seqs = tf.keras.preprocessing.sequence.pad_sequences(wine_seqs, maxlen = SEQ_LEN, padding=\"post\")\n",
        "  return wine_seqs, tokenizer\n",
        "\n",
        "input_data, tokenizer = tokenise_data(input_data_train)\n",
        "print(type(input_data), input_data.shape, input_data[1, :])\n",
        "X_test = tokenise_data(input_data_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "De1dNEela0xf",
        "colab_type": "code",
        "outputId": "7888c79f-fa23-4211-bba9-0a157a3035a1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "# Tokenize output data\n",
        "def tokenize_labels(input_labels):\n",
        "  label_tokenizer = tf.keras.preprocessing.text.Tokenizer(split=' ', filters='!\"#$%&()*+,./:;<=>?@[\\\\]^`{|}~\\t\\n')\n",
        "  label_tokenizer.fit_on_texts(input_labels)\n",
        "  print(label_tokenizer.word_index)\n",
        "  wine_labels_seq = np.array(label_tokenizer.texts_to_sequences(input_labels))\n",
        "  return wine_labels_seq, label_tokenizer\n",
        "\n",
        "wine_labels = pd.DataFrame({'variety': processor['variety']})\n",
        "wine_labels = wine_labels.replace(' ', '_', regex=True)\n",
        "train_labels_list = []\n",
        "for item in wine_labels['variety']:\n",
        "    train_labels_list.append(str(item))\n",
        "\n",
        "output_labels, label_tokenizer = tokenize_labels(train_labels_list)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'pinot_noir': 1, 'chardonnay': 2, 'cabernet_sauvignon': 3, 'red_blend': 4, 'bordeaux-style_red_blend': 5, 'riesling': 6, 'sauvignon_blanc': 7, 'syrah': 8, 'rosé': 9, 'merlot': 10, 'nebbiolo': 11, 'zinfandel': 12, 'sangiovese': 13, 'malbec': 14, 'portuguese_red': 15, 'white_blend': 16, 'sparkling_blend': 17, 'tempranillo': 18, 'rhône-style_red_blend': 19, 'pinot_gris': 20, 'champagne_blend': 21, 'cabernet_franc': 22, 'grüner_veltliner': 23, 'portuguese_white': 24, 'pinot_grigio': 25, 'bordeaux-style_white_blend': 26, 'gewürztraminer': 27, 'gamay': 28}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IayGwWl1P47K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Divide into two\n",
        "X_train, X_val, y_train, y_val = sk.train_test_split(input_data,\n",
        "                                                    output_labels,\n",
        "                                                    test_size=0.20,\n",
        "                                                    random_state=42)\n",
        "\n",
        "print('Val: ' + str(len(X_val)) + ' Train: ' + str(len(X_train)))\n",
        "\n",
        "X_train = X_train.astype(\"float32\")\n",
        "X_val = X_val.astype(\"float32\")\n",
        "y_train = y_train.astype(\"float32\")\n",
        "y_val = y_val.astype(\"float32\")\n",
        "\n",
        "print(type(X_train), X_train.shape)\n",
        "\n",
        "# X_train = X_train / 1024.0\n",
        "# X_val = X_val / 1024.0\n",
        "# y_train = y_train / 1024.0\n",
        "# y_val = y_val / 1024.0\n",
        "\n",
        "print(X_train.shape)\n",
        "print(y_train.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6WuJB7r9GqHA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "reverse_word_index = dict([(value, key) for (key, value) in tokenizer.word_index.items()])\n",
        "\n",
        "def decode_article(text):\n",
        "    return ' '.join([reverse_word_index.get(i, '?') for i in text])\n",
        "\n",
        "\n",
        "reverse_label_index = dict([(value, key) for (key, value) in label_tokenizer.word_index.items()])\n",
        "\n",
        "def decode_label(text):\n",
        "    return ' '.join([reverse_label_index.get(i, '?') for i in text])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yJe3oFLEKZ7q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "test_entry= 54\n",
        "\n",
        "print(decode_article(X_train[test_entry,:]))\n",
        "print('---')\n",
        "print(X_train[test_entry, :])\n",
        "\n",
        "print(decode_label(y_train[test_entry, :]))\n",
        "print('---')\n",
        "print(y_train[test_entry, :])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vPKx3igVKzrt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "EMBEDDING_SIZE = SEQ_LEN\n",
        "EMBEDDING_SIZE_2 = 64\n",
        "EMBEDDING_SIZE_3 = (num_labels+1)\n",
        "BATCH_SIZE = 64\n",
        "EPOCHS = 10\n",
        "LR = 1e-5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MWOLbcHa2mtk",
        "colab_type": "code",
        "outputId": "d8b9ba42-fc8a-46dc-ac70-0c17807a29e0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 399
        }
      },
      "source": [
        "model = tf.keras.Sequential([\n",
        "    # Add an Embedding layer\n",
        "    tf.keras.layers.Embedding(VOCAB_LEN, EMBEDDING_SIZE),\n",
        "    # tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(128, return_sequences=True)),\n",
        "    # tf.keras.layers.Dropout(0.4),\n",
        "    tf.keras.layers.Conv1D(128, 5, activation='relu'),\n",
        "    tf.keras.layers.Dropout(0.7), \n",
        "    tf.keras.layers.GlobalMaxPooling1D(),\n",
        "    # tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(128, return_sequences=False)),\n",
        "    tf.keras.layers.Dense(128, activation='relu'),\n",
        "    tf.keras.layers.Dropout(0.7),\n",
        "    # Add a Dense layer with additional units and softmax\n",
        "    tf.keras.layers.Dense(EMBEDDING_SIZE_3, activation='softmax')\n",
        "])\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_3 (Embedding)      (None, None, 76)          2696708   \n",
            "_________________________________________________________________\n",
            "conv1d_2 (Conv1D)            (None, None, 128)         48768     \n",
            "_________________________________________________________________\n",
            "dropout_3 (Dropout)          (None, None, 128)         0         \n",
            "_________________________________________________________________\n",
            "global_max_pooling1d_2 (Glob (None, 128)               0         \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 128)               16512     \n",
            "_________________________________________________________________\n",
            "dropout_4 (Dropout)          (None, 128)               0         \n",
            "_________________________________________________________________\n",
            "dense_4 (Dense)              (None, 29)                3741      \n",
            "=================================================================\n",
            "Total params: 2,765,729\n",
            "Trainable params: 2,765,729\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZYGRhRR4K65",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss='sparse_categorical_crossentropy',\n",
        "              metrics=['accuracy'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m1vpuyhV4_2e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "checkpoint_dir = './KnightData/classifer_training_checkpoints'\n",
        "# Name of the checkpoint files\n",
        "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt_{epoch}\")\n",
        "\n",
        "checkpoint_callback=tf.keras.callbacks.ModelCheckpoint(\n",
        "    filepath=checkpoint_prefix,\n",
        "    monitor='accuracy',\n",
        "    save_best_only=True,\n",
        "    mode='auto',\n",
        "    save_weights_only=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T95jYDeq4x8z",
        "colab_type": "code",
        "outputId": "fbb18ff2-c75c-4454-db64-55aa0a3cccf7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 416
        }
      },
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    batch_size = 128,\n",
        "                    epochs  =EPOCHS,\n",
        "                    validation_data=(X_val, y_val),\n",
        "                    validation_steps = 30,\n",
        "                    callbacks = [checkpoint_callback])\n",
        "\n",
        "loss, accuracy = model.evaluate(X_val, y_val)\n",
        "\n",
        "print(\"Loss: \", loss)\n",
        "print(\"Accuracy: \", accuracy)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "517/517 [==============================] - 14s 26ms/step - loss: 2.3563 - accuracy: 0.3275 - val_loss: 1.9660 - val_accuracy: 0.5260\n",
            "Epoch 2/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 1.5284 - accuracy: 0.5347 - val_loss: 1.6259 - val_accuracy: 0.6383\n",
            "Epoch 3/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 1.2632 - accuracy: 0.6101 - val_loss: 1.4454 - val_accuracy: 0.6630\n",
            "Epoch 4/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 1.1213 - accuracy: 0.6550 - val_loss: 1.3844 - val_accuracy: 0.6698\n",
            "Epoch 5/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 1.0095 - accuracy: 0.6879 - val_loss: 1.2973 - val_accuracy: 0.6747\n",
            "Epoch 6/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 0.9277 - accuracy: 0.7121 - val_loss: 1.2503 - val_accuracy: 0.6729\n",
            "Epoch 7/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 0.8567 - accuracy: 0.7323 - val_loss: 1.2221 - val_accuracy: 0.6708\n",
            "Epoch 8/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 0.8048 - accuracy: 0.7493 - val_loss: 1.2073 - val_accuracy: 0.6727\n",
            "Epoch 9/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 0.7524 - accuracy: 0.7634 - val_loss: 1.1614 - val_accuracy: 0.6766\n",
            "Epoch 10/10\n",
            "517/517 [==============================] - 14s 27ms/step - loss: 0.7111 - accuracy: 0.7761 - val_loss: 1.1745 - val_accuracy: 0.6701\n",
            "517/517 [==============================] - 1s 2ms/step - loss: 1.2043 - accuracy: 0.6631\n",
            "Loss:  1.2043119668960571\n",
            "Accuracy:  0.6630776524543762\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "grPRJTJ0AMV_",
        "colab_type": "code",
        "outputId": "6b3e2b33-3ad9-45ea-df8e-a8e9bbbaf693",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 325
        }
      },
      "source": [
        "history_dict = history.history\n",
        "history_dict.keys()\n",
        "\n",
        "acc = history_dict['accuracy']\n",
        "val_acc = history_dict['val_accuracy']\n",
        "loss = history_dict['loss']\n",
        "val_loss = history_dict['val_loss']\n",
        "\n",
        "epochs = range(1, len(acc) + 1)\n",
        "\n",
        "# \"bo\" is for \"blue dot\"\n",
        "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
        "# b is for \"solid blue line\"\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qLzHNvWH5vsT",
        "colab_type": "code",
        "outputId": "b87d0ab4-3077-4f7d-96ba-97def84c2ba9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 325
        }
      },
      "source": [
        "plt.clf()   # clear figure\n",
        "\n",
        "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IvwmkOvQ-j4p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sample_predict(sample_pred_text, pad):\n",
        "  encoded_sample_pred_text = tokenizer.texts_to_sequences(sample_pred_text)\n",
        "  print(encoded_sample_pred_text)\n",
        "  print(type(encoded_sample_pred_text))\n",
        "\n",
        "  if pad:\n",
        "    encoded_sample_pred_text = pad_to_size(encoded_sample_pred_text, SEQ_LEN)\n",
        "    \n",
        "  encoded_sample_pred_text = np.array(encoded_sample_pred_text)\n",
        "  encoded_sample_pred_text = encoded_sample_pred_text.astype(\"float32\")\n",
        "  predictions = model.predict(encoded_sample_pred_text)"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}