news-headlines-sarcasm-detection-cnn.ipynb

{"cells":[{"metadata":{},"cell_type":"markdown","source":"# News Headlines Sarcasm Detection using CNN\n\nIn this notebook, I will be using the [News headlines dataset](https://www.kaggle.com/rmisra/news-headlines-dataset-for-sarcasm-detection/kernels) by Rishabh Misra. \nThe dataset consists of many records with article_link,headline and is_sarcastic field where is_sarcastic field is 1 if headline is sarcastic and 0 if its not sarcastic.\n"},{"metadata":{},"cell_type":"markdown","source":"Import the necessary packages:\n\nFirst import the neccessary packages that we need.In this notebook I will be mainly using the torchtext library for processing the data."},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import numpy as np\nimport os\nimport torch\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport torch.nn as nn\nfrom torchvision.utils import make_grid\n%matplotlib inline\nimport torch.nn.functional as F","execution_count":45,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Analyze the Data:\n\nWe check how many sarcastic and non sarcastic headlines are present in our dataset."},{"metadata":{"trusted":true},"cell_type":"code","source":"dataframe = pd.read_json(\"../input/news-headlines-dataset-for-sarcasm-detection/Sarcasm_Headlines_Dataset_v2.json\", lines=True)\ndataframe.head()","execution_count":46,"outputs":[{"output_type":"execute_result","execution_count":46,"data":{"text/plain":"   is_sarcastic                                           headline  \\\n0             1  thirtysomething scientists unveil doomsday clo...   \n1             0  dem rep. totally nails why congress is falling...   \n2             0  eat your veggies: 9 deliciously different recipes   \n3             1  inclement weather prevents liar from getting t...   \n4             1  mother comes pretty close to using word 'strea...   \n\n                                        article_link  \n0  https://www.theonion.com/thirtysomething-scien...  \n1  https://www.huffingtonpost.com/entry/donna-edw...  \n2  https://www.huffingtonpost.com/entry/eat-your-...  \n3  https://local.theonion.com/inclement-weather-p...  \n4  https://www.theonion.com/mother-comes-pretty-c...  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>is_sarcastic</th>\n      <th>headline</th>\n      <th>article_link</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>thirtysomething scientists unveil doomsday clo...</td>\n      <td>https://www.theonion.com/thirtysomething-scien...</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0</td>\n      <td>dem rep. totally nails why congress is falling...</td>\n      <td>https://www.huffingtonpost.com/entry/donna-edw...</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0</td>\n      <td>eat your veggies: 9 deliciously different recipes</td>\n      <td>https://www.huffingtonpost.com/entry/eat-your-...</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>inclement weather prevents liar from getting t...</td>\n      <td>https://local.theonion.com/inclement-weather-p...</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1</td>\n      <td>mother comes pretty close to using word 'strea...</td>\n      <td>https://www.theonion.com/mother-comes-pretty-c...</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"is_sarcastic_texts =[]\nnot_is_sarcastic_texts =[]\nfor index, row in dataframe.iterrows():\n    if row['is_sarcastic'] == 1:\n        is_sarcastic_texts.append(row)\n    else:\n        not_is_sarcastic_texts.append(row)\n\nprint(\"Number of Sarcastic Texts:\",len(is_sarcastic_texts))\nprint(\"Number of Non Sarcastic Texts:\",len(not_is_sarcastic_texts))\n\n\"\"\" Plot the counts of sentiment and compare\"\"\"\nfig = plt.figure()\nax = fig.add_axes([0,0,1,1])\nsentiments = ['Sarcastict','Not Sarcastict']\nnumber = [len(is_sarcastic_texts),len(not_is_sarcastic_texts)]\nax.bar(sentiments,number)\nplt.show() ","execution_count":47,"outputs":[{"output_type":"stream","text":"Number of Sarcastic Texts: 13634\nNumber of Non Sarcastic Texts: 14985\n","name":"stdout"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"# Read the Data:\n\nWe will be using the torchtext library from Pytorch where we define the TEXT and LABEL field as shown below."},{"metadata":{"trusted":true},"cell_type":"code","source":"from torchtext import data\nimport random\n\nSEED = 1234\n\nrandom.seed(SEED)\nnp.random.seed(SEED)\ntorch.manual_seed(SEED)\ntorch.backends.cudnn.deterministic = True\n\nTEXT = data.Field(tokenize = 'spacy', batch_first = True)\nLABEL = data.LabelField(dtype = torch.float)","execution_count":48,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Using the torchtext we read the json file and as we are interested only in headlines and is_sarcastic field we ignore the article_link field in the data. Then we split the data into training data and validation data in 80:20 ratio as shown below and check the length of the training data and validation data."},{"metadata":{"trusted":true},"cell_type":"code","source":"import torchtext\nTRAIN_JSON = '../input/news-headlines-dataset-for-sarcasm-detection/Sarcasm_Headlines_Dataset_v2.json'\n\nfields = {'headline': ('text', TEXT), 'is_sarcastic': ('label', LABEL)}\n\ndataset = torchtext.data.TabularDataset(path=TRAIN_JSON,format='json',fields=fields)\nprint(dataset)\n\n(train_data,valid_data) = dataset.split(split_ratio=[0.8,0.1])\n\n\"\"\"train_data, valid_data = d.split(random_state = random.seed(SEED))\"\"\"\n\n\nprint(f'Number of training examples: {len(train_data)}')\nprint(f'Number of testing examples: {len(valid_data)}')","execution_count":49,"outputs":[{"output_type":"stream","text":"<torchtext.data.dataset.TabularDataset object at 0x7f734b557790>\nNumber of training examples: 25439\nNumber of testing examples: 3180\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"Then we build the vocabulary out of our dataset. We use glove.6B.100d vectors in this notebook for the text and similarly build the vocabulary for label field as well."},{"metadata":{"trusted":true},"cell_type":"code","source":"\nMAX_VOCAB_SIZE = 25657\n\nTEXT.build_vocab(train_data, \n                 max_size = MAX_VOCAB_SIZE, \n                 vectors = \"glove.6B.100d\", \n                 unk_init = torch.Tensor.normal_)\n\nLABEL.build_vocab(train_data)","execution_count":50,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Then we print out the length of the vocabulary of Text and Label and make sure the len label vocabulary is 2 as we have two unique values for our label which is sarcastic and non sarcastic."},{"metadata":{"trusted":true},"cell_type":"code","source":"print(len(TEXT.vocab))\nprint(len(LABEL.vocab))\nprint(LABEL.vocab.stoi)\nprint(TEXT.vocab.stoi[TEXT.pad_token])","execution_count":51,"outputs":[{"output_type":"stream","text":"25657\n2\ndefaultdict(None, {0: 0, 1: 1})\n1\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(vars(train_data.examples[6]))","execution_count":52,"outputs":[{"output_type":"stream","text":"{'text': ['listen', 'up', '!', 'my', 'favorite', 'americana', 'discoveries', 'of', '2014'], 'label': 0}\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"# Batch Iterators for the data:\n\nWe define the batch size and check the device and if we have GPU access then we assign the device to cuda to train our data in GPU as shown below. We will use the BucketIterator for iterating over the training data and validation data and define the sorting mechanism in the batch as well, we will sort according to its length in a particular batch."},{"metadata":{"trusted":true},"cell_type":"code","source":"BATCH_SIZE = 128\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\ntrain_iterator, valid_iterator = data.BucketIterator.splits(\n    (train_data, valid_data), \n    batch_size = BATCH_SIZE, sort_within_batch = True,\n    sort_key = lambda x: len(x.text),\n    device = device)","execution_count":53,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Defining our CNN Model:\n\nNext we define our CNN model where we define the multiple convolution neural networks according to the filter sizes.\nIn the first layer we define the Embedding layer and we have our convolution networks according to our filter sizes and then finally we have the Linear layer and we also add a dropout as well.\nIn the forward method we pass the text through embedding layer and then pass throught the convolution neural networks where we apply relu function and then maxpool them and add a dropout and then finally pass through the Linear layer to return the output."},{"metadata":{"trusted":true},"cell_type":"code","source":"class CNN(nn.Module):\n    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, output_dim, \n                 dropout, pad_idx):\n        \n        super().__init__()\n                \n        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx = pad_idx)\n        \n        self.convs = nn.ModuleList([\n                                    nn.Conv2d(in_channels = 1, \n                                              out_channels = n_filters, \n                                              kernel_size = (fs, embedding_dim)) \n                                    for fs in filter_sizes\n                                    ])\n        \n        self.fc = nn.Linear(len(filter_sizes) * n_filters, output_dim)\n        \n        self.dropout = nn.Dropout(dropout)\n        \n    def forward(self, text):\n                \n        #text = [batch size, sent len]\n        \n        embedded = self.embedding(text)\n                \n        #embedded = [batch size, sent len, emb dim]\n        \n        embedded = embedded.unsqueeze(1)\n        \n        #embedded = [batch size, 1, sent len, emb dim]\n        \n        conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs]\n            \n        #conved_n = [batch size, n_filters, sent len - filter_sizes[n] + 1]\n                \n        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]\n        \n        #pooled_n = [batch size, n_filters]\n        \n        cat = self.dropout(torch.cat(pooled, dim = 1))\n\n        #cat = [batch size, n_filters * len(filter_sizes)]\n            \n        return self.fc(cat)","execution_count":54,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Defining the Hyperparameters\n\nIn this step, we define the input_dim, embedding dim and filters , output dim , filters and padding as shown below."},{"metadata":{"trusted":true},"cell_type":"code","source":"INPUT_DIM = len(TEXT.vocab)\nEMBEDDING_DIM = 100\nN_FILTERS = 100\nFILTER_SIZES = [1,2,3]\nOUTPUT_DIM = 1\nDROPOUT = 0.5\nPAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n\nmodel = CNN(INPUT_DIM, EMBEDDING_DIM, N_FILTERS, FILTER_SIZES, OUTPUT_DIM, DROPOUT, PAD_IDX)\nmodel","execution_count":55,"outputs":[{"output_type":"execute_result","execution_count":55,"data":{"text/plain":"CNN(\n  (embedding): Embedding(25657, 100, padding_idx=1)\n  (convs): ModuleList(\n    (0): Conv2d(1, 100, kernel_size=(1, 100), stride=(1, 1))\n    (1): Conv2d(1, 100, kernel_size=(2, 100), stride=(1, 1))\n    (2): Conv2d(1, 100, kernel_size=(3, 100), stride=(1, 1))\n  )\n  (fc): Linear(in_features=300, out_features=1, bias=True)\n  (dropout): Dropout(p=0.5, inplace=False)\n)"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"The below method shows how many parameters the model has."},{"metadata":{"trusted":true},"cell_type":"code","source":"\ndef count_parameters(model):\n    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n\nprint(f'The model has {count_parameters(model):,} trainable parameters')","execution_count":56,"outputs":[{"output_type":"stream","text":"The model has 2,626,301 trainable parameters\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"Then we use the pretrained embeddings and copy those weights."},{"metadata":{"trusted":true},"cell_type":"code","source":"pretrained_embeddings = TEXT.vocab.vectors\n\nmodel.embedding.weight.data.copy_(pretrained_embeddings)","execution_count":57,"outputs":[{"output_type":"execute_result","execution_count":57,"data":{"text/plain":"tensor([[-0.1117, -0.4966,  0.1631,  ...,  1.2647, -0.2753, -0.1325],\n        [-0.8555, -0.7208,  1.3755,  ...,  0.0825, -1.1314,  0.3997],\n        [-0.1897,  0.0500,  0.1908,  ..., -0.3980,  0.4765, -0.1598],\n        ...,\n        [ 0.2272, -1.8329, -1.2672,  ..., -0.8241,  1.3403,  0.9017],\n        [ 0.3542,  1.3837,  0.5389,  ...,  0.4686,  0.6476, -0.8975],\n        [-0.3223, -0.8340, -0.1413,  ...,  0.6861, -0.0195, -0.2755]])"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"UNK_IDX = TEXT.vocab.stoi[TEXT.unk_token]\n\nmodel.embedding.weight.data[UNK_IDX] = torch.zeros(EMBEDDING_DIM)\nmodel.embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM)","execution_count":58,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Next we define our Optimizer, Loss functions. In this case we will be using the Adam optimizer and Binary cross entropy loss function and move the model to device to train."},{"metadata":{"trusted":true},"cell_type":"code","source":"import torch.optim as optim\n\noptimizer = optim.Adam(model.parameters())\n\ncriterion = nn.BCEWithLogitsLoss()\n\nmodel = model.to(device)\ncriterion = criterion.to(device)","execution_count":59,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model","execution_count":60,"outputs":[{"output_type":"execute_result","execution_count":60,"data":{"text/plain":"CNN(\n  (embedding): Embedding(25657, 100, padding_idx=1)\n  (convs): ModuleList(\n    (0): Conv2d(1, 100, kernel_size=(1, 100), stride=(1, 1))\n    (1): Conv2d(1, 100, kernel_size=(2, 100), stride=(1, 1))\n    (2): Conv2d(1, 100, kernel_size=(3, 100), stride=(1, 1))\n  )\n  (fc): Linear(in_features=300, out_features=1, bias=True)\n  (dropout): Dropout(p=0.5, inplace=False)\n)"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"device","execution_count":61,"outputs":[{"output_type":"execute_result","execution_count":61,"data":{"text/plain":"device(type='cuda')"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"Then we define the accuraccy function on to check each epoch on how our model is doing."},{"metadata":{"trusted":true},"cell_type":"code","source":"def binary_accuracy(preds, y):\n    \"\"\"\n    Returns accuracy per batch, i.e. if you get 8/10 right, this returns 0.8, NOT 8\n    \"\"\"\n\n    #round predictions to the closest integer\n    rounded_preds = torch.round(torch.sigmoid(preds))\n    correct = (rounded_preds == y).float() #convert into float for division \n    acc = correct.sum() / len(correct)\n    return acc","execution_count":62,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Train Model:\n\nThen we define the training function which iterates over our training data and in calculates the loss and optimizes it at each and every step."},{"metadata":{"trusted":true},"cell_type":"code","source":"def train(model, iterator, optimizer, criterion):\n    \n    epoch_loss = 0\n    epoch_acc = 0\n    \n    model.train()\n    \n    for batch in iterator:\n        \n        optimizer.zero_grad()\n        \n        predictions = model(batch.text).squeeze(1)\n        \n        loss = criterion(predictions, batch.label)\n        \n        acc = binary_accuracy(predictions, batch.label)\n        \n        loss.backward()\n        \n        optimizer.step()\n        \n        epoch_loss += loss.item()\n        epoch_acc += acc.item()\n        \n    return epoch_loss / len(iterator), epoch_acc / len(iterator)","execution_count":63,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Then we define the evaluate method to evaluate how well our model is doing in each epoch."},{"metadata":{"trusted":true},"cell_type":"code","source":"def evaluate(model, iterator, criterion):\n    \n    epoch_loss = 0\n    epoch_acc = 0\n    \n    model.eval()\n    \n    with torch.no_grad():\n    \n        for batch in iterator:\n\n            predictions = model(batch.text).squeeze(1)\n            \n            loss = criterion(predictions, batch.label)\n            \n            acc = binary_accuracy(predictions, batch.label)\n\n            epoch_loss += loss.item()\n            epoch_acc += acc.item()\n        \n    return epoch_loss / len(iterator), epoch_acc / len(iterator)","execution_count":64,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Then define the utility function to check how much time each epoch is taking."},{"metadata":{"trusted":true},"cell_type":"code","source":"import time\n\ndef epoch_time(start_time, end_time):\n    elapsed_time = end_time - start_time\n    elapsed_mins = int(elapsed_time / 60)\n    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n    return elapsed_mins, elapsed_secs","execution_count":65,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"This is the main step where we actually train our model and in each epoch we record train_loss,valida_loss,train_acc and valid_acc in history.In each epoch we check if its best validation loss then we save our model."},{"metadata":{"trusted":true},"cell_type":"code","source":"history=[]","execution_count":66,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"N_EPOCHS = 5\n\nbest_valid_loss = float('inf')\n\nfor epoch in range(N_EPOCHS):\n\n    start_time = time.time()\n    \n    train_loss, train_acc = train(model, train_iterator, optimizer, criterion)\n    valid_loss, valid_acc = evaluate(model, valid_iterator, criterion)\n    \n    end_time = time.time()\n\n    epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n    \n    if valid_loss < best_valid_loss:\n        best_valid_loss = valid_loss\n        torch.save(model.state_dict(), 'news-sarcasm-model-1.0.pt')\n    \n    print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n    print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n    print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc*100:.2f}%')\n    result = {'val_loss': valid_loss, 'val_acc': valid_acc}\n    history.append(result)","execution_count":67,"outputs":[{"output_type":"stream","text":"Epoch: 01 | Epoch Time: 0m 1s\n\tTrain Loss: 0.515 | Train Acc: 74.21%\n\t Val. Loss: 0.373 |  Val. Acc: 84.74%\nEpoch: 02 | Epoch Time: 0m 1s\n\tTrain Loss: 0.318 | Train Acc: 86.46%\n\t Val. Loss: 0.311 |  Val. Acc: 86.73%\nEpoch: 03 | Epoch Time: 0m 1s\n\tTrain Loss: 0.227 | Train Acc: 90.93%\n\t Val. Loss: 0.299 |  Val. Acc: 87.04%\nEpoch: 04 | Epoch Time: 0m 1s\n\tTrain Loss: 0.155 | Train Acc: 94.19%\n\t Val. Loss: 0.322 |  Val. Acc: 87.97%\nEpoch: 05 | Epoch Time: 0m 1s\n\tTrain Loss: 0.113 | Train Acc: 96.03%\n\t Val. Loss: 0.328 |  Val. Acc: 87.99%\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"# Plotting the Accuraccy:\n\nNext, we plot the epoch vs accuraccy graph and from the graph we can see at each epoch the accuracy is increasing."},{"metadata":{"trusted":true},"cell_type":"code","source":"\"\"\"Plot the loss and accuraccy\"\"\"\n\naccuracies = [x['val_acc'] for x in history]\nplt.plot(accuracies, '-x')\nplt.xlabel('epoch')\nplt.ylabel('accuracy')\nplt.title('Accuracy vs. No. of epochs');","execution_count":68,"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"}}]},{"metadata":{},"cell_type":"markdown","source":"# Plotting the Loss:\n\nNext, we define the epoc vs loss graph and from the graph we can see at each epoch the accuracy is increasing"},{"metadata":{"trusted":true},"cell_type":"code","source":"losses = [x['val_loss'] for x in history]\nplt.plot(losses, '-x')\nplt.xlabel('epoch')\nplt.ylabel('loss')\nplt.title('Loss vs. No. of epochs');","execution_count":69,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deXxU9b3/8dcnG2FJAEnYkkAWEAjKZkAIGFwrVi1SFxYFXJHe0tbb3tva3va2vb3ttb3X/m5vtRXEBVRAXLDU3VoFkTVhk9UmIYGwhi2EJWT7/P6YAw5hQiaQk5NkPs/HIw9mzvnOzHtOwnzmnO/5fo+oKsYYY0xNYV4HMMYY0zRZgTDGGBOQFQhjjDEBWYEwxhgTkBUIY4wxAVmBMMYYE5AVCGOaARHpIiJLRaRURJ70Og+AiBSIyI1e5zDusQJhXNWSPkRE5BcioiJyt9+yCGdZsssvPw04CMSq6g9cfi1jACsQxtTXYeA/RCS8kV+3J7BFbWSraURWIIwnRKSViPyviOxxfv5XRFo56+JE5G0ROSoih0XkMxEJc9b9SER2O4datovIDQGee7iI7PP/EBeRcSKy0bk9TESyReSYiOwXkd/XI/r7QDlwXy3vq72IzBWRYhEpFJGfnskexDbJFJE1IlLi/JvpLH8RmAr8UESOB9ojc7bn/4jITuc9PSMirZ1114pIkYj8REQOOnt19wabWUQeEZGtzjbfIiJD/F56kIhsdDK/KiLRzmNq/R2a5sN+YcYr/wYMBwYBA4FhwE+ddT8AioB4oAvwE0BFpA8wAxiqqjHAzUBBzSdW1ZXACeB6v8WTgHnO7T8Af1DVWCANWFiP3Ar8DPi5iEQGWP9HoD2QCowGpgAP1PWkInIZ8A7wf0An4PfAOyLSSVXvB14Bfqeq7VT1bwGe4rfA5fi2Zy8gAfh3v/VdgThn+VRglrM9L5jZOZz2C2dZLPAN4JDf894DjAFSgAHA/c7ygL/DuraDaVqsQBiv3Av8h6oeUNVi4JfAZGddBdAN6KmqFar6mXNopQpoBaSLSKSqFqhqXi3PPx+YCCAiMcDXnWVnnr+XiMSp6nGnoARNVRcDxcDD/sudPZbxwI9VtVRVC4An/d7XhdwK/ENVX1LVSlWdD2wDbq/rgSIiwCPAP6vqYVUtBX4DTKjR9GeqelpVl+ArRvcEkflhfIVpjfrkqmqh33P+n6ruUdXDwF/xFSio/XdomhErEMYr3QH/D5pCZxnAfwO5wIciki8ijwOoai7wGL5vtAdEZIGIdCewecA3ncNW3wTW+n2wPYTv2/Y251DObReR/6f49oKi/ZbFAVEB3ldCEM9Xc3vU57HxQBsgxzmkcxTfobB4vzZHVPVEjefuHkTmJKC2Igywz+/2SaCdczvg79A0L1YgjFf24Ot4PaOHswznm+wPVDUV3zfo75/pa1DVeao6ynms4ju0ch5V3YLvg+4Wzj28hKr+Q1UnAp2dx78uIm3rE15VP8L3AfhPfosP4vvmXPN97Q7iKWtuj/o89iBwCuivqh2cn/aq2s6vTcca7/HM9q4r8y58h+Hq5UK/Q9N8WIEwjSFSRKL9fiLwHe75qYjEi0gcvuPlLwOIyG0i0ss5dHIM36GlKhHpIyLXO3sFZfg+FKsu8LrzgO8CWcBrZxaKyH0iEq+q1cBRZ/GFnqc2/wb88MwdVa3C15/xaxGJEZGewPfPvK86vAtcLiKTnFNnxwPpwNt1PdB5H88C/09EOgOISIKI3Fyj6S9FJEpErgFuA14LIvNs4F9E5Crx6eW0uaDafodBbAfThFiBMI3hXXwf5md+fgH8J5ANbAS+ANY6ywB6A38DjgMrgD+p6qf4+h+ewPetdx++PYCfXOB15wPXAn9X1YN+y8cAm0XkOL4O6wmqWgbgnCV0TTBvSlU/B1bXWPwdfB3k+cAyfEXqeee5fyIi79XyXIfwfWj/AF8n8A+B22rkvpAf4dujWSkix/Btvz5+6/cBR/DtNbwCTFfVbXVlVtXXgF87y0qBt4DLgshT2+/QNCNi/UbGtGwici3wsqomep3FNC+2B2GMMSYgKxDGGGMCskNMxhhjArI9CGOMMQFFeB2gIcXFxWlycrLXMYwxptnIyck5qKrxgda1qAKRnJxMdna21zGMMabZEJGaI/jPskNMxhhjArICYYwxJiArEMYYYwKyAmGMMSYgKxDGGGMCCukC8cySPJbnnTsX2vK8gzyz5ELT3xtjTGgI6QIxILE9M+atO1sklucdZMa8dQxIbO9xMmOM8V6LGgdRX5lpcfz+noE8PCebMVd05dPtxTw1aTCZaXFeRzPGGM+F9B4EwIi0Tgjw5trd3Hd1DysOxhjjCPkCkVN4hGpnvsIXlxec1ydhjDGhKqQLxJk+hz9OGky7VhH0Tzi3T8IYY0JZSBeIjUUlPDVpMDf268K9V/dgVf4hfn5bOhuLSryOZowxngvpAjF9dNrZPocHRqYQHias23WU6aPTPE5mjDHec7VAiMgYEdkuIrki8niA9WNFZKOIrBeRbBEZ5Szv4yw783NMRB5zM2vX9tGMHZTAgjU7OXyi3M2XMsaYZsG1AiEi4cDTwC1AOjBRRNJrNPsYGKiqg4AHgdkAqrpdVQc5y68CTgKL3Mp6xrSsVMoqqnlpRa2z3xpjTMhwcw9iGJCrqvmqWg4sAMb6N1DV4/rVNU/bAoGuf3oDkKeqrn9qX94lhuv7dmbOigLKKqrcfjljjGnS3CwQCcAuv/tFzrJziMg4EdkGvINvL6KmCcD82l5ERKY5h6eyi4uLLzEyPJqVyuET5byWU3TJz2WMMc2ZmwVCAiw7bw9BVRepal/gDuBX5zyBSBTwDeC12l5EVWepaoaqZsTHB7xqXr0MS7mMQUkdmP1ZPlXVgXZojDEmNLhZIIqAJL/7icCe2hqr6lIgTUT8hzLfAqxV1f3uRDyfiPBoViqFh07yweZ9jfWyxhjT5LhZINYAvUUkxdkTmAAs9m8gIr1ERJzbQ4Ao4JBfk4lc4PCSW77WvyvJndowc0keX3WRGGNMaHGtQKhqJTAD+ADYCixU1c0iMl1EpjvN7gQ2ich6fGc8jT/TaS0ibYCbgDfdylib8DDhkaxUNhSVsGrH4cZ+eWOMaRKkJX1DzsjI0Ozs7AZ5rrKKKkY+8XcGJLbnhQeGNchzGmNMUyMiOaqaEWhdSI+kvpDoyHDuz0zmk+3FbN9X6nUcY4xpdFYgLuC+4T1pHRnOrKX5XkcxxphGZwXiAjq2jWL80CT+sn43e0tOeR3HGGMalRWIOjw0KgUFnl+2w+soxhjTqKxA1CHpsjbcemU35q/eRcmpCq/jGGNMo7ECEYRpWakcP13JvFU7vY5ijDGNxgpEEK5IaM81veN4/vMdnK60SfyMMaHBCkSQpmWlUlx6mr+sq3W2EGOMaVGsQARpVK840rvFMnNpHtU2iZ8xJgRYgQiSiPDo6FTyik/w8bYDXscxxhjXWYGoh1uv7EZCh9bMWprndRRjjHGdFYh6iAgP4+FrUlhTcIScwiNexzHGGFdZgainezKSaN860vYijDEtnhWIemrbKoIpI3ry4Zb95BUf9zqOMca4xgrERZiamUxkeBizP7NJ/IwxLZcViIsQ164Vd12VyBtrd3OgtMzrOMYY4worEBfpkWtSqaiqZs7yAq+jGGOMK6xAXKSUuLaM6d+Vl1YUcvx0pddxjDGmwblaIERkjIhsF5FcEXk8wPqxIrJRRNaLSLaIjPJb10FEXheRbSKyVURGuJn1YkzLSuVYWSWvrtnldRRjjGlwrhUIEQkHngZuAdKBiSKSXqPZx8BAVR0EPAjM9lv3B+B9Ve0LDAS2upX1Yg3u0ZFhKZfx3Gf5VFRVex3HGGMalJt7EMOAXFXNV9VyYAEw1r+Bqh5X1TMTG7UFFEBEYoEs4DmnXbmqHnUx60WbPjqVPSVlvL3RJvEzxrQsbhaIBMD/2EuRs+wcIjJORLYB7+DbiwBIBYqBF0RknYjMFpG2gV5ERKY5h6eyi4uLG/YdBOHayzvTu3M7Zi7J56taZ4wxzZ+bBUICLDvvE1RVFzmHke4AfuUsjgCGAH9W1cHACeC8Pgzn8bNUNUNVM+Lj4xsmeT2EhQnTslLZtq+Upf842Oivb4wxbnGzQBQBSX73E4Faj8Oo6lIgTUTinMcWqeoqZ/Xr+ApGkzR2UAJdYlsxc4lNv2GMaTncLBBrgN4ikiIiUcAEYLF/AxHpJSLi3B4CRAGHVHUfsEtE+jhNbwC2uJj1kkRFhPHgyBSW5x3ii6ISr+MYY0yDcK1AqGolMAP4AN8ZSAtVdbOITBeR6U6zO4FNIrIe3xlP4/06rb8DvCIiG4FBwG/cytoQJl7dg5hWEcy0SfyMMS1EhJtPrqrvAu/WWPaM3+3fAr+t5bHrgQw38zWk2OhIJl3dg2c/y2fnoZP06NTG60jGGHNJbCR1A3pgZArhYcJzy2wSP2NM82cFogF1bR/NHYMSeDV7F4dPlHsdxxhjLokViAY2LSuVsopqXlpR6HUUY4y5JFYgGljvLjHc0Lczc1YUcKq8yus4xhhz0axAuODR0WkcPlHO6zk2iZ8xpvmyAuGCockdGZTUgWc/20FVtU2/YYxpnqxAuEBEmD46lZ2HT/L+pn1exzHGmItiBcIlN6V3JSWuLTOX5tkkfsaYZskKhEvCw4SHr0lhY1EJK/MPex3HGGPqzQqEi+4ckkhcuyibfsMY0yxZgXBRdGQ492cm8+n2YrbtO+Z1HGOMqRcrEC67b3hP2kSFM2upTb9hjGlerEC4rEObKMYPTWLx+j3sOXrK6zjGGBM0KxCN4KFRKSjw/LIdXkcxxpigWYFoBIkd23DbgG7MX72TklMVXscxxpigWIFoJNOyUjlRXsUrq2wSP2NM82AFopH0796ea3rH8cLnBZyutEn8jDFNnxWIRvRoVhrFpad5a91ur6MYY0ydXC0QIjJGRLaLSK6IPB5g/VgR2Sgi60UkW0RG+a0rEJEvzqxzM2djGdmrE/27xzJzaT7VNomfMaaJc61AiEg48DRwC5AOTBSR9BrNPgYGquog4EFgdo3116nqIFVtNtemvhARYVpWKvnFJ/h42wGv4xhjzAW5uQcxDMhV1XxVLQcWAGP9G6jqcf1qJru2QIv/Wn3rld1I6NCamUts+g1jTNPmZoFIAPyvmFPkLDuHiIwTkW3AO/j2Is5Q4EMRyRGRabW9iIhMcw5PZRcXFzdQdPdEhIfxyDUpZBceIafQJvEzxjRdbhYICbDsvD0EVV2kqn2BO4Bf+a0aqapD8B2i+raIZAV6EVWdpaoZqpoRHx/fELldd8/QJDq0iWTmEpt+wxjTdLlZIIqAJL/7icCe2hqr6lIgTUTinPt7nH8PAIvwHbJqEdpERTBleE8+2rqf3APHvY5jjDEBuVkg1gC9RSRFRKKACcBi/wYi0ktExLk9BIgCDolIWxGJcZa3Bb4GbHIxa6ObkplMVHgYsz+zvQhjTNPkWoFQ1UpgBvABsBVYqKqbRWS6iEx3mt0JbBKR9fjOeBrvdFp3AZaJyAZgNfCOqr7vVlYvxLVrxV1XJfLm2t0cKC3zOo4xxpxHWtLlMDMyMjQ7u/kMmSg4eILrnvyUb41O44dj+nodxxgTgkQkp7ahBDaS2kPJcW0Z078rL60s5PjpSq/jGGPMOaxAeGxaViqlZZUsWL3T6yjGGHMOKxAeG9yjI1enXMbzy3ZQUVXtdRxjjDnLCkQT8OjoVPaUlPH2xlrPAjbGmEZnBaIJuPbyzlzepR0zl+TTkk4aMMY0b1YgmoCwMGFaVhrb9pWy5MumP12IMSY0WIFoIr4xsDtdY6OZtdQGzhljmgYrEE1EVEQYD45KZnneITYWHfU6jjHGWIFoSiYO60FMqwhm2l6EMaYJsALRhMRERzJpeA/e+2IvOw+d9DqOMSbEWYFoYh4cmUJ4mDB7me1FGGO8ZQWiiekSG80dgxJYmL2LwyfKvY5jjAlhViCaoGlZqZRVVDN3RYHXUYwxIcwKRBPUu0sMN/brzJzlBZwqr/I6jjEmRFmBaKKmZaVx5GQFr+XsqruxMca4wApEEzU0uSODe3Rg9mc7qLRJ/IwxHrAC0USJCI9mpbHz8Ene37zP6zjGmBBkBaIJuym9CylxbW0SP2OMJ1wtECIyRkS2i0iuiDweYP1YEdkoIutFJFtERtVYHy4i60TkbTdzNlXhYcIj16Tyxe4SVuQf8jqOMSbEuFYgRCQceBq4BUgHJopIeo1mHwMDVXUQ8CAwu8b67wFb3crYHHxzSAJx7aKYucQGzhljGpebexDDgFxVzVfVcmABMNa/gaoe16+OnbQFzh5HEZFE4FbOLxohJToynPszk1nyZTFb9x7zOo4xJoS4WSASAP9zNIucZecQkXEisg14B99exBn/C/wQuOApPCIyzTk8lV1c3DKvpXDf8J60iQrnWZvEzxjTiNwsEBJg2Xk9raq6SFX7AncAvwIQkduAA6qaU9eLqOosVc1Q1Yz4+PhLzdwkdWgTxfihSSzesIc9R095HccYEyLcLBBFQJLf/USg1osuq+pSIE1E4oCRwDdEpADfoanrReRlF7M2eQ+NSkGB55ft8DqKMSZEuFkg1gC9RSRFRKKACcBi/wYi0ktExLk9BIgCDqnqj1U1UVWTncf9XVXvczFrk5fYsQ23D+jG/NU7KTlZ4XUcY0wICKpAiMj3RCRWfJ4TkbUi8rULPUZVK4EZwAf4zkRaqKqbRWS6iEx3mt0JbBKR9fjOeBqvdsJ/raZlpXGivIqXVxV6HcUYEwIkmM9jEdmgqgNF5Gbg28DPgBdUdYjbAesjIyNDs7OzvY7hqsnPrWLbvlI+++F1REeGex3HGNPMiUiOqmYEWhfsIaYzHc5fx1cYNhC4E9q4bProNIpLT/PWut1eRzHGtHDBFogcEfkQX4H4QERiqOP0U+OOzLRO9O8ey6zP8qmutqNxxhj3BFsgHgIeB4aq6kkgEnjAtVSmViLCo6PTyC8+wd+27vc6jjGmBQu2QIwAtqvqURG5D/gpUOJeLHMhX7+iK4kdWzPTBs4ZY1wUbIH4M3BSRAbiG91cCMx1LZW5oIjwMB4elUJO4RGyCw57HccY00IFWyAqndNPxwJ/UNU/ADHuxTJ1uWdoEh3aRNpehDHGNcEWiFIR+TEwGXjHmak10r1Ypi5toiKYMiKZj7bsJ/fAca/jGGNaoGALxHjgNPCgqu7DN+nef7uWygRl6oietIoIY/ZnthdhjGl4QRUIpyi8ArR3JtIrU1Xrg/BYp3atuDsjkTfX7ubAsTKv4xhjWphgp9q4B1gN3A3cA6wSkbvcDGaC8/CoVCqqq3lheYHXUYwxLUywh5j+Dd8YiKmqOgXfxYB+5l4sE6zkuLbcckVXXl5ZyPHTlV7HMca0IMEWiDBVPeB3/1A9Hmtc9mhWGqVllSxYvdPrKMaYFiTYD/n3ReQDEblfRO7Hd/W3d92LZepjYFIHrk65jOeW7aCiymZAMcY0jGA7qf8VmAUMAAYCs1T1R24GM/UzfXQae0vK+OuGWq/JZIwx9RIRbENVfQN4w8Us5hJc2yeePl1imLkkn3GDE3Cuw2SMMRftgnsQIlIqIscC/JSKyLHGCmnqJiI8kpXK9v2lfPplsddxjDEtwAULhKrGqGpsgJ8YVY1trJAmON8Y2J2usdHMWmID54wxl87VM5FEZIyIbBeRXBF5PMD6sSKyUUTWi0i2iIxylkeLyGoR2SAim0Xkl27mbCmiIsJ4aFQKK/IPsWHXUa/jGGOaOdcKhDNf09PALUA6MFFE0ms0+xgYqKqDgAeB2c7y08D1qjoQGASMEZHhbmVtSSYMSyKmVQSzbBI/Y8wlcnMPYhiQq6r5qloOLMA3G+xZqnpcv7oodltAneWqqmdmoIt0fuzyaUGIiY7k3uE9eW/TXgoPnfA6jjGmGXOzQCQAu/zuFznLziEi40RkG76xFQ/6LQ8XkfXAAeAjVV3lYtYW5YGRyYSHCbM/2+F1FGNMM+ZmgQh0nuV5ewGqukhV+wJ3AL/yW17lHHpKBIaJyBUBX0RkmtN/kV1cbGfvAHSJjWbc4AQWZu/i0PHTXscxxjRTbhaIIiDJ734iUOsoLlVdCqSJSFyN5UeBT4ExtTxulqpmqGpGfHz8JYduKaZlpXK6spq5Kwq9jmKMaabcLBBrgN4ikiIiUcAEYLF/AxHpJc6ILhEZAkQBh0QkXkQ6OMtbAzcC21zM2uL06hzDjf06M3dFAafKq7yOY4xphlwrEKpaCcwAPgC2AgtVdbOITBeR6U6zO4FNTl/D08B4p9O6G/CJiGzEV2g+UtW33craUj06Oo0jJyt4LWdX3Y2NMc3KM0vyWJ538Jxly/MO8sySvAZ7DfnqJKLmLyMjQ7Ozs72O0WSoKnf+eTnFx0/zyQ+uJSLcJuA1pqVYnneQGfPW8T93D6DHZW04UHqaGfPW8dSkwWSmxdX9BA4RyVHVjEDrgp6LyTQ/IsK0rDSmv5zDe5v2cfvA7l5HMsZcJFVlb0kZW/YcY+veY2zdd4zIcOHBF7NpExVOdGR4vYtDXaxAtHA3pXchNa4ts5bmc9uAbjaJnzHNQHllNf84UMrWvaVnC8KWvccoOVVxtk1ypzYM6dGRIyfKWbnjMA+NSmnQ4gBWIFq88DDfJH4/fvMLVuQdIrNXw/4BGWMuzeET5b49gr3H2LLHVwhyDxynstp3+D86Moy+XWP5+pXdSO8eS3q3GPp0jaVdq4izh5m+e30vXl61kxFpnWwPwtTPuMEJPPnhlzyzNN8KhDEeqapWCg+dYItfMdi6t5R9x8rOtukS24r0brFc37cz6d1j6dctluRObQkPO3/P/0xxOHNYaXhap4vqg7gQKxAhIDoynAdGJvPfH2xn695j9OtmE/Ea46YTpyvZtq/0nGKwfV8ppyp8p5xHhAm9OrcjM60T/brFOj8xdGrXKujX2FhUck4xyEyL46lJg9lYVNJgBcLOYgoRJScrGPHEx9zcvyv/b/wgr+MY0yKc6Tg+u0ewz/dv4eGTnPlobd86kn7dYujXLZZ0pxj07tKOVhHh3oZ32FlMhvZtIpkwtAdzVhTwLzf3IaFDa68jGdOsBOo43rrvGEdPnttx3K9bLN8ckugrBt1j6d4+utmeHGIFIoQ8dE0Kc1YU8PyyHfzstpozrxtjzgjUcZxXfJyKqnM7jm+5ohvp3WJI7x57tuO4JWlZ78ZcUEKH1tw+oBvzV+/ku9f3pn2bSK8jGeOpmh3HZ/YOanYc93M6jvt1iyW9e+0dxy2NFYgQMy0rjbfW7+HlVYV8+7peXscxptHU7DjeuvcY2/ae33E8Iq3T2b6C+nYctzRWIEJMevdYsi6P54XPC3hoVArRkU2jo8yYhuLfcXxmgNnWvaUUHDpxtuM4NjqC9O6xTBiW1CQ7jpsKKxAh6NGsVO6dvYpF63YzcVgPr+MYc9HKK6vJPXD83LEFNTqOe3ZqQ3q3WMYNTmgRHceNyQpECMpM68QVCbE8uzSf8RlJhIXAsVTT9D2zJI8Bie3POYd/ed5BNhaVMH10GkecjuMtZ372nN9x3CcEOo4bk225ECQiPJqVxnfmr+Ojrfu5uX9XryMZw4DE9syYt44/ThhMtw7R/GX9HmYuzaNf11he/LzAOo49YAUiRN1yRVcSO7Zm5pI8KxCmSchMi+NXY/sz9YXVZ+chChM4VVFlHccesQIRoiLCw3jkmlR+vngz2QWHyUi+zOtIJsSt33WUX/51y9n7E4Ym8cux/a3j2EN2BZkQdndGIh3bRPLMknyvo5gQ9+baIu6ZuQJFadsqnO9e34sPt+wnp/CI19FCmhWIENYmKoLJI5L529b95B4o9TqOCUFV1cpv3t3K9xduoFd8OyqqlD/fdxXf/1ofnpo0mBnz1p13WU3TeFwtECIyRkS2i0iuiDweYP1YEdkoIutFJFtERjnLk0TkExHZKiKbReR7buYMZVNH9KRVRBjPLt3hdRQTYkpOVfDgi2uYtTSfKSN6cuuAbvzp3iEBZyc13nCtD0JEwoGngZuAImCNiCxW1S1+zT4GFquqisgAYCHQF6gEfqCqa0UkBsgRkY9qPNY0gE7tWnF3RiIL1xTx/a9dTpfYaK8jmRCQV3ycR+Zks/PwSX4z7komXR14PE5mWlyDXyXNBM/NPYhhQK6q5qtqObAAGOvfQFWP61fzjbcF1Fm+V1XXOrdLga1AgotZQ9rDo1KprK7mhc8LvI5iQsAn2w9wx9OfU3KqgnmPDK+1OBjvuVkgEoBdfveLCPAhLyLjRGQb8A7wYID1ycBgYFWgFxGRac7hqezi4uIGiB16kuPacssV3XhlVSGlZRV1P8CYi6CqzFqax0MvriGpYxv+MmMkw1Ls7LmmzM0CEWjEynlXJ1LVRaraF7gD+NU5TyDSDngDeExVjwV6EVWdpaoZqpoRHx/fALFD07SsVErLKlmwelfdjY2pp7KKKr6/cAO/eXcbt1zRjde/NYLEjm28jmXq4GaBKAKS/O4nAntqa6yqS4E0EYkDEJFIfMXhFVV908WcBhiY1IHhqZfx3LIdlFdWex3HtCD7j5UxftZKFq3bzQ9uupynJg2mTZQNwWoO3CwQa4DeIpIiIlHABGCxfwMR6SXOjFkiMgSIAg45y54Dtqrq713MaPw8OjqNfcfK+OuGWuu4MfWybucRbv/jMnL3lzJz8lV854beNkleM+JagVDVSmAG8AG+TuaFqrpZRKaLyHSn2Z3AJhFZj++Mp/FOp/VIYDJwvXMK7HoR+bpbWY3PtZfH06dLDLOW5tOSrlVuvPFGThHjZ62kVWQYb/7TSJvSpRmSlvRBkJGRodnZ2V7HaNbeyCniB69t4IUHhnJdn85exzHNUGVVNU+8t43Zy3aQmdaJpycNoWPbKK9jmVqISI6qZgRaZyOpzTluH9idbu2jmbkkz+sophkqOVnBg3Oymb1sB/dnJjPnwWFWHJoxKxDmHFERYTw4MoWV+YfZsOuo13FMM5J74Dh3/OlzVuQd5IlvXskvvtGfyHD7iGnO7LdnzjNhWBIx0RHMWmqT+JngfLLtAEYPzMsAABKCSURBVOOe/pzSMt/gtwl2pcIWwQqEOU9MdCT3De/Je5v2UnDwhNdxTBOmqjyzJI8H56yhR6c2/GXGKIba1PEthhUIE9ADmclEhIUxe5ntRZjAyiqq+OdX1/PEe9v4+pXdeH16JgkdWnsdyzQgKxAmoM6x0YwbnMBr2UUcOn7a6zimidlXUsY9M1fw1vo9/OvNfXhq4mBaR9mFfVoaKxCmVo9kpXC6spo5Kwq9jmKakLU7j3D7U8vIO3CcZ6dk8O3retngtxbKCoSpVa/OMdzYrwtzVxRwsrzS6zimCXg9p4gJM1fSOjKcRd8eyU3pXbyOZFxkBcJc0PTRqRw9WcFr2UVeRzEeqqyq5j/f3sK/vLaBjOSO/OXbI7m8S4zXsYzLrECYC8pIvowhPTrw7Gf5VFbZJH6hqORkBQ+8uObs4Le5NvgtZFiBMHV6dHQaRUdO8e6mfV5HMY0s90Apd/zpc1bmH+K3d/oGv0XY4LeQYb9pU6eb+nUhNa4ts5bm2SR+IcQ3+G05pWUVzH9kOOOH2uC3UGMFwtQpLEx4JCuVTbuPsTzvkNdxjMtUlT9/6hv81jPON/gtwwa/hSQrECYo4wYnENeuFc/YJH4tWllFFY+9up7fvr+N2wZ057VHbfBbKLMCYYISHRnOAyOT+ewfB9myJ+DVX00zt7fkFPfMXMHiDb7Bb/83YZANfgtxViBM0Coqq2kVEcaspV/tRSzPO2h7FS1ATuERbv/j5+QXn+DZyTb4zfhYgTBBG5Z6GQIs3rCHoiMnWZ53kBnz1jEgsb3X0cwlWJi9i4mzVtK2VTiL/imTG23wm3HYlcNN0DLT4vjd3QP57vx13Pnn5Zw4XcUz911FZlqc19HMRaisquY3727j+c93MKpXHE9NGkyHNja+wXzF1T0IERkjIttFJFdEHg+wfqyIbHSuOZ0tIqP81j0vIgdEZJObGU39fGNgd27o25n9x05z/HQlP3pjI3/+NI/DJ8q9jmbq4ejJch54cQ3Pf76DB0Ym8+IDQ604mPO4ViBEJBx4GrgFSAcmikh6jWYfAwNVdRDwIDDbb92LwBi38pmLszzvIOt2HWXGdWm0axVBbOsIfvv+Nob/18f8y2sb+KKoxOuIpg65B0q542nf4Lff3TmAn99ug99MYG4eYhoG5KpqPoCILADGAlvONFDV437t2wLqt26piCS7mM/U05k+h6cmDSYzLY7MXnHMmLeO3945gI1FR1m0bjev5xQxuEcHpo5I5pYru9Iqws6CaUo+3rqf7y1YT3RkOAumDeeqnja+wdTOza8NCcAuv/tFzrJziMg4EdkGvINvL6JeRGSac3gqu7i4+KLDmrptLCo5WxzA1yfx1KTBHDlZzq/HXcnKn9zAz29P5+jJCh57dT0jn/g7T364nb0lpzxOblSVP32ay8Nzs0mJa8viGSOtOJg6iVtTJ4jI3cDNqvqwc38yMExVv1NL+yzg31X1Rr9lycDbqnpFMK+ZkZGh2dnZlxrdXKLqamVZ7kHmrijg420HCBPh5v5dmDIimatTLrPTJxvZqfIqfvTGRhZv2MPtA7vzuzsH2PgGc5aI5KhqRqB1bh5iKgKS/O4nAntqa+wcUkoTkThVPehiLuOysDAh6/J4si6PZ9fhk7y8spAFa3bx7hf76NMlhimZPbljUAJtW9lJdG7bW3KKaXNz2LSnhB+O6cO3RqdZgTZBc3MPIgL4ErgB2A2sASap6ma/Nr2APFVVERkC/BVIVCeU7UG0HKfKq/jrhj28uLyALXuPERMdwd1XJTF5RE9S4tp6Ha9Fyik8zKMvraWsooo/TBjEDf1sfIM5nyd7EKpaKSIzgA+AcOB5Vd0sItOd9c8AdwJTRKQCOAWM9ysO84FrgTgRKQJ+rqrPuZXXuKt1VDj3DE3i7oxE1u48wpzlhcxdUcDzn+9g9OXxTM3syejLOxMeZt9uG8LCNbv46Vub6N4hmvmPXE1vu7iPuQiu7UF4wfYgmpcDx8qYv3oXr6wq5EDpaXpc1obJw3tyd0ainZN/kSqrqvn1u1t54fMCrukdxx8n2uA3c2EX2oOwAmE8V1FVzQeb9zF3eSGrCw4THRnGHYMSmDyiJ/272zQewTp6spwZ89axLPcgD41K4ce39LXxDaZOViBMs7FlzzFeWlnAonW7KauoZmhyR6aMSObm/l2JirAPu9r8Y38pD8/NZu/RMn497gruzkiq+0HGYAXCNEMlJyt4LWcXc1cUsvPwSTrHtGLS1T2YNKwHnWOjvY7XpPxty34ee3U9raPCeea+q7iqZ0evI5lmxAqEabaqq5UlXxYzZ0UBn24vJiJMGHNFV6ZmJpPRs2NIn7LpG/yWx/98uJ0rurdn1pSr6NbeLu5j6sercRDGXLKwMOG6vp25rm9nCg6e4KWVhSzM3sXbG/fSr1ssU0f0ZOyghJAb+HWqvIp/fX0Db2/cy9hB3fntnQOIjgytbWDcZ3sQptk5WV7JW+v2MHdFAdv2ldK+dST3ZCQyeXgyPTq18Tqe6/YcPcW0l7LZvOcYPxrTl0ezUkN6T8pcGjvEZFokVWX1jsPMXVnI+5v2Ua3KdX06M2VET7J6xxPWAsdUZBccZvrLOZyuqOYPEwdxfV8b/GYujR1iMi2SiHB1aieuTu3EvpIy5q3eybxVO7n/hTUkd2rD5BHJ3HVVIu1bR3odtUG8umYnP31rEwkdWrNgWga9OtvgN+Mu24MwLUp5ZTXvbdrL3BWF5BQeoXVkOOOGJDBlRE/6do31Ot5Fqayq5j/f2cqLy32D356aOIT2bVpG0TPes0NMJiRt2l3C3BUF/GX9Hk5XVnN1ymVMzUzmpvQuRDaTAWRHTpQzY/5aPs89xMOjUnjcBr+ZBmYFwoS0IyfKWZi9i5dWFlJ05BRdY6O59+oeTBjWg/iYVl7Hq9WX+0t5eE42+0rK+M03r+SuqxK9jmRaICsQxgBV1con2w4wZ0UBn/3jIJHhwq1XdmNKZjKDkzo0qTOBPtqyn8cWrKNNqwhmTr6KIT1s8Jtxh3VSGwOEhwk3pnfhxvQu5BUf56UVhbyeU8Rb6/dwZUJ7pozoye0Du3s6nkBVefqTXJ786EuuTGjPrMkZdG1vI8eNN2wPwoS046crWbRuN3OXF/CPA8fp2CaS8UN7cO/VPUi6rHHHVPgPfrtjUHeesMFvphHYISZj6qCqrMg/xNzlhXy4ZR8AN/TrwtQRyYzs1cn1w0+7j55i2txstuw9xuNj+jLNBr+ZRmKHmIypg4iQmRZHZlocu4+eYt6qQuav3sVHW/aTGt+WqSOS+eaQBGKiG/700jUFh/mWM/jt+alDua5v5wZ/DWMuhu1BGFOLsooq3v3CN6Zi/a6jtI0K55tDEpkyomeDXaFtweqd/Owvm0jq2IZZUzLo1bldgzyvMcGyQ0zGXKINu44yd0Uhf924h/LKajLTOjFlRDI39ut8UeMSKqqq+bUz+C3r8nj+OHFwixnxbZoXzwqEiIwB/oDvmtSzVfWJGuvHAr8CqoFK4DFVXRbMYwOxAmHcduj4aV7N3sXLKwrZU1JG9/bR3Du8JxOGJtGpXXBjKo6cKOfb89ayPO8Qj1yTwuO39LNrcRvPeFIgRCQc+BK4CSgC1gATVXWLX5t2wAlVVREZACxU1b7BPDYQKxCmsVRWVfPxtgPMXVHA57mHiAoP47aB3Zg6IpmBSR1qfdz2faU8MjebfcfK+K9xV3KnDX4zHvOqk3oYkKuq+U6IBcBY4OyHvKoe92vfFtBgH2uMlyLCw7i5f1du7t+Vf+wv5aWVhbyRU8Sba3czMKkDU0f0ZM/RUwzp2ZHMtDgAPty8j+/OX0d4mPDqtOEMtsFvpolzs0AkALv87hcBV9dsJCLjgP8COgO31uexzuOnAdMAevToccmhjamv3l1i+I+xV/CvN/fhzbW7mbOigO8v3EBsdATlVdX87q6BFB48wZMffUl4mPDkPQOtOJhmwc0CEeig6nnHs1R1EbBIRLLw9UfcGOxjncfPAmaB7xDTRac15hLFREcyNTOZKSN68nnuIeasKOBvW/bz3fnrAIiKCGPW5Ku4to+dxmqaBzcLRBGQ5Hc/EdhTW2NVXSoiaSISV9/HGtOUiAijescxqnccuw6f5J9fXU924REezUq14mCaFTfnDV4D9BaRFBGJAiYAi/0biEgvcYaLisgQIAo4FMxjjWkOdh05Sf7BE3z3+l68smony/MOeh3JmKC5tgehqpUiMgP4AN+pqs+r6mYRme6sfwa4E5giIhXAKWC8+k6rCvhYt7Ia44bleQeZMW8dT00aTGZaHMPTOp1z35imzgbKGeOSZ5bkMSCx/TnFYHneQTYWlTB9dJqHyYz5io2kNsYYE9CFCoRdu9AYY0xAViCMMcYEZAXCGGNMQFYgjDHGBGQFwhhjTEAt6iwmESkGCi/y4XFAUxzFZLnqx3LVj+Wqn5aYq6eqxgda0aIKxKUQkezaTvXykuWqH8tVP5arfkItlx1iMsYYE5AVCGOMMQFZgfjKLK8D1MJy1Y/lqh/LVT8hlcv6IIwxxgRkexDGGGMCsgJhjDEmoJAqECIyRkS2i0iuiDweYL2IyP856zc6FzFqCrmuFZESEVnv/Px7I+V6XkQOiMimWtZ7tb3qyuXV9koSkU9EZKuIbBaR7wVo0+jbLMhcjb7NRCRaRFaLyAYn1y8DtPFiewWTy5O/Mee1w0VknYi8HWBdw24vVQ2JH3wXHsoDUvFduW4DkF6jzdeB9/BdE3s4sKqJ5LoWeNuDbZYFDAE21bK+0bdXkLm82l7dgCHO7RjgyybyNxZMrkbfZs42aOfcjgRWAcObwPYKJpcnf2POa38fmBfo9Rt6e4XSHsQwIFdV81W1HFgAjK3RZiwwV31WAh1EpFsTyOUJVV0KHL5AEy+2VzC5PKGqe1V1rXO7FNgKJNRo1ujbLMhcjc7ZBsedu5HOT82zZrzYXsHk8oSIJAK3ArNradKg2yuUCkQCsMvvfhHn/ycJpo0XuQBGOLu874lIf5czBcuL7RUsT7eXiCQDg/F9+/Tn6Ta7QC7wYJs5h0vWAweAj1S1SWyvIHKBN39j/wv8EKiuZX2Dbq9QKhASYFnNbwXBtGlowbzmWnzzpQwE/gi85XKmYHmxvYLh6fYSkXbAG8Bjqnqs5uoAD2mUbVZHLk+2mapWqeogIBEYJiJX1GjiyfYKIlejby8RuQ04oKo5F2oWYNlFb69QKhBFQJLf/URgz0W0afRcqnrszC6vqr4LRIpIU7jqvRfbq05ebi8RicT3IfyKqr4ZoIkn26yuXF7/janqUeBTYEyNVZ7+jdWWy6PtNRL4hogU4DsUfb2IvFyjTYNur1AqEGuA3iKSIiJRwARgcY02i4EpzpkAw4ESVd3rdS4R6Soi4twehu/3dsjlXMHwYnvVyavt5bzmc8BWVf19Lc0afZsFk8uLbSYi8SLSwbndGrgR2FajmRfbq85cXmwvVf2xqiaqajK+z4m/q+p9NZo16PaKuPi4zYuqVorIDOADfGcOPa+qm0VkurP+GeBdfGcB5AIngQeaSK67gG+JSCVwCpigzikLbhKR+fjO1ogTkSLg5/g67DzbXkHm8mR74fuGNxn4wjl+DfAToIdfNi+2WTC5vNhm3YA5IhKO7wN2oaq+7fX/ySBzefU3dh43t5dNtWGMMSagUDrEZIwxph6sQBhjjAnICoQxxpiArEAYY4wJyAqEMcaYgKxAGNMEiG920PNm5zTGS1YgjDHGBGQFwph6EJH7xHetgPUiMtOZ1O24iDwpImtF5GMRiXfaDhKRleKbl3+RiHR0lvcSkb85E72tFZE05+nbicjrIrJNRF45M1LXGK9YgTAmSCLSDxgPjHQmcqsC7gXaAmtVdQiwBN/IboC5wI9UdQDwhd/yV4CnnYneMoEzUyEMBh4D0vFdH2Sk62/KmAsImak2jGkANwBXAWucL/et8U0HXQ286rR5GXhTRNoDHVR1ibN8DvCaiMQACaq6CEBVywCc51utqkXO/fVAMrDM/bdlTGBWIIwJngBzVPXH5ywU+VmNdheav+ZCh41O+92uwv5/Go/ZISZjgvcxcJeIdAYQkctEpCe+/0d3OW0mActUtQQ4IiLXOMsnA0uc6zAUicgdznO0EpE2jfoujAmSfUMxJkiqukVEfgp8KCJhQAXwbeAE0F9EcoASfP0UAFOBZ5wCkM9XM2tOBmaKyH84z3F3I74NY4Jms7kac4lE5LiqtvM6hzENzQ4xGWOMCcj2IIwxxgRkexDGGGMCsgJhjDEmICsQxhhjArICYYwxJiArEMYYYwL6/91DJseHPzrYAAAAAElFTkSuQmCC\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"# Final Accuracy of our Model:\n\nThen we calculate the final accuraccy of our model against the validation data."},{"metadata":{"trusted":true},"cell_type":"code","source":"model.load_state_dict(torch.load('news-sarcasm-model-1.0.pt'))\n\nvall, valacc = evaluate(model, valid_iterator, criterion)\n\nprint(f'Valid Loss: {vall:.3f} | Valid Acc: {valacc*100:.2f}%')","execution_count":70,"outputs":[{"output_type":"stream","text":"Valid Loss: 0.299 | Valid Acc: 87.04%\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"# Making Predictions:\n\nThen we define the predict method where we define pass the text through the model and according it to the output we if its near to 1 we predict it as Sarcastic and if its near to 0 we predict as Not Sarcastic.\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"import spacy\nnlp = spacy.load('en')\n\ndef predict_sentiment(model, sentence, min_len = 5):\n    model.eval()\n    tokenized = [tok.text for tok in nlp.tokenizer(sentence)]\n    if len(tokenized) < min_len:\n        tokenized += ['<pad>'] * (min_len - len(tokenized))\n    indexed = [TEXT.vocab.stoi[t] for t in tokenized]\n    tensor = torch.LongTensor(indexed).to(device)\n    tensor = tensor.unsqueeze(0)\n    prediction = torch.sigmoid(model(tensor))\n    print(prediction.item())\n    pred = round(prediction.item())\n    if pred == 1:\n        return \"Sarcastic\"\n    else:\n        return \"Not Sarcastic\"","execution_count":71,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"predict_sentiment(model, \"product of the day: happy man #wine tool who's it's the #weekend? time to open up &amp; drink up!\")","execution_count":72,"outputs":[{"output_type":"stream","text":"0.03369327262043953\n","name":"stdout"},{"output_type":"execute_result","execution_count":72,"data":{"text/plain":"'Not Sarcastic'"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"predict_sentiment(model, \"thirtysomething scientists unveil doomsday clock of hair loss\")","execution_count":73,"outputs":[{"output_type":"stream","text":"0.9944638609886169\n","name":"stdout"},{"output_type":"execute_result","execution_count":73,"data":{"text/plain":"'Sarcastic'"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"# Save and upload\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"saved_weights_fname='news-sarcasm-model-1.0.pth'","execution_count":74,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.save(model.state_dict(), saved_weights_fname)","execution_count":75,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!pip install jovian --upgrade --quiet","execution_count":76,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import jovian\n","execution_count":77,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.Javascript object>","application/javascript":"if (window.IPython && IPython.notebook.kernel) IPython.notebook.kernel.execute('jovian.utils.jupyter.get_notebook_name_saved = lambda: \"' + IPython.notebook.notebook_name + '\"')"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"jovian.commit(project=\"News Headlines Sarcasm Detection\", environment=None, outputs=[saved_weights_fname])","execution_count":78,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.Javascript object>","application/javascript":"window.require && require([\"base/js/namespace\"],function(Jupyter){Jupyter.notebook.save_checkpoint()})"},"metadata":{}},{"output_type":"stream","text":"[jovian] Attempting to save notebook..\u001b[0m\n[jovian] Detected Kaggle notebook...\u001b[0m\n[jovian] Please enter your API key ( from https://jovian.ml/ ):\u001b[0m\nAPI KEY: ········\n[jovian] Uploading notebook to https://jovian.ml/siddeshbb/News Headlines Sarcasm Detection\u001b[0m\n","name":"stdout"},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.Javascript object>","application/javascript":"\n    require([\"base/js/namespace\"],function(Jupyter) {\n        var nbJson = JSON.stringify(Jupyter.notebook.toJSON());\n\n        console.log(\"[jovian] Extracted notebook JSON:\");\n        console.log(nbJson);\n\n        function jvnLog (data) {\n          console.log(\"Result from jovian.commit:\");\n          if (data.content.text) {\n              var result = JSON.parse(data.content.text.trim());\n              var msg = result['msg'];\n              var err = result['err'];\n              if (msg) {\n                  element.text(\"Committed successfully: \" + msg)\n              } else {\n                  alert(\"Notebook commit failed. Error: \" + (err || \"Unknown\"))\n              }\n          }\n          \n        };\n        \n        var pythonCode = `\nfrom contextlib import redirect_stdout, redirect_stderr\nfrom io import StringIO\nimport json\n \nwith open(\"News Headlines Sarcasm Detection.ipynb\", 'w') as f:\n    f.write(r\"\"\"${nbJson}\"\"\")\n\njvn_update = StringIO()\njvn_update_err = StringIO()\nwith redirect_stdout(jvn_update), redirect_stderr(jvn_update_err):\n    from jovian import commit\n\njvn_f_out = StringIO()\njvn_f_err = StringIO()\nwith redirect_stdout(jvn_f_out), redirect_stderr(jvn_f_err):\n    jvn_msg = jovian.commit(message=None, files=[], outputs=['news-sarcasm-model-1.0.pth'], environment=None, privacy='auto', filename='News Headlines Sarcasm Detection.ipynb', project='News Headlines Sarcasm Detection', new_project=None)\n\nprint(json.dumps({'msg': jvn_msg, 'err': jvn_f_err.getvalue(), 'update': jvn_update.getvalue()}))\n        `;\n\n        console.log(\"Invoking jovian.commit\")\n        // console.log(pythonCode)\n\n        Jupyter.notebook.kernel.execute(pythonCode, { iopub: { output: jvnLog }});\n    });"},"metadata":{}}]}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.6","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":4}