lectures/cap11_4_cnn_text.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNOl45gUCB7uo/oHZzoXb8/",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/viniciusrpb/cic0269_natural_language_processing/blob/main/lectures/cap11_4_cnn_text.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Capítulo 11 - Redes Neurais Convolucionais\n",
        "\n",
        "## 11.4 - Redes Neurais Convolucionais em Textos\n",
        "\n",
        "O objetivo deste notebook é detalhar como utilizar redes neurais convolucionais e camadas associadas em textos. Como as redes neurais devem receber entradas numéricas, temos que pré-processar os textos de forma a garantir que seus termos estejam representados por números e que os textos estejam sob uma forma estruturada de mesmo tamanho (lembre-se que textos podem ter diferentes quantidades de palavras). "
      ],
      "metadata": {
        "id": "t0lv6SPzPbXi"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8qesw4rNMsde"
      },
      "outputs": [],
      "source": [
        "!pip install keras\n",
        "!pip install tensorflow"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense,Conv1D,Embedding,GlobalMaxPooling1D,MaxPooling1D,Activation,Flatten,Dropout,BatchNormalization\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from tensorflow.keras.optimizers import SGD\n",
        "from tensorflow.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
        "from keras.utils.np_utils import to_categorical\n",
        "from sklearn.metrics import classification_report\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "kLa3daEePeVT"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Carregamento do corpus para Pandas DataFrames\n",
        "\n",
        "PS.: Mais informações sobre a divisão de um conjunto de dados em treinamento, validação e teste, você encontra nesse link."
      ],
      "metadata": {
        "id": "WlJzC1vbQhgz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "path_train = 'https://raw.githubusercontent.com/viniciusrpb/cic0269_natural_language_processing/main/datasets/corpora/tweets_polarity_classification/twitter-2013train-A.txt'\n",
        "path_test = 'https://raw.githubusercontent.com/viniciusrpb/cic0269_natural_language_processing/main/datasets/corpora/tweets_polarity_classification/twitter-2013test-A.txt'\n",
        "path_valid = 'https://raw.githubusercontent.com/viniciusrpb/cic0269_natural_language_processing/main/datasets/corpora/tweets_polarity_classification/twitter-2013dev-A.txt'\n",
        "\n",
        "df_train = pd.read_csv(path_train,names=['id','polarity','text'],sep='\\t')\n",
        "df_valid = pd.read_csv(path_valid,names=['id','polarity','text'],sep='\\t')\n",
        "df_test = pd.read_csv(path_test,names=['id','polarity','text'],sep='\\t')"
      ],
      "metadata": {
        "id": "kJ8N5yE_Nwm6"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'Train size {df_train.shape}')\n",
        "print(f'Valid size {df_valid.shape}')\n",
        "print(f'Test size {df_test.shape}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DSwe3wvLP_xb",
        "outputId": "0f31f72f-bf73-4015-96a4-96bfd946d947"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train size (9684, 3)\n",
            "Valid size (1654, 3)\n",
            "Test size (3547, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df_train = df_train.drop(labels=['id'],axis=1)\n",
        "df_valid = df_valid.drop(labels=['id'],axis=1)\n",
        "df_test = df_test.drop(labels=['id'],axis=1)"
      ],
      "metadata": {
        "id": "JEEwUpt-Qa-o"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Geração dos Logits dos labels utilizando a função to_categorical do Tensorflow:"
      ],
      "metadata": {
        "id": "Z-DT8xuoQyUi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df_train['polarity'] = pd.Categorical(df_train['polarity'])\n",
        "y_train_int = df_train['polarity'].cat.codes\n",
        "\n",
        "df_valid['polarity'] = pd.Categorical(df_valid['polarity'])\n",
        "y_valid_int = df_valid['polarity'].cat.codes\n",
        "\n",
        "df_test['polarity'] = pd.Categorical(df_test['polarity'])\n",
        "y_test_int = df_test['polarity'].cat.codes"
      ],
      "metadata": {
        "id": "BrT8ydnGb4Eq"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y_train = to_categorical(y_train_int)\n",
        "y_valid = to_categorical(y_valid_int)\n",
        "y_test = to_categorical(y_test_int)"
      ],
      "metadata": {
        "id": "V4Wd20UQdP9z"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Numericalização\n",
        "\n",
        "Esse é o processo de transformar as palavras de um texto em números. Por exemplo: os textos\n",
        "\n",
        "1.   \"Eu quero jogar futebol\"\n",
        "2.   \"Não dá para assistir futebol\"\n",
        "3.   \"Não vou jogar meu boné fora\"\n",
        "\n",
        "Constrói-se o vocabulário com índices:\n",
        "\n",
        "1. eu\n",
        "2. quero\n",
        "3. jogar\n",
        "4. futebol\n",
        "5. não\n",
        "6. dá\n",
        "7. para\n",
        "8. assistir\n",
        "9. vou\n",
        "10. jogar\n",
        "11. meu\n",
        "12. boné\n",
        "13. fora\n",
        "\n",
        "Assim, a geração do vocabulário do *corpus* de treinamento **deve ser feita apenas para os textos de treinamento**, já que eles são conhecidos para os modelos de linguagem e de classificação:"
      ],
      "metadata": {
        "id": "xuz2GYQw1WlX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_tweets = df_train['text'].to_list()\n",
        "\n",
        "vocabulary = {}\n",
        "\n",
        "for i in range(0,len(train_tweets)):\n",
        "    train_tweets[i] = train_tweets[i].lower()\n",
        "    for word in train_tweets[i].split():\n",
        "        if word not in vocabulary:\n",
        "            vocabulary[word] = 1\n",
        "        else:\n",
        "            vocabulary[word]+=1"
      ],
      "metadata": {
        "id": "o0uf2O6e5wIJ"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vocab_size = len(vocabulary)"
      ],
      "metadata": {
        "id": "mmxCCUKF2coO"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Outra possibilidade consiste em utilizar a classe [Tokenizer](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/text/Tokenizer) do tensorflow."
      ],
      "metadata": {
        "id": "ELORL8Ci57E9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tokenizer = Tokenizer(num_words = vocab_size)\n",
        "tokenizer.fit_on_texts(df_train['text'])"
      ],
      "metadata": {
        "id": "9jjAj7fSdyP1"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Com o word_index é possível ver o vocabulário e os índices de cada palavra:"
      ],
      "metadata": {
        "id": "rILp14RlsJbb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "word_index = tokenizer.word_index\n",
        "print(f\"{word_index['blue']} is the index of word 'blue'\")\n",
        "print(f\"{word_index['launch']} is the index of word 'launch'\")"
      ],
      "metadata": {
        "id": "xm3_0C352bam",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "06231038-234b-424c-85f5-adf12c54109f"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "919 is the index of word 'blue'\n",
            "865 is the index of word 'launch'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "O próximo passo consiste em transformar as palavras em números de acordo com os índices do vocabulário. É o último passo da numericalização, em que se obtém um vetor de números inteiros a partir de um tweet de entrada. Fazendo-se para os textos de treinamento, tem-se que:"
      ],
      "metadata": {
        "id": "QInQoKxFsTIz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_sequences = tokenizer.texts_to_sequences(df_train['text'])"
      ],
      "metadata": {
        "id": "7pX2C5C62gkm"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Veja o resultado para um dos tweets de treinamento:"
      ],
      "metadata": {
        "id": "ihdqwgCGsgpa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Tweet: {df_train['text'][0]}\")\n",
        "print('Tweet numericalizado: ')\n",
        "print(train_sequences[0])\n",
        "print(f'Quantidade de palavras no tweet: {len(train_sequences[0])}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "59_mHl-b2lga",
        "outputId": "e13ea4ba-9492-4254-8398-61360efeaac9"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tweet: Gas by my house hit $3.39!!!! I\\u2019m going to Chapel Hill on Sat. :)\n",
            "Tweet numericalizado: \n",
            "[2711, 68, 22, 191, 383, 72, 2909, 4, 57, 31, 2, 1966, 1127, 6, 115]\n",
            "Quantidade de palavras no tweet: 15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Acontece que os tweets podem variar na quantidade de palavras e as redes neurais não processam os tweets representados em estruturas de dimensões distintas. Veja um outro exemplo de tweet de treinamento:"
      ],
      "metadata": {
        "id": "zg_tWI_WvgNe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Tweet: {df_train['text'][2]}\")\n",
        "print('Tweet numericalizado: ')\n",
        "print(train_sequences[2])\n",
        "print(f'Quantidade de palavras no tweet: {len(train_sequences[2])}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rn_YFJXu2nNm",
        "outputId": "e46c2751-1003-49d2-f3a0-c1b390870dc0"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tweet: its not that I\\u2019m a GSP fan\\u002c i just hate Nick Diaz. can\\u2019t wait for february.\n",
            "Tweet numericalizado: \n",
            "[141, 61, 23, 4, 57, 8, 5680, 475, 3, 4, 30, 574, 501, 2177, 55, 35, 103, 10, 269]\n",
            "Quantidade de palavras no tweet: 19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pós-processamento da numericalização\n",
        "\n",
        "Vamos tornar todos os vetores numéricos acrescentando-se zeros ao final, precisamos fixar um tamanho para os vetores numéricos resultantes da numericalização.\n",
        "\n",
        "Uma estratégia consiste em calcular a quantidade de tweets que existe para cada quantidade possível de palavras. Supondo que o tweets pós-processados não possuirão mais do que $50$ palavras, montamos o seguinte histograma:"
      ],
      "metadata": {
        "id": "HFhFxk-Qvwi9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "max_words = 50\n",
        "\n",
        "hist = {}\n",
        "\n",
        "hist['qtde'] = [x for x in range(0,max_words)]\n",
        "\n",
        "lista = [0]*(max_words)\n",
        "for x in train_sequences:\n",
        "    lista[len(x)]+=1\n",
        "\n",
        "hist['num tweets'] = lista"
      ],
      "metadata": {
        "id": "LU2YIq73v8Fb"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fig = plt.figure(figsize = (10, 5))\n",
        " \n",
        "# creating the bar plot\n",
        "plt.bar(hist['qtde'],hist['num tweets'],\n",
        "        color ='blue')\n",
        " \n",
        "plt.xlabel(\"Number of words\")\n",
        "plt.ylabel(\"Number of tweets\")\n",
        "plt.title(\"Comparando a quantidade de palavras e a quantidade de tweets\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 350
        },
        "id": "OwJFdyEVwWYL",
        "outputId": "d1557b70-7d8a-4c8a-9abe-b80d4192ea92"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Pode-se verificar que grande parte dos tweets do treinamento possui entre 10 e 30 palavras. Por isso, vamos ajustar o tamanho dos vetores numericalizados como 32:"
      ],
      "metadata": {
        "id": "YSBQ3tCe1tFd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "max_length = 32"
      ],
      "metadata": {
        "id": "Dp8IbQ5f1bd_"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Assim, tweets cujos vetores numericalizados possuírem menos do que 32 palavras serão completados com zeros. Tweets que possuírem mais do que 32 palavras serão truncados (terão algumas palavras removidas)\n",
        "\n",
        "A função que faz essas operações de truncamento e de padding é [pad_sequences](https://www.tensorflow.org/api_docs/python/tf/keras/utils/pad_sequences). Ajustamos a seguir o tipo de truncamento (se é no início ou no final) e o padding (inclusão de zeros ocorre no início ou no final):"
      ],
      "metadata": {
        "id": "IPonN9N32kzL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "trunc_type = 'post'\n",
        "padding_type = 'post'"
      ],
      "metadata": {
        "id": "BlmM1HE02Y38"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Agora vai..."
      ],
      "metadata": {
        "id": "M4vObkUn1aJM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_padded = pad_sequences(train_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)"
      ],
      "metadata": {
        "id": "7dz_Q2b_2jgH"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Veja o resultado em que todos os vetores \"padded\" possuem tamanho $32$:"
      ],
      "metadata": {
        "id": "i9fE8J7X3dBg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Tweet:')\n",
        "print(df_train['text'][0])\n",
        "print('\\nVetor numericalizado do tweet:')\n",
        "print(train_sequences[0])\n",
        "print('\\nVetor numericalizado pós-processado com padding e truncamento:')\n",
        "print(train_padded[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IAB4cLYh3Eh1",
        "outputId": "a3482650-3fc5-4117-da0f-d9ac8f83a672"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tweet:\n",
            "Gas by my house hit $3.39!!!! I\\u2019m going to Chapel Hill on Sat. :)\n",
            "\n",
            "Vetor numericalizado do tweet:\n",
            "[2711, 68, 22, 191, 383, 72, 2909, 4, 57, 31, 2, 1966, 1127, 6, 115]\n",
            "\n",
            "Vetor numericalizado pós-processado com padding e truncamento:\n",
            "[2711   68   22  191  383   72 2909    4   57   31    2 1966 1127    6\n",
            "  115    0    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Tweet:')\n",
        "print(df_train['text'][2])\n",
        "print('\\nVetor numericalizado do tweet:')\n",
        "print(train_sequences[2])\n",
        "print('\\nVetor numericalizado pós-processado com padding e truncamento:')\n",
        "print(train_padded[2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oS21dum_2EE8",
        "outputId": "dbe1c191-fd55-40e0-d234-80db4003c0b1"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tweet:\n",
            "its not that I\\u2019m a GSP fan\\u002c i just hate Nick Diaz. can\\u2019t wait for february.\n",
            "\n",
            "Vetor numericalizado do tweet:\n",
            "[141, 61, 23, 4, 57, 8, 5680, 475, 3, 4, 30, 574, 501, 2177, 55, 35, 103, 10, 269]\n",
            "\n",
            "Vetor numericalizado pós-processado com padding e truncamento:\n",
            "[ 141   61   23    4   57    8 5680  475    3    4   30  574  501 2177\n",
            "   55   35  103   10  269    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finalmente, temos que numericalizar os tweets de validação e de testes:"
      ],
      "metadata": {
        "id": "bDHrcuEqNhgl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "valid_sequences = tokenizer.texts_to_sequences(df_valid['text'])\n",
        "test_sequences = tokenizer.texts_to_sequences(df_test['text'])\n",
        "\n",
        "valid_padded = pad_sequences(valid_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)\n",
        "test_padded = pad_sequences(test_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)"
      ],
      "metadata": {
        "id": "VWNRPhj0Nhnb"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Arquitetura da Rede Neural Convolucional Profunda (RNCP)\n",
        "\n",
        "Começamos pela camada de entrada da RNCP. Poderíamos até colocar os vetores numericalizados ou one-hot encoding como entrada da rede (utilizando a camada de [Input](https://www.tensorflow.org/api_docs/python/tf/keras/layers/InputLayer)), mas trata-se de um espaço esparso que é difícil de identificar relacionamentos entre as palavras (Fonte: [Word Embeddings Tensorflow](https://www.tensorflow.org/text/guide/word_embeddings)).\n",
        "\n",
        "Por isso, uma abordagem mais apropriada trata-se da criação de word embeddings de tamanho fixo. Nessa representação, cada palavra é representada por um vetor de tamanho $n$ em que palavras similares em relação a um contexto possuem valores (codificação) parecidas:\n",
        "\n"
      ],
      "metadata": {
        "id": "8ZBTwtGUR7oW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![embedding.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "dgOOrsB-6SIW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos utilizar uma camada [Embedding](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Embedding), que possui pesos inicializados aleatoriamente e que são ajustados durante o treinamento via backpropagation. A embedding layer recebe como entrada uma matriz de dimensões *batch_size* $\\times$ *input_length* e gera como saída uma matriz de *batch_size* $\\times$ *output_dim*.\n",
        "\n",
        "No exemplo abaixo, vamos criar um embedding que recebe uma entrada quatro instâncias contendo uma palavra cada. Assim, os parâmetros do objeto *Embedding* são ajustados como:\n",
        "\n",
        "*   dimensão da entrada (```input_dim```): O vetor de entrada é descrito por em um espaço de características de 4 dimensões. Por exemplo, o vocabulário de um corpus de treinamento, em que cada palavra é um eixo desse espaço;\n",
        "*   comprimento da entrada (```input_length```): quantidade de palavras (números) no vetor de entrada. Por exemplo, a quantidade total de palavras de um texto;\n",
        "*   dimensão da saída (```output_dim```): vamos gerar um vetor de 16 dimensões para cada número da instância da entrada.\n",
        "\n"
      ],
      "metadata": {
        "id": "8YycAUa_6f1N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = 16\n",
        "\n",
        "embedding_model = Sequential()\n",
        "embedding_model.add(Embedding(input_dim = 4,output_dim = n, input_length = 2))"
      ],
      "metadata": {
        "id": "7hktOGWa6f-s"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Veja como a predição ocorre para três vetores de entrada, cada um composto por duas palavras:"
      ],
      "metadata": {
        "id": "B4WPCs-c7b2Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "preds = embedding_model.predict([[3,1],[2,0],[1,1]])\n",
        "print(preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kj1cnf9r7Q3q",
        "outputId": "31d346c3-170b-4f7f-bb17-b50283909d16"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[-0.03738808 -0.01555153  0.01267136  0.02722342  0.0076576\n",
            "    0.00764887  0.00492281  0.01170427 -0.00802235  0.02911219\n",
            "   -0.0155543   0.04267925  0.03391931 -0.01232327 -0.00943492\n",
            "    0.02474544]\n",
            "  [-0.01647995  0.01380012  0.04392635 -0.01922065 -0.01734706\n",
            "   -0.0153716  -0.02368927 -0.00586349  0.04357848  0.02374974\n",
            "   -0.02012072  0.01302186 -0.03841271  0.02272666  0.01341662\n",
            "    0.00260087]]\n",
            "\n",
            " [[-0.04955786 -0.03345659  0.022073   -0.00538725 -0.02730136\n",
            "   -0.04410125  0.04446191 -0.00538515  0.02903019  0.00852995\n",
            "    0.01167786 -0.02818509  0.02656514  0.04522653 -0.01819725\n",
            "    0.03533561]\n",
            "  [ 0.03563949 -0.04505098 -0.00352506  0.03791815 -0.00921858\n",
            "   -0.0410561  -0.03654842 -0.00542773 -0.03253347 -0.02154924\n",
            "    0.02824259 -0.01819972 -0.03610264 -0.04260318  0.02475048\n",
            "    0.00755868]]\n",
            "\n",
            " [[-0.01647995  0.01380012  0.04392635 -0.01922065 -0.01734706\n",
            "   -0.0153716  -0.02368927 -0.00586349  0.04357848  0.02374974\n",
            "   -0.02012072  0.01302186 -0.03841271  0.02272666  0.01341662\n",
            "    0.00260087]\n",
            "  [-0.01647995  0.01380012  0.04392635 -0.01922065 -0.01734706\n",
            "   -0.0153716  -0.02368927 -0.00586349  0.04357848  0.02374974\n",
            "   -0.02012072  0.01302186 -0.03841271  0.02272666  0.01341662\n",
            "    0.00260087]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Voltando para o problema de classificação de polaridade de tweets, vamos gerar embeddings de dimensão 32:"
      ],
      "metadata": {
        "id": "XfMq0CjK8nEV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = 32"
      ],
      "metadata": {
        "id": "GrZxojkR8tIM"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Agora vamos implementar a arquitetura da nossa rede:\n",
        "\n",
        "\n",
        "\n",
        "*   Camada [Conv1D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv1D): realiza a operação de convolução como mostra a imagem abaixo (observe a existência de *padding* nas bordas do sinal de entrada - vetor com linhas escuras):\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "qbhmrsUK87WL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![conv1d.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "r9s41L_KOEk1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   Camada [MaxPooling1D](https://keras.io/api/layers/pooling_layers/max_pooling1d/) ou [AveragePooling1D](https://keras.io/api/layers/pooling_layers/average_pooling1d/): funciona da mesma maneira que as camadas Max Pooling 2D, reduzindo a dimensão dos vetores conforme o parâmetro de stride. Existem também as variações *Minimum Pooling (MinPool1D)* e *Average Pooling (AvgPooling)*. A figura abaixo ilustra o processamento de um max pooling com ```pool_size = 2```."
      ],
      "metadata": {
        "id": "InCD8br5pu5E"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![maxpool1d.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "8aP1HqFzT5SE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   Camada [GlobalMaxPooling1D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/GlobalMaxPool1D) ou [GlobalAveragePooling1D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/GlobalAveragePooling1D): seleciona o maior valor em uma entrada como mostra a figura abaixo, que ilustra o *Global Max Pooling*."
      ],
      "metadata": {
        "id": "kV4J0qJipvKC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![globalmaxpool1d.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "87Wc-E_GVBhC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Importante:** Em imagens, é muito comum utilizar a camada *Flatten*. Assim, qual é a diferença entre Flatten() e *GlobalxxxPooling1D*, em que *xxx* $\\in \\{ Max, Min, Average\\}$?\n",
        "\n",
        " Suponha que temos a seguinte entrada (*batch_size*,$m$,$n$) em que $m$ e $n$ são números inteiros. Veja como fica as saídas nas seguintes camadas:\n",
        "\n",
        "*   *Flatten*: (*batch_size*,$m \\times n$)\n",
        "*   *GlobalxxxPooling1D*: (*batch_size*, 1,1)\n",
        "\n",
        "Para textos, o uso de *Flatten* e *GlobalxxxPooling1D* possuem o mesmo efeito quando a entrada para qualquer uma dessas camadas é (*batch_size*,$k$), em que $k$ é um inteiro. "
      ],
      "metadata": {
        "id": "ybCRoBLfaxLA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Definindo a Arquitetura\n",
        "\n",
        "De qualquer maneira, temos a seguinte arquitetura, em que os hiperparâmetros (número de filtros, kernel_size, strides) foram ajustados aleatoriamente, com exceção da Embedding Layer, que foi ajustada com os seguintes detalhes:\n",
        "\n",
        "\n",
        "\n",
        "*  ```input_dim = vocab_size```: o espaço de características one hot encoding que é passado na entrada possui ```vocab_size``` dimensões;\n",
        "*  ```output_dim = n```: a dimensionalidade de saída do word embedding é ajustado para $n$;\n",
        "*  ```input_length = max_length```: o tamanho de cada *tweet* foi truncado para *max_length* palavras;\n",
        "\n",
        "Veja também onde está a camada *GlobalMaxPooling1D*. Lembre-se que na camada anterior, a Conv1D recebe um *tweet* em sua forma numericalizada e truncada, e gera ```filters``` mapas de ativação. Por isso, a operação de *GlobalMaxPooling1D* nesses    que o total de *tweets* por *batch* é igual a *batch_size*.\n",
        "\n"
      ],
      "metadata": {
        "id": "Kg5HES41bAuv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = Sequential()\n",
        "model.add(Embedding(input_dim = vocab_size, output_dim = n, input_length=max_length))\n",
        "model.add(Conv1D(filters=128, kernel_size=11, padding='same',strides=1))\n",
        "model.add(Activation('relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(GlobalMaxPooling1D())\n",
        "model.add(Dense(256))\n",
        "model.add(Activation('relu'))\n",
        "model.add(Dense(3))\n",
        "model.add(Activation('softmax'))\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "lFnqMSwQR-C9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f38bce21-a32e-4869-aefe-453e494b673b"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding_1 (Embedding)     (None, 32, 32)            1161472   \n",
            "                                                                 \n",
            " conv1d (Conv1D)             (None, 32, 128)           45184     \n",
            "                                                                 \n",
            " activation (Activation)     (None, 32, 128)           0         \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 32, 128)          512       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " global_max_pooling1d (Globa  (None, 128)              0         \n",
            " lMaxPooling1D)                                                  \n",
            "                                                                 \n",
            " dense (Dense)               (None, 256)               33024     \n",
            "                                                                 \n",
            " activation_1 (Activation)   (None, 256)               0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 256)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 3)                 771       \n",
            "                                                                 \n",
            " activation_2 (Activation)   (None, 3)                 0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,240,963\n",
            "Trainable params: 1,240,707\n",
            "Non-trainable params: 256\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos treinar o modelo utilizando um ```batch_size=32``` e em $50$ épocas:"
      ],
      "metadata": {
        "id": "lT4BVn37ANGT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sgd = SGD(learning_rate=0.000001)\n",
        "model.compile(loss=\"categorical_crossentropy\",optimizer=sgd,metrics=['accuracy'])\n",
        "history_fine = model.fit(train_padded,y_train,\n",
        "                         validation_data=(valid_padded,y_valid),\n",
        "                         epochs=100,\n",
        "                         batch_size=32)"
      ],
      "metadata": {
        "id": "NVCoUJfAZ21I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7dfc97d4-dad9-481b-d22e-18faee234a01"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "303/303 [==============================] - 9s 27ms/step - loss: 1.2583 - accuracy: 0.3580 - val_loss: 1.0924 - val_accuracy: 0.4075\n",
            "Epoch 2/100\n",
            "303/303 [==============================] - 9s 28ms/step - loss: 1.2439 - accuracy: 0.3647 - val_loss: 1.0752 - val_accuracy: 0.4135\n",
            "Epoch 3/100\n",
            "303/303 [==============================] - 9s 30ms/step - loss: 1.2140 - accuracy: 0.3840 - val_loss: 1.0691 - val_accuracy: 0.4154\n",
            "Epoch 4/100\n",
            "303/303 [==============================] - 6s 19ms/step - loss: 1.1992 - accuracy: 0.3968 - val_loss: 1.0683 - val_accuracy: 0.4232\n",
            "Epoch 5/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1924 - accuracy: 0.3992 - val_loss: 1.0682 - val_accuracy: 0.4268\n",
            "Epoch 6/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1955 - accuracy: 0.4041 - val_loss: 1.0689 - val_accuracy: 0.4317\n",
            "Epoch 7/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1955 - accuracy: 0.4044 - val_loss: 1.0699 - val_accuracy: 0.4305\n",
            "Epoch 8/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1718 - accuracy: 0.4156 - val_loss: 1.0713 - val_accuracy: 0.4323\n",
            "Epoch 9/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1821 - accuracy: 0.4122 - val_loss: 1.0726 - val_accuracy: 0.4335\n",
            "Epoch 10/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1749 - accuracy: 0.4151 - val_loss: 1.0734 - val_accuracy: 0.4329\n",
            "Epoch 11/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1602 - accuracy: 0.4176 - val_loss: 1.0743 - val_accuracy: 0.4323\n",
            "Epoch 12/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1629 - accuracy: 0.4185 - val_loss: 1.0750 - val_accuracy: 0.4323\n",
            "Epoch 13/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1667 - accuracy: 0.4178 - val_loss: 1.0759 - val_accuracy: 0.4335\n",
            "Epoch 14/100\n",
            "303/303 [==============================] - 6s 19ms/step - loss: 1.1651 - accuracy: 0.4160 - val_loss: 1.0764 - val_accuracy: 0.4329\n",
            "Epoch 15/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1623 - accuracy: 0.4184 - val_loss: 1.0770 - val_accuracy: 0.4299\n",
            "Epoch 16/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1505 - accuracy: 0.4183 - val_loss: 1.0776 - val_accuracy: 0.4299\n",
            "Epoch 17/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1505 - accuracy: 0.4244 - val_loss: 1.0778 - val_accuracy: 0.4323\n",
            "Epoch 18/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1504 - accuracy: 0.4228 - val_loss: 1.0781 - val_accuracy: 0.4305\n",
            "Epoch 19/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1438 - accuracy: 0.4261 - val_loss: 1.0783 - val_accuracy: 0.4311\n",
            "Epoch 20/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1500 - accuracy: 0.4216 - val_loss: 1.0783 - val_accuracy: 0.4293\n",
            "Epoch 21/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1455 - accuracy: 0.4231 - val_loss: 1.0785 - val_accuracy: 0.4311\n",
            "Epoch 22/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1410 - accuracy: 0.4187 - val_loss: 1.0784 - val_accuracy: 0.4317\n",
            "Epoch 23/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1374 - accuracy: 0.4179 - val_loss: 1.0785 - val_accuracy: 0.4317\n",
            "Epoch 24/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1399 - accuracy: 0.4257 - val_loss: 1.0784 - val_accuracy: 0.4299\n",
            "Epoch 25/100\n",
            "303/303 [==============================] - 6s 21ms/step - loss: 1.1308 - accuracy: 0.4300 - val_loss: 1.0782 - val_accuracy: 0.4305\n",
            "Epoch 26/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.1372 - accuracy: 0.4194 - val_loss: 1.0782 - val_accuracy: 0.4311\n",
            "Epoch 27/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1415 - accuracy: 0.4230 - val_loss: 1.0780 - val_accuracy: 0.4299\n",
            "Epoch 28/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1311 - accuracy: 0.4276 - val_loss: 1.0780 - val_accuracy: 0.4305\n",
            "Epoch 29/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1351 - accuracy: 0.4267 - val_loss: 1.0777 - val_accuracy: 0.4293\n",
            "Epoch 30/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1169 - accuracy: 0.4253 - val_loss: 1.0774 - val_accuracy: 0.4281\n",
            "Epoch 31/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1216 - accuracy: 0.4273 - val_loss: 1.0773 - val_accuracy: 0.4287\n",
            "Epoch 32/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.1225 - accuracy: 0.4285 - val_loss: 1.0770 - val_accuracy: 0.4287\n",
            "Epoch 33/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1238 - accuracy: 0.4208 - val_loss: 1.0771 - val_accuracy: 0.4293\n",
            "Epoch 34/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1131 - accuracy: 0.4259 - val_loss: 1.0769 - val_accuracy: 0.4341\n",
            "Epoch 35/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1163 - accuracy: 0.4191 - val_loss: 1.0767 - val_accuracy: 0.4311\n",
            "Epoch 36/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1129 - accuracy: 0.4327 - val_loss: 1.0764 - val_accuracy: 0.4305\n",
            "Epoch 37/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1149 - accuracy: 0.4312 - val_loss: 1.0762 - val_accuracy: 0.4305\n",
            "Epoch 38/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1130 - accuracy: 0.4259 - val_loss: 1.0760 - val_accuracy: 0.4317\n",
            "Epoch 39/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1075 - accuracy: 0.4334 - val_loss: 1.0756 - val_accuracy: 0.4293\n",
            "Epoch 40/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1044 - accuracy: 0.4299 - val_loss: 1.0756 - val_accuracy: 0.4299\n",
            "Epoch 41/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1011 - accuracy: 0.4392 - val_loss: 1.0752 - val_accuracy: 0.4287\n",
            "Epoch 42/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.1018 - accuracy: 0.4337 - val_loss: 1.0751 - val_accuracy: 0.4305\n",
            "Epoch 43/100\n",
            "303/303 [==============================] - 6s 19ms/step - loss: 1.1004 - accuracy: 0.4294 - val_loss: 1.0747 - val_accuracy: 0.4305\n",
            "Epoch 44/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.1053 - accuracy: 0.4318 - val_loss: 1.0744 - val_accuracy: 0.4335\n",
            "Epoch 45/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.1051 - accuracy: 0.4280 - val_loss: 1.0743 - val_accuracy: 0.4335\n",
            "Epoch 46/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0904 - accuracy: 0.4298 - val_loss: 1.0740 - val_accuracy: 0.4341\n",
            "Epoch 47/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0970 - accuracy: 0.4285 - val_loss: 1.0739 - val_accuracy: 0.4353\n",
            "Epoch 48/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0947 - accuracy: 0.4294 - val_loss: 1.0737 - val_accuracy: 0.4347\n",
            "Epoch 49/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0990 - accuracy: 0.4297 - val_loss: 1.0736 - val_accuracy: 0.4365\n",
            "Epoch 50/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0883 - accuracy: 0.4359 - val_loss: 1.0733 - val_accuracy: 0.4377\n",
            "Epoch 51/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0869 - accuracy: 0.4312 - val_loss: 1.0733 - val_accuracy: 0.4383\n",
            "Epoch 52/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0951 - accuracy: 0.4406 - val_loss: 1.0731 - val_accuracy: 0.4347\n",
            "Epoch 53/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0897 - accuracy: 0.4328 - val_loss: 1.0730 - val_accuracy: 0.4347\n",
            "Epoch 54/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0841 - accuracy: 0.4412 - val_loss: 1.0728 - val_accuracy: 0.4335\n",
            "Epoch 55/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0860 - accuracy: 0.4340 - val_loss: 1.0726 - val_accuracy: 0.4329\n",
            "Epoch 56/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0823 - accuracy: 0.4365 - val_loss: 1.0725 - val_accuracy: 0.4323\n",
            "Epoch 57/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0783 - accuracy: 0.4376 - val_loss: 1.0722 - val_accuracy: 0.4329\n",
            "Epoch 58/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0903 - accuracy: 0.4243 - val_loss: 1.0721 - val_accuracy: 0.4347\n",
            "Epoch 59/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0792 - accuracy: 0.4312 - val_loss: 1.0720 - val_accuracy: 0.4347\n",
            "Epoch 60/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0793 - accuracy: 0.4376 - val_loss: 1.0719 - val_accuracy: 0.4341\n",
            "Epoch 61/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0744 - accuracy: 0.4334 - val_loss: 1.0717 - val_accuracy: 0.4335\n",
            "Epoch 62/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0687 - accuracy: 0.4390 - val_loss: 1.0716 - val_accuracy: 0.4353\n",
            "Epoch 63/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0754 - accuracy: 0.4347 - val_loss: 1.0714 - val_accuracy: 0.4365\n",
            "Epoch 64/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0752 - accuracy: 0.4387 - val_loss: 1.0712 - val_accuracy: 0.4365\n",
            "Epoch 65/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0709 - accuracy: 0.4401 - val_loss: 1.0711 - val_accuracy: 0.4365\n",
            "Epoch 66/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0700 - accuracy: 0.4382 - val_loss: 1.0711 - val_accuracy: 0.4359\n",
            "Epoch 67/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0726 - accuracy: 0.4315 - val_loss: 1.0709 - val_accuracy: 0.4377\n",
            "Epoch 68/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0677 - accuracy: 0.4329 - val_loss: 1.0709 - val_accuracy: 0.4365\n",
            "Epoch 69/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0727 - accuracy: 0.4377 - val_loss: 1.0706 - val_accuracy: 0.4365\n",
            "Epoch 70/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0711 - accuracy: 0.4363 - val_loss: 1.0705 - val_accuracy: 0.4383\n",
            "Epoch 71/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0725 - accuracy: 0.4316 - val_loss: 1.0703 - val_accuracy: 0.4383\n",
            "Epoch 72/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0656 - accuracy: 0.4416 - val_loss: 1.0702 - val_accuracy: 0.4383\n",
            "Epoch 73/100\n",
            "303/303 [==============================] - 6s 19ms/step - loss: 1.0647 - accuracy: 0.4357 - val_loss: 1.0702 - val_accuracy: 0.4377\n",
            "Epoch 74/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0652 - accuracy: 0.4407 - val_loss: 1.0700 - val_accuracy: 0.4383\n",
            "Epoch 75/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0620 - accuracy: 0.4450 - val_loss: 1.0699 - val_accuracy: 0.4383\n",
            "Epoch 76/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0615 - accuracy: 0.4386 - val_loss: 1.0698 - val_accuracy: 0.4371\n",
            "Epoch 77/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0670 - accuracy: 0.4392 - val_loss: 1.0697 - val_accuracy: 0.4365\n",
            "Epoch 78/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0618 - accuracy: 0.4328 - val_loss: 1.0695 - val_accuracy: 0.4383\n",
            "Epoch 79/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0578 - accuracy: 0.4422 - val_loss: 1.0695 - val_accuracy: 0.4365\n",
            "Epoch 80/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0640 - accuracy: 0.4316 - val_loss: 1.0693 - val_accuracy: 0.4371\n",
            "Epoch 81/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0631 - accuracy: 0.4419 - val_loss: 1.0691 - val_accuracy: 0.4389\n",
            "Epoch 82/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0561 - accuracy: 0.4464 - val_loss: 1.0691 - val_accuracy: 0.4389\n",
            "Epoch 83/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0584 - accuracy: 0.4474 - val_loss: 1.0691 - val_accuracy: 0.4359\n",
            "Epoch 84/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0581 - accuracy: 0.4451 - val_loss: 1.0689 - val_accuracy: 0.4377\n",
            "Epoch 85/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0604 - accuracy: 0.4426 - val_loss: 1.0687 - val_accuracy: 0.4377\n",
            "Epoch 86/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0546 - accuracy: 0.4420 - val_loss: 1.0686 - val_accuracy: 0.4377\n",
            "Epoch 87/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0549 - accuracy: 0.4440 - val_loss: 1.0686 - val_accuracy: 0.4377\n",
            "Epoch 88/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0531 - accuracy: 0.4442 - val_loss: 1.0685 - val_accuracy: 0.4371\n",
            "Epoch 89/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0530 - accuracy: 0.4459 - val_loss: 1.0684 - val_accuracy: 0.4371\n",
            "Epoch 90/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0530 - accuracy: 0.4424 - val_loss: 1.0683 - val_accuracy: 0.4371\n",
            "Epoch 91/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0516 - accuracy: 0.4469 - val_loss: 1.0682 - val_accuracy: 0.4365\n",
            "Epoch 92/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0549 - accuracy: 0.4366 - val_loss: 1.0680 - val_accuracy: 0.4383\n",
            "Epoch 93/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0507 - accuracy: 0.4453 - val_loss: 1.0679 - val_accuracy: 0.4383\n",
            "Epoch 94/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0525 - accuracy: 0.4452 - val_loss: 1.0678 - val_accuracy: 0.4401\n",
            "Epoch 95/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0440 - accuracy: 0.4468 - val_loss: 1.0679 - val_accuracy: 0.4401\n",
            "Epoch 96/100\n",
            "303/303 [==============================] - 5s 16ms/step - loss: 1.0476 - accuracy: 0.4454 - val_loss: 1.0677 - val_accuracy: 0.4414\n",
            "Epoch 97/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0432 - accuracy: 0.4497 - val_loss: 1.0676 - val_accuracy: 0.4407\n",
            "Epoch 98/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0431 - accuracy: 0.4544 - val_loss: 1.0676 - val_accuracy: 0.4407\n",
            "Epoch 99/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0494 - accuracy: 0.4476 - val_loss: 1.0675 - val_accuracy: 0.4420\n",
            "Epoch 100/100\n",
            "303/303 [==============================] - 5s 15ms/step - loss: 1.0460 - accuracy: 0.4483 - val_loss: 1.0675 - val_accuracy: 0.4426\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(history_fine.history['loss'])\n",
        "plt.plot(history_fine.history['val_loss'])\n",
        "plt.title('model loss')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['training set','validation set'], loc='upper left')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "OJHj7NfRfJrS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "59f15549-c0a7-4376-89e2-7f9e9f819223"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(history_fine.history['accuracy'])\n",
        "plt.plot(history_fine.history['val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['training set','validation set'], loc='upper left')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "cUKzQDzCgdVX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "3c8bfcd9-36b6-461a-bebd-3d81cf34a446"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUVd6A3zOT3nslJKFDAqk0EaQKioAVUVHRFVy7rLLq7n6rsu6uu2JZuwJ2UIqCSO/SI6EEEgiENNIr6T1zvj/uJKQTQgII532eecjce8+5Zybh/O6vCyklCoVCoVA0RXelF6BQKBSKqxMlIBQKhULRIkpAKBQKhaJFlIBQKBQKRYsoAaFQKBSKFlECQqFQKBQtogSEQgEIIb4SQrzRzmuThBDju3pNCsWVRgkIhUKhULSIEhAKxTWEEMLkSq9Bce2gBITid4PRtDNPCHFMCFEqhFgshHAXQmwQQhQLIbYKIRwbXD9VCBEjhCgQQuwUQvRvcC5ECHHYOG4ZYNHkXrcJIY4ax+4TQgxq5xonCyGOCCGKhBApQojXmpy/0ThfgfH8LONxSyHE20KIZCFEoRBij/HYaCFEagvfw3jjz68JIVYKIb4TQhQBs4QQQ4QQ+433yBBCfCiEMGswPkAIsUUIkS+EyBJC/EUI4SGEKBNCODe4LlQIkSOEMG3PZ1dceygBofi9cRcwAegDTAE2AH8BXNH+np8FEEL0Ab4HnjeeWw/8IoQwM26Wq4FvASdghXFejGNDgC+AxwFn4DNgjRDCvB3rKwUeAhyAycATQojbjfP6Gtf7gXFNwcBR47gFQBhwg3FNfwYM7fxOpgErjfdcAtQCcwEXYDgwDnjSuAZbYCuwEfACegHbpJSZwE5geoN5HwR+kFJWt3MdimsMJSAUvzc+kFJmSSnTgN1AhJTyiJSyAlgFhBivuxdYJ6XcYtzgFgCWaBvwMMAUeE9KWS2lXAkcbHCPOcBnUsoIKWWtlPJroNI4rk2klDullMellAYp5TE0IXWT8fT9wFYp5ffG++ZJKY8KIXTAo8BzUso04z33SSkr2/md7JdSrjbes1xKeUhKeUBKWSOlTEITcHVruA3IlFK+LaWskFIWSykjjOe+BmYCCCH0wH1oQlRxnaIEhOL3RlaDn8tbeG9j/NkLSK47IaU0ACmAt/FcmmxcqTK5wc++wAtGE02BEKIA8DGOaxMhxFAhxA6jaaYQ+CPakzzGOeJbGOaCZuJq6Vx7SGmyhj5CiLVCiEyj2elf7VgDwM/AACGEP5qWViil/K2Da1JcAygBobhWSUfb6AEQQgi0zTENyAC8jcfq6N7g5xTgn1JKhwYvKynl9+2471JgDeAjpbQHPgXq7pMC9GxhTC5Q0cq5UsCqwefQo5mnGtK0JPMnQCzQW0pph2aCa7iGHi0t3KiFLUfTIh5EaQ/XPUpAKK5VlgOThRDjjE7WF9DMRPuA/UAN8KwQwlQIcScwpMHYhcAfjdqAEEJYG53Ptu24ry2QL6WsEEIMQTMr1bEEGC+EmC6EMBFCOAshgo3azRfAO0IILyGEXggx3OjzOA1YGO9vCvwNuJAvxBYoAkqEEP2AJxqcWwt4CiGeF0KYCyFshRBDG5z/BpgFTEUJiOseJSAU1yRSylNoT8IfoD2hTwGmSCmrpJRVwJ1oG2E+mr/ipwZjI4HZwIfAOeCM8dr28CQwXwhRDPwdTVDVzXsWuBVNWOWjOaiDjKdfBI6j+ULygf8AOilloXHORWjaTynQKKqpBV5EE0zFaMJuWYM1FKOZj6YAmUAcMKbB+b1ozvHDUsqGZjfFdYhQDYMUCkVDhBDbgaVSykVXei2KK4sSEAqFoh4hxGBgC5oPpfhKr0dxZVEmJoVCAYAQ4mu0HInnlXBQgNIgFAqFQtEKSoNQKBQKRYtcM4W9XFxcpJ+f35VehkKhUPyuOHToUK6UsmluDXANCQg/Pz8iIyOv9DIUCoXid4UQotVwZmViUigUCkWLKAGhUCgUihZRAkKhUCgULXLN+CBaorq6mtTUVCoqKq70UhRNsLCwoFu3bpiaql40CsXVyjUtIFJTU7G1tcXPz4/GhTsVVxIpJXl5eaSmpuLv73+ll6NQKFrhmjYxVVRU4OzsrITDVYYQAmdnZ6XZKRRXOde0gACUcLhKUb8XheLq55oXEAqFQnEtsP54BukF5Zf1nkpAdCEFBQV8/PHHHRp76623UlBQ0OY1f//739m6dWuH5r8UVq9ezYkTJy77fRWK65XUc2U8ueQwn+zsaFfajqEERBfSloCoqalpc+z69etxcHBo85r58+czfvz4Dq+voygBoVBcXjZGZwJw+Oy5y3pfJSC6kJdffpn4+HiCg4OZN28eO3fuZOTIkUydOpUBAwYAcPvttxMWFkZAQACff/55/Vg/Pz9yc3NJSkqif//+zJ49m4CAAG6++WbKyzU1c9asWaxcubL++ldffZXQ0FAGDhxIbGwsADk5OUyYMIGAgAAee+wxfH19yc3NbbTO2tpaZs2aRWBgIAMHDuTdd98FID4+nkmTJhEWFsbIkSOJjY1l3759rFmzhnnz5hEcHEx8/OV9olEorkc2xWgCIjazmLKqth8uO5NrOsy1Ia//EsOJ9KJOnXOAlx2vTglo9fybb75JdHQ0R48eBWDnzp0cPnyY6Ojo+vDOL774AicnJ8rLyxk8eDB33XUXzs7OjeaJi4vj+++/Z+HChUyfPp0ff/yRmTNnNrufi4sLhw8f5uOPP2bBggUsWrSI119/nbFjx/LKK6+wceNGFi9e3Gzc0aNHSUtLIzo6GqDetDVnzhw+/fRTevfuTUREBE8++STbt29n6tSp3Hbbbdx9990d++IUCkW7yS6uIDL5HME+DhxNKSAqpZDhPZ0vPLATUBrEZWbIkCGNYv/ff/99goKCGDZsGCkpKcTFxTUb4+/vT3BwMABhYWEkJSW1OPedd97Z7Jo9e/YwY8YMACZNmoSjo2OzcT169CAhIYFnnnmGjRs3YmdnR0lJCfv27eOee+4hODiYxx9/nIyMjEv56AqFogNsjslCSnjlln7A5TUzXTcaRFtP+pcTa2vr+p937tzJ1q1b2b9/P1ZWVowePbrF3ABzc/P6n/V6fb2JqbXr9Hr9BX0cDXF0dCQqKopNmzbx6aefsnz5ct577z0cHBzqtR+FQnFl2BidSQ8Xa4b4O9HT1ZrDyZdPQCgNoguxtbWluLj1zo2FhYU4OjpiZWVFbGwsBw4c6PQ1jBgxguXLlwOwefNmzp1r/seVm5uLwWDgrrvu4o033uDw4cPY2dnh7+/PihUrAC37OSoqql2fS6FQdA4FZVXsT8hjYqAHQghCuztyJKWAy9UJVAmILsTZ2ZkRI0YQGBjIvHnzmp2fNGkSNTU19O/fn5dffplhw4Z1+hpeffVVNm/eTGBgICtWrMDDwwNbW9tG16SlpTF69GiCg4OZOXMm//73vwFYsmQJixcvJigoiICAAH7++WcAZsyYwVtvvUVISIhyUisUXciWE1nUGiS3BHoAEOrrSH5pFUl5ZZfl/tdMT+rw8HDZtGHQyZMn6d+//xVa0dVBZWUler0eExMT9u/fzxNPPHHVmI3U70ehaJvHvj7IyYxi9rw0BiEEpzKLmfjeLhbcE8TdYd065R5CiENSyvCWzl03PojrlbNnzzJ9+nQMBgNmZmYsXLjwSi9JoVC0g5LKGnbF5TJzqG99aZrebjbYmptw+Oy5ThMQbaEExDVO7969OXLkyJVehkKhuEg2x2RSVWNg8iCP+mM6nSC4u8Nlc1QrH4RCoVBchfwSlY63gyWh3RuHpod2d+R0VjEllVqkYk2tgcKy6i5Zg9IgFAqF4irjXGkVu+Ny+cNI/2aVj0N9HTFI2HIik5T8cpZGnGVUHxf+e3dQp69DCQiFQnHdIKUkKrWQAC87TPVXrwFlQ3QmNQbJ1CCvZueCfbQabXOXaWHnI3u7MCnQo9l1nYESEAqF4rogt6SSV346zpYTWcy6wY/XpnZN8mxlTS25JVV4O1i2e4yUspGm8EtUOj1crRngadfsWntLU54c3ZPqWgP3D/XF38W62TWdxdUrQq9TbGxsAEhPT2+11tHo0aNpGtLblPfee4+ysvOx0u0pH97ZJCUlsXTp0st6T4WiJTbHZDLx3V38eiqH0O4OfL0/iaMpXfP/4Z0tp5n07i6qaw3tun7LiSyC529hSUQyAFlFFRxIzGNqkFerjbX+PKkff508oEuFAygBcdXi5eVVX6m1IzQVEO0pH97ZKAGhuBqITitkzreH8LC34JdnbuTrR4fgbmvBKz8db/cm3hJSSiqqaxsdMxgka46mU1xZQ9q5Czf3OZiUz9NLD1NVY+Cvq6JZvCeRdccykBJuG9TcvHS5UQKiC3n55Zf56KOP6t+/9tprLFiwgJKSEsaNG1dfmrsuQ7khSUlJBAYGAlBeXs6MGTPo378/d9xxR6NaTE888QTh4eEEBATw6quvAloBwPT0dMaMGcOYMWOA8+XDAd555x0CAwMJDAzkvffeq79fa2XFG7JixQoCAwMJCgpi1KhRgFYufN68eQwePJhBgwbx2Wef1X/+3bt3ExwcXF9CXKG43PxyLB0TnWDJY0Pp62GLrYUpr00N4GRGEYv3JHZozrKqGu7+dD93fbIPg+F8snFUagEZhVo9tcS80jbnOJVZzB++Ooi3oyW/zhvNLYEe/GPtCd7bepoBnnb0crPp0No6k+vHB7HhZcg83rlzegyEW95s9fS9997L888/z1NPPQXA8uXL2bRpExYWFqxatQo7Oztyc3MZNmwYU6dObVWd/OSTT7CysuLkyZMcO3aM0NDQ+nP//Oc/cXJyora2lnHjxnHs2DGeffZZ3nnnHXbs2IGLi0ujuQ4dOsSXX35JREQEUkqGDh3KTTfdhKOjY7vKis+fP59Nmzbh7e1db7JavHgx9vb2HDx4kMrKSkaMGMHNN9/Mm2++yYIFC1i7dm2Hvl7F9UdxRTW1BomDlVmnzCelZMPxTG7o5dJozkmBHkwY4M57W09za6An3Z2t2j1nda2BJ5cc5pAxF2H3mVxu6uMKaG1BdQIMEpJyS6Hv+XHRaYW8sDwKC1Md9lZmnEgvwtJMzzePDsHNzoIP7gvhxRVRrD6aztTgK689gNIgupSQkBCys7NJT08nKioKR0dHfHx8kFLyl7/8hUGDBjF+/HjS0tLIyspqdZ5du3bVb9SDBg1i0KBB9eeWL19OaGgoISEhxMTEXLDT2549e7jjjjuwtrbGxsaGO++8k927dwPtKys+YsQIZs2axcKFC6mt1dTrzZs388033xAcHMzQoUPJy8trsWy5QnEhnlp6hFlfHuy0+WLSizibX8bkgc2jfOZPC0AvBK+uiW538TuDQfLnlcfYeSqH+dMCcLU156u9mhYipWT98UxG9XHF1txEExAN2Hkqm1NZxdhbmVFYXk13J0u+fnQI3Rw14WSi1/H29GAWPRTOIyP8Lu2DdxLXjwbRxpN+V3LPPfewcuVKMjMzuffeewGtCF5OTg6HDh3C1NQUPz+/Fst8X4jExEQWLFjAwYMHcXR0ZNasWR2ap472lBX/9NNPiYiIYN26dYSFhXHo0CGklHzwwQdMnDix0bU7d+7s8FoU1x+ZhRXsjstBAEUV1dhZmF7ynOuPZ6DXCSYMaC4gPO0tmTuhD2+sO8nmE1lMDGg5VDQ5r5Tdcbkk55USnVbE/oQ8/jShDw8N9yOvpIr/bYsjMbeU4opq0grKeW58b/JKqkhoIiBiM4vxcbLkm0eHtLpevU4wfoD7pX3oTkRpEF3Mvffeyw8//MDKlSu55557AK3Mt5ubG6ampuzYsYPk5OQ25xg1alS9szc6Oppjx44BUFRUhLW1Nfb29mRlZbFhw4b6Ma2V5B45ciSrV6+mrKyM0tJSVq1axciRI9v9eeLj4xk6dCjz58/H1dWVlJQUJk6cyCeffEJ1tZbNefr0aUpLS1VZcMVFsSYqDSk188yRs5ceYaQ90WdwQ09nnKxbNlk9fIMffd1tmf/LCcqrapudTy8oZ+qHe/nb6mi+3p9MTkklc8f34ZmxvQB4YGh3THSCb/Ynse54BiY6wc0D3PFzsSapiQ/idFYxfd1tm93jaub60SCuEAEBARQXF+Pt7Y2npycADzzwAFOmTGHgwIGEh4fTr1+/Nud44okneOSRR+jfvz/9+/cnLCwMgKCgIEJCQujXrx8+Pj6MGDGifsycOXOYNGkSXl5e7Nixo/54aGgos2bNYsgQ7SnmscceIyQkpNUudU2ZN28ecXFxSCkZN24cQUFBDBo0iKSkJEJDQ5FS4urqyurVqxk0aBB6vZ6goCBmzZrF3LlzL+arU1xn/Hw0nb7utpzJKSEyKb/ert9RTmYUk5RXxpxRPVu9xlSvY/60AO79/AAf7ohj3sTz/xdrDZLnfzhKTa2Btc/cyABPO3S6xn5CNzsLJg/yZGVkKnaWpvW+Dn9nK9YdS6eqxoCZiY6qGgMJOaWM73/1aAftQkp5TbzCwsJkU06cONHsmOLqQf1+FHXEZRVJ35fWysW7E+Rt7++W936275LnfGtjrPR/ea3MLa644LVzfzgie/1lnTyeWlB/7L0tp6XvS2vlj4dS2hx7KDlf+r60Vvq+tFb+8FuylFLKHw+lSN+X1sq4rGIppZSxGdrnW30k9RI+UQsYDFKmRkqZEtnhKYBI2cq+qkxMCoXiirP6SDo6AbcFeRLu58jRlAKqai6co1BYVs2qI6nNjkujeWlYD2ecbcxbGNmYV27tj7W5CVM+3MOsL39j8Z5E/rftNHeEeHNnaNtltUN8HBjUzb6Rr8PPmMBW56iOzSwCoK9HJ5mYKksg8kv4/CZYOBZ2/rtz5m2CEhAKheKykF1c0SyxDLTN/OeoNEb0csHN1oLBfk5UVBuISS+84JzLIs8yd1kUZ5t0WDuTXUJCbim3DPRs19pcbc3Z9Pwonh3bmxPpRfxj7Qm6OVoxf9qFy3EIIfjXHQN5+56gel9HjzoBYfRDnM4qxkQn6OHSCbkNyfvh/RBY+zwYauHWBXD34kuftwWueR+EbFLjRHF1IK+RToadSVlVDYt2JzJnVA8sTPVXejmdipSSqR/s5ZaBHrw6pfGme/hsASn55Tw3rg8A4b5aeevIpHOENCl13ZS4rBJAS0prmMsQbRQuw/yd2r1GdzsL5k7ow9Nje7HrdA693bSkuvYQ6G1PoLd9/XsHKzMcrExJNGoQpzJL8HexxszkAs/kGVGw/Q1wGwBhs8DJv/H5yC9g/Z/BoTvc+y34DIUu3N+6VIMQQkwSQpwSQpwRQrzcxnV3CSGkECK8yfHuQogSIcSLHbm/hYUFeXl5ajO6ypBSkpeXh4WFxZVeyhWhsqaW6LTmT8dbT2bzzpbT7IjNvgKr6lrySqvILKrg11M5zc79fDQNcxMdEwM0B66bnQW+zlYcTMq/4LxncjQB0TTnIDGnFJ3gohLg6jDV6xjX371DYxvi53w+kulUVhF9LmReOr4SFk+ElN9g3/vwfjB8czus/ZP2+v4+WDsXeoyG2duh+7AuFQ7QhRqEEEIPfARMAFKBg0KINVLKE02uswWeAyJamOYdYEMLx9tFt27dSE1NJSen+R+l4spiYWFBt25d3zLxamR5ZCqv/hzN3pfH4ml/vuLnKaOdOiq1sN2mka6gsqaWjIKKejt6Z5CQo22UCbmlZBVV4G6nPRxIKdkYncmYvm6NntbDfZ3YcSq7TQuAlJIz2UYB0SSkNDGvDG9HS8xNrpwm5u9iTURCHqWVNaTklzM9zOf8ydoaOLMFqozrTj0IEZ9C9+Ew/RuorYYj38Kx5ecrQAgdjHwRxvwFdJfnc3WliWkIcEZKmQAghPgBmAY0TfX9B/AfYF7Dg0KI24FEoO2CJm1gamqKv7//hS9UKC4jJ9KLMEiITitqIiC0nJFjqZe36m5DSiprePSrgxxMymfxw+GM7dc5YZkJxid9gP3xedwe4g1omc7ZxZXNksMG+zny4+FUEnJL6enast0+p6SS4gqtq1ozDSK3BP/OsPdfAn7O1qw6ksZxo7ZYr0FICetfgENfNR4Q/ihM+g+YGHM2Rr+sva4gXWli8gZSGrxPNR6rRwgRCvhIKdc1OW4DvAS83tYNhBBzhBCRQohIpSUoLoSUkv3xV97kGG986m3qhI01CojjqYWNCsBdLgrLq3lwcQSHks/h42jFc98fJb7Bxn4pJOaWYqbXYW9pyr743Prj205mIwSM7ts45yHcT/MdRBrNTEm5pc2+rzrtwdHKlOQGTmopJUm5ZfhfoonoUvFz0e6/5YRWRqc+Se63hZpwGP40PB2pvZ6PhtvePS8crhKuWBSTEEKHZkJ6oYXTrwHvSinb/OuUUn4upQyXUoa7ul5aUo3i2ue3xHzuW3iATTGt1726HNRtujHpRfXHiiuqST1Xjp+zFcWVNResBNpRPtgWx9xlR5sdP1daxQOLDhCdVshH94eydPZQTE10zPkmkuKKS+93HJ9Tip+LFUP9ndifkFd/fHtsFkHdHHBpEora09UaRytTVh5K5cHFEYxesJN7Pt1PZc35KKg6QTumrxsp58qoMZbuzimpxK/qNM+eeRT+F6S9PhysOYAvI3W9GjbFZGJhqsPHyQrid8DGl6HvrTDhH+DSW3s5+FxgtitDV5qY0oCGn7qb8VgdtkAgsNNoY/QA1gghpgJDgbuFEP8FHACDEKJCSvlhF65XcY1zMkPbkH89ndNlLRpbpKoMYn6CkmzOhTxFXmkVQmimpjpOZ2nawz3hPry16RTHUgtaNa10FCklS387S0ZhBX+a0EfbsIy8tfkUpzNL+PzBcMb0cwPgo/tDmbk4grnLolj4UFj7ogFrquDX/0BReqPDd6dkYm9pCmahzM7vSeq5MsxN9GSlJvBu3xhY9d35i71DEYMfY7CfE5tPZOFpb8HkgZ6sO55BdFoRYeapcHoT8fkTsDE3YWgPJ346kkZ6QQXdna1IO5vIIrO3sakxA//R2pynN2rRQQ+suNSvsd34uVjTS6Tyh+INuFnr0P+8Bk6tA9e+cOfnoLv6swy6UkAcBHoLIfzRBMMM4P66k1LKQqC+FrUQYifwopQyEhjZ4PhrQIkSDopLpS7iZdfpnMsT/lyQAvs+gKgfoFIzj2SaDwRgmL8z+xPyOFdahaO1Wb156bZBnny4/QxRKYXcEdKyE7+wvBpbc5NmZR8aUlJZg4lONAqXjc8pre9VsCYqnafGaPWEyqtqWXM0nduCPOuFA8Dwns7Mm9iXNzfEEpNeRKC7BSTugh5jQN946ziQkMcgbzusNs6FI9+BvQ+grU8iCawux16AbewmIszNyfppPaKqgL3mO9AnSygwXm+ohqilkLSH1255mweG+TKipzMF5dWsO57BydgThB2bBaXZDLGJ4YjbY/g5n8856G4n6L75MSwoI3/aCjz7DdYWuPtt2DYf0g6Bd9j5hSfs1H5PF8KtvzbuIv5m7Krz+c78v9jKYioNjpAUB0494Z4vwfz3UZOpywSElLJGCPE0sAnQA19IKWOEEPPRUrvXdNW9FYqWqLNZpxWUk5RX1rXtGhN+hRWzoKoEBkyDoPtgxSwsj34JPMDUYC/2J+RxIqOIEb1ciM0oxtbchO5OVgR627XoqDYYJJ/tSmDB5lP8+46BTB/culnigUUReNlb8MnM85vh3jOa7b+7kxU/H03jydE9EUKwITqDksoapoc3n2/yQE/e3BDLkeR8AiPehGM/gP8ouPsrsHYG4FByPjM+P8DfXXbyaMl3MGoejP1b/RxJuaWMWbCTt24byF0eOWz+4p/cmrqeSp0l3+nv4KGn/46oi/eXUgvx3PoaXnln8JqxBPSuuNiYM8BZz8hDzwLlEHAnt8b8RJFtL/xcwoz3KWHU8VdwLozmido/8UHvBoJg8GzY+z78+l+4f5l27MgS+PnJC/8u63AP1HITeozWIoqaYukIVsa8i5pKWDYTB4q5q+pVbh93C7NH9Wj/va4SujRRTkq5Hljf5NjfW7l2dCvHX+v0hSmuS85klzLU34mIxHx2x+V0jYCQEg58Apv/ptmWZ2wFZ2OxuKD76HbwC7xMpzJhgDuv/HScmPRCRvRy4VRmMX08bBFCMKibA98dSKa61oCpXtuICsqqeGF5FNuMORInMopaWwGFZdVEpRQQkybIL62qz+7dHZeLj5Mls0f14P9WRxObWUx/TztWRKbS3UnzDzSlm6MlrrbmOBz9BLJ/gH63QdwWWDgaZiwFj4FsislijP4YDxcvZJ/5cPoPeZGG6W11EUw93GzR+XRnS6+/8k5SFkWVBiaH+J4XDqA9oY94DtwDYOWjmu+g/1QIf4R/6z/FpzQew33LKPUZxdFjp7kn8x10GWHMMdvELbv+AhVJrHZ6lNPVN2Gib7CJW9hpTuEdb0D6Ec0UtvZ5TdhN+4g6bafl32ktxG/XSlusbyMlS2cC/SZr0UhRyyD1N5Z3m0/MGT/+3FklNi4z13wmtUIB2gabW1LJnFH+ZBRWsOt0Dg8N9+v8G236Kxz4CPpOhjs/a2xKGPwHTH77jNk2+3CxmYGnvQUn0ouQUhKbWcSUIK2L2KBu9lTWGDidVUyAlz35pVVM/XAPWUUVvD41gG8PJJNR2Hq/40NntcifGoNk3fEMHhzmS3WtgQMJeUwJ8mLyQE/+tSaK0tV/oqZkF/8rqcTaTI94u8F2YGEPg6YjQh7kYeeTTM78HALuhLu/gLTDsGwmfD4GaeXE46VV2JmWUObQhydzH8dj0W8snT2sXjDV5UDUlZ8Y3tOF9cczAcG4BiatRvQaD4/vhgMfw9HvIXolQcA/q+/nXscbKMmr5KnqZ9lv/y+sv7+Xv+ggwdAP19s/5ZPtXvi7tBDBNHQO7P9A+x3lngY7b7jn6/NP/W0R/iiEPQIZRyG3lWZYGVFwdAmcMLYQHv0KpdwGZ2LppwSEQnH1Umde6u1my8jeLqw+klZfirnTiPxCEw5D5sCk/3Ayq4SY9FTuDjP6Elz7clgXyNTqjWCoZYCnHTHpRWQWVVBUUVO/iQR1cwDgWGohAV72vLnhJGpqNZ4AACAASURBVJmFFSx7fBhhvk5sPZlV70toiYNJ5zDVC7o5WrHmaBoPDvMlKqWAksoaRvZ2wclwjjW2b9I7K4ZTTmM5VATT+nqDeYPkq7x4zam7803+iJ5ogx9e49/BRQjoFgZzdsK+9ykqPMemYxmE9PCk/11/5cNscx7+8jcW7U7gz5O00tkJuaU4WpniaBQYw3topilzEx039HShVRx94Zb/wLhXIWYVefm5LNzSkx5J5zDV6yjChrxp32F9dhX/TOrDtgIPtg66iaSVGxnVt4WoRgt7GPYU7PwXmNvBrHXtEw51CAFeIdqrJQZNh7H/pwmIkiwY/jQPVNUywMuuPjHw94YSEIrrgjoB0cvNhsoaA0siznLk7DmGGjeriyYjCiqKwHeEFo2SuBvWz4NeE2DSm6DT8cH2ODZEZzKqj1aErryqlsWVY/nI9H04s5UALz92nMrmqLE5Tl8POwB8na2wtzQlKqWAPu62LI9MZc6oHoT5apuZl70lJzNab8QUmZRPgJc9Ewa489amU6SeK2N3XC5CwEjrVPj8Ifxr8nm66hm2ZI9gaA9n7r+7hS5nefFw6CvKEg4yJ+l+5qdXcnOd7cjWHSb+kyU7z/DfmlPsv2ss2Ftyoz0M6+HExuhM5k3sixCChJwSejSIyOrpao2nvQUDPO2wNGtHRrCZFYQ8gJOUuOzfysGkfNxsLTDVC7x6BEDvgeg3xJKSkEBaQTmVNYbWs8CH/VH73Q2ZrUUTdTamFhB0b/1bOwvdJfe1uJJc/XFWCkUncCa7BAtTHd4Olgzv6YxeJ9gdl3vhgU2REva8B5+Phq9vgw9CNcfn8ge1CJW7F4NOj5SS3xLzkRI2G/Mu4nNK2FQbToWFK+z/iKFWGfQlmT0HDwPnS0Frfgh7jpwt4P9WR+NhZ8Fz43rXL8HTwYLckkqtHHZpnlaKwfiqKC0iKqWQwX6OTDWarH4+ms7eM7mM86jAduUM0OmpnrWR7SY3UlljYHp4KyVPnHvCzf/A7A/ryNW5cLiFLm9bTmQx0Nu+UUb4pAAPEnJL64VyQm5pI3+PEIIljw3lzbsGNZuvLYQQhPk6Epl0jjPZJfg5W9f7GfycraiulfWO+Fb9Sxb2cN9S6Dnmou59vaI0CMV1QVx2CT1cbNDpBPaWpgT7OLA7LocXJ17EU2RVGax5BqJXwoDbtWSnQ1/Bjn+ChQPc9722AaFtirklVYCWKDVzmC/xOSXUYEJJwEwsDr3LiMRf2WAOnIU+1ndhbz6p/laDutnz0Y54QMtHsDY//1/Vy7gZ58dH4vHjHVqklBETU1v+JobR0+FpfJwGEO7ryIrIFPLOnWObw7+0MNIHN2Hp0otbAqPYeSr7gl3OLEz1BHjbc/jsuUbHs4srOJpSwNzxfRodnxjgwd/XxLAhOhMPewtyiivp4dp4w+7RwRyPwX5ObIrJoriimmENtL86jWHHKc2J3ylltRVKQCiuUtb/GQw1cNs7nTLdmewSwv3Ox9aM6u3Ke9tO1+chtElZPkR9DwcXQX6iZhO/ca5mkw66F3JOa3kBTufDGH9L1BzFEwPc2XYym4KyKs5kl6ATYDv+RegzFFlbzZ+WRzGsJpKH+RG+L4G7FoKFPYOMfogbe7lw68DGSX2eDha4UIjjzy9otvRpH2nF22qrid+9knszN2O+ZQucHMJc1yk8luzNe6Yf41qeAA+sBBct/2H+tABKKvu2q7R4aHcHvv/tbKPIqm0ns5ESJjSpo+RmZ0Fod0c2RmfWl9DorA27rgTHubJqermdn7MuF2JPXC6Wpnrc7S7cJEhxYZSAuBwc/V6Lfhg4HbxDL5xsk34EDn0NPW7SomGusvosXU5VKRz+GmoqtOgRj8CLGl5YXs2WE1ncGeKNTicoq6ohraCcGa7n4/xH9nHh3a2n2RWXw7TgBiXCDAbY+BIUnNXe11ZB0l6orYRuQ7TmLL3GNb6ha+MnaICDifm42JjxxOhebIrJYuvJbM5kl+DrbI25pQ30vQUBZHq58VJCCA69hjAx/h34fAyMfpkRPW/lrtBuPDeud7OEPk8bHZ+avYu+8hz8YWMjp+lbh3zItZ3B6hEpEPklI1L/jyPmpliIamom/AuTBmu3NjdppJm0RWh3R77cm8TJjKJ64bXlRBbdHC1bjNC5JdCDN9adZKexvHdTDaKjBHjZYWGqo6La0EhAuNuZY2Gqo7Sqlv6edqoHTCehfBBdSU0V/PIcrP4j/PY5LBoLn43Uol0qW3EyHlsOX0zSNsgVs+DdANj2Dy3x5nohfrsmHIROK9vQhAsV21sRmcKLK6L49bS2OdWFWTbcUIK7OeBuZ87aYxmNB8f+ov2uziVBcQaU5UHog/DHvfDYlubCoRUiEvMZ4u9EUDd7vOwt2BidQXxOSbPyGQFedoCgIngWPPwLSAP8NBubDwfytv1yusvGJSsoy8dvz58J151me9/XGgkHg0ESmXyOvn5+MPwpePogPLyWEw6j2eb6ICbDLyIprAmhxiY+h5M1M1NJZQ17zuQyYYB7i5vxxABN6/lybyI6oTneOwNTvY4QH20tDb9LIUS9FtFiiKuiQygNoqsoztIclykRmjlixPMQ/aOWbLN2Lmz+Pxh4txZbbmr8gz6xGvZ/CL43avHmGVGaMNm9QLNtj3i29fuVZIOV82WrE9+lxK7XPm/4o7DnXciK0RKngE92xvPj4VS+emQw3Rxb3giOpWplLb7cl8SYfm7EZWvCuKGA0OkEtw3y4tv9yRSWV2t1ggwGzeHs3Aue2Nfh7zL1XBlpBeXMHumPEIKJgR4siTiLlLJZ+exQX0fE3kStG5nrDfDMYUjcqf2dRHyq/T34j4LAuyF5H8SswqS2ko+YTpb5SG5uMFd8TgkFZdXnTWlCgP9IQueO5FLxsrfA3c6cw2cLuCO0mtnfRFJVY+C2QV4tXu9jzAiPTiuiu5NVp/ZlGNHLmSMp55ppJX7O1sRmFndthvx1htIguoKKQvh6ihZZcveXMP41sHSAwX+AP+6Gx7ZpTs6oZfDNVFg8Xnvt/xCGPA4PrdbCCPvcDPf/oKX273tfc5K2RM5peG8gLH9I2+R+z9TWaIXVek+EG54FM1tt0zZyKDmfM9klTP90f7MeAHVEpxWi1wl2nc4hPqeEM9klmOgEvs6NN46pQV5U1RrYFJOpHTi1HrKiSRv4NKXVHS+3XdcJbYi/5kSdFOBBVY2B6lpJzyab2i2BHmyZe9P5p2GdDnqO1dpJzj2hxdXnJ8Evz0LsOgiZCX/cwy8OD5Je0DgX4mCS9nQ/2O8iYvvbiRCC0O6ORCTmMf3T/Rw5e47/zQgmzLf1lqCTjFpEZ2/Ys0f1YPPzN2Fl1vj51teoOfg5KwHRWSgBcamsmKVllZYbQwANtfDjY5AfD/f9AIF3Nr5eCOgWDrd/BC/Ewsyf4IEftdfsHXDrf0HfpA/uTS9DaY6mTTRFSk0jMdRC7FrY+e/2r72yRIvC+Xw0zHc+//pslOaYvRKkREB5PvS7VUtiGjpHSzzKPglARmEFfdxtKK+uZfpn+zmTXawJlc1/g4+GUpKXTkJuKTOHdsdMr+Pb/clG279Vs6S4Qd3s6e5kxS9R6dr3+Ot/qLTzY/QmZ97adKrDH+G3xHzsLEzqw1bD/ZxwsdH8SA21GNA23qbH6rF1h1EvwnNHtb+NF2I1p73HQDztLZplU0cm5eNiY95p5pymhHZ3JKuokrSCcr56ZEhj300LTArUuuJ1lv+hDnMTfYvtQM+bmJSA6CyUgLgUitIhZhWc/AUWjoXsWNj6GsRt1jJAe9zU9nhLB82m3Xu89vIObfk63+GamWHv/6C6SYmFqO8heQ9MXqA9Xe76L0T/pG14SXth9VNwdGnzOfd9CG/303wkNVWazXrEczDsSW0zXvGw1vawKWX5sP9jWP2klkjV2cSuA72ZVmoBtPo5Ztbwy/NwNoLMgnLC/ZxY9vhwDBKeWrQN+d2dWtXUnFOUr/srAKP7ujF5kCcrIlOITitqcRMWQjAlyJO9Z3IpiloDmcf4TN5BtdTz0+FUKqprm41pDxGJ+Qz2c0JvrLaq1wluDvBACOjZmjBoC51e+9swPz/W08GyWTb1weR8wn0du8xBe+sgT8b3d+eHOcMY0auNDGgjvdxseH1qADOH+XbJeppy60BPXry5D8E+DpflftcDygdxKZwy1iGc8r5WluDz0VBTDoMf016dyU0vw1fGuPthT2jHyvK1J2efoRDykFYxNPeMtnnvfBNyT2mO3qilYON+3sF6bAVs/iv0vlnrceszpHFkldsAzbG+8WWY/LYmbFIiNLv4idWaA1lvpmksd395ft68eEjaDf2m1Ff6vCik1Orl+990voaRlRNM/Cds+ht8cTPfGXwozR9PnxPuLOlVhOWJFcjkQsS0jyA/AdfdbzNc159A7/E4Wpux6kgapVXl3BHS5Gm3thoOfcUjVWmY6pMxbDlCiVU3/pcTyvTwbiyPTGVDdEarJbdbI6e4koSc0maVUV+Y0IcJA9yxszBtZeTF4WVvQX5pFRXVtViY6skpriQlv5wHu3Az9nawZNHD4Rc15uEb/LpmMS1gb2nK02N7X/hCRbtRAuJSiF2vxb6HPqQ98f74By0ufdKbnX8vvxHgN1LL4nXrDwgt0qmiUGtVqNOBzhzu/Q6+mqxVr5z2sSYEvr0dVjwCs7dp5SF+fkorEXHvkpZDaIPvg+wTmt+jplKroZ99gmoTa0yDH4DwR8DMBn54AJbcrWkdWdFabX3Qau8bK31eFNknteihEc83Ph42CwLvJu/AUqq3fUx4ypeQAn2BVOHCssDPuC/kTqguJ/fA9/ybL3G1fA5XWwfCu1mTm3aGXq5Bjefc8BJELsYFeN4Eakt1/E08Q5ifK2/eOYiIxHx++C2lkYCoqTWg14k2n9DP+x8a+wGcbcwZ07eVwnQdwMOYLJdZWIGfizVHUzQTZ0j31n0CCsXFogRER6ko0pqnDPuj9vRt7w2Pbuzae45+Wdv8v5l2/tiI5+sjfACwcYWnf2s8bsZSWDgGlt6r5RjYusP0b9vOrxj/GuScgiPfgmcwv/i+wkunerPlxlvxdjCWVXhsi6at7P9QaxAz5m/gFQxrnoVFEzQ/S+Bd7f98scbW5H1vaX7O3IY4n7uYUeXNkseG1ps4nvl4L2TCfQCmliwwmc2b1a/DllfBxIwlxd9ibp5P0enfYOD7Wq2c3xZC5GLtu5vwOh9uj2PB5tPodYJ1tweg0wmmGzu71dURyimu5J5P9+FiY87HM0Nxsz1ffC23pJK9Z3I5llrI9thsLE31BHrZt/9zdwAve+3+6YXlRgFxDr1OdPl9FdcXSkB0lDNbtLIFfSdfvnv63Qh/3KMJJwATi9b9Fg1x9NU0i6+ngok5PLj5wiYgnV6LpCk4i8GpF2+8uY0yKknKLT0vIMys4Z6vtKd+h+7nw0Ln7NRCfFc+ChnHYNzf2w4ZLUyFw99o+Qfe4WDbcjvQOqesp/35zXlUb1c+2B5HQVkVJnodywr68qj3ePpEfAJCj3nfWyi19MTuyEL46owWJbbhJegzSVsXMCXIi3e3xvHIDX70MxbMuyesG+9sOc2yyBTmju/DnG8jySyqIKuokts/3MvnD4XTw9Waz3cl8PmuBMqqajE30RHobc+jI/w6t0psC3gafwcZxkimoykF9Pe0bV/xO4WinSgB0VFi14OVi2a/v5xcrNmmDt8b4KGftcqYDTWOtjAxB5fe/JaQR1aRlqiXlFfa2EEpBDRs+AKahvLwWtgwD/a+p+Ux3LVIEyix67QWnGW5SKCwpAz7wpMIKTUz3fjXWl1OnVPWo6GA6OPK/7bFsedMLm62FkgJGTf+iz7Vt2q1kuw8sQboMxpWPQ6r5oBrf7hzYb3Q8nW2ZtPzo/BrEBnjZmfB2H5u/HgoldT8co6mFPDJA2F0c7RkzjeR3PPpfmwsTMgpruTWgR788aaeDPC0a9ykpgupE5IZheXUGiRRKYXcHtJyToJC0VGUgOgINVVaV63+U35fiWl+Izo07JeodCxN9dRKSXJeK7kYTTExgyn/A88gra7SZyM1f0ZJFth5U+vSh9OZJeQU6yhzuY9JD72kaTptkFFQgb2laaP496Bu9thbmvLrqRz6eWpP//17+IJdkyJ8/W8D561atNNNf9Z8NA1oKcrpviE+bDmRxbrjGbxySz8mBWqazc9P38iz3x+hVko+nRlaX4b7cmJhqsfJ2oyMwgric0ooqaypzzBWKDoLJSA6QvIerQl9v8toXrpCVNcaWH88gwkD3DmZUdRqchpARXUtH2yP45ZATy0zGLRsaNf+sO4FLToq7BGy3Ecy+7sjHD9XiJutOeaVeiZdQDiApkE0NC8BmOh13NjLhV1xOVTXGnCzNcetteYsbv3h9o/b/dlH9XYlqJs9Id0dmdOgn7CrrTnfzxnW7nm6Cg87CzIKKzhirLIa3F2Fdyo6FyUgOkLsejCx1DKcr3H2nsnlXFk1U4K8KKuqbVODWH88g492xPPJznhm3eDPn27ug425iZbH8eQ+QHPo3vHBHgrKq/lsZhhx2SW8tenU+XIXbZBZVN5MQADc1MeVdccz2Hoyu8W+yh3FRK9j9VMjrtrCb14OFqSe08xf9pam+KsMYkUnoxLlLpbaGs2O3nOsZs+/xlkTlY6dhQmj+rjg52xFcn4pBkPLZSg2RGfiYWfB/UO78+W+RMa//Wt92CdArUHy3A9HyCut4oc5w7g5wMNYrA5OpBddcC0ZBRX1ztmGjOyj+URKKmvOay6dxNUqHAA87S2NGkQBQT4O6HRX71oVv0+UgLhY4jZBcToEzbjSK2kXEQl5JLZhFmqLiupaNsdkMSnQA3MTPb4u1lRUG8gubl5ZtrSyhl2nc5gU6MEbtw/kxyduwMpMz8xFEWyM1mod/W9bHHvP5DF/WkB9yegAY1hmTHrhBdeSV1qFZwvmI097S/q6a4l1nS0grmY8HSwoLK/mVFYxISp7WNEFKAFxsRxcDLaeWoTMVU5+aRUPf/kbf/npeIfG7zyVQ0llDVOMrSvronyS8poLnJ2ncqisMdSXeQ7t7siPT9zAAC87nlxyiL+uOs4H2+O4O6xboyxjV1tz3O3MiWmiQcxddpQXV0TVv882RlF5tGBiArjJ2Jhm4HUkIOo6y0mp/A+KrkEJiIshLx7it0HYI1oHsauc7w4kU1FtICIxj+ziigsPaMK++FxszE0YbmztWFcMLbkFAbExJhNna7NGGcSO1mYsfWwYY/q6sSTiLH3dbfnHtMBmZpsAL3ui085rECWVNaw7lsGmmMx6c1a6MQfCqwUTE8ATN/Xk8wfDWhUg1yIN/THB3ZSAUHQ+SkBcDJFfgM5EK61xldHUL1BRXcvX+5Lo426DQVJv5rkYotMKGeB1Prbf094CU70gqYmjuqK6lu0ns7g5wL2+QF0dlmZ6PnswjH/eEcjiWYNbTOQK9LIjPqeE8iqtON6euFyqag0UV9QQn6P1W85sIQeiIY7WZtwc0HKC3bWKp1GD8HexvnDbVIWiAygB0V6qy+HoEuh3G9h5XunVNKKiupYxb+/kH2tP1HdbW3UkjbzSKl6fGkgfd5vmndMuQK1BcjKjuFHpBhO9Dh9Hq2YaxN4zuZRW1dabl5piotfxwFDf8xnYTQjwtscg4WSmZmbaEZuNiVHQHDaGcNYlybUUxXS94m6v9V1W1UsVXYUSEO0lZhWUn9Oa/lxlRKUUkJxXxuI9iXy4/QwGg2Th7gQGetszrIcTkwd6cTApn6yi9puZEnNLKK+urY8yqsPPxZqk3MYaxIboTGwtTLih54VLQLdE3T1i0oswGCTbT2UzMcADBytTDidrRegyCsubJcld75ib6Hl1ygAeG+l/4YsVig6gBER7ObgYXPpoFVWvMiIS8xFC60729pbTzF1+lIScUmaP6oEQgsmDPJFSy1OoI6e4sk2BEZ2mPc03jQryddY0iDpNpbrWwNaTWUzo797h+kPeDpY4WJkSk1ZIdHohOcWVjB/gRoiPA4caaBBKe2jOIyP86yPBFIrORgmI9lCWD2mRMOjexn0TrhIiEvPo52HH+/eFMLqvKz8fTcfbwZJbjaUhernZ0M/DlnVGM1N0WiE3v/srMxdF1G/0TYlJL8TcRNesRaafszWlVbXkllQBmnmpoKyaiYEdt/8LIQjwsiMmvYjtsdkIATf1cSO0uyNnsksoLKsms7DiunJAKxRXA0pAtIdMY5hoeyqnXmaqagwcSj7HUH8nTPU6Pn4glNuDvfi/2wY0Khx32yBPIpPPsf54BvctPEBpZS1x2SWcyGg5QS06rYh+LRSf820S6rok4iwuNmaMNoaZdpRAL3tOZRazKSaL0O6OOFmbEWrsd3wk5RwZheX1TlmFQnF5UAKiPWQe0/71CGr7uivA8bQCKqoNDOuhhZdamZnw3oyQ+sJydUwepOUyPLnkME7WZvz05A2Y6ARrotKbzSmlJCa9sJn/Ac6HuibllpJWUM62k1ncO9gHc5NLK1o4wMuOqloDJzOKGNtPa6wT5OOATmgmtNySKmViUiguM0pAtIeMY2Dn3bE2ml3MgYS6DmZtr83fxZohfk70crNh+ePDCfS2Z2RvF9ZGZTQzM6WeK6eooqbF5jPejpbodYLkvDKWRiQDcN+Q7pf8ORr6Osb11wSEjbkJfT3s2GD0nSgTk0JxeelSASGEmCSEOCWEOCOEeLmN6+4SQkghRLjx/QQhxCEhxHHjv2O7cp0XJPNYx/swdDERifn0cbfBqR1x8N/8YQibnh+Fu7FcxZQgL9IKyutDSeuoK3vRkgZhqtfRzdGS01nFLDuYwth+7nRzvPSaVP7O1liZ6fF2OF82AyC0u0N93oWXMjEpFJeVLhMQQgg98BFwCzAAuE8IMaCF62yB54CIBodzgSlSyoHAw8C3XbXOC1JVBrmnwWPQFVtCa9TUGjiUlM/QC2gPdViY6hslsk0Y4I65iY5fohrnSESnFaHXCfp62DadAtAa7GyLzSa3pIoHh1+4THd70OkEDw334/GbejTKtA5t0GNZaRAKxeWlKzWIIcAZKWWClLIK+AGY1sJ1/wD+A9THXEopj0gp64zjMYClEMK8C9faOtknQRrA8+oTENHpRZRW1TK0R8dKXNtamDK2nxtrj2VQ2yATOya9kN5uNliYtuxX8HO2otYg8XO2YmSvjuU+tMTLt/TjoeF+jY7VOapBJckpFJebrhQQ3kBKg/epxmP1CCFCAR8p5bo25rkLOCylbFZCVAgxRwgRKYSIzMnJ6Yw1NyfTWDDuKtQgIhLyABrVP7pYpgR5kVtSyQHjXKAJnrZi632NjuqZw3y7vMS0n7MVTtZm2FmYYG2ukuQUisvJFXNSCyF0wDvAC21cE4CmXTze0nkp5edSynApZbir66WFWbZKxjGwsAeHS3fEdjYRifn0cLXGzbbjT9Zj+7lhbabnx0OpSCnJLqogp7iSQO/m/oc6Rvd1ZXx/N+4J82n1ms5CCMHwns70bKElqEKh6Fq68pEsDWi4g3QzHqvDFggEdhptzh7AGiHEVCllpBCiG7AKeEhKGd+F62ybzGOa9tCFCXKFZdX8d1MsO0/lMC3Yiz/c6I+zTXOLWl5JJf/3czQllbU4WJpyICGPacHeLczYfixM9UwL8WZpxFnSCsoZ2VszGbWlQfR0tWHRw4Mv6b4Xw5t3DqSmtuWEPoVC0XV0pYA4CPQWQvijCYYZwP11J6WUhUC9AVsIsRN40SgcHIB1wMtSyr1duMa2qa2BrBgI75r6S1JK1kSl84+1J8gvrSLcz4lPfo3ni72JzBzqy7xJfRvlF7yx7iRbTmQxwNOOs3ml2JibMHngpRcOfH1qAP09bHlvaxwRiVrY7IAWIpiuFLYWbbciVSgUXUOXCQgpZY0Q4mlgE6AHvpBSxggh5gORUso1bQx/GugF/F0I8XfjsZullNldtd4WyTsDNRVd5qD+eGc8b206RVA3e756ZAiB3vacyS7h451nWLQnkbzSKt6ZHoQQgt1xOaw6ksazY3vxp5v7duo6TPU6Hhzux+0h3izclUBljUHrJa1QKK5rRGu1eH5vhIeHy8jIyM6d9Nhy+Gk2PLEf3JtF6F4SZ/PKmPDur4zp68ZHD4Q266Pw4fY4Fmw+zdzxfZgzqgcT39uFiU6w/rmRrUYXKRQKxcUihDgkpQxv6Zx6TGyLjCjQm2tVXDuZ13+JQa8TvDY1oJlwAHhqTC8Sc8t4d+tp9sbncja/jO9nD1PCQaFQXDaUgGiLzGOa5tDB9qJSymbtNQG2nMhiW2w2f7m1X6vJX0II/n3nQFLPlRGRmM/08G4M73n1lfpQKBTXLu0KcxVC/CSEmGwMTb0+kFKr4trB/IfX1sRw38IDzeoclVfV8tqaGPq42/DIiLYbvZiZ6PjswTDmTezLXyd3rolLoVAoLkR7N/yP0SKQ4oQQbwohOtdLejWye4HWQa6DDYIik/M5kJDPwaTGdY4+2xVPWkE586cFYqq/8NfvYGXGU2N6YW+pInkUCsXlpV0CQkq5VUr5ABAKJAFbhRD7hBCPCCGuvZ3r5C+w/Q0YOB0G3t2hKc4aC8x9sSex/lh+aRWLdidyS6AHw3ooc5FCobi6abfJSAjhDMwCHgOOAP9DExhbumRlV4rMaPjpcfAOg6nvdyhBrqCsiqKKGpytzdh8IpOUfE1YfPZrPKVVNfxpQuc7vRUKhaKzaa8PYhWwG7BCq7I6VUq5TEr5DHDt1ECoKoPv7wMLO5ixFEw7Vl76rFEgPDe+Nzoh+HJvEtlFFXy9P4k7gr3p7d5ylVSFQqG4mmhveM77UsodLZ1oLX72d0nyXig8C/ctA9uO91iuExCD/ZyYPMiT5ZEpFJRXUVMreW58785arUKhUHQp7TUxDTCWvwBACOEohHiyAhTtJgAAE0FJREFUi9Z05UjaAzpT8B91SdPUCQgfJyseHeFPSWUNPx1O455wn/pKqAqFQnG1014BMVtKWVD3Rkp5DpjdNUu6giTt0XwPZpfWIS0lvwwXGzNszE0I8nEg3NcRMxMdz47r1UkLVSgUiq6nvSYmvRBCSGNQv7Fb3IV7XP6eqCyB9CNw4/OXPNXZ/DJ8nM4LmXemB5NZVIGnapmpUCh+R7RXQGwElgkhPjO+f9x47Noh5QDIWvC78ZKnOptf1qhVZndnK7o7X3rfZoVCobictFdAvIQmFJ4wvt8CLOqSFV0pkvaCzgR8hl7SNNW1BtILKrg9WAkEhULx+6ZdAkJKaQA+Mb6uTZL3glcomF2aEzmjoIJag2xkYlIoFIrfI+3Ng+gthFgphDghhEioe3X14i4bVaWQdgj+v727D7Krru84/v5kk83DErJ5AiQPJGCqLqIkrilVbBEfGsQRmPoAakttHeoMKdjRKlhbLZ06o+PEttPUShWK40NURM1oRkzRYuMosEmQmABDBLPZDSSBfYDsbrJP3/5xzsLN5mz2ht2zd/eez2smk3vOPefe75mT7Gd/53fO77fi9WP+qKE7mJY7IMxsiiv3LqbbSVoP/cAbga8CX8urqAm3/34Y7B+3/gdwQJjZ1FduQMyOiHtIJhjaFxGfBi7Pr6wJ9rttoJox9z9AEhC1NdM48/TsYbzNzKaKcjupj6VDfT+WTiPaSjUNsbHvF3D2apg59iEwmtu6WDp/duYkQGZmU0m5LYgbScZhugF4DfB+4Nq8ippQvd3Q0jQu/Q9w4jMQZmZT1agtiPShuPdExEeBI8AHcq9qIrVuh8G+Fz3vw3DNz3Szetn80Tc0M5vkRg2IiBiQNPbe28lqxcWwvglOXzLmj+rs7uPZo/3uoDazqlBuH8ROSZuB7wBdQysj4q5cqppIEiwanxFWSwfpMzOb6soNiFnAM8ClJesCmPoBMY58i6uZVZNyn6Surn6HnLzQgvCgfGY29ZUVEJJuJ2kxHCci/mLcK5rCmtu6WVBXy9xZ1TdNt5kVT7mXmH5Y8noWcBVwYPzLmXr2PdPFj3Y9yUP7O/nF3qc594zqeTzEzIqt3EtM3y1dlvRNYFsuFU0hg4PBe//rPlo7ejhn4RwuefkZXP3aZZUuy8xsXJTbghhuFXDGeBYyFe1q7aS1o4fPvfNVvLvRwWBm1aXcPojnOL4P4imSOSIKbeueg9RME295xZmVLsXMbNyVe4lp7IMUVaGtew7SeM585tdV1+yrZmZQ/nwQV0maV7JcL+nK/Mqa/Jqf6ebRg8/xlga3HsysOpU7WN+nIqJzaCEiOoBP5VPS1PCTPU8B8NaGsypciZlZPsoNiKztyhnob52kRyXtlXTTSbb7E0khqbFk3c3pfo9K+uMy65wwW/cc5GVnzmX5Qj81bWbVqdyAaJK0QdJ56Z8NwPaT7ZCOArsRuAxoAK6R1JCx3VyS4cTvK1nXAFwNnA+sA/4j/bxJob2rlwd+1+bLS2ZW1coNiL8GeoFvAZuAo8D1o+yzFtgbEY9HRG+63xUZ2/0T8Nn0M4dcAWyKiGMR8QSwN/28SeGnjxxiMHBAmFlVK/cupi5gxEtEI1gC7C9ZbgGOm9NT0hpgWUT8SNLfDtv3V8P2PWE8bknXAdcBLF++/BTLe/G27jnImafP5IIl80bf2Mxsiir3LqatkupLludLunssX5xOYboB+MiL/YyIuDUiGiOicfHixWMpp2y/PXyEnz5yiHXnn8U0TytqZlWs3CepF6V3LgEQEe2SRnuSuhUofbx4abpuyFzglcD/SgI4C9gs6R1l7FsRg4PBzXftYtaMaay/dHzmkDAzm6zK7YMYlPT8NRxJK8gY3XWYB4BVklZKqiXpdN489GZEdEbEoohYERErSC4pvSMimtLtrpY0U9JKkqE97i+z1tx8Z/t+7n+ijU+87RUsnjuz0uWYmeWq3BbE3wHbJN0LCHgD6bX/kUREv6T1wN1ADXBbROyWdAvQFBGbT7LvbknfBvYA/cD1ETFQZq25ePrIMT6z5RHWrljgcZfMrBAUMVpDIN0wuaR0HbATmA0cioif51jbKWlsbIympqbcPv/Dm3ayZddTbLnxYl56hkceMbPqIGl7RDRmvVfuYH0fJHlWYSnwIHAR8EuOn4K0ah3rH+AHvz7An79uhcPBzAqj3D6IG4HXAvsi4o3AaqDj5LtUj6c6jxIBDS85vdKlmJlNmHID4mhEHAWQNDMiHgFell9Zk0trRw8AS+o917SZFUe5ndQt6XMQ3we2SmoH9uVX1uRyoCN5yPtsB4SZFUi5T1Jflb78tKSfAfOAH+dW1SRzIG1BnDVvVoUrMTObOKc85WhE3JtHIZPZgY4eFp02k1kzJs14gWZmuSu3D6LQWjt6WFLv1oOZFYsDogwHOnrc/2BmheOAGEVEcKDjqAPCzArHATGKju4+evoGHBBmVjgOiFG88AyE+yDMrFgcEKMYusXVLQgzKxoHxCgcEGZWVA6IURzoPErt9GksrKutdClmZhPKATGK5BmI2aSz3pmZFYYDYhTJMxDuoDaz4nFAjOJARw9nz3P/g5kVjwPiJPoGBjn03DF3UJtZITkgTmJooiDPA2FmReSAOAnf4mpmReaAOIkDnUMB4U5qMyseB8RJeCY5MysyB8RJtHb0sLCu1hMFmVkhOSBOwvNAmFmROSBOwg/JmVmROSBGEBG0trsFYWbF5YAYwXPH+unqHeAl89yCMLNickCMoL2rF4CFdTMrXImZWWU4IEbQlgbEAg/zbWYF5YAYQXt3EhDzHRBmVlAOiBG0dfUBsGCOA8LMiskBMYKhPoj5dTMqXImZWWXkGhCS1kl6VNJeSTdlvP8hSbskPShpm6SGdP0MSXek7z0s6eY868zS1t3LjBpx2szpE/3VZmaTQm4BIakG2AhcBjQA1wwFQIlvRMQFEXEh8DlgQ7r+XcDMiLgAeA3wV5JW5FVrlvauXurn1HqqUTMrrDxbEGuBvRHxeET0ApuAK0o3iIhnSxbrgBh6C6iTNB2YDfQCpdvmrr271/0PZlZoeQbEEmB/yXJLuu44kq6X9FuSFsQN6eo7gS7gSaAZ+HxEtGXse52kJklNhw8fHtfi27v63P9gZoVW8U7qiNgYEecBHwc+ma5eCwwAZwMrgY9IOjdj31sjojEiGhcvXjyudbV19/oZCDMrtDwDohVYVrK8NF03kk3Alenr9wI/joi+iDgE/AJozKXKEbR39TLfl5jMrMDyDIgHgFWSVkqqBa4GNpduIGlVyeLlwGPp62bg0nSbOuAi4JEcaz3O4GAkfRBuQZhZgeV2D2dE9EtaD9wN1AC3RcRuSbcATRGxGVgv6c1AH9AOXJvuvhG4XdJuQMDtEfFQXrUO9+zRPgYD6t2CMLMCy/Um/4jYAmwZtu4fSl7fOMJ+R0huda2IF8Zhcie1mRVXxTupJ6P27mSYDfdBmFmROSAytHskVzMzB0SWtqGRXN2CMLMCc0BkcAvCzMwBkamtu5fa6dOYU1tT6VLMzCrGAZEheUhuhgfqM7NCc0BkaOvqc/+DmRWeAyJDh5+iNjNzQGRp6+71XNRmVngOiAztXZ4LwszMATHMwGDQ0dPnFoSZFZ4DYpjOnj4iYP4cj8NkZsXmgBimzQ/JmZkBDogTtHuYDTMzwAFxAg+zYWaWcEAM83wLwgFhZgXngBimrSuZC8K3uZpZ0Tkghmnv7mXWjGnM9kB9ZlZwDohh2rp63UFtZoYD4gTtDggzM8ABcYI2D9RnZgY4IE7Q0e1hNszMwAFxgrauXhZ4mA0zMwdEqf6BQTo9UJ+ZGeCAOE5HT/IMhDupzcwcEMd54ukuAJbUz65wJWZmleeAKLFjXzsAFy6vr3AlZmaV54AosaO5nXMWzmHRaTMrXYqZWcU5IFIRwY7mDtYsn1/pUszMJgUHRKqlvYfDzx1jjS8vmZkBDojn7WhO+h9WuwVhZgY4IJ63s7mDObU1vPysuZUuxcxsUsg1ICStk/SopL2Sbsp4/0OSdkl6UNI2SQ0l771K0i8l7U63mZVnrdv3tfPqpfVMr3FmmplBjgEhqQbYCFwGNADXlAZA6hsRcUFEXAh8DtiQ7jsd+BrwoYg4H7gE6Mur1p7eAR5+8lnWnOP+BzOzIXn+urwW2BsRj0dEL7AJuKJ0g4h4tmSxDoj09VuBhyLi1+l2z0TEQF6FPtTSQf9g+A4mM7MSeQbEEmB/yXJLuu44kq6X9FuSFsQN6erfA0LS3ZJ2SPpY1hdIuk5Sk6Smw4cPv+hCdzR3AO6gNjMrVfEL7hGxMSLOAz4OfDJdPR24GHhf+vdVkt6Use+tEdEYEY2LFy9+0TXsaG5n5aI6zwNhZlYiz4BoBZaVLC9N141kE3Bl+roF+HlEPB0R3cAWYE0eRUYEO5vbWe3nH8zMjpNnQDwArJK0UlItcDWwuXQDSatKFi8HHktf3w1cIGlO2mH9R8CePIpsbuvm6SO97n8wMxtmel4fHBH9ktaT/LCvAW6LiN2SbgGaImIzsF7Sm0nuUGoHrk33bZe0gSRkAtgSET/Ko86+gUHWnX8Wv79yQR4fb2Y2ZSkiRt9qCmhsbIympqZKl2FmNqVI2h4RjVnvVbyT2szMJicHhJmZZXJAmJlZJgeEmZllckCYmVkmB4SZmWVyQJiZWSYHhJmZZaqaB+UkHQb2jeEjFgFPj1M5U0URjxmKedw+5uI41eM+JyIyRzutmoAYK0lNIz1NWK2KeMxQzOP2MRfHeB63LzGZmVkmB4SZmWVyQLzg1koXUAFFPGYo5nH7mItj3I7bfRBmZpbJLQgzM8vkgDAzs0yFDwhJ6yQ9KmmvpJsqXU8eJC2T9DNJeyTtlnRjun6BpK2SHkv/rsp5VyXVSNop6Yfp8kpJ96Xn/FvplLhVQ1K9pDslPSLpYUl/UIRzLelv0n/fv5H0TUmzqvFcS7pN0iFJvylZl3l+lfi39PgfkrTmVL6r0AEhqQbYCFwGNADXSGqobFW56Ac+EhENwEXA9elx3gTcExGrgHvS5Wp0I/BwyfJngS9ExEtJprr9y4pUlZ9/BX4cES8HXk1y7FV9riUtAW4AGiPilSTTHF9NdZ7r/wbWDVs30vm9DFiV/rkO+OKpfFGhAwJYC+yNiMcjohfYBFxR4ZrGXUQ8GRE70tfPkfzAWEJyrHekm90BXFmZCvMjaSlwOfDldFnApcCd6SZVddyS5gF/CHwFICJ6I6KDApxrYDowW9J0YA7wJFV4riPi50DbsNUjnd8rgK9G4ldAvaSXlPtdRQ+IJcD+kuWWdF3VkrQCWA3cB5wZEU+mbz0FnFmhsvL0L8DHgMF0eSHQERH96XK1nfOVwGHg9vSy2pcl1VHl5zoiWoHPA80kwdAJbKe6z3Wpkc7vmH7GFT0gCkXSacB3gQ9HxLOl70Vyv3NV3fMs6e3AoYjYXulaJtB0YA3wxYhYDXQx7HJSlZ7r+SS/La8EzgbqOPEyTCGM5/ktekC0AstKlpem66qOpBkk4fD1iLgrXX1wqLmZ/n2oUvXl5PXAOyT9juTy4aUk1+fr08sQUH3nvAVoiYj70uU7SQKj2s/1m4EnIuJwRPQBd5Gc/2o+16VGOr9j+hlX9IB4AFiV3ulQS9KptbnCNY279Lr7V4CHI2JDyVubgWvT19cCP5jo2vIUETdHxNKIWEFybn8aEe8Dfga8M92sqo47Ip4C9kt6WbrqTcAeqvxck1xaukjSnPTf+9BxV+25Hmak87sZ+LP0bqaLgM6SS1GjKvyT1JLeRnKduga4LSL+ucIljTtJFwP/B+zihWvxnyDph/g2sJxkqPR3R8Twzq+qIOkS4KMR8XZJ55K0KBYAO4H3R8SxStY3niRdSNIpXws8DnyA5JfBqj7Xkv4ReA/JXXs7gQ+SXG+vqnMt6ZvAJSTDeh8EPgV8n4zzm4blv5NcbusGPhARTWV/V9EDwszMshX9EpOZmY3AAWFmZpkcEGZmlskBYWZmmRwQZmaWyQFhNglIumRotFmzycIBYWZmmRwQZqdA0vsl3S/pQUlfSueaOCLpC+lcBPdIWpxue6GkX6Xj8H+vZIz+l0r6H0m/lrRD0nnpx59WMo/D19OHnMwqxgFhViZJryB5Uvf1EXEhMAC8j2RguKaIOB+4l+TJVoCvAh+PiFeRPMU+tP7rwMaIeDXwOpLRRyEZZffDJHOTnEsylpBZxUwffRMzS70JeA3wQPrL/WySQdEGgW+l23wNuCudl6E+Iu5N198BfEfSXGBJRHwPICKOAqSfd39EtKTLDwIrgG35H5ZZNgeEWfkE3BERNx+3Uvr7Ydu92PFrSscIGsD/P63CfInJrHz3AO+UdAY8Pw/wOST/j4ZGDH0vsC0iOoF2SW9I1/8pcG86o1+LpCvTz5gpac6EHoVZmfwbilmZImKPpE8CP5E0DegDrieZlGdt+t4hkn4KSIZd/s80AIZGVYUkLL4k6Zb0M941gYdhVjaP5mo2RpKORMRpla7DbLz5EpOZmWVyC8LMzDK5BWFmZpkcEGZmlskBYWZmmRwQZmaWyQFhZmaZ/h+9Akngoro4IwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Avaliação com os Dados de Teste"
      ],
      "metadata": {
        "id": "QP7yxTEPg1Nv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_prob = model.predict(test_padded)\n",
        "y_pred = np.argmax(y_prob,axis=1)"
      ],
      "metadata": {
        "id": "yM-hXxVtg4J2"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(classification_report(y_test_int,y_pred))"
      ],
      "metadata": {
        "id": "u42IOHfzlCnM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13b1c6fd-02df-4e21-c28b-6fd47afad1be"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.00      0.00      0.00       559\n",
            "           1       0.43      0.86      0.57      1513\n",
            "           2       0.43      0.15      0.23      1475\n",
            "\n",
            "    accuracy                           0.43      3547\n",
            "   macro avg       0.29      0.34      0.27      3547\n",
            "weighted avg       0.36      0.43      0.34      3547\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ]
    }
  ]
}