diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..42eb591 --- /dev/null +++ b/.gitignore @@ -0,0 +1,211 @@ +# Указанные папки +dataset/ +.venv/ +.vscode/ +imgs/ +venv/ + +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +Pipfile.lock + +# PEP 582 +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# macOS +.DS_Store +.AppleDouble +.LSOverride +Icon +._* +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# Windows +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db +*.tmp +*.temp +*.bak +*.swp +*~.nib +local.properties +.settings/ +.loadpath +.recommenders +.target/ +.metadata +.factorypath +.buildpath +.classpath +.project +.externalToolBuilders/ +*.launch +.pydevproject +.cproject +.autotools +.factorypath +.buildpath +.target/ +.tern-project +.idea/ +*.sublime-workspace +*.sublime-project + +# Linux +*~ +.fuse_hidden* +.directory +.Trash-* +.nfs* + +# IDE +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# Data files +*.csv +*.json +*.pkl +*.pickle +*.h5 +*.hdf5 +*.parquet +*.feather +*.xlsx +*.xls +*.numbers + +# Model files +*.model +*.joblib +*.pkl +*.h5 +*.hdf5 +*.onnx +*.pb +*.tflite + +# Logs +*.log +logs/ + +# Temporary files +tmp/ +temp/ +.tmp/ +.temp/ + +# OS generated files +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db diff --git a/1. data_exploration.ipynb b/1. data_exploration.ipynb new file mode 100644 index 0000000..606fca7 --- /dev/null +++ b/1. data_exploration.ipynb @@ -0,0 +1,1713 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Natural Language Processing Challenge - Data Exploration\n", + "\n", + "## Project Overview\n", + "\n", + "This notebook explores a dataset containing news articles to identify whether a news headline is real or fake news.\n", + "\n", + "### Dataset Information\n", + "- **Training Data**: `dataset/data.csv` (39,998 articles)\n", + "- **Validation Data**: `dataset/validation_data.csv` (4,956 articles)\n", + "\n", + "### Columns\n", + "- **`label`**: 0 if fake news, 1 if real news\n", + "- **`title`**: The headline of the news article\n", + "- **`text`**: The full content of the article\n", + "- **`subject`**: The category or topic of the news\n", + "- **`date`**: The publication date of the article\n", + "\n", + "### Goal\n", + "Build a classifier to distinguish between real and fake news, then predict labels for the validation dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All libraries imported successfully!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package wordnet to /Users/sergej/nltk_data...\n", + "[nltk_data] Package wordnet is already up-to-date!\n" + ] + } + ], + "source": [ + "# Standard data science libraries\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Text processing libraries\n", + "import re\n", + "import string\n", + "from collections import Counter\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.stem import WordNetLemmatizer\n", + "\n", + "# Machine learning libraries\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\n", + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# Visualization settings - using basic matplotlib to avoid seaborn compatibility issues\n", + "plt.style.use('default')\n", + "plt.rcParams['figure.figsize'] = (12, 8)\n", + "\n", + "# Download required NLTK data\n", + "try:\n", + " nltk.data.find('tokenizers/punkt')\n", + "except LookupError:\n", + " nltk.download('punkt')\n", + " \n", + "try:\n", + " nltk.data.find('corpora/stopwords')\n", + "except LookupError:\n", + " nltk.download('stopwords')\n", + " \n", + "try:\n", + " nltk.data.find('corpora/wordnet')\n", + "except LookupError:\n", + " nltk.download('wordnet')\n", + "\n", + "print(\"All libraries imported successfully!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Load and Explore the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading training data...\n", + "Training data shape: (39942, 5)\n", + "\n", + "Loading validation data...\n", + "Validation data shape: (4956, 5)\n", + "\n", + "✅ Data loaded successfully!\n" + ] + } + ], + "source": [ + "# Load the training data\n", + "print(\"Loading training data...\")\n", + "train_data = pd.read_csv('dataset/data.csv')\n", + "print(f\"Training data shape: {train_data.shape}\")\n", + "\n", + "# Load the validation data\n", + "print(\"\\nLoading validation data...\")\n", + "validation_data = pd.read_csv('dataset/validation_data.csv')\n", + "print(f\"Validation data shape: {validation_data.shape}\")\n", + "\n", + "print(\"\\n✅ Data loaded successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== TRAINING DATA INFO ===\n", + "\n", + "RangeIndex: 39942 entries, 0 to 39941\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 label 39942 non-null int64 \n", + " 1 title 39942 non-null object\n", + " 2 text 39942 non-null object\n", + " 3 subject 39942 non-null object\n", + " 4 date 39942 non-null object\n", + "dtypes: int64(1), object(4)\n", + "memory usage: 1.5+ MB\n", + "None\n", + "\n", + "=== VALIDATION DATA INFO ===\n", + "\n", + "RangeIndex: 4956 entries, 0 to 4955\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 label 4956 non-null int64 \n", + " 1 title 4956 non-null object\n", + " 2 text 4956 non-null object\n", + " 3 subject 4956 non-null object\n", + " 4 date 4956 non-null object\n", + "dtypes: int64(1), object(4)\n", + "memory usage: 193.7+ KB\n", + "None\n" + ] + } + ], + "source": [ + "# Display basic information about the datasets\n", + "print(\"=== TRAINING DATA INFO ===\")\n", + "print(train_data.info())\n", + "print(\"\\n=== VALIDATION DATA INFO ===\")\n", + "print(validation_data.info())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== TRAINING DATA PREVIEW ===\n", + " label title \\\n", + "0 1 As U.S. budget fight looms, Republicans flip t... \n", + "1 1 U.S. military to accept transgender recruits o... \n", + "2 1 Senior U.S. Republican senator: 'Let Mr. Muell... \n", + "3 1 FBI Russia probe helped by Australian diplomat... \n", + "4 1 Trump wants Postal Service to charge 'much mor... \n", + "\n", + " text subject \\\n", + "0 WASHINGTON (Reuters) - The head of a conservat... politicsNews \n", + "1 WASHINGTON (Reuters) - Transgender people will... politicsNews \n", + "2 WASHINGTON (Reuters) - The special counsel inv... politicsNews \n", + "3 WASHINGTON (Reuters) - Trump campaign adviser ... politicsNews \n", + "4 SEATTLE/WASHINGTON (Reuters) - President Donal... politicsNews \n", + "\n", + " date \n", + "0 December 31, 2017 \n", + "1 December 29, 2017 \n", + "2 December 31, 2017 \n", + "3 December 30, 2017 \n", + "4 December 29, 2017 \n", + "\n", + "=== VALIDATION DATA PREVIEW ===\n", + " label title \\\n", + "0 2 UK's May 'receiving regular updates' on London... \n", + "1 2 UK transport police leading investigation of L... \n", + "2 2 Pacific nations crack down on North Korean shi... \n", + "3 2 Three suspected al Qaeda militants killed in Y... \n", + "4 2 Chinese academics prod Beijing to consider Nor... \n", + "\n", + " text subject \\\n", + "0 LONDON (Reuters) - British Prime Minister Ther... worldnews \n", + "1 LONDON (Reuters) - British counter-terrorism p... worldnews \n", + "2 WELLINGTON (Reuters) - South Pacific island na... worldnews \n", + "3 ADEN, Yemen (Reuters) - Three suspected al Qae... worldnews \n", + "4 BEIJING (Reuters) - Chinese academics are publ... worldnews \n", + "\n", + " date \n", + "0 September 15, 2017 \n", + "1 September 15, 2017 \n", + "2 September 15, 2017 \n", + "3 September 15, 2017 \n", + "4 September 15, 2017 \n" + ] + } + ], + "source": [ + "# Display first few rows of training data\n", + "print(\"=== TRAINING DATA PREVIEW ===\")\n", + "print(train_data.head())\n", + "print(\"\\n=== VALIDATION DATA PREVIEW ===\")\n", + "print(validation_data.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== MISSING VALUES IN TRAINING DATA ===\n", + "label 0\n", + "title 0\n", + "text 0\n", + "subject 0\n", + "date 0\n", + "dtype: int64\n", + "\n", + "=== MISSING VALUES IN VALIDATION DATA ===\n", + "label 0\n", + "title 0\n", + "text 0\n", + "subject 0\n", + "date 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# Check for missing values\n", + "print(\"=== MISSING VALUES IN TRAINING DATA ===\")\n", + "print(train_data.isnull().sum())\n", + "print(\"\\n=== MISSING VALUES IN VALIDATION DATA ===\")\n", + "print(validation_data.isnull().sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== TRAINING DATA TYPES ===\n", + "label int64\n", + "title object\n", + "text object\n", + "subject object\n", + "date object\n", + "dtype: object\n", + "\n", + "=== VALIDATION DATA TYPES ===\n", + "label int64\n", + "title object\n", + "text object\n", + "subject object\n", + "date object\n", + "dtype: object\n" + ] + } + ], + "source": [ + "# Check data types\n", + "print(\"=== TRAINING DATA TYPES ===\")\n", + "print(train_data.dtypes)\n", + "print(\"\\n=== VALIDATION DATA TYPES ===\")\n", + "print(validation_data.dtypes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Data Distribution Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== LABEL DISTRIBUTION ===\n", + "Training data:\n", + "label\n", + "1 19999\n", + "0 19943\n", + "Name: count, dtype: int64\n", + "\n", + "Fake news percentage: 49.93%\n", + "Real news percentage: 50.07%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze label distribution\n", + "print(\"=== LABEL DISTRIBUTION ===\")\n", + "print(\"Training data:\")\n", + "print(train_data['label'].value_counts())\n", + "print(f\"\\nFake news percentage: {(train_data['label'] == 0).mean() * 100:.2f}%\")\n", + "print(f\"Real news percentage: {(train_data['label'] == 1).mean() * 100:.2f}%\")\n", + "\n", + "# Visualize label distribution\n", + "plt.figure(figsize=(10, 6))\n", + "train_data['label'].value_counts().plot(kind='bar', color=['red', 'green'])\n", + "plt.title('Label Distribution in Training Data')\n", + "plt.xlabel('Label (0=Fake, 1=Real)')\n", + "plt.ylabel('Count')\n", + "plt.xticks(rotation=0)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== SUBJECT DISTRIBUTION ===\n", + "subject\n", + "politicsNews 11272\n", + "News 9050\n", + "worldnews 8727\n", + "politics 6841\n", + "left-news 2482\n", + "Government News 1570\n", + "Name: count, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAMWCAYAAAAgRDUeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdL1JREFUeJzt3QeYFFXaP+yDImACjGBAUHEVcw6YFUHFjDmhYhbjKqKLqLi7mBXFvOacMS7mLCpmBcOaM7gqIqygwnzXc/5vzzdDUMChesJ9X1czdHdNT81MdU3Vr57znEYVFRUVCQAAAAAKNEuRXwwAAAAAglAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAOqZU045JTVq1Cj997///cNl27Vrl/bZZ59UVz355JP5e42PRf1cq4r7PXv2TEW45ppr8tf75JNPUtHq4nay0UYb5duMiO81vmcAYOYSSgFAmb311ltpxx13TG3btk3NmjVLiyyySNpss83ShRdemOq6f/7zn2nQoEHTtGyELRG6lG6zzTZbmn/++VPHjh3TiSeemD777LOyrFfRavO6/VmT/o5/71aO8K02iCCt9DOYZZZZUvPmzdPSSy+d9tprr/TII4/8qde++OKLc7gJALVFo4qKiopyrwQANFTPP/982njjjdNiiy2Wunfvnlq3bp0+//zz9MILL6QPP/wwffDBBzNU0XPqqaemb7/9Noc6v2f8+PH5xDcCoJlhrrnmyoHbtJwIRwix+OKLp9122y1tueWWaeLEiemHH35IQ4cOTXfddVc+Sb/yyivTrrvuWvk5scwvv/ySmjRpkr+PmbFeJb/99lu+RXBYEut02GGHpYEDB07z68zouk2YMCH9+uuvqWnTppNVbM1sNbWdjB07Nt19993VHjvnnHPSF198kc4777xqj2+//fZpzjnnnOGvFdtFiG1jesXPObat+FmXI5SK937//v0rf2axH4j3wEcffZR23nnndMMNN8zQ72L55ZfP+4QiKgsBYFo0nqalAICZ4h//+Edq0aJFDl5atmxZ7bmRI0fO9K9fjpPuP7LqqqumPffcs9pjn376aercuXMO7jp06JBWWmml/HgEJVVDopkhQoEIRxo3bpxv5TLrrLPmWznU1HYSP8dJf7e33HJLDh8nfbyquIY6bty4NPvss0/z15qRMKpkZoW00yr2CZP+PE4//fR0xBFH5GqnGFp4xhlnlG39AKCmGL4HAGUUFRHLLbfcZIFUWHDBBScb9jSlyp54PKqjJhU9paKqIob/zDfffOnII4/MJ/Z/1Cto1KhR6aijjkpt2rTJYUT79u3zCXBUjlQV9wcMGJBWWGGFHAwtsMACafPNN08vv/xy5XpFoHPttddWDkea0b5EMbQxvveofjnzzDN/t6fUf/7zn9StW7dcdRbrteiii+bqqh9//PEP16vUN2r48OFp9913T/PMM09ab731qj03JTfeeGMeYhVfb7XVVktPP/30NPUomvQ1f2/dptZTKkKK2Ibid7Xwwgvnyq34HU5afRNVMvF9RWXeHHPMkYeJVv1Z/p5Jt5PSujz33HPpmGOOyb/7CJyiuikq9P6s+HpbbbVVeuihh9Lqq6+ew6jLLrssP3f11VenTTbZJL8/4ntedtll0yWXXPKHPaVK28ptt92Ww+DYLuL3temmm05WkTjp76v0/jv77LPT5ZdfnpZccsn8tddYY40cKE/q9ttvz+sVrx8/96gO+7N9qiKQvOCCC/LrRmVeaXue1p9JfO1hw4alp556qnLbKv18vv/++3Tsscfm93JU6sU+Y4sttkhvvPHGDK8vAEwLlVIAUEYRtgwZMiS9/fbb+eS1JkUgFSeiMQwohgPGCW1UpFx33XVT/Zz//e9/acMNN0xffvllOuigg/KwwhhieMIJJ6Svv/46nX/++ZXL9ujRI4cTcfK6//7756FtzzzzTP5aESRcf/31+fE111wzHXjggflz4mR+Rq2zzjr583+vr06EVl26dMnDzQ4//PAcTMX3cv/99+egJipQpmW9dtppp7TUUkvl/k5/1OkgTvJvvfXWXMUSgUCERBHOvfTSS9P9O53en1lpqGanTp3SIYcckt57770cRkRQEoFR1Yqf+N3Heu2www5527jjjjvS8ccfn4OI+B3OiPgZR3B38skn5+Amto9o/B4/jz8rvpcYyhnb4QEHHJBDvxDfX4Rw22yzTa5cu++++9Khhx6aQ9II5P5IVBxFhV2EMBHsRDC3xx57pBdffPEPP/emm25KP/30U16nCHXic+PnGcPqSj/rBx54IO2yyy755xrvvfi5x3slQsA/K4Kp+JmcdNJJ6dlnn01du3ad5p9J/G7i9xWh09/+9rf8WKtWrfLHWP/oYxbbfQyhHTFiRA4BY18QQWaEnQAwU0RPKQCgPB5++OGKWWedNd/WWWedil69elU89NBDFb/88ku15T7++ONIRiquvvrqyV4jHj/55JMr78f/47Ftttmm2nKHHnpofvyNN96ofKxt27YV3bt3r7x/2mmnVcw555wV77//frXP7d27d17Hzz77LN9//PHH82sdccQRk63PxIkTK/8fr1X19X9P6Xs866yzprrMtttum5f58ccf8/0nnngi34+P4bXXXsv3b7/99t/9WlNbr9LPbrfddpvqc1XF/bi9/PLLlY99+umnFc2aNavYfvvtKx+LrxU/62l5zamtW/zuY9n4OYWRI0dWNGnSpKJz584VEyZMqFxu4MCBebmrrrqq8rENN9wwP3bddddVPjZ+/PiK1q1bV3Tr1q3ij0y6nZTWpVOnTtV+30cffXTeTkaNGlUxrbp27TrZzybux+sPHjx4suX/97//TfZYly5dKpZYYolqj8X3HLeS0rbSoUOH/L2XDBgwID/+1ltvTfX3Vdo255tvvorvv/++8vF77rknP37fffdVPrbCCitULLroohU//fRT5WNPPvlkXm5K28CkYp2XW265qT5/991359eK9Z7en0m8btWfScm4ceOqbUOl77lp06YV/fr1+8N1BoAZZfgeAJRRzLIXlVJR4RBDZaLyIip9oqri3nvv/VOvPWnVSFRJhAcffHCqnxPDjtZff/1c/RLD/0q3qMSJRtulYWl33nlnrhSJCplJzcwm3FHlEaJaZUqiEirEsK+o+ppRBx988HRVcMWQvZKoLtt2223zOsTPbGZ59NFHc2VYDLWs2uQ9qopi+FVU7Ez6s6vapyh6LkVFVlTJzKio5qr6+45tJ77n6AH2Z0XFTrwXJlW1r1RUOsX2GRU98X1UHdI2Nfvuu2+1flOxzmFafg5RARXvjal97ldffZVn09x7770rt9UQ6xeVUzPrPfBnfyZR4VfahuL399133+WvE9Vpr776ao2sNwBMiVAKAMos+tLEzFoxzCeGfMVQuTjhjBnYYujMjIrhZ1XFMLA48Zy0J1FV0Y9p8ODBuUdQ1VuEUlWbr0cvrBjSM++886YijRkzJn+ce+65pxpkRI+jf/3rX3mWsQg1Lrroomk6MZ/0dWb05xz+8pe/5FCsJvorTU0p+CkNayuJwGWJJZaYLBiKHkqTBoYRsMR2N6MigJv09cKfec0/+h3EsMTYHqOHVfRii+3zxBNPzM9Ny+/5z6zzH31u6WcefdgmNaXHauo98Gd/JjHML2Y/jG05Aqp478RrvPnmm9P93gGA6aGnFADUEhEmREAVtwg1oqIjKpeiGmlq1UfTU4kzLRVMcXIa1Vu9evWa4vOxXuUUvbeimXNUAk3NOeeck5tK33PPPenhhx/OvZ5KfbUimJkW0zPL27Soid/fnzW1mfv+qGdW0a/5e7+DCEOjMfkyyyyTzj333NyMP943Uf0Xocqkzfhrep1n5vc7Pe+BqiFXTfxMonda9Knab7/90mmnnZbD5giwowpvWj4fAGaUUAoAaqFoFB6iuXjVioxJZ1X7vWFSUfVUtdokZhiLE8zfmwEsqqmiEqNUGfV7y8XwtJi16/eqpWpyKF8Mc4wT8KpD0KYmhkrFrU+fPrlR+7rrrpsuvfTS9Pe//73G1yt+zpN6//338wx3UW1S+v1N+rub2u9vWtctmuSXGoJHZVRJDOn7+OOP//B3WBdFA+9oYh9DW6tWLT3xxBOpNij9TiadzW9qj02vCDGj2XpsW6VZIafnZzK1bSua3sesjFdeeWW1x2ObjaopAJhZDN8DgDKKE8cpVVmU+j6VhmZFZVCcHJZ6OpXETG9TE8PWqrrwwgvzx9+baS1mZYvwJwKnScUJasywF7p165bXO2Z+m1TV7yeGE00pjJleEd5E9VNUgBx33HFTXW706NGV61gS4VRUfcSJe02vV4ifV9W+O59//nmu0urcuXNlZU2EeDEMKoZDlUTgePfdd0/2etO6bhE6xc8jZlWs+jOPYCG+Vmlmtvqk9POs+v3G93r11Ven2iCGtMaMizHDZWmYXWmGxug19WcDqaj6e+edd/LHUrXg9PxMprZtxWtMuh+KKs2YuRIAZiaVUgBQRtF8PHoPbb/99nn4TVS5RGXPrbfemiuaYghfyf7775+ns4+PUUkVAVVU5ExNVMtEA/XNN988Byc33HBD2n333dNKK6001c+JwCcqLrbaaqscAkUD77Fjx+YT6qimiH5UEY5FVcVee+2VA5GoFIqvEVVYzzzzTH6uZ8+e+fXi86MhdwwrihP2qNxaa621fvdnEgFPrGu8XpxADx06tLKx+vXXX59WXHHFqX7u448/nr92TG0fQw0joIrPiZPuCNJKZmS9piZCiOhdFUFB9OMpBYVVA7tdd901HX/88fn3HMvF7/ySSy7J6zhpI+lpXbeowor+Y/F14ucfv+uomoqvH0NAp6WirK6JoC+CuK233joddNBBOfi54oor8pDOUlVhucVQuGh0H9V58f6NflMDBw7M20nVoOr3RKgU74EQ20pUWUXfuagUjG0phtjNyM8ktq3Y7qJiMIb/xTKbbLJJfr/369cvr2/Hjh3z+/3GG2+sVoEHADPFDM/bBwD8af/+978r9ttvv4plllmmYq655qpo0qRJRfv27SsOP/zwihEjRlRbNqZ979GjR0WLFi0q5p577oqdd965YuTIkXl6+JNPPrlyufh/PDZ8+PCKHXfcMS87zzzzVPTs2bPi559/rvaaMUV99+7dqz0WU9mfcMIJeT1ifeaff/6Kjh07Vpx99tkVv/zyS+Vyv/32W8VZZ52V1z2WW2CBBSq22GKLildeeaVymXfffbdigw02qJh99tnzOk36tSadgj6WKd0aN25cMe+881astdZaeX0+/fTTyT7niSeeyMvGx/DRRx/ln+eSSy5Z0axZs/z5G2+8ccWjjz5a7fOmtl6ln92333472dcqPVdV3D/ssMMqbrjhhoqlllqqomnTphWrrLJK5fpU9fDDD1csv/zy+We19NJL58+Z0mtObd2uvvrqfD9+TlUNHDgw/w5mm222ilatWlUccsghFT/88EO1ZTbccMOK5ZZbbrJ1iteObeCPTLqdlNZl6NChv/v7mBZdu3adbB3ifjw+Jffee2/FiiuumH+/7dq1qzjjjDMqrrrqqsl+NvE9x23Sdbv99tunuN3F9zS1n0tpmdjeJzXp+y/ccsst+XcS20P8zmOdu3Xrlh/7I7HOVd8HsV+IbWvPPffM29Cf+Zl88803+eca+4R4rvTzGTduXMVf//rXioUWWihvd+uuu27FkCFDJvsZAkBNaxT/zJy4CwCo7aIpclT5xGx1wMyz8sor5+q2Rx55pNyrAgC1hp5SANBA/frrr+m7777TyBhq+H01aV+zJ598Mr3xxhtpo402Ktt6AUBtpKcUADRA0cj8lltuST///HOeTh6oGdEcPJrQR0+v6An27rvv5pkfW7dunQ4++OByrx4A1CqG7wFAAxTNyKN58iGHHJJOPPHEcq8O1BvRpPzAAw9Mzz33XPr222/zjHcR/MYkBTELIwDw/xNKAQAAAFA4PaUAAAAAKJxQCgAAAIDCaXReQyZOnJi++uqrNPfcc6dGjRqVe3UAAAAAyiI6Rf3000950o9ZZpl6PZRQqoZEINWmTZtyrwYAAABArfD555+nRRdddKrPC6VqSFRIlX7gzZs3L/fqAAAAAJTF6NGjc+FOKSuZGqFUDSkN2YtASigFAAAANHSN/qC9kUbnAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABSucblXgPJr1/uBcq9Cg/HJ6V3LvQoAAABQK6iUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBhhVJPP/102nrrrdPCCy+cGjVqlAYNGlTt+YqKitS3b9+00EILpdlnnz116tQp/ec//6m2zPfff5/22GOP1Lx589SyZcvUo0ePNGbMmGrLvPnmm2n99ddPzZo1S23atElnnnnmZOty++23p2WWWSYvs8IKK6QHH3xwJn3XAAAAAJQ1lBo7dmxaaaWV0kUXXTTF5yM8uuCCC9Kll16aXnzxxTTnnHOmLl26pHHjxlUuE4HUsGHD0iOPPJLuv//+HHQdeOCBlc+PHj06de7cObVt2za98sor6ayzzkqnnHJKuvzyyyuXef7559Nuu+2WA63XXnstbbfddvn29ttvz+SfAAAAAEDD1KgiypFqgaiUuvvuu3MYFGK1ooLqr3/9azr22GPzYz/++GNq1apVuuaaa9Kuu+6a3nnnnbTsssumoUOHptVXXz0vM3jw4LTlllumL774In/+JZdckv72t7+lb775JjVp0iQv07t371yV9e677+b7u+yySw7IItQqWXvttdPKK6+cA7FpEeFXixYt8jpG1VZd0q73A+VehQbjk9O7lnsVAAAAYKaa1oyk1vaU+vjjj3OQFEP2SuIbWmuttdKQIUPy/fgYQ/ZKgVSI5WeZZZZcWVVaZoMNNqgMpEJUW7333nvphx9+qFym6tcpLVP6OlMyfvz4/EOuegMAAABg2tTaUCoCqRCVUVXF/dJz8XHBBRes9nzjxo3TvPPOW22ZKb1G1a8xtWVKz09J//79c0hWukWvKgAAAADqeChV251wwgm5DK10+/zzz8u9SgAAAAB1Rq0NpVq3bp0/jhgxotrjcb/0XHwcOXJkted/++23PCNf1WWm9BpVv8bUlik9PyVNmzbN4yKr3gAAAACo46HU4osvnkOhxx57rPKx6NsUvaLWWWedfD8+jho1Ks+qV/L444+niRMn5t5TpWViRr5ff/21cpmYqW/ppZdO88wzT+UyVb9OaZnS1wEAAACgHoVSY8aMSa+//nq+lZqbx/8/++yzPBvfUUcdlf7+97+ne++9N7311ltp7733zjPqlWbo69ChQ9p8883TAQcckF566aX03HPPpZ49e+aZ+WK5sPvuu+cm5z169EjDhg1Lt956axowYEA65phjKtfjyCOPzLP2nXPOOXlGvlNOOSW9/PLL+bUAAAAAqHmNUxlF8LPxxhtX3i8FRd27d0/XXHNN6tWrVxo7dmw68MADc0XUeuutl8OjZs2aVX7OjTfemMOjTTfdNM+6161bt3TBBRdUPh9NyB9++OF02GGHpdVWWy3NP//8qW/fvvk1Szp27Jhuuumm1KdPn3TiiSempZZaKg0aNCgtv/zyhf0sAAAAABqSRhUVFRXlXon6IIYWRgAWTc/rWn+pdr0fKPcqNBifnN613KsAAAAAtSIjqbU9pQAAAACov4RSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4RoX/yUBitGu9wPlXoUG45PTu5Z7FQAAgDpGpRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFC4xsV/SQBgRrXr/UC5V6FB+eT0ruVeBQCAekulFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAULhaHUpNmDAhnXTSSWnxxRdPs88+e1pyySXTaaedlioqKiqXif/37ds3LbTQQnmZTp06pf/85z/VXuf7779Pe+yxR2revHlq2bJl6tGjRxozZky1Zd588820/vrrp2bNmqU2bdqkM888s7DvEwAAAKChqdWh1BlnnJEuueSSNHDgwPTOO+/k+xEWXXjhhZXLxP0LLrggXXrppenFF19Mc845Z+rSpUsaN25c5TIRSA0bNiw98sgj6f77709PP/10OvDAAyufHz16dOrcuXNq27ZteuWVV9JZZ52VTjnllHT55ZcX/j0DAAAANASNUy32/PPPp2233TZ17do132/Xrl26+eab00svvVRZJXX++eenPn365OXCddddl1q1apUGDRqUdt111xxmDR48OA0dOjStvvrqeZkItbbccst09tlnp4UXXjjdeOON6ZdffklXXXVVatKkSVpuueXS66+/ns4999xq4RUAAAAADaBSqmPHjumxxx5L77//fr7/xhtvpGeffTZtscUW+f7HH3+cvvnmmzxkr6RFixZprbXWSkOGDMn342MM2SsFUiGWn2WWWXJlVWmZDTbYIAdSJVFt9d5776UffvihsO8XAAAAoKGo1ZVSvXv3zkPrlllmmTTrrLPmHlP/+Mc/8nC8EIFUiMqoquJ+6bn4uOCCC1Z7vnHjxmneeeettkz0rZr0NUrPzTPPPJOt2/jx4/OtJNYTAAAAgHpQKXXbbbfloXU33XRTevXVV9O1116bh9zFx3Lr379/rsoq3aI5OgAAAAD1IJQ67rjjcrVU9IZaYYUV0l577ZWOPvroHAiF1q1b548jRoyo9nlxv/RcfBw5cmS153/77bc8I1/VZab0GlW/xqROOOGE9OOPP1bePv/88xr7vgEAAADqu1odSv3vf//LvZ+qimF8EydOzP+PIXcRGkXfqarD6KJX1DrrrJPvx8dRo0blWfVKHn/88fwa0XuqtEzMyPfrr79WLhMz9S299NJTHLoXmjZtmpo3b17tBgAAAEA9CKW23nrr3EPqgQceSJ988km6++6784x422+/fX6+UaNG6aijjkp///vf07333pveeuuttPfee+cZ9bbbbru8TIcOHdLmm2+eDjjggDxr33PPPZd69uyZq69iubD77rvnJuc9evRIw4YNS7feemsaMGBAOuaYY8r6/QMAAADUV7W60fmFF16YTjrppHTooYfmIXgRIh100EGpb9++lcv06tUrjR07Nh144IG5Imq99dZLgwcPTs2aNatcJvpSRRC16aab5sqrbt26pQsuuKDy+egJ9fDDD6fDDjssrbbaamn++efPXyNeEwAAAICa16iioqJiJrxugxPDBiPciv5SdW0oX7veD5R7FRqMT07vWu5VaFBs28WxbRfHdl0s2zYAwMzLSGr18D0AAAAA6iehFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFa1z8lwQAgOra9X6g3KvQoHxyetdyrwIAqJQCAAAAoHhCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoG6EUksssUT67rvvJnt81KhR+TkAAAAAqPFQ6pNPPkkTJkyY7PHx48enL7/8ckZeEgAAAIAGpPH0LHzvvfdW/v+hhx5KLVq0qLwfIdVjjz2W2rVrV7NrCAAAAEDDDqW22267/LFRo0ape/fu1Z6bbbbZciB1zjnn1OwaAgAAANCwQ6mJEyfmj4svvngaOnRomn/++WfWegEAAABQj01XKFXy8ccf1/yaAAAAANBgzFAoFaJ/VNxGjhxZWUFVctVVV9XEugEAAABQT81QKHXqqaemfv36pdVXXz0ttNBCuccUAAAAAMzUUOrSSy9N11xzTdprr71m5NMBAAAAaOBmmZFP+uWXX1LHjh1TEb788su05557pvnmmy/NPvvsaYUVVkgvv/xy5fMVFRWpb9++uWIrnu/UqVP6z3/+U+01vv/++7THHnuk5s2bp5YtW6YePXqkMWPGVFvmzTffTOuvv35q1qxZatOmTTrzzDML+f4AAAAAGqIZCqX233//dNNNN6WZ7Ycffkjrrrtumm222dK///3vNHz48HTOOeekeeaZp3KZCI8uuOCCXL314osvpjnnnDN16dIljRs3rnKZCKSGDRuWHnnkkXT//fenp59+Oh144IGVz48ePTp17tw5tW3bNr3yyivprLPOSqecckq6/PLLZ/r3CAAAANAQzdDwvQh8IrB59NFH04orrphDo6rOPffcGlm5M844I1ctXX311ZWPLb744tWqpM4///zUp0+ftO222+bHrrvuutSqVas0aNCgtOuuu6Z33nknDR48OA0dOjT3wAoXXnhh2nLLLdPZZ5+dFl544XTjjTfm6q9o0N6kSZO03HLLpddffz1/H1XDKwAAAADKWCkVQ91WXnnlNMsss6S33347vfbaa5W3CHNqyr333puDpJ122iktuOCCaZVVVklXXHFF5fMff/xx+uabb/KQvZIWLVqktdZaKw0ZMiTfj48xZK8USIVYPtY9KqtKy2ywwQY5kCqJaqv33nsvV2sBAAAAUAsqpZ544olUhI8++ihdcskl6ZhjjkknnnhirnY64ogjcnjUvXv3HEiFqIyqKu6XnouPEWhV1bhx4zTvvPNWW6ZqBVbV14znqg4XLBk/fny+VR0CCAAAAMBMDKWKMnHixFzh9M9//jPfj0qpqMyK/lERSpVT//7906mnnlrWdQAAAABoUKHUxhtvnBo1ajTV5x9//PFUE2JGvWWXXbbaYx06dEh33nln/n/r1q3zxxEjRuRlS+J+DC8sLTNy5Mhqr/Hbb7/lGflKnx8f43OqKt0vLTOpE044IVdwVa2Uiv5XAAAAAMyknlIR+Ky00kqVtwiOolH4q6++mlZYYYVUU2LmvejrVNX777+fZ8kLMeQuQqPHHnusWjgUvaLWWWedfD8+jho1Ks+qVzU0iyqs6D1VWiZm5Pv1118rl4mZ+pZeeukpDt0LTZs2Tc2bN692AwAAAGAmVkqdd955U3z8lFNOSWPGjEk15eijj04dO3bMw/d23nnn9NJLL+VZ/+IWolrrqKOOSn//+9/TUkstlUOqk046Kc+ot91221VWVm2++ebpgAMOyMP+Injq2bNnnpkvlgu77757HorXo0ePdPzxx+chggMGDJjq9wkAAABAGSqlpmbPPfdMV111VY293hprrJHuvvvudPPNN6fll18+nXbaaen8889Pe+yxR+UyvXr1Socffng68MAD8/IRig0ePDg1a9ascpkbb7wxLbPMMmnTTTdNW265ZVpvvfUqg63SjH0PP/xwns1vtdVWS3/9619T375982sCAAAAUMsbnQ8ZMqRaGFQTttpqq3ybmqiW6tevX75NTcy0d9NNN/3u11lxxRXTM88886fWFQAAAICZGErtsMMO1e5XVFSkr7/+Or388st5+BwAAAAA1HgoFcPdqppllllyU/CoVurcufOMvCQAAAAADcgMhVJXX311za8JAAAAAA3Gn+op9corr6R33nkn/3+55ZZLq6yySk2tFwAAAAD12AyFUiNHjky77rprevLJJ1PLli3zY6NGjUobb7xxuuWWW9ICCyxQ0+sJAAAAQD0yy4x80uGHH55++umnNGzYsPT999/n29tvv51Gjx6djjjiiJpfSwAAAADqlRmqlBo8eHB69NFHU4cOHSofW3bZZdNFF12k0TkAAAAAM6dSauLEiWm22Wab7PF4LJ4DAAAAgBoPpTbZZJN05JFHpq+++qrysS+//DIdffTRadNNN52RlwQAAACgAZmhUGrgwIG5f1S7du3SkksumW+LL754fuzCCy+s+bUEAAAAoF6ZoZ5Sbdq0Sa+++mruK/Xuu+/mx6K/VKdOnWp6/QAAAABo6JVSjz/+eG5oHhVRjRo1SptttlmeiS9ua6yxRlpuueXSM888M/PWFgAAAICGF0qdf/756YADDkjNmzef7LkWLVqkgw46KJ177rk1uX4AAAAANPRQ6o033kibb775VJ/v3LlzeuWVV2pivQAAAACox6YrlBoxYkSabbbZpvp848aN07ffflsT6wUAAABAPTZdodQiiyyS3n777ak+/+abb6aFFlqoJtYLAAAAgHpsukKpLbfcMp100klp3Lhxkz33888/p5NPPjlttdVWNbl+AAAAANRDjadn4T59+qS77ror/eUvf0k9e/ZMSy+9dH783XffTRdddFGaMGFC+tvf/jaz1hUAAACAhhhKtWrVKj3//PPpkEMOSSeccEKqqKjIjzdq1Ch16dIlB1OxDAAAAADUWCgV2rZtmx588MH0ww8/pA8++CAHU0sttVSaZ555pvelAAAAAGigpjuUKokQao011qjZtQEAAACgQZiuRucAAAAAUBOEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOHqVCh1+umnp0aNGqWjjjqq8rFx48alww47LM0333xprrnmSt26dUsjRoyo9nmfffZZ6tq1a5pjjjnSggsumI477rj022+/VVvmySefTKuuumpq2rRpat++fbrmmmsK+74AAAAAGpo6E0oNHTo0XXbZZWnFFVes9vjRRx+d7rvvvnT77benp556Kn311Vdphx12qHx+woQJOZD65Zdf0vPPP5+uvfbaHDj17du3cpmPP/44L7Pxxhun119/PYde+++/f3rooYcK/R4BAAAAGoo6EUqNGTMm7bHHHumKK65I88wzT+XjP/74Y7ryyivTueeemzbZZJO02mqrpauvvjqHTy+88EJe5uGHH07Dhw9PN9xwQ1p55ZXTFltskU477bR00UUX5aAqXHrppWnxxRdP55xzTurQoUPq2bNn2nHHHdN5551Xtu8ZAAAAoD6rE6FUDM+LSqZOnTpVe/yVV15Jv/76a7XHl1lmmbTYYoulIUOG5PvxcYUVVkitWrWqXKZLly5p9OjRadiwYZXLTPrasUzpNaZk/Pjx+TWq3gAAAACYNo1TLXfLLbekV199NQ/fm9Q333yTmjRpklq2bFnt8Qig4rnSMlUDqdLzped+b5kImn7++ec0++yzT/a1+/fvn0499dQa+A4BAAAAGp5aXSn1+eefpyOPPDLdeOONqVmzZqk2OeGEE/LwwdIt1hUAAACAehBKxfC8kSNH5lnxGjdunG/RzPyCCy7I/49qpugLNWrUqGqfF7PvtW7dOv8/Pk46G1/p/h8t07x58ylWSYWYpS+er3oDAAAAoB6EUptuuml666238ox4pdvqq6+em56X/j/bbLOlxx57rPJz3nvvvfTZZ5+lddZZJ9+Pj/EaEW6VPPLIIzlEWnbZZSuXqfoapWVKrwEAAABAA+opNffcc6fll1++2mNzzjlnmm+++Sof79GjRzrmmGPSvPPOm4Omww8/PIdJa6+9dn6+c+fOOXzaa6+90plnnpn7R/Xp0yc3T49qp3DwwQengQMHpl69eqX99tsvPf744+m2225LDzzwQBm+awAAAID6r1aHUtPivPPOS7PMMkvq1q1bnhEvZs27+OKLK5+fddZZ0/33358OOeSQHFZFqNW9e/fUr1+/ymUWX3zxHEAdffTRacCAAWnRRRdN//rXv/JrAQAAAFDz6lwo9eSTT1a7Hw3QL7roonybmrZt26YHH3zwd193o402Sq+99lqNrScAAAAAdbSnFAAAAAD1k1AKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAoXOPivyQAAEDD0K73A+VehQbjk9O7lnsVgOmkUgoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwtXqUKp///5pjTXWSHPPPXdacMEF03bbbZfee++9asuMGzcuHXbYYWm++eZLc801V+rWrVsaMWJEtWU+++yz1LVr1zTHHHPk1znuuOPSb7/9Vm2ZJ598Mq266qqpadOmqX379umaa64p5HsEAAAAaIhqdSj11FNP5cDphRdeSI888kj69ddfU+fOndPYsWMrlzn66KPTfffdl26//fa8/FdffZV22GGHyucnTJiQA6lffvklPf/88+naa6/NgVPfvn0rl/n444/zMhtvvHF6/fXX01FHHZX233//9NBDDxX+PQMAAAA0BI1TLTZ48OBq9yNMikqnV155JW2wwQbpxx9/TFdeeWW66aab0iabbJKXufrqq1OHDh1ykLX22munhx9+OA0fPjw9+uijqVWrVmnllVdOp512Wjr++OPTKaeckpo0aZIuvfTStPjii6dzzjknv0Z8/rPPPpvOO++81KVLl7J87wAAAAD1Wa2ulJpUhFBh3nnnzR8jnIrqqU6dOlUus8wyy6TFFlssDRkyJN+PjyussEIOpEoiaBo9enQaNmxY5TJVX6O0TOk1AAAAAGhAlVJVTZw4MQ+rW3fdddPyyy+fH/vmm29ypVPLli2rLRsBVDxXWqZqIFV6vvTc7y0TwdXPP/+cZp999snWZ/z48flWEssCAAAAUM8qpaK31Ntvv51uueWWVFuasLdo0aLy1qZNm3KvEgAAAECdUSdCqZ49e6b7778/PfHEE2nRRRetfLx169a5gfmoUaOqLR+z78VzpWUmnY2vdP+PlmnevPkUq6TCCSeckIcTlm6ff/55DX23AAAAAPVfrQ6lKioqciB19913p8cffzw3I69qtdVWS7PNNlt67LHHKh9777330meffZbWWWedfD8+vvXWW2nkyJGVy8RMfhE4LbvsspXLVH2N0jKl15iSpk2b5teoegMAAACgHvSUiiF7MbPePffck+aee+7KHlAxXC4qmOJjjx490jHHHJObn0cwdPjhh+cwKWbeC507d87h01577ZXOPPPM/Bp9+vTJrx3BUjj44IPTwIEDU69evdJ+++2XA7DbbrstPfDAA2X9/gEAAADqq1pdKXXJJZfkoXEbbbRRWmihhSpvt956a+Uy5513Xtpqq61St27d0gYbbJCH4t11112Vz88666x56F98jLBqzz33THvvvXfq169f5TJRgRUBVFRHrbTSSumcc85J//rXv/IMfAAAAAA0sEqpGL73R5o1a5YuuuiifJuatm3bpgcffPB3XyeCr9dee22G1hMAAACAelQpBQAAAED9JJQCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHCNi/+SAAAAQF3WrvcD5V6FBuOT07um+kqlFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0pN4qKLLkrt2rVLzZo1S2uttVZ66aWXyr1KAAAAAPWOUKqKW2+9NR1zzDHp5JNPTq+++mpaaaWVUpcuXdLIkSPLvWoAAAAA9YpQqopzzz03HXDAAWnfffdNyy67bLr00kvTHHPMka666qpyrxoAAABAvdK43CtQW/zyyy/plVdeSSeccELlY7PMMkvq1KlTGjJkyGTLjx8/Pt9Kfvzxx/xx9OjRqa6ZOP5/5V6FBqMubh91mW27OLbt4tiui2XbLo5tu1i27eLYtotjuy6Wbbs4o+vgtl1a54qKit9dTij1f/773/+mCRMmpFatWlV7PO6/++67ky3fv3//dOqpp072eJs2bWbqelK3tTi/3GsAM4dtm/rKtk19ZdumPrJdU1+1qMPb9k8//ZRatGgx1eeFUjMoKqqi/1TJxIkT0/fff5/mm2++1KhRo7KuW0MQqWsEgJ9//nlq3rx5uVcHaoTtmvrKtk19ZdumvrJtU1/ZtosTFVIRSC288MK/u5xQ6v/MP//8adZZZ00jRoyo9njcb9269WTLN23aNN+qatmy5UxfT6qLHYmdCfWN7Zr6yrZNfWXbpr6ybVNf2baL8XsVUiUanf+fJk2apNVWWy099thj1aqf4v4666xT1nUDAAAAqG9USlURw/G6d++eVl999bTmmmum888/P40dOzbPxgcAAABAzRFKVbHLLrukb7/9NvXt2zd98803aeWVV06DBw+erPk55RdDJ08++eTJhlBCXWa7pr6ybVNf2bapr2zb1Fe27dqnUcUfzc8HAAAAADVMTykAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAACijioqK/PGHH35IDYlQCqZg4sSJ5V4FAP7goO27774r96oA8Af7amDa3i+NGjVK999/f9p5553T888/n3777bfUEAilYAqB1Cyz/L+3xquvvpq+/vrrcq8SVB7YvfPOO+mjjz4SnJIa+kHbAw88kLbeeuv01FNPlXuVYJpU3W//+uuvZV0XKGpf/eSTT6YbbrghjRkzptyrBLVao0aN0t1335123333tO6666Z55pknNW7cODUEQimYSiD1t7/9LR1xxBHpmWeeST///HO5V40GrHRgN2jQoNSlS5f073//W4UIqaEftO26665pyy23TM2bNy/3KsF0HV+cc8456YwzzrAfp94ft9x1111phx12yBd5be/w+z7++ON0zDHHpP79+6dTTjklLbPMMvnxN998M40YMSLVZ0IpqKJ0wNinT590xRVXpJNOOiltvvnmafbZZy/3qtGAxYHdgw8+mPbcc8/Uu3fvtOOOO6YFFlig2jIqp2goPv3009SrV6/0z3/+M++rV1555fz4yy+/nH788cdyrx787vFFbLsRSrVs2XKyYRmGOlGfjluefvrptM8++6TzzjsvnXvuualt27aTbee2efj/jR07Ns0555y5Cvy///1vGjBgQNp4441Tx44d08EHH5yGDh2a6iuhFEzijTfeSLfffnu+RVVKnOwPHz48XXbZZfkPLBQpDtj+97//pYsuuigdeuih+RaVIZ9//nn+Y3XbbbflZoilEx6o70rB0y677JL/f/7556eNNtoorbXWWrnk/a233ir3KsIUXXvttemaa65JgwcPTj179kytWrVK48ePT6NHj84BVZzIO0mnvnjhhRfyhd3u3bvnoXuPPPJI3kfvu+++6frrr8/LxDYPDd1bb72V/vOf/6RFFlkkffDBB+nAAw9Mq6++ej7v3HTTTdMdd9yR30/Dhg1L9VXDGKQI01BiXDL33HPn8buRUEcifeWVV1b2LIlePvfcc0/+IwtFbJfRd2SOOebIwVR8jJ5Sl19+ef4D9vrrr6d27dqlF198MQ8FmXXWWR3gUW/F8I+FFlootW/fPp/gxJXEGA6ywgorpE6dOuUr8RtssEF69tln82NQ244v4mJCHD+suOKKeV/+2GOP5QsO8847b96eY9hGkyZNyrrO8Ge39zh+nn/++fNFg9jGI4SN7TyC17iAFh8vvvjifLK98MILl3u1oWyi8OGnn35K2267bW5sfvrpp+dzz3i/RIXUHnvskd8j8b5Zfvnl80WM+sqldRq80gFjDNeLJDqGRbVp0ybvGKJcMgKq+P8TTzyR1lhjjfT++++Xe5VpINtl/GGKsvewzjrr5D9Sa665Zvriiy/S3nvvnZvwx9CluB/bqUCK+nqiEwdiXbt2TX379s3hbDTOjf1xXE0cOHBgHta66qqr5oopVYPUlpON0j651Jcy9tPR8DlaA+y00075uCKGZXfo0CHdeOONDW4KcOqX2N5feeWV3O8vTrT/8Y9/5BPpQw45JDdsPvbYY/MEFTH0OgKrX375pdyrDGUVxystWrRIJ598crrgggtyEURcVIvj/eOPPz4tuuii+X114okn5ovRm222WaqvVErB/00rHgeHs802W+7Xc8kll6QPP/ww95KK2Q9KJ0bxB7RZs2blXl0aiDvvvDPdcsst6aCDDsoHcVENEtthXF2cMGFCroyKq+pxi20ztl/BFPXtqnvcmjZtmi8cRAhVapwbYVRJXHmPE/0IcuPADmpLU/MzzzwzjRw5Mh111FE5PI0qkiFDhuT+IHGCsfTSS+eq19deey1XxEJdFhd1Yz8cTZqjd1qcZEfz5sUXX7xymbgAHKMSTFJBQ6/+jgsV8Tege/fu+WJbHL8sueSSOYwK0UomzgNi6F5McrTEEkuk+qpRhcHrNPADxpLozfPXv/41p9PbbLNN5Ul/XOGMGQ+il098jKFSDWV6TspzEh4BU2kIR1RCxRjzuLo4abPnGMYX2+tzzz2XlltuuTKtNcw8sb+db775Kq8WHn744WncuHE5pC0dtMUkAFdddVU+aLvvvvvSKqusUu7VhiyudF933XX5KngMz4t9eYjjitIEKrG/j6EbsX3Hft6FBericUtUPsVxS2zX0eYiZq+OSu+4gFASw/iir1Tsr+NCcGmSCmhoPvvss7TUUkvlACrOOXv37p37F8cQ7pgMI9430b4jqqNuuummdMABB+Twqj5T406DVAqk4oQ+rmKGGMsbJcdxJT7CpwikYocQDc7jimaUIsdJTwRSEVhBTYsDu4cffjhXfETQFKLvwldffZW3w5LomRNXVe6+++58ZUUgRX0UwWv0iIoJJ6Jn2pdffpmbQ8c2H/vi0sl9hFbLLrtsevzxxwVS1BqxL48heYMGDcrHEBFIla4Dx4l7bLtxDBJhVQzFjhP5+BtgJlXqkthmn3nmmdwn7cILL8wtLiJkjaHUDz30UPr222+rjUh46aWXcvNmgRQNWZxLbrfddrlaMIZtr7DCCjnUjckv+vXrVzn6IdoSRAuZ+h5IBaEUDVac6MdV90int9hii1w636NHj9xYLnYIUUYfO4Q4YIz+PXEiFPdjmEgEVlDTogIkwqezzjorV+bFxzjZXnvttfNwjzhxCeutt16+Ah+lvA7sqK9ieMeWW26ZLwLEAVwMdYqLAzHEOvbd33zzTT65j95S0WvqL3/5S7lXmQYqZkKNi1hVxf46gqiVVlppsgtZETxFKBW90hZbbLH08ssvVx5f6IlGXREha9ziAkIMUY2m5nGBNyqi4mNU/pWmsI+eUtEXJ0JaE1HQUMUMe3GsH83LozXHu+++m/bbb790wgkn5Fs8/uabb+b+ayUNZXSOv3w0GJNefYw3fozdjWnFx44dm4eDRFVKNNEdNWpU7vEQorQyprCNIKp0cgQ1peoI6uhXttdee6UNN9wwB6SXXnpp6tOnTz6Yi/5ScdWxJILUtm3blmmtYeaJWU6jKipmJItGuRFExUxOEdLGvjj2z3Fl8dRTT80n9nESb79MuUSVSExvP2mYFNtpnICE0vFDqRIqKkViu44+U9ErrVSBbTumLomT69imY0bJ9ddfP1d5xD47Krnfe++9fOxy5JFH5tEHpYbOUdkKDfXYJo7tN9lkk9xnLT7GBbUojth7771zQURpiHe0JYghsQ2JUIoGo3TAePPNN+eDwRDlxXEQGON3o7x+zjnnzEOiYpmzzz57stdQIUVNiwO6559/Pg/zCFHOGzNARgPEOKiL0t4ITeMWV1PicaivYoKJffbZJ89IFtWBUSkYYVQMzevcuXO6995700ILLZT3248++qjZmyi7OBmPapA4PogLB3GiHmLoaVz8ivA0QtTS8UNUYcdjUelaOi6JixOOL6hLYpa93XbbLQ/Hi4sGcZE3+kXFMUuMLIjqqQigYp8ew1QNS6Whi2OXqBaMsHa11VbL55nt2rXLs2rffvvteZbtCKhi5E6EUhHiNiQandOgRHlxlA3HH8roTRInP7feemtOp9944438xzROemLoVBxMRpNdTUeZWWL3O2bMmLz9xSw10c8shuXF1caYYS+uNkZY+vbbb+cT8whMo+mhCinqs9jO77///twgOq66x/shqlFi9sno+zd69OjcJDSqWuvzTDTU/v13nGiXwqSoioq+H3H8ECfocewQ+/PYdiNcjSGnMfPeueeea9IU6vxEQXESHQ2YI1yNmfZ22mmnHEbFxYT+/fvn/jjxnogemdHwfJlllin3qkNZJgGIyu+o6o73RAzXDqeddlr+2xAXnOM8oH379rniNo5rGiqhFA1ulr0Qs+zFVZ7oAXH11VfnUCCmHI/he/ExyirjxD8+d2qvATUphnPE+PIIQ+NqSczKESctRx99dP5/qVGo0nfq40Fb9PiLapIYste6dev8WPRXi1vpvRBX46MSxXuA2qDq/jiqXTt27Jj75eyxxx5p3333TQMHDszHDxFCRRPzmLwiLootuOCC+Sp49JAqzfILdWVfHcfNse2WRJuBCJ2i0Xn0+Ivj5W7duuV+rNDQ3y/xNyEursXfi9j3x4W0CHNDTNgSQW6EuD/933Du+HvRUAmlqLeqhklRUhxJdJTNxwFjiJOc+GMaO4d11103nxBFtUqM8Z3Sa0BN/qGKYXjRtyyGH8XJTBzQxYn5tddem6tEonw3KkRieti4wl71c6E+KG3PURkVVw3joC1K2SN8iuGs0WMtGkDHML2oaI1q1sMOO6yyCgXKpXQiEccQ0eT8tttuy81pY9uNACqaPMcU3hFMlcQ+P4ZmR8+QOK6IpuYqpahL++poZB4VUrGvjoqP6IcTQ4zieDqOW+666670zjvv5JPv+BjDlKChinPPmIkyzi2j71q8f2JERBzfxNDXkjje79u3b54NvkOHDqnBilAK6rNevXpVLLbYYhXrrbdexQILLFCx/vrrVzz77LOVz996660VHTt2rGjUqFFF7969y7quNAx33HFHxcILL5y3yc033zxve9dee21+bvz48RWffvppxQEHHJAfb926dcXYsWMrJk6cWO7Vhhr36KOPVswxxxwVAwcOrBgxYkTFhRdemLf7K664onKZ2P7ff//9iq233rpi+PDhZV1fKO3DO3XqVLHUUktVzDvvvBUffvhhfnzChAn546BBgyqaNGlScfjhh1eMGzduss8vLQd1xV133ZX31X/9618rTjnllIqVV165om3bthWjR4/Oz//00095/xzHNc2bN8/HMdDQ/Pbbb/ljHLPHe+XEE0/M97/44ov8fjnssMOm+Hm//vprRUMnlKJeu+yyyypatWpV8dprr+X7ceIfJzxxIlTVu+++m5+zU2BmKW1bsS1GOBrbZvjoo4/yNtmnT5/JPue2226r+OCDDwpfV5jZ4oAtTsyPPfbYiuOOOy4/9vXXX1e0adOmomfPnpXLOXmntthtt90qLrnkksr7pQsHG2ywQcU777xT+XjpAkIEU3ES371794pffvmlLOsMNSEuGKy22moVAwYMyPcjcFpkkUUq9t9//yke63zzzTdlWEson88++6wyoC0dt2y22WYV//jHPypGjhyZ3y8HHnhg5d+H66+/PhdF8P8zLol6LWYvi2bmK6+8crrlllvSEUcckWcBiSbS0XQubiGak8Z0nFFKHyX1UFNiBpq4AFAaphEND6NnVJTwRu+ymKEpeknF8KUQDXBLonHokksuWbZ1h5klhoLEEKYvvvgitWzZMr8vVl999bTFFlvk4XmhNBMqlFvsl2OWvZjOuySOI84///w8a++xxx6b+1SG0ixjMWwjelbG3wB9o6jLov3F999/nydfiTYD0fKia9eu6YorrsjPx5DV0kyocawTrQegoYhm5fvvv3/+GxETsZTavmy88cZp+PDhadVVV01bbrll7pEZopVMNDmPc9To0cb/I5Si3ogZQEoHhaUDw5ipLBrnxuPR3+H0009PhxxySGXz0TvuuGOy19HjgZoyfvz4PFtYNDYste+LA7o4AY8/VPEHK/5QRVAaoolzTBcb/c2gIcxctvjii+dmn+utt14OpKoetD3wwAN5OnEHbZTTjz/+mE+y4xgiGjzHhCgnn3xy2mWXXfKFrjhRj319PBZ9o0oBVByT7LjjjumJJ56onDQF6qLoDRUXyKJvVFxUi0CqdNwSF9eiz1Q08oeGKPpfxt+HueaaK22zzTY5mAprrrlmPq6fe+65U69evfJjcTwTjc/j70OcH1SdNKChE0pRb05w+vTpk3cG0TAu7sdB4F577ZUuvPDCvGOIP6AHH3xwZaods53FdLUws8T0r2eddVb+QxVXSmK73GqrrfIMj3GlcaONNson4aWmzQ8//HAOpDTXp74phbJRGfXf//43N8qN7TxO6F966aVcoRon9SFmJIuDtng/RDNQB22USxxXxEWFkSNH5gtWsX+Ok/BoVFvaXiOcisrX2IbjxCMudkXA2rt372oN+e3XqQumNP9V7IPjeCaOqWNilmjwX7qAe8kll6R33303LbPMMmVYWyi/uBCx/fbbp+OOOy6NGzcuzzw5atSoXE17+eWXp88//zyff3bq1Cntvvvu+bGoLizNrM3/Y/Y96s2sIFE6vNlmm6Wvv/46D/lYbbXV0gcffJD+9re/5YqpKLPv3LlzvvIes5l9++23aciQISqjmKni6nicdMcw0ubNm+f/R8VezLJx/PHH56nDoyokDvKiFD7C0uWWW67cqw01LobjxTCnOLmJCtYIbOME59lnn80n8SuttFI+cY8Zyp566qk8c80qq6xS7tWmgc+yF+FTDF2KmZNiVrEYjhezpMZxRgyx7tevX142TjKuu+66fGEsKgAHDx6cT+bNmkpdUdpWY98bU9mHuDAQlaxR4R3Dk2L2yDixXmihhfJyEdDGcUvMIAwNRVyoiL8LVcPYqIKK/X78TZh99tnTvffem9sTxN+RoUOH5hmE4wJ1hFYCqckJpagX4sp6JNURTEX1SQROMUVznNDEH8uokoqhIDFdc0xfG6WUUVIfB4ylz4Wa8M0336RPPvkkrb322tX+UMWJSpTqxgFdjCWPq+hRCh/BaZyMxxCROMlxEk59PMmJ90RcKDj11FPz/jb2y3HSE6Xt0Vft/fffz33/4qJCHOTF8JD27duXe/UhX7yKCwhxXBEnFzGU77PPPktXXXVVuvXWW6sFU7FMXGRo06ZNDlijesqFL+qSBx98MA87jfYCUdEaF9JiW48La7EfjyGrcdwS+/XFFlssnXHGGQIpGpR4H6ywwgr5WGb55ZdP3bp1y8fxm2yySX4+wtroExvnl3HuGcFUXKBWLfv7hFLUWXEyE1VPO+ywQw6aIpUOcRAYV3MiHIgr89HkPP6wxlC9uMXBYjwfOxMHjNSkKNGNUCmunmy44Ya590KU60YD56iSiisl0Sg3/h/VIXEC8/jjj+crJgsvvHBq3bp1ub8FqPFAKgKoqC6J4KnU0D+G8UX/tDipj315XEywP6Y2qVrh9Pzzz+cLCTH0NC5oVQ2m4gLYzjvvnE455ZRqn+8khLomhhzdcMMN+YJtTMASvXHOOeecPJw6qrmjmXMMT4pJguL9EcfdpWNvaCjib8Aee+yRK75j+4+LzXEcE1VQMdIh/h688847+cJbtOuI45wohuD3CaWok6KZaJzoh9LVnDjZj1n0Yohe/NGMsCpOguKAMa7iTHqyo0KKmhYn3tttt10+YIs/QPHHKf4YReVHXFWJflJxknPCCSfk4R3RM8ewDuqTGJoaFwRiuHSICsCY2fS+++7LFSXxfiiJYCqGV9955535+diXQ7lNKUyKx1588cU8/DQuOlStmLrmmmvSgAED8nDU/fbbr2zrDX/G22+/nS+qxXH03//+93wsUzpWjosJcbvyyitzxRQ0dFFRGGFtVEpFQLXooovmoXsxhDsusEUoFRebo3gi+g7edNNNjvf/gFCKOimaKsa04THcKXYG8Uc0pl6ON38EAZFWxwlQ7AiWXXbZ/Ac2epfAzBZl7dHsNk5iInyKvgtxlX3gwIF5GF8c+MUsNvExpgyPaj49R6gPYjuOq+mHHXZYbhBdGtIUJ/PnnXdeLmOPoSAdOnSo3OajT0n0+IuZm6IkPmax8V6gNgRSUeE3ZsyY3AMtAtO4iPXyyy+nI488slowFY3P48p5NO13oYu6Ki7uxn47mjBHf8sIWEvvhwim/vnPf+b+atFDKvpMQUNU9Xj9rrvuysNX27Vrl0466aQcUIU4F41ZhaM3ZhRRREWtIa5/TChFnd0ZRDAVVyfjyvujjz6ag6h4LPqSRM+euFofB44jRozIsx7ENM5QhPfeey+fuMQBXVxJWWONNSpL46MiJLbTmA42rjrqIUV9En394opgDP045phjUv/+/fPjr7/+eh6u9+abb+YKwbhYUNqfRx+p+H9cVYTaIGZRipPvmDk1TjCiyjX26dEzJIZhx7Yd+/MYslF1u1WBTV1v3hwn19HIPypBYnsv7adj2z777LPzLNdxYQEaqqrnojHBRRznRw/MuCAXM2tXFRejzSA8bYRS1MkrmKX/x8FiVEHFTiFOhDbffPPK51555ZV8FT7KKaOqSq8SihT9y6ICJETFVPSYqkr/HOqT0qFEHKjFfjmuIEZz6Li6Hr14QjT779u3bw6oohFoDGtVJUhtExcLIkCNCwhR1RrDTA855JDcrDb6Rq255pq5+jVaBsTFsAivbMfUZVVPnOPY5MADD8wjEaK6tWowBQ352OaPgqnoDxsXL+JvBNNPKEWdC6Si6WLMbtOzZ880zzzz5OFScTU+hkFFlVT0lJr0c4IQgHIEUzFTTexm42TcEFLquwijok9UVAdGFUk0849QNg7YQpSyR2+SqJaKkOovf/lLuVcZqomTirigdccdd1QeRwwfPjzPsLTeeuvloU3xeDwWFSMqo6jtqp5AT3osXLofw1CjL1rMVv3DDz/kiwoxEuH2229PXbp0KePaQ/kqv2P4dvjqq68mq+aeNJiKoXzzzTdfvngRsw0zfUwLQp1QCpeiV0+EUhFGRTPzECWTcdIT/XlinHsM5auqlLsKpChaXDWJKr24AvnXv/41jzGH+ioae0YT3AhiL7vsstxLKk5yzjzzzNyrJERlSeyvYwiIK++UW4RLkx4v/PTTT2ns2LHVqkhiuGlcWIgT9KicimOS6B8SgVQMa4LarDRMOiaeiGPhGEEQbS5i2437MUlLzEod23osG7OKxX67a9euuVdaXAiGhiTeE3GsEsO042JbXECLGbarivdK6RwzzkGPOuqoPNGRmbRnjLN06owY4x6z3EToVGoYF2/++KMawVRUS8WBYlRKxclQqY+PEx/KHUzFiXn0adAzh/o0xGmjjTbKw5tKon9fNH6OipKYJjmaf0Y/v7gSHwd3MfwpZi+L0vbYl8dUyVAuVaupY8hpbLNxMhHBamzbMStkbMulZeLkPbb3Saf2VilFbRa9oWK237gwFttvHBvHNh6jC2LbjZPu6JkWt0suuaTy8+Lib9yP4+w55pijrN8DFC0mr4jhq1ERG5NaxAQAbdq0mWy5UjAVH3feeee05ZZb5l6ETD/D96i1Jh3DHr2j3n///TzdZlyRf+yxx3KZcZzobL/99vlkJ4ZLRaIdTUpVRlFby4ChLosqkhi21KJFi9x3J8Kn8MYbb6TVV189N/Hv1KlTtcb/a6+9dr5KH7M3xQ1qy/FF9DyLoRcx1DRm742Ze8ePH5+r+2I2ybjQFSfvcSIf4kTFxS7qgmjIH8OoI5i67bbb8sWECGBjNuCYjKIUzA4aNChXepS2az2k4P+9f84///x8keKGG2743QvL3jN/nuF71Erxh7L05o6rNCFCptgpRMVJHDRGir3nnnvmg8ioooqZ9pZeeul8RT6WjavzUFsIpKgv5pxzzvTSSy/lYanbbbdd7kUS4ip86Wp7TDRRsuCCC+bHY0jfLrvsUsY1h+rHF9GHMo4fTj/99NwaIMLTuKj12WefpfPOOy83fF5rrbXy0KaoBIzwKj530mF/UNvELL9RDRX9/Nq2bZtWWmmlPLveoosumi/wxkWCUhVg7MernlA7uaahX0QOzZs3z+HtmDFjUr9+/fJ7Kkypnsd75s9TKUWtLqmPMe3xRzTG6cYf0qiGipmb4g/oZpttlkOouB+z4ESvhyWWWKLcqw9Qb8UhQ9xiHx09SmJ4U1ROxcl6VEzFSdC5556bh37ECX1UVEVj6LhSHyXw0asEaoPYHmPmvOgXdfTRR+fHRo8ena6//vpcPRWBVQy/jhORuNAVzZ6jYsqkKdQFb731Vj5OjqHS//3vf/M2/a9//SsNGzYsN/GPRswxO2qceEcbjNi2VXvQkJW2/0lHNsSonKgyjNYD8bcizj1DhLsma6k5QilqrZj5I4bqxVCPrbfeOi2yyCKVlVPR+yHEjqNUcqykHqCYg7YYthfVJDF0OnooxOPx2GKLLZYDqptuuin35IleJtE4Oob0rbLKKuVefci++eabPJNeXPSKY42YMbIkqq7322+/3D/kwgsvrPZ5pZN3qAuij1RcFIgLBxdffHGu+ojj5uhzef/99+f+UlFJFX3SYqhqNO+P9wU01GObGO4a4W3MohfB7QEHHFAZTF199dX5sSiEiMkCopr2k08+ya0M+POEUtRKMV14HBTGSU2UzoeqV3AimLrqqqvSvffem0vqhw4dmoeSVK2yAqDmvfzyy7lqJA7I9t5773yCv/nmm+f9b5zoRDAVszhF75KYtSn6MJiNhtrmzTffTDvssEM+oYiTkKqh6f7775++/PLLHKZCXVM6Fo5j6dg3R6PyuGjQsWPHPMFE7J8jmIoK1mjKHJUfEcBGFVVUt0JD9Pjjj+djm9133z199NFH6YcffkibbrppGjBgQH4+WhBEMBX9B+M9FBWHUT1FzXD2TtnFmz3e3FXFsJCojIox8JNOtxx/bCOUikakcfITJ0gRSEVJvUAKYOaJySTiwC2uHkYgFfvnCJziqmHsf6OqNa4cxj55mWWWSauuuqpAilopZvGNiVFiG45mttEKIERlX0ymMqWZlqAuiH1xbNfRCye28d122y23vXjkkUdypVTsn6N3WuzDY7KgGOoX279AioYqQqi4xcW26DMYRRHRgiDC3J49e+ZlotIwembG888++6xAqoaplKKsnnnmmTw+98UXX6xWEh9B1amnnpq++uqr1KxZs8qS+Qiknn766TwkJA4YSyGUknqAmScOFeKq4corr5yrU+NKYlwxrHpVPh6PhuYxJCr209FcF2q71157LU+aEsP2YvbI6CUSzftfeOGF/H99dqgrSttqXKSN/XLVvjixjccJdvRRi2qQCKZKy0dFa1RTQUO92BatCEaNGpV7Yu6888758fibEBNsxUWLuOBWqphi5lBWQlnFjDYx9C4CpRjHO27cuPz4BhtskId8RDAVJ0KlwCn+cMZjUVJfCqTij6pACmDmKJ24RJPy6PMXFapxIj9kyJD8fOyL4wSoVatWeUh1hFGTVrhCbRXD9m699dbcqzJmJIvm0K+++mo+oY8qboEUdWk/HUPyIoCKCwi9evXKQ4xCnFzHifcee+yRK6YiuCpt2wIpGrIIaCOojXPQmFm4JI559tprr9ybLaqjYrIAZh6VUpRFbHZxElMKkyKljjHthx56aLrgggvyH8poPhqVVDEzzuGHH55nD4kEO67GR2WV2W8AZv5JTtVK1QignnjiidzzL/qTxBCQOPkJpedVrlIXxfClgw8+OA/ri5P59u3bl3uVYLr21XFRIIbqxUl0zAoWM4ZFb7Sojoqm5iH23TEjX1zcjRNxaGimVP0aI3Oir1q8Vw477LB8Dlry3Xff5eF8m2yyib8LM5FQirKIN3jMbBCef/75fHIzaNCgfAVn3333TQMHDswnOBFCxUxOzz33XFphhRXSggsumK8CRartxAdg5h60PfbYY+nuu+/OZe1xgSAaQMd+OK60R7+FddddNwdT0f8P6rqoAIxgaokllsgz/0ZfNKiN4lh40UUXzSFq7K/jwu1OO+2Ue0cdddRRufdqVK1G1VQcS1cVF4CPPPLIyqntoaEd2zz11FO5wCGa+++zzz65/2U8d+aZZ+Y+bHEuWjWYMpHWzOenS+GefPLJ3I8kejbEH84dd9wx/zGNP6QxjXhMXxtN5eLNf+yxx+ZqqWhmHrM6xRC/UlNzgRTAzBEHbXGhIHpExaQS0Scqwqlo7PnZZ5/lIU6XX355LnXv27dvbpQL9WEoX1wUi8lWTPNNbRUjBuI4OXrdRFP+2F/HELxobL7FFlvk4+ullloqH1eXAqm4kPD+++/n/1988cUCKRqkeK9E6BTvjZiBNcLbCG6jujB6GB9yyCF5Vtbrr78+nXLKKZWfJ5Ca+fyEKUuVVCTOUTYcb/qYwWD++efPj2277bbptttuy8HUEUcckU+GQiTYpcbmsZyhewAzT0x5HAdk/fr1y/vjmFo8GpvHicxGG22Un49gKsrdP/3008rKV6jrYphTzCa50EILlXtVYIqif1/0inr77bdz6BQf40JtnGDHhd/OnTvncCpmCgsxI+pVV12VPvzww3KvOpRVtIuJCqhzzjkn91mLYoi46BZ9jCOUinPNCHw33XTTXI0Y56wUQyhFIaIy6tJLL83/79atW54974MPPkjLL798np42ROAUpZOlYCrGwsf0m9FotCppNUDNK43mj0rUqEiNHgulflEhpguP0vZ55pknN4YuXVyIIdhxQAf1RZycQG0WF2svu+yy3JQ/KqZiUqAYlheVHtFPKi4mlEYUxP8juIpjbmjIYsKsli1b5t5q7733Xh6qHcP34gJciOF8cTwTfQUfeOABF9wK5OyeQsqMY5a9Hj16VD4WCXT8EZ1zzjnzEL1XXnklPx4nOSGCqbgqH1fgDdMDKKasPfbFMaw6LgbEwVpcdS+JfXH0L4lK1TiYK10giFnLACh+uOm//vWvvN+OYdTRAy2GIUWri7POOivfIqiKitYYmRBVINCQRVVUDHONNgRRTbj55pvncDdE/+I4N43KwkUWWSQtsMAC5V7dBsUYKGaqmF45yowPOOCAfCIT49gjpDr11FPz8/Fc/EGNhqKRUseVnxCzgkSvqZ133jnf12AOYOaL4dTRADQuCKy33nq5D8lqq62WeyyUgqs4WIsrjaXKqklnsQGguGAqhubFcXZcOIjRCNHgPEYnzDXXXPniQlSzqpKioZnSLHvRdiCqvdu1a5erpaI3Zsl9992X+65FwQTFM/seM02fPn3yePZowhizNUVp8T//+c/cLDdm2SsFU7fffnseqhdDRmLWm/h/DBuJ6Zmd7ADM/IO26EVSqniKytZ55503T4EcFwa++OKLPENqzLT39NNPp+uuuy7PWmNmMoDaIYbxRcuLGHIdF3lbt26d9+3jxo0zHJUGe2wT1U9x3BIhVBzbxIyVUfjwt7/9LfczjqGtcREuhupFkBsX5mK2d4qn9ISZplOnTvnKTAzVi3LJSKajedzee++de0ZFqXGIKWxjDHzMdBNjeKPHVMy2FzsTmSnAzBP72RjqceCBB+Zm5uHGG2/Ms9LEFcRoAhr78gih4iDujTfeyJVUAimA2iNGGsQ+O/bRRx99dBo+fHh+vGnTpuVeNSjLsU00Kt9kk01yCBXnnsccc0w+folheyeddFL6/vvvcwAVBRERXMVzAqnyUSnFTDVkyJA8y0HM1BS9SWK4XozjjVLjaJQbgVSpuVwsEw3oSrPsReWUWfYAZp44BIir6zGMOi4cHH744al79+7p5ptvzn1KzjjjjNS+ffs8hDpmoYlpx5W2A9ROQ4cOTccdd1zeh5tBkoZcJRWFEFEcEaFTVEz17t07NW/ePL8/YhbhEENbF1tssXxsExXilI9Qipk+jjfe8LEj+O9//5ueeOKJasFUVEzF8JCYerwqPaQAiumz8NJLL+XmnnHwFsOrV1999XxRIA7iok9JXHUHoG4wZI+GfGzz+eef54tn0TJm++23z60HwgsvvJALJeaee+502GGH5Yopag9n/dSo0ux5VU941l577Xy1Pa7CRzIdjc4jlY4Gc7vuumueFSQCqqoEUgAzR+yfH3/88VwdFSKEimmPP/zww/x4zLAX3n333TyTUwzdA6BuEEjRUI9tok9xTNLyl7/8Jc+q99prr1U7H40ZKaOHZv/+/dOjjz5a1vWlOpVS1Jiq1U0xNjem3GzSpEnaeOON84wg0SfqyCOPzGN4S0P5Pv7441w9FcNFYhkAZq4JEyakM888M/eI2nPPPfPwvWhkHuHUdtttl3stjB49Oj8flVOxv44hfAAAtbFCKibJiuKHaEMQw/SiP2a0HYjhelEEURJV4BFKxWRc0TKG2kEoRY2LN3/sCGIq2rjyvtVWW+UwKprNxVj3aDQ3atSo3Fx34YUXrnaiJJgCKEY0M4/9dVxAWGONNdLmm2+eZ5+JCScipAqxr27ZsmW5VxUAYKo9jKNKavz48XkEThRJRNP/008/Pc8gHMP1qgZThrjWPsZIUaOuvPLKPF34oEGD8g4ipqiNBuZnn3127lsSJz4xlC/6lcTJUCjlogIpgOLEML3YX0cT0Jh1Zscdd8xBVcxYUyKQAgBqq7Fjx+bG/tdcc00aNmxY5aidlVZaKV9kW2SRRfJQvmuvvbbycwRStY9KKWpUVER9+eWX6Y477qgczhfT0nbr1i2P8b3iiivy4/FYhw4dBFEAtcCvv/6aG4AOHDgw9//74IMPcjNQAIDa7K233sp9Mi+//PI0YMCAdOCBB1Y+9/rrr+d2BBF53HLLLXloH7WPUIoZNukMebEp9ejRI3399dfp3//+d34+huTNNttsOcE+5JBD0ttvv50WXXTRys8xZA+g9szGF40/l1pqqdS2bdtyrxYAwBSPWaJfVOPGjVOLFi0qJ2eJC2uPPfZYOvbYY/M5aUlUgceELlE1Re3UuNwrQN0PpKJv1Oyzz55at26d9tlnn9xk7s4778zVUaVlYqex5JJLTnblXSAFUF5xcFc6yOvUqVO5VwcAYIriWCXaxET1UwzDi4mz4rxzmWWWST179szPxyx7cQ6677775s8pzSpM7SWUYrrFyUspbOrdu3e65557ct+o5ZZbLu200055RxAzOkXz3M6dO+fg6eqrr847DSWTALVPqVIKAKC2KV08iwbmMWt7VEM1bdo0T64V/aMeeeSRHExFU/M494yWBDFaJ85Jqf0M32OGK6RiXO7RRx+dZ2uKGZqiT9QFF1yQx/FGv6joLxVBVFRRxUx8L7zwQt45TDrsDwAAAKYmZnH/6aef0vPPP5/69OmTH4texjvvvHMaOXJkHrq32GKL5XYx119/fT4njZE61H5CKWbIk08+mZPpZZddNgdTYfTo0XkHENVTEVhFX5IY3xtD97p06ZJT65h1L+4DAADAH1VIRQFEtBiImd0POuigdMkll1QuE8FUjNaJZR544IG0+OKLp19++SU1adKkrOvOtBNKMd2++eabPJNeJNJRGhljeku+//77tN9++6U2bdqkCy+8sNrnaWoOAADAtLrrrrvyRCx77LFHLn6I8GnIkCF5JE4ptPrqq69yaDXHHHPk0TmKIOoWY6iYbtHQPHYOCy64YP742muvVT4377zzpvnnnz9PJz4pgRQAAADT4p133sn9o9ZYY4205pprpgEDBqTx48fnUThRDVWarGXhhRfOw/fuuOMOgVQdJJRihsQsBhFIRfXT+eefn15//fX8eIzzjZ1HVEoBAADA9Bo2bFi66aab8sRZ0dw8ehOvuuqquU1MTLK18cYbVwumFlpoodSuXbtyrzYzwPA9/pSokopZDWLY3uqrr57H7n788ce5bDL+XyqpBAAAgD8ShQ7bbLNN7iG1zjrrpMGDB1d7Ph6Pc9A4z4zzUf2j6jaVUvwpq6yySrr11lvzDHs//vhj2myzzfJOInYMv/76q0AKAACAP1Sql5l77rnTeeedlzp27JjeeuutdPPNN1dbLiqmrrnmmnwOGv2kqNtUSlEjYvjewQcfnIf19erVK7Vv377cqwQAAEAdmmUvihsmTpyYG5kPHz48HXHEEbk38aGHHpq23Xbbap8X/aWaNm1atvWmZqiUokasvPLKeWrON954I5100knp3XffLfcqAQAAUAcCqQceeCBtt912acMNN0xrrbVWGjRoUFp22WVz/+LoYxznmvfee2+1zxVI1Q9CKWpMDOUbOHBg+vrrr1OLFi3KvToAAADUYhFIPfjgg2mnnXZKXbt2TZdeemmeba9bt265T/Hyyy+fzj333Lxs//7987LUL4bvUePGjRuXmjVrVu7VAAAAoBaLPsS77bZbrorq169f+vzzz9Omm26aZ9e77LLLKpcbOnRo+sc//pEuuOCCtNhii5V1nalZKqWocQIpAAAA/sjPP/+c3nvvvdSlS5c0evTotPbaa1cLpOJjjMSJ6qmYYEsgVf8IpQAAAIDCvPnmm/lj8+bN00orrZQuv/zyPFQvmplHS5gwZsyYdN9996Xbb789956KJujUP0IpAAAAoBAjRoxIO+ywQ7rwwgvz/fXXXz89/fTTadFFF83D82abbbb8+D//+c/0/vvvp6233jr3noob9U/jcq8AAAAA0DDErHlRFfX222/n+3vvvXd666230rPPPpsrpaJy6qOPPkoPP/xwevzxx9Piiy9e7lVmJtLoHAAAAKhxETdMqcIpwqbOnTunQYMGpa222ir3lrrxxhvTI488kr7//vu09NJLp8MOOyx16NChLOtNcYRSAAAAwEzz1VdfpYUXXrjy/oQJE9IBBxyQPw4YMCC1bNmyrOtH+egpBQAAAMwUMRQv+kXtu+++6ZprrsmPzTrrrKlTp07poYceSt99911+7LfffivzmlIOKqUAAACAmTZ0784770z33ntveuqpp1KbNm3S8ccfn7p06ZK6d++e/ve//6W7775bI/MGSigFAAAA1GgYNWrUqNSkSZPUuHHj/HHMmDFp5MiR6aijjsoz8MX9FVdcMb3++uvphhtuSKuttlq5V50yEEoBAAAANRZI3Xfffal///5p7NixuW/UySefnDbddNM077zz5uVefPHFdM8996Rzzjknz8Y3fPjwPMSPhkcoBQAAANSI6BO1zTbbpL59+6ZWrVqll19+Od18882pd+/e6aCDDqoMpsIrr7ySlxFINVxCKQAAAOBPmThxYq6U2m233XLwdOmll1Y+d9ZZZ6V+/fqlm266KW299da5qXkM6wOz7wEAAAB/yiyzzJKH7n377bepZcuW+bFffvklfzzuuONSt27d0j/+8Y8cXgmkKBFKAQAAANPliy++SDfeeGO64oor8v9LwVT79u3zbHrjxo3LDc5LwVSHDh3SbLPNZpY9qhFKAQAAANNs2LBhaauttkqDBw9OH3zwQbWeUEcffXSaa6650k477VQZTIVPP/00zT333Gn8+PF5mB8EPaUAAACAaQ6k1l9//XTYYYflYXnNmzfPj8eMezEsb4sttkiDBg1Kp512Wvrhhx/yrHvff/99evjhh9Nzzz2XVlxxxXJ/C9QiBnICAAAAfyjCpUMPPTTtscceOXQqOeOMM9IJJ5yQNtxwwxxMbbfddmn55ZdPF1xwQfr666/T/PPPn1588cW07LLLlnX9qX1USgEAAAB/6J133smz50UfqQigoodUzLJ3xBFHpPPPPz9XSM0666ypZ8+eqWvXrpWfF7GDXlJMiVAKAAAA+EM33HBD2meffdKvv/5aGTJFk/OPP/44D+l7++2301FHHZVGjx6dg6uVVlqp3KtMLafROQAAAPCH2rVrl4fnxex6IWpcosl5BFITJ07MQ/Z22WWX/FyrVq3KvLbUBUIpAAAAYJpCqRYtWqRrr702z6ZXdUheDOUL7733Xl5uzjnnLOOaUlcIpQAAAIA/FFVRF198cRo8eHA66aST0vDhwyufiyF7vXr1SldddVU6+eST09xzz13WdaVu0FMKAAAAmCYTJkxI//rXv3Iz8/bt26eOHTum2WabLX355Zfp5ZdfTg8++GBaZZVVyr2a1BFCKQAAAGC6vPjii+nMM89MH374Ya6KWm+99VKPHj1yUAXTSigFAAAAzFDV1Kyzzlru1aAO01MKAAAAmG6l5uZBvQszQqUUAAAAAIVTKQUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAB1yJNPPpkaNWqURo0a9aeWAQAoN6EUAECBvv3223TIIYekxRZbLDVt2jS1bt06denSJT333HM19jU6duyYvv7669SiRYsaeT0hFwAwMzSeKa8KAMAUdevWLf3yyy/p2muvTUsssUQaMWJEeuyxx9J3331XY1+jSZMmOewCAKjNVEoBABQkKo2eeeaZdMYZZ6SNN944tW3bNq255prphBNOSNtss0365JNPckXS66+/Xu1z4rGoVqoqKqtWXHHF1KxZs7T22munt99++3crm5599tm0/vrrp9lnnz21adMmHXHEEWns2LGVz48fPz4df/zx+bmo4Grfvn268sor8zrFuoZ55pknv+4+++wzk39SAEBDIJQCACjIXHPNlW+DBg3KIdCfcdxxx6VzzjknDR06NC2wwAJp6623Tr/++usUl/3www/T5ptvnqu03nzzzXTrrbfmkKpnz56Vy+y9997p5ptvThdccEF655130mWXXZbXNUKqO++8My/z3nvv5WGBAwYM+FPrDgAQDN8DAChI48aN0zXXXJMOOOCAdOmll6ZVV101bbjhhmnXXXfNVU/T4+STT06bbbZZ/n8MBVx00UXT3XffnXbeeefJlu3fv3/aY4890lFHHZXvL7XUUjl8iq99ySWXpM8++yzddttt6ZFHHkmdOnXKy8TQwpJ55503f1xwwQVTy5Yt/9TPAACgRKUUAECBolrpq6++Svfee2+uXoqhdhFORVg1PdZZZ51qodHSSy+dK5ym5I033sivX6rUils0V584cWL6+OOP83DBWWedNYdUAABFUSkFAFCw6AMVVU5xO+mkk9L++++fK5+i31SoqKioXHZqQ/Kmx5gxY9JBBx2U+0hNKmYB/OCDD/701wAAmF4qpQAAymzZZZfNTcejN1SIvk0lVZueV/XCCy9U/v+HH35I77//furQocMUl41KrOHDh+fm5ZPeYqa+FVZYIVdNPfXUU1P8/FgmTJgw4U99nwAAVQmlAAAK8t1336VNNtkk3XDDDbnheAydu/3229OZZ56Ztt122zwzXsykd/rpp+eheBES9enTZ4qv1a9fv/TYY4/lWfdiNrz5558/bbfddlNcNmbVe/7553Nj8wi5/vOf/6R77rmnstF5u3btUvfu3dN+++2Xm7DHesWwwugzFWKWwJh17/7770/ffvttrrwCAPizhFIAAAWJXk5rrbVWOu+889IGG2yQll9++Tx8LxqfDxw4MC9z1VVXpd9++y2tttpquTH53//+9ym+VgRXRx55ZF7um2++Sffdd19lRdOkool6BFxRTbX++uunVVZZJfXt2zctvPDClctEw/Mdd9wxHXrooWmZZZbJ6xTVW2GRRRZJp556aurdu3dq1apVtVn7AABmVKOKqk0LAACo8x566KG0xRZbpHHjxk01qAIAKDeVUgAA9ciIESPy0LylllpKIAUA1Gpm3wMAqEe23HLL9NNPP6WLL7643KsCAPC7DN8DAAAAoHCG7wEAAABQOKEUAAAAAIUTSgEAAABQOKEUAAAAAIUTSgEAAABQOKEUAAAAAIUTSgEAAABQOKEUAAAAAIUTSgEAAACQivb/AaXuC7FVZFJrAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze subject distribution\n", + "print(\"=== SUBJECT DISTRIBUTION ===\")\n", + "print(train_data['subject'].value_counts())\n", + "\n", + "# Visualize subject distribution\n", + "plt.figure(figsize=(12, 8))\n", + "train_data['subject'].value_counts().plot(kind='bar')\n", + "plt.title('Subject Distribution in Training Data')\n", + "plt.xlabel('Subject')\n", + "plt.ylabel('Count')\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== DATE ANALYSIS ===\n", + "Date parsing results:\n", + "Training data - Successfully parsed: 39,934 (100.0%)\n", + "Training data - Parsing errors: 8 (0.0%)\n", + "Validation data - Successfully parsed: 4,954 (100.0%)\n", + "Validation data - Parsing errors: 2 (0.0%)\n", + "\n", + "Sample problematic dates from training data:\n", + "29357 https://100percentfedup.com/served-roy-moore-v...\n", + "35506 https://100percentfedup.com/video-hillary-aske...\n", + "35507 https://100percentfedup.com/12-yr-old-black-co...\n", + "35838 https://fedup.wpengine.com/wp-content/uploads/...\n", + "35839 https://fedup.wpengine.com/wp-content/uploads/...\n", + "37431 https://fedup.wpengine.com/wp-content/uploads/...\n", + "37432 https://fedup.wpengine.com/wp-content/uploads/...\n", + "38932 MSNBC HOST Rudely Assumes Steel Worker Would N...\n", + "Name: date_clean, dtype: object\n", + "\n", + "Date range in training data: 2015-03-31 00:00:00 to 2018-02-19 00:00:00\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze date distribution with comprehensive parsing\n", + "print(\"=== DATE ANALYSIS ===\")\n", + "\n", + "# Clean date strings by removing extra spaces\n", + "train_data['date_clean'] = train_data['date'].str.strip()\n", + "validation_data['date_clean'] = validation_data['date'].str.strip()\n", + "\n", + "# Function to parse dates with multiple formats\n", + "def parse_dates_robust(date_series):\n", + " \"\"\"Parse dates with multiple format support\"\"\"\n", + " # Try different date formats\n", + " formats = [\n", + " '%B %d, %Y', # December 20, 2017\n", + " '%d-%b-%y', # 19-Feb-18\n", + " '%Y-%m-%d', # 2017-12-20\n", + " '%m/%d/%Y', # 12/20/2017\n", + " '%d/%m/%Y', # 20/12/2017\n", + " ]\n", + " \n", + " parsed_dates = pd.Series([pd.NaT] * len(date_series), index=date_series.index)\n", + " \n", + " for fmt in formats:\n", + " try:\n", + " # Try to parse with current format\n", + " temp_parsed = pd.to_datetime(date_series, format=fmt, errors='coerce')\n", + " # Update only the ones that weren't parsed yet\n", + " mask = parsed_dates.isna() & temp_parsed.notna()\n", + " parsed_dates[mask] = temp_parsed[mask]\n", + " except:\n", + " continue\n", + " \n", + " # Try pandas automatic parsing for any remaining\n", + " remaining_mask = parsed_dates.isna()\n", + " if remaining_mask.any():\n", + " try:\n", + " auto_parsed = pd.to_datetime(date_series[remaining_mask], errors='coerce')\n", + " parsed_dates[remaining_mask] = auto_parsed\n", + " except:\n", + " pass\n", + " \n", + " return parsed_dates\n", + "\n", + "# Parse dates\n", + "train_data['date_parsed'] = parse_dates_robust(train_data['date_clean'])\n", + "validation_data['date_parsed'] = parse_dates_robust(validation_data['date_clean'])\n", + "\n", + "# Check parsing results\n", + "train_parse_errors = train_data['date_parsed'].isna().sum()\n", + "val_parse_errors = validation_data['date_parsed'].isna().sum()\n", + "\n", + "print(f\"Date parsing results:\")\n", + "print(f\"Training data - Successfully parsed: {len(train_data) - train_parse_errors:,} ({((len(train_data) - train_parse_errors) / len(train_data) * 100):.1f}%)\")\n", + "print(f\"Training data - Parsing errors: {train_parse_errors:,} ({train_parse_errors / len(train_data) * 100:.1f}%)\")\n", + "print(f\"Validation data - Successfully parsed: {len(validation_data) - val_parse_errors:,} ({((len(validation_data) - val_parse_errors) / len(validation_data) * 100):.1f}%)\")\n", + "print(f\"Validation data - Parsing errors: {val_parse_errors:,} ({val_parse_errors / len(validation_data) * 100:.1f}%)\")\n", + "\n", + "if train_parse_errors > 0:\n", + " print(\"\\nSample problematic dates from training data:\")\n", + " print(train_data[train_data['date_parsed'].isna()]['date_clean'].head(10))\n", + "\n", + "# Show date range for successfully parsed dates\n", + "if train_parse_errors < len(train_data):\n", + " valid_dates = train_data['date_parsed'].dropna()\n", + " print(f\"\\nDate range in training data: {valid_dates.min()} to {valid_dates.max()}\")\n", + " \n", + " # Visualize date distribution by year\n", + " plt.figure(figsize=(12, 6))\n", + " valid_dates.dt.year.value_counts().sort_index().plot(kind='bar')\n", + " plt.title('Article Distribution by Year (Successfully Parsed Dates)')\n", + " plt.xlabel('Year')\n", + " plt.ylabel('Number of Articles')\n", + " plt.xticks(rotation=45)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "else:\n", + " print(\"\\nNo dates could be parsed successfully.\")\n", + " print(\"\\nSample date values:\")\n", + " print(train_data['date_clean'].head(10))\n", + " print(\"\\nUnique date formats:\")\n", + " print(train_data['date_clean'].value_counts().head(10))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== TEXT AND TITLE LENGTH ANALYSIS ===\n", + "Text length statistics:\n", + "count 39942.000000\n", + "mean 2384.637875\n", + "std 1765.895463\n", + "min 1.000000\n", + "25% 1259.000000\n", + "50% 2197.000000\n", + "75% 3069.000000\n", + "max 49705.000000\n", + "Name: text_length, dtype: float64\n", + "\n", + "Title length statistics:\n", + "count 39942.000000\n", + "mean 79.774723\n", + "std 24.811136\n", + "min 8.000000\n", + "25% 63.000000\n", + "50% 73.000000\n", + "75% 90.000000\n", + "max 286.000000\n", + "Name: title_length, dtype: float64\n", + "\n", + "Word count statistics:\n", + "count 39942.000000\n", + "mean 391.735867\n", + "std 286.378195\n", + "min 0.000000\n", + "25% 207.000000\n", + "50% 363.500000\n", + "75% 506.000000\n", + "max 7033.000000\n", + "Name: word_count, dtype: float64\n", + "\n", + "Title word count statistics:\n", + "count 39942.000000\n", + "mean 12.392870\n", + "std 4.038761\n", + "min 1.000000\n", + "25% 10.000000\n", + "50% 11.000000\n", + "75% 14.000000\n", + "max 42.000000\n", + "Name: title_word_count, dtype: float64\n" + ] + } + ], + "source": [ + "# Analyze text and title lengths\n", + "print(\"=== TEXT AND TITLE LENGTH ANALYSIS ===\")\n", + "\n", + "# Calculate lengths\n", + "train_data['text_length'] = train_data['text'].str.len()\n", + "train_data['title_length'] = train_data['title'].str.len()\n", + "train_data['word_count'] = train_data['text'].str.split().str.len()\n", + "train_data['title_word_count'] = train_data['title'].str.split().str.len()\n", + "\n", + "print(f\"Text length statistics:\")\n", + "print(train_data['text_length'].describe())\n", + "print(f\"\\nTitle length statistics:\")\n", + "print(train_data['title_length'].describe())\n", + "print(f\"\\nWord count statistics:\")\n", + "print(train_data['word_count'].describe())\n", + "print(f\"\\nTitle word count statistics:\")\n", + "print(train_data['title_word_count'].describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== LENGTH DISTRIBUTIONS BY LABEL ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize length distributions by label\n", + "print(\"=== LENGTH DISTRIBUTIONS BY LABEL ===\")\n", + "\n", + "# Separate fake and real news\n", + "fake_news = train_data[train_data['label'] == 0]\n", + "real_news = train_data[train_data['label'] == 1]\n", + "\n", + "# Create subplots\n", + "fig, axes = plt.subplots(2, 2, figsize=(15, 12))\n", + "\n", + "axes[0, 0].hist(fake_news['text_length'], bins=50, alpha=0.7, label='Fake', color='red')\n", + "axes[0, 0].hist(real_news['text_length'], bins=50, alpha=0.7, label='Real', color='green')\n", + "axes[0, 0].set_title('Text Length Distribution by Label')\n", + "axes[0, 0].set_xlabel('Text Length (characters)')\n", + "axes[0, 0].set_ylabel('Frequency')\n", + "axes[0, 0].legend()\n", + "\n", + "axes[0, 1].hist(fake_news['title_length'], bins=30, alpha=0.7, label='Fake', color='red')\n", + "axes[0, 1].hist(real_news['title_length'], bins=30, alpha=0.7, label='Real', color='green')\n", + "axes[0, 1].set_title('Title Length Distribution by Label')\n", + "axes[0, 1].set_xlabel('Title Length (characters)')\n", + "axes[0, 1].set_ylabel('Frequency')\n", + "axes[0, 1].legend()\n", + "\n", + "axes[1, 0].hist(fake_news['word_count'], bins=50, alpha=0.7, label='Fake', color='red')\n", + "axes[1, 0].hist(real_news['word_count'], bins=50, alpha=0.7, label='Real', color='green')\n", + "axes[1, 0].set_title('Word Count Distribution by Label')\n", + "axes[1, 0].set_xlabel('Word Count')\n", + "axes[1, 0].set_ylabel('Frequency')\n", + "axes[1, 0].legend()\n", + "\n", + "axes[1, 1].hist(fake_news['title_word_count'], bins=20, alpha=0.7, label='Fake', color='red')\n", + "axes[1, 1].hist(real_news['title_word_count'], bins=20, alpha=0.7, label='Real', color='green')\n", + "axes[1, 1].set_title('Title Word Count Distribution by Label')\n", + "axes[1, 1].set_xlabel('Title Word Count')\n", + "axes[1, 1].set_ylabel('Frequency')\n", + "axes[1, 1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Text Preprocessing Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Text preprocessing functions defined!\n" + ] + } + ], + "source": [ + "# Text preprocessing functions\n", + "def clean_text(text):\n", + " \"\"\"Clean and preprocess text data\"\"\"\n", + " if pd.isna(text):\n", + " return \"\"\n", + " \n", + " # Convert to lowercase\n", + " text = text.lower()\n", + " \n", + " # Remove special characters and digits\n", + " text = re.sub(r'[^a-zA-Z\\s]', '', text)\n", + " \n", + " # Remove extra whitespace\n", + " text = ' '.join(text.split())\n", + " \n", + " return text\n", + "\n", + "def remove_stopwords(text):\n", + " \"\"\"Remove stopwords from text\"\"\"\n", + " if pd.isna(text):\n", + " return \"\"\n", + " \n", + " try:\n", + " stop_words = set(stopwords.words('english'))\n", + " words = word_tokenize(text)\n", + " filtered_words = [word for word in words if word.lower() not in stop_words]\n", + " return ' '.join(filtered_words)\n", + " except:\n", + " return text\n", + "\n", + "def lemmatize_text(text):\n", + " \"\"\"Lemmatize text\"\"\"\n", + " if pd.isna(text):\n", + " return \"\"\n", + " \n", + " try:\n", + " lemmatizer = WordNetLemmatizer()\n", + " words = word_tokenize(text)\n", + " lemmatized_words = [lemmatizer.lemmatize(word) for word in words]\n", + " return ' '.join(lemmatized_words)\n", + " except:\n", + " return text\n", + "\n", + "def preprocess_text(text):\n", + " \"\"\"Complete text preprocessing pipeline\"\"\"\n", + " text = clean_text(text)\n", + " text = remove_stopwords(text)\n", + " text = lemmatize_text(text)\n", + " return text\n", + "\n", + "print(\"Text preprocessing functions defined!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Word Frequency Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== WORD FREQUENCY ANALYSIS ===\n", + "Most common words in all articles:\n", + "trump: 122117\n", + "said: 118254\n", + "u: 54189\n", + "state: 51728\n", + "would: 49438\n", + "president: 48701\n", + "republican: 37084\n", + "people: 36420\n", + "one: 31535\n", + "year: 30011\n", + "reuters: 26711\n", + "new: 26710\n", + "also: 26608\n", + "donald: 25991\n", + "house: 25842\n", + "clinton: 24311\n", + "government: 24207\n", + "time: 22899\n", + "obama: 21929\n", + "say: 21899\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze most common words\n", + "print(\"=== WORD FREQUENCY ANALYSIS ===\")\n", + "\n", + "# Get all text\n", + "all_text = ' '.join(train_data['text'].astype(str))\n", + "all_text_clean = preprocess_text(all_text)\n", + "\n", + "# Count word frequencies\n", + "words = all_text_clean.split()\n", + "word_freq = Counter(words)\n", + "most_common_words = word_freq.most_common(20)\n", + "\n", + "print(\"Most common words in all articles:\")\n", + "for word, count in most_common_words:\n", + " print(f\"{word}: {count}\")\n", + "\n", + "# Visualize most common words\n", + "words_list, counts_list = zip(*most_common_words)\n", + "\n", + "plt.figure(figsize=(12, 8))\n", + "plt.barh(range(len(words_list)), counts_list)\n", + "plt.yticks(range(len(words_list)), words_list)\n", + "plt.xlabel('Frequency')\n", + "plt.title('Most Common Words in All Articles')\n", + "plt.gca().invert_yaxis()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== WORD FREQUENCY COMPARISON ===\n", + "Most common words in FAKE news:\n", + "trump: 68316\n", + "said: 25868\n", + "president: 22858\n", + "people: 22297\n", + "would: 19413\n", + "one: 19366\n", + "state: 17413\n", + "donald: 15737\n", + "like: 15146\n", + "republican: 15012\n", + "\n", + "Most common words in REAL news:\n", + "said: 92386\n", + "trump: 53801\n", + "u: 39802\n", + "state: 34315\n", + "would: 30025\n", + "reuters: 26456\n", + "president: 25843\n", + "republican: 22072\n", + "year: 17926\n", + "government: 17909\n" + ] + } + ], + "source": [ + "# Compare word frequencies between fake and real news\n", + "print(\"=== WORD FREQUENCY COMPARISON ===\")\n", + "\n", + "# Get text for fake and real news separately\n", + "fake_text = ' '.join(fake_news['text'].astype(str))\n", + "real_text = ' '.join(real_news['text'].astype(str))\n", + "\n", + "fake_text_clean = preprocess_text(fake_text)\n", + "real_text_clean = preprocess_text(real_text)\n", + "\n", + "# Count frequencies\n", + "fake_words = fake_text_clean.split()\n", + "real_words = real_text_clean.split()\n", + "\n", + "fake_freq = Counter(fake_words)\n", + "real_freq = Counter(real_words)\n", + "\n", + "print(\"Most common words in FAKE news:\")\n", + "for word, count in fake_freq.most_common(10):\n", + " print(f\"{word}: {count}\")\n", + "\n", + "print(\"\\nMost common words in REAL news:\")\n", + "for word, count in real_freq.most_common(10):\n", + " print(f\"{word}: {count}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Sample Articles Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== SAMPLE ARTICLES ===\n", + "\n", + "📰 SAMPLE FAKE NEWS ARTICLES:\n", + "\n", + "--- Article 19999 ---\n", + "Title: Donald Trump Sends Out Embarrassing New Year’s Eve Message; This is Disturbing\n", + "Subject: News\n", + "Date: December 31, 2017\n", + "Text (first 200 chars): Donald Trump just couldn t wish all Americans a Happy New Year and leave it at that. Instead, he had to give a shout out to his enemies, haters and the very dishonest fake news media. The former rea...\n", + "\n", + "--- Article 20000 ---\n", + "Title: Drunk Bragging Trump Staffer Started Russian Collusion Investigation\n", + "Subject: News\n", + "Date: December 31, 2017\n", + "Text (first 200 chars): House Intelligence Committee Chairman Devin Nunes is going to have a bad day. He s been under the assumption, like many of us, that the Christopher Steele-dossier was what prompted the Russia investig...\n", + "\n", + "--- Article 20001 ---\n", + "Title: Sheriff David Clarke Becomes An Internet Joke For Threatening To Poke People ‘In The Eye’\n", + "Subject: News\n", + "Date: December 30, 2017\n", + "Text (first 200 chars): On Friday, it was revealed that former Milwaukee Sheriff David Clarke, who was being considered for Homeland Security Secretary in Donald Trump s administration, has an email scandal of his own.In Jan...\n", + "\n", + "📰 SAMPLE REAL NEWS ARTICLES:\n", + "\n", + "--- Article 0 ---\n", + "Title: As U.S. budget fight looms, Republicans flip their fiscal script\n", + "Subject: politicsNews\n", + "Date: December 31, 2017 \n", + "Text (first 200 chars): WASHINGTON (Reuters) - The head of a conservative Republican faction in the U.S. Congress, who voted this month for a huge expansion of the national debt to pay for tax cuts, called himself a “fiscal ...\n", + "\n", + "--- Article 1 ---\n", + "Title: U.S. military to accept transgender recruits on Monday: Pentagon\n", + "Subject: politicsNews\n", + "Date: December 29, 2017 \n", + "Text (first 200 chars): WASHINGTON (Reuters) - Transgender people will be allowed for the first time to enlist in the U.S. military starting on Monday as ordered by federal courts, the Pentagon said on Friday, after Presiden...\n", + "\n", + "--- Article 2 ---\n", + "Title: Senior U.S. Republican senator: 'Let Mr. Mueller do his job'\n", + "Subject: politicsNews\n", + "Date: December 31, 2017 \n", + "Text (first 200 chars): WASHINGTON (Reuters) - The special counsel investigation of links between Russia and President Trump’s 2016 election campaign should continue without interference in 2018, despite calls from some Trum...\n" + ] + } + ], + "source": [ + "# Display sample articles\n", + "print(\"=== SAMPLE ARTICLES ===\")\n", + "\n", + "print(\"\\n📰 SAMPLE FAKE NEWS ARTICLES:\")\n", + "fake_samples = fake_news.head(3)\n", + "for idx, row in fake_samples.iterrows():\n", + " print(f\"\\n--- Article {idx} ---\")\n", + " print(f\"Title: {row['title']}\")\n", + " print(f\"Subject: {row['subject']}\")\n", + " print(f\"Date: {row['date']}\")\n", + " print(f\"Text (first 200 chars): {row['text'][:200]}...\")\n", + "\n", + "print(\"\\n📰 SAMPLE REAL NEWS ARTICLES:\")\n", + "real_samples = real_news.head(3)\n", + "for idx, row in real_samples.iterrows():\n", + " print(f\"\\n--- Article {idx} ---\")\n", + " print(f\"Title: {row['title']}\")\n", + " print(f\"Subject: {row['subject']}\")\n", + " print(f\"Date: {row['date']}\")\n", + " print(f\"Text (first 200 chars): {row['text'][:200]}...\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Data Quality Assessment" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== DATA QUALITY ASSESSMENT ===\n", + "Duplicate rows - Training: 201, Validation: 8\n", + "Empty text - Training: 610, Validation: 21\n", + "Very short text (<50 chars) - Training: 795, Validation: 41\n", + "Very long text (>10000 chars) - Training: 137, Validation: 215\n" + ] + } + ], + "source": [ + "# Assess data quality\n", + "print(\"=== DATA QUALITY ASSESSMENT ===\")\n", + "\n", + "# Check for duplicates\n", + "train_duplicates = train_data.duplicated().sum()\n", + "val_duplicates = validation_data.duplicated().sum()\n", + "print(f\"Duplicate rows - Training: {train_duplicates}, Validation: {val_duplicates}\")\n", + "\n", + "# Check for empty text\n", + "train_empty_text = (train_data['text'].str.strip() == '').sum()\n", + "val_empty_text = (validation_data['text'].str.strip() == '').sum()\n", + "print(f\"Empty text - Training: {train_empty_text}, Validation: {val_empty_text}\")\n", + "\n", + "# Check for very short text\n", + "train_short_text = (train_data['text'].str.len() < 50).sum()\n", + "val_short_text = (validation_data['text'].str.len() < 50).sum()\n", + "print(f\"Very short text (<50 chars) - Training: {train_short_text}, Validation: {val_short_text}\")\n", + "\n", + "# Check for very long text\n", + "train_long_text = (train_data['text'].str.len() > 10000).sum()\n", + "val_long_text = (validation_data['text'].str.len() > 10000).sum()\n", + "print(f\"Very long text (>10000 chars) - Training: {train_long_text}, Validation: {val_long_text}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Summary Statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== SUMMARY STATISTICS ===\n", + "\n", + "📊 DATASET OVERVIEW:\n", + "Training articles: 39,942\n", + "Validation articles: 4,956\n", + "Total articles: 44,898\n", + "\n", + "📈 LABEL DISTRIBUTION:\n", + "Fake news: 19,943 (49.9%)\n", + "Real news: 19,999 (50.1%)\n", + "\n", + "📝 TEXT STATISTICS:\n", + "Average text length: 2385 characters\n", + "Average word count: 392 words\n", + "Average title length: 80 characters\n", + "Average title word count: 12 words\n", + "\n", + "📅 DATE RANGE:\n", + "From: 2015-03-31 00:00:00\n", + "To: 2018-02-19 00:00:00\n", + "Span: 1056 days\n", + "Successfully parsed: 39,934 (100.0%)\n", + "\n", + "🏷️ SUBJECTS:\n", + "politicsNews: 11,272 articles\n", + "News: 9,050 articles\n", + "worldnews: 8,727 articles\n", + "politics: 6,841 articles\n", + "left-news: 2,482 articles\n", + "Government News: 1,570 articles\n" + ] + } + ], + "source": [ + "# Summary statistics\n", + "print(\"=== SUMMARY STATISTICS ===\")\n", + "\n", + "print(f\"\\n📊 DATASET OVERVIEW:\")\n", + "print(f\"Training articles: {len(train_data):,}\")\n", + "print(f\"Validation articles: {len(validation_data):,}\")\n", + "print(f\"Total articles: {len(train_data) + len(validation_data):,}\")\n", + "\n", + "print(f\"\\n📈 LABEL DISTRIBUTION:\")\n", + "print(f\"Fake news: {(train_data['label'] == 0).sum():,} ({(train_data['label'] == 0).mean() * 100:.1f}%)\")\n", + "print(f\"Real news: {(train_data['label'] == 1).sum():,} ({(train_data['label'] == 1).mean() * 100:.1f}%)\")\n", + "\n", + "print(f\"\\n📝 TEXT STATISTICS:\")\n", + "print(f\"Average text length: {train_data['text_length'].mean():.0f} characters\")\n", + "print(f\"Average word count: {train_data['word_count'].mean():.0f} words\")\n", + "print(f\"Average title length: {train_data['title_length'].mean():.0f} characters\")\n", + "print(f\"Average title word count: {train_data['title_word_count'].mean():.0f} words\")\n", + "\n", + "print(f\"\\n📅 DATE RANGE:\")\n", + "if 'date_parsed' in train_data.columns and train_data['date_parsed'].notna().any():\n", + " valid_dates = train_data['date_parsed'].dropna()\n", + " print(f\"From: {valid_dates.min()}\")\n", + " print(f\"To: {valid_dates.max()}\")\n", + " print(f\"Span: {(valid_dates.max() - valid_dates.min()).days} days\")\n", + " print(f\"Successfully parsed: {len(valid_dates):,} ({len(valid_dates)/len(train_data)*100:.1f}%)\")\n", + "else:\n", + " print(\"Date parsing not available\")\n", + "\n", + "print(f\"\\n🏷️ SUBJECTS:\")\n", + "for subject, count in train_data['subject'].value_counts().items():\n", + " print(f\"{subject}: {count:,} articles\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['label', 'title', 'text', 'subject', 'date', 'date_clean',\n", + " 'date_parsed', 'text_length', 'title_length', 'word_count',\n", + " 'title_word_count'],\n", + " dtype='object')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_data['year'] = train_data['date_parsed'].dt.year\n", + "train_data['month'] = train_data['date_parsed'].dt.month\n", + "train_data['year_month'] = train_data['date_parsed'].dt.to_period('M')\n", + "train_data['day_of_week'] = train_data['date_parsed'].dt.dayofweek \n", + "\n", + "def plot_date_features(df, column_name, title, xlabel):\n", + " df_plot = df.groupby(column_name)['label'].value_counts(normalize=True).unstack().fillna(0)\n", + " \n", + " if 0 not in df_plot.columns:\n", + " df_plot[0] = 0\n", + " if 1 not in df_plot.columns:\n", + " df_plot[1] = 0\n", + " \n", + " df_plot.plot(kind='bar', stacked=True, figsize=(10, 6))\n", + " plt.title(title)\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel('Proportion')\n", + " plt.legend(['Fake', 'Real'])\n", + " plt.show()\n", + "\n", + "plot_date_features(train_data, 'year', 'Class proportion by year', 'Year')\n", + "plot_date_features(train_data, 'month', 'Class proportion by month', 'Month')\n", + "plot_date_features(train_data, 'day_of_week', 'Class proportion by day of the week', 'Day of the week (Mon=0, Sun=6)')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Aggregate data by month and calculate normalized proportions\n", + "monthly_proportions = train_data.groupby('year_month')['label'].value_counts(normalize=True).unstack().fillna(0)\n", + "\n", + "# Build a line chart\n", + "plt.figure(figsize=(15, 7))\n", + "plt.plot(monthly_proportions.index.astype(str), monthly_proportions[0], label='Fake News', marker='o')\n", + "plt.plot(monthly_proportions.index.astype(str), monthly_proportions[1], label='Real News', marker='o')\n", + "\n", + "plt.title('Proportion of fake and real news by month')\n", + "plt.xlabel('Year and month')\n", + "plt.ylabel('Proportion of total news for the month')\n", + "plt.xticks(rotation=45)\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "numerical_features = [\n", + " 'label', 'text_length', 'title_length', 'word_count', \n", + " 'title_word_count', 'year', 'month', 'day_of_week'\n", + "]\n", + "\n", + "corr_data = train_data[numerical_features].copy()\n", + "\n", + "\n", + "corr_data = corr_data.fillna(0)\n", + "\n", + "\n", + "correlation_matrix = corr_data.corr()\n", + "\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt='.2f', linewidths=.5)\n", + "plt.title('Corr matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Key Insights and Recommendations" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== KEY INSIGHTS ===\n", + "\n", + "🔍 DATA CHARACTERISTICS:\n", + "• The dataset is well-balanced with roughly equal fake and real news\n", + "• Text lengths vary significantly, indicating diverse article types\n", + "• Multiple subjects are represented, providing good coverage\n", + "• Date range spans multiple years, allowing temporal analysis\n", + "\n", + "📊 DISTRIBUTION PATTERNS:\n", + "• Fake and real news have similar length distributions\n", + "• Subject distribution shows some bias toward certain topics\n", + "• Word frequency analysis reveals common terms in both categories\n", + "\n", + "⚠️ POTENTIAL CHALLENGES:\n", + "• Some articles may have inconsistent formatting\n", + "• Date parsing may require additional cleaning\n", + "• Text preprocessing will be crucial for model performance\n", + "\n", + "💡 RECOMMENDATIONS:\n", + "• Use text preprocessing to clean and normalize content\n", + "• Consider feature engineering (length, word count, etc.)\n", + "• Implement cross-validation for robust model evaluation\n", + "• Use ensemble methods to improve classification accuracy\n", + "• Consider temporal features if date parsing is successful\n" + ] + } + ], + "source": [ + "# Key insights\n", + "print(\"=== KEY INSIGHTS ===\")\n", + "\n", + "print(\"\\n🔍 DATA CHARACTERISTICS:\")\n", + "print(\"• The dataset is well-balanced with roughly equal fake and real news\")\n", + "print(\"• Text lengths vary significantly, indicating diverse article types\")\n", + "print(\"• Multiple subjects are represented, providing good coverage\")\n", + "print(\"• Date range spans multiple years, allowing temporal analysis\")\n", + "\n", + "print(\"\\n📊 DISTRIBUTION PATTERNS:\")\n", + "print(\"• Fake and real news have similar length distributions\")\n", + "print(\"• Subject distribution shows some bias toward certain topics\")\n", + "print(\"• Word frequency analysis reveals common terms in both categories\")\n", + "\n", + "print(\"\\n⚠️ POTENTIAL CHALLENGES:\")\n", + "print(\"• Some articles may have inconsistent formatting\")\n", + "print(\"• Date parsing may require additional cleaning\")\n", + "print(\"• Text preprocessing will be crucial for model performance\")\n", + "\n", + "print(\"\\n💡 RECOMMENDATIONS:\")\n", + "print(\"• Use text preprocessing to clean and normalize content\")\n", + "print(\"• Consider feature engineering (length, word count, etc.)\")\n", + "print(\"• Implement cross-validation for robust model evaluation\")\n", + "print(\"• Use ensemble methods to improve classification accuracy\")\n", + "print(\"• Consider temporal features if date parsing is successful\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
labeltitletextsubjectdatedate_cleandate_parsedtext_lengthtitle_lengthword_counttitle_word_countyearmonthyear_monthday_of_week
01As U.S. budget fight looms, Republicans flip t...WASHINGTON (Reuters) - The head of a conservat...politicsNewsDecember 31, 2017December 31, 20172017-12-31465964749102017.012.02017-126.0
11U.S. military to accept transgender recruits o...WASHINGTON (Reuters) - Transgender people will...politicsNewsDecember 29, 2017December 29, 20172017-12-2940776462492017.012.02017-124.0
21Senior U.S. Republican senator: 'Let Mr. Muell...WASHINGTON (Reuters) - The special counsel inv...politicsNewsDecember 31, 2017December 31, 20172017-12-31278960457102017.012.02017-126.0
31FBI Russia probe helped by Australian diplomat...WASHINGTON (Reuters) - Trump campaign adviser ...politicsNewsDecember 30, 2017December 30, 20172017-12-3024615937692017.012.02017-125.0
41Trump wants Postal Service to charge 'much mor...SEATTLE/WASHINGTON (Reuters) - President Donal...politicsNewsDecember 29, 2017December 29, 20172017-12-29520469852112017.012.02017-124.0
................................................
399370THIS IS NOT A JOKE! Soros-Linked Group Has Pla...The Left has been organizing for decades, and ...left-newsSep 22, 2016Sep 22, 20162016-09-225026124841202016.09.02016-093.0
399380THE SMARTEST WOMAN In Politics: “How Trump Can...Monica Crowley offers some of the most brillia...left-newsSep 22, 2016Sep 22, 20162016-09-22465185791152016.09.02016-093.0
399390BREAKING! SHOCKING VIDEO FROM CHARLOTTE RIOTS:...Protest underway in Charlotte: Things got com...left-newsSep 21, 2016Sep 21, 20162016-09-211898126122016.09.02016-092.0
399400BREAKING! Charlotte News Station Reports Cops ...Local Charlotte, NC news station WSOCTV is rep...left-newsSep 21, 2016Sep 21, 20162016-09-212302110380182016.09.02016-092.0
399410BIG MISTAKE! HILLARY JUST Proved To America Sh...Dividing America will be Obama s legacy. Hilla...left-newsSep 21, 2016Sep 21, 20162016-09-21989102171162016.09.02016-092.0
\n", + "

39942 rows × 15 columns

\n", + "
" + ], + "text/plain": [ + " label title \\\n", + "0 1 As U.S. budget fight looms, Republicans flip t... \n", + "1 1 U.S. military to accept transgender recruits o... \n", + "2 1 Senior U.S. Republican senator: 'Let Mr. Muell... \n", + "3 1 FBI Russia probe helped by Australian diplomat... \n", + "4 1 Trump wants Postal Service to charge 'much mor... \n", + "... ... ... \n", + "39937 0 THIS IS NOT A JOKE! Soros-Linked Group Has Pla... \n", + "39938 0 THE SMARTEST WOMAN In Politics: “How Trump Can... \n", + "39939 0 BREAKING! SHOCKING VIDEO FROM CHARLOTTE RIOTS:... \n", + "39940 0 BREAKING! Charlotte News Station Reports Cops ... \n", + "39941 0 BIG MISTAKE! HILLARY JUST Proved To America Sh... \n", + "\n", + " text subject \\\n", + "0 WASHINGTON (Reuters) - The head of a conservat... politicsNews \n", + "1 WASHINGTON (Reuters) - Transgender people will... politicsNews \n", + "2 WASHINGTON (Reuters) - The special counsel inv... politicsNews \n", + "3 WASHINGTON (Reuters) - Trump campaign adviser ... politicsNews \n", + "4 SEATTLE/WASHINGTON (Reuters) - President Donal... politicsNews \n", + "... ... ... \n", + "39937 The Left has been organizing for decades, and ... left-news \n", + "39938 Monica Crowley offers some of the most brillia... left-news \n", + "39939 Protest underway in Charlotte: Things got com... left-news \n", + "39940 Local Charlotte, NC news station WSOCTV is rep... left-news \n", + "39941 Dividing America will be Obama s legacy. Hilla... left-news \n", + "\n", + " date date_clean date_parsed text_length \\\n", + "0 December 31, 2017 December 31, 2017 2017-12-31 4659 \n", + "1 December 29, 2017 December 29, 2017 2017-12-29 4077 \n", + "2 December 31, 2017 December 31, 2017 2017-12-31 2789 \n", + "3 December 30, 2017 December 30, 2017 2017-12-30 2461 \n", + "4 December 29, 2017 December 29, 2017 2017-12-29 5204 \n", + "... ... ... ... ... \n", + "39937 Sep 22, 2016 Sep 22, 2016 2016-09-22 5026 \n", + "39938 Sep 22, 2016 Sep 22, 2016 2016-09-22 4651 \n", + "39939 Sep 21, 2016 Sep 21, 2016 2016-09-21 189 \n", + "39940 Sep 21, 2016 Sep 21, 2016 2016-09-21 2302 \n", + "39941 Sep 21, 2016 Sep 21, 2016 2016-09-21 989 \n", + "\n", + " title_length word_count title_word_count year month year_month \\\n", + "0 64 749 10 2017.0 12.0 2017-12 \n", + "1 64 624 9 2017.0 12.0 2017-12 \n", + "2 60 457 10 2017.0 12.0 2017-12 \n", + "3 59 376 9 2017.0 12.0 2017-12 \n", + "4 69 852 11 2017.0 12.0 2017-12 \n", + "... ... ... ... ... ... ... \n", + "39937 124 841 20 2016.0 9.0 2016-09 \n", + "39938 85 791 15 2016.0 9.0 2016-09 \n", + "39939 81 26 12 2016.0 9.0 2016-09 \n", + "39940 110 380 18 2016.0 9.0 2016-09 \n", + "39941 102 171 16 2016.0 9.0 2016-09 \n", + "\n", + " day_of_week \n", + "0 6.0 \n", + "1 4.0 \n", + "2 6.0 \n", + "3 5.0 \n", + "4 4.0 \n", + "... ... \n", + "39937 3.0 \n", + "39938 3.0 \n", + "39939 2.0 \n", + "39940 2.0 \n", + "39941 2.0 \n", + "\n", + "[39942 rows x 15 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/2.1 enhanced_classifier.ipynb b/2.1 enhanced_classifier.ipynb new file mode 100644 index 0000000..7641825 --- /dev/null +++ b/2.1 enhanced_classifier.ipynb @@ -0,0 +1,728 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Enhanced Fake News Classifier\n", + "\n", + "## Overview\n", + "This notebook implements an enhanced fake news classifier with:\n", + "- Robust text preprocessing (cleaning, stopword removal, lemmatization)\n", + "- Advanced feature engineering (length, punctuation, lexical diversity, subject, dates)\n", + "- TF-IDF vectorization and numerical feature scaling\n", + "- Multiple models (Logistic Regression, Random Forest, Gradient Boosting, SVM)\n", + "- Soft-voting ensemble and cross-validation\n", + "- Predictions on validation set with confidence scores\n", + "\n", + "Run cells top-to-bottom.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package wordnet to /Users/sergej/nltk_data...\n", + "[nltk_data] Package wordnet is already up-to-date!\n" + ] + } + ], + "source": [ + "# Imports and setup\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Text processing\n", + "import re\n", + "from collections import Counter\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.stem import WordNetLemmatizer\n", + "\n", + "# ML\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, VotingClassifier\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import classification_report, accuracy_score\n", + "from sklearn.preprocessing import StandardScaler\n", + "from scipy.sparse import hstack\n", + "\n", + "# NLTK data\n", + "for pkg, path in [('punkt','tokenizers/punkt'),('stopwords','corpora/stopwords'),('wordnet','corpora/wordnet')]:\n", + " try:\n", + " nltk.data.find(path)\n", + " except LookupError:\n", + " nltk.download(pkg)\n", + "\n", + "print('Setup complete')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading data...\n", + "Training: (39942, 5), Validation: (4956, 5)\n" + ] + } + ], + "source": [ + "# Load data\n", + "print('Loading data...')\n", + "train_data = pd.read_csv('dataset/data.csv')\n", + "validation_data = pd.read_csv('dataset/validation_data.csv')\n", + "print(f'Training: {train_data.shape}, Validation: {validation_data.shape}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preprocessing functions ready\n" + ] + } + ], + "source": [ + "# Preprocessing functions\n", + "def clean_text(text):\n", + " if pd.isna(text):\n", + " return ''\n", + " text = text.lower()\n", + " text = re.sub(r'[^a-zA-Z\\s]', '', text)\n", + " text = ' '.join(text.split())\n", + " return text\n", + "\n", + "def remove_stopwords(text):\n", + " if pd.isna(text):\n", + " return ''\n", + " try:\n", + " stop_words = set(stopwords.words('english'))\n", + " words = word_tokenize(text)\n", + " return ' '.join([w for w in words if w.lower() not in stop_words])\n", + " except:\n", + " return text\n", + "\n", + "def lemmatize_text(text):\n", + " if pd.isna(text):\n", + " return ''\n", + " try:\n", + " lemmatizer = WordNetLemmatizer()\n", + " words = word_tokenize(text)\n", + " return ' '.join([lemmatizer.lemmatize(w) for w in words])\n", + " except:\n", + " return text\n", + "\n", + "def preprocess_text(text):\n", + " text = clean_text(text)\n", + " text = remove_stopwords(text)\n", + " text = lemmatize_text(text)\n", + " return text\n", + "\n", + "print('Preprocessing functions ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date parser ready\n" + ] + } + ], + "source": [ + "# Advanced date parsing\n", + "\n", + "def parse_dates_robust(date_series):\n", + " formats = ['%B %d, %Y', '%d-%b-%y', '%Y-%m-%d', '%m/%d/%Y', '%d/%m/%Y']\n", + " parsed_dates = pd.Series([pd.NaT] * len(date_series), index=date_series.index)\n", + " for fmt in formats:\n", + " try:\n", + " temp = pd.to_datetime(date_series, format=fmt, errors='coerce')\n", + " mask = parsed_dates.isna() & temp.notna()\n", + " parsed_dates[mask] = temp[mask]\n", + " except:\n", + " continue\n", + " return parsed_dates\n", + "\n", + "print('Date parser ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Engineering features...\n", + "Features ready\n" + ] + } + ], + "source": [ + "# Feature engineering\n", + "print('Engineering features...')\n", + "\n", + "# Process text\n", + "data = train_data.copy()\n", + "data['text_processed'] = data['text'].apply(preprocess_text)\n", + "data['title_processed'] = data['title'].apply(preprocess_text)\n", + "\n", + "# Basic lengths\n", + "data['text_length'] = data['text'].str.len()\n", + "data['title_length'] = data['title'].str.len()\n", + "data['word_count'] = data['text'].str.split().str.len()\n", + "data['title_word_count'] = data['title'].str.split().str.len()\n", + "\n", + "# Advanced text features\n", + "data['avg_word_length'] = data['text'].str.split().str.join(' ').str.len() / data['word_count']\n", + "data['title_avg_word_length'] = data['title'].str.split().str.join(' ').str.len() / data['title_word_count']\n", + "\n", + "# Punctuation features (escape regex)\n", + "data['exclamation_count'] = data['text'].str.count(r'!')\n", + "data['question_count'] = data['text'].str.count(r'\\?')\n", + "data['quote_count'] = data['text'].str.count(r'\"')\n", + "data['capital_ratio'] = data['text'].str.count(r'[A-Z]') / data['text_length']\n", + "\n", + "# Lexical diversity\n", + "data['unique_words_ratio'] = data['text_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "data['title_unique_words_ratio'] = data['title_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "\n", + "# Subject encoding\n", + "from sklearn.preprocessing import LabelEncoder\n", + "le = LabelEncoder()\n", + "data['subject_encoded'] = le.fit_transform(data['subject'])\n", + "subject_mapping = dict(zip(le.classes_, le.transform(le.classes_)))\n", + "DEFAULT_SUBJECT = 0\n", + "\n", + "# Date features\n", + "data['date_clean'] = data['date'].str.strip()\n", + "data['date_parsed'] = parse_dates_robust(data['date_clean'])\n", + "data['year'] = data['date_parsed'].dt.year\n", + "data['month'] = data['date_parsed'].dt.month\n", + "data['day_of_week'] = data['date_parsed'].dt.dayofweek\n", + "data['is_weekend'] = data['day_of_week'].isin([5, 6]).astype(int)\n", + "\n", + "numerical_features = [\n", + " 'text_length','title_length','word_count','title_word_count',\n", + " 'avg_word_length','title_avg_word_length',\n", + " 'exclamation_count','question_count','quote_count','capital_ratio',\n", + " 'unique_words_ratio','title_unique_words_ratio',\n", + " 'subject_encoded','year','month','day_of_week','is_weekend'\n", + "]\n", + "\n", + "print('Features ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vectorization and scaling complete\n" + ] + } + ], + "source": [ + "# Train/test split and vectorization\n", + "X_text = data['text_processed']\n", + "X_num = data[numerical_features].fillna(0)\n", + "y = data['label']\n", + "\n", + "X_train_text, X_test_text, X_train_num, X_test_num, y_train, y_test = train_test_split(\n", + " X_text, X_num, y, test_size=0.2, random_state=42, stratify=y\n", + ")\n", + "\n", + "# TF-IDF\n", + "tfidf_vectorizer = TfidfVectorizer(\n", + " max_features=8000,\n", + " ngram_range=(1,3),\n", + " min_df=3,\n", + " max_df=0.8,\n", + " sublinear_tf=True\n", + ")\n", + "X_train_tfidf = tfidf_vectorizer.fit_transform(X_train_text)\n", + "X_test_tfidf = tfidf_vectorizer.transform(X_test_text)\n", + "\n", + "# Scale numerical features\n", + "scaler = StandardScaler()\n", + "X_train_num_scaled = scaler.fit_transform(X_train_num)\n", + "X_test_num_scaled = scaler.transform(X_test_num)\n", + "\n", + "# Combine\n", + "from scipy.sparse import hstack\n", + "X_train_combined = hstack([X_train_tfidf, X_train_num_scaled])\n", + "X_test_combined = hstack([X_test_tfidf, X_test_num_scaled])\n", + "\n", + "print('Vectorization and scaling complete')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Logistic Regression: 0.9999\n", + "Random Forest: 1.0000\n", + "Gradient Boosting: 1.0000\n", + "SVM: 0.9996\n", + "Ensemble: 0.9999\n", + "\n", + "Best model: Random Forest (1.0000)\n" + ] + } + ], + "source": [ + "# Train models\n", + "lr_model = LogisticRegression(random_state=42, max_iter=2000, C=1.0)\n", + "rf_model = RandomForestClassifier(n_estimators=200, random_state=42, max_depth=20)\n", + "gb_model = GradientBoostingClassifier(n_estimators=100, random_state=42)\n", + "svm_model = SVC(random_state=42, probability=True, kernel='rbf')\n", + "ensemble_model = VotingClassifier(\n", + " estimators=[('lr', lr_model), ('rf', rf_model), ('gb', gb_model), ('svm', svm_model)],\n", + " voting='soft'\n", + ")\n", + "\n", + "models = {\n", + " 'Logistic Regression': lr_model,\n", + " 'Random Forest': rf_model,\n", + " 'Gradient Boosting': gb_model,\n", + " 'SVM': svm_model,\n", + " 'Ensemble': ensemble_model\n", + "}\n", + "\n", + "results = {}\n", + "for name, model in models.items():\n", + " model.fit(X_train_combined, y_train)\n", + " y_pred = model.predict(X_test_combined)\n", + " acc = accuracy_score(y_test, y_pred)\n", + " results[name] = acc\n", + " print(f\"{name}: {acc:.4f}\")\n", + "\n", + "best_model_name = max(results, key=results.get)\n", + "best_model = models[best_model_name]\n", + "print(f\"\\nBest model: {best_model_name} ({results[best_model_name]:.4f})\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CV scores: [0.99984353 0.99953059 0.99968706 0.99968701 0.99968701]\n", + "CV mean: 0.9996870403386608 +/- 0.0001979206855330111\n" + ] + } + ], + "source": [ + "# Cross-validation\n", + "cv_scores = cross_val_score(best_model, X_train_combined, y_train, cv=5)\n", + "print('CV scores:', cv_scores)\n", + "print('CV mean:', cv_scores.mean(), '+/-', cv_scores.std()*2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9998748278883465\n", + " precision recall f1-score support\n", + "\n", + " Fake 1.00 1.00 1.00 3989\n", + " Real 1.00 1.00 1.00 4000\n", + "\n", + " accuracy 1.00 7989\n", + " macro avg 1.00 1.00 1.00 7989\n", + "weighted avg 1.00 1.00 1.00 7989\n", + "\n" + ] + } + ], + "source": [ + "print('Accuracy:', accuracy_score(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred, target_names=['Fake','Real']))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9998748278883465\n", + " precision recall f1-score support\n", + "\n", + " Fake 1.00 1.00 1.00 3989\n", + " Real 1.00 1.00 1.00 4000\n", + "\n", + " accuracy 1.00 7989\n", + " macro avg 1.00 1.00 1.00 7989\n", + "weighted avg 1.00 1.00 1.00 7989\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, accuracy_score, classification_report\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Confusion matrix\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "\n", + "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Fake', 'Real'])\n", + "disp.plot(cmap=plt.cm.Blues)\n", + "plt.title('Confusion Matrix')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top text features:\n", + "like: 0.0081\n", + "know: 0.0092\n", + "minister: 0.0101\n", + "washington: 0.0114\n", + "image: 0.0173\n", + "image via: 0.0177\n", + "washington reuters: 0.0203\n", + "via: 0.0279\n", + "said: 0.0375\n", + "reuters: 0.1008\n", + "\n", + "Numerical features:\n", + "text_length: 0.0067\n", + "title_length: 0.0499\n", + "word_count: 0.0049\n", + "title_word_count: 0.0377\n", + "avg_word_length: 0.0096\n", + "title_avg_word_length: 0.0003\n", + "exclamation_count: 0.0145\n", + "question_count: 0.0145\n", + "quote_count: 0.0002\n", + "capital_ratio: 0.0016\n", + "unique_words_ratio: 0.0015\n", + "title_unique_words_ratio: 0.0013\n", + "subject_encoded: 0.0980\n", + "year: 0.0314\n", + "month: 0.0280\n", + "day_of_week: 0.0251\n", + "is_weekend: 0.0002\n" + ] + } + ], + "source": [ + "# Feature importance (if available)\n", + "if hasattr(best_model, 'feature_importances_'):\n", + " importances = best_model.feature_importances_\n", + " text_size = X_train_tfidf.shape[1]\n", + " text_imps = importances[:text_size]\n", + " top_idx = np.argsort(text_imps)[-10:]\n", + " top_feats = [tfidf_vectorizer.get_feature_names_out()[i] for i in top_idx]\n", + " print('Top text features:')\n", + " for f, w in zip(top_feats, text_imps[top_idx]):\n", + " print(f'{f}: {w:.4f}')\n", + " num_imps = importances[text_size:]\n", + " print('\\nNumerical features:')\n", + " for f, w in zip(numerical_features, num_imps):\n", + " print(f'{f}: {w:.4f}')\n", + "else:\n", + " print('Model has no feature_importances_ attribute')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlabelprobability_fakeprobability_realconfidence
0010.0715430.9284570.928457
1110.1784410.8215590.821559
2210.1284390.8715610.871561
3310.0538860.9461140.946114
4410.0772230.9227770.922777
\n", + "
" + ], + "text/plain": [ + " id label probability_fake probability_real confidence\n", + "0 0 1 0.071543 0.928457 0.928457\n", + "1 1 1 0.178441 0.821559 0.821559\n", + "2 2 1 0.128439 0.871561 0.871561\n", + "3 3 1 0.053886 0.946114 0.946114\n", + "4 4 1 0.077223 0.922777 0.922777" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Predict on validation data\n", + "val = validation_data.copy()\n", + "val['text_processed'] = val['text'].apply(preprocess_text)\n", + "val['title_processed'] = val['title'].apply(preprocess_text)\n", + "val['text_length'] = val['text'].str.len()\n", + "val['title_length'] = val['title'].str.len()\n", + "val['word_count'] = val['text'].str.split().str.len()\n", + "val['title_word_count'] = val['title'].str.split().str.len()\n", + "val['avg_word_length'] = val['text'].str.split().str.join(' ').str.len() / val['word_count']\n", + "val['title_avg_word_length'] = val['title'].str.split().str.join(' ').str.len() / val['title_word_count']\n", + "val['exclamation_count'] = val['text'].str.count(r'!')\n", + "val['question_count'] = val['text'].str.count(r'\\?')\n", + "val['quote_count'] = val['text'].str.count(r'\"')\n", + "val['capital_ratio'] = val['text'].str.count(r'[A-Z]') / val['text_length']\n", + "val['unique_words_ratio'] = val['text_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "val['title_unique_words_ratio'] = val['title_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "\n", + "# Subject encoding with unseen handling\n", + "val['subject_encoded'] = val['subject'].map(subject_mapping).fillna(DEFAULT_SUBJECT).astype(int)\n", + "\n", + "# Date features\n", + "val['date_clean'] = val['date'].str.strip()\n", + "val['date_parsed'] = parse_dates_robust(val['date_clean'])\n", + "val['year'] = val['date_parsed'].dt.year\n", + "val['month'] = val['date_parsed'].dt.month\n", + "val['day_of_week'] = val['date_parsed'].dt.dayofweek\n", + "val['is_weekend'] = val['day_of_week'].isin([5, 6]).astype(int)\n", + "\n", + "X_val_text = val['text_processed']\n", + "X_val_num = val[numerical_features].fillna(0)\n", + "X_val_num_scaled = scaler.transform(X_val_num)\n", + "X_val_tfidf = tfidf_vectorizer.transform(X_val_text)\n", + "X_val_combined = hstack([X_val_tfidf, X_val_num_scaled])\n", + "\n", + "val_pred = best_model.predict(X_val_combined)\n", + "val_proba = best_model.predict_proba(X_val_combined)\n", + "\n", + "submission = pd.DataFrame({\n", + " 'id': range(len(val)),\n", + " 'label': val_pred,\n", + " 'probability_fake': val_proba[:, 0],\n", + " 'probability_real': val_proba[:, 1],\n", + " 'confidence': np.max(val_proba, axis=1)\n", + "})\n", + "\n", + "submission.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved to enhanced_fake_news_predictions.csv\n", + "Distribution:\n", + "label\n", + "fake 0.702986\n", + "real 0.297014\n", + "Name: proportion, dtype: float64\n" + ] + } + ], + "source": [ + "# Save predictions\n", + "submission.to_csv('enhanced_fake_news_predictions.csv', index=False)\n", + "print(\"Saved to enhanced_fake_news_predictions.csv\")\n", + "print('Distribution:')\n", + "print(submission['label'].value_counts(normalize=True).rename({0:'fake',1:'real'}))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved labeled validation to: dataset/validation_data_labeled.csv\n" + ] + } + ], + "source": [ + "# Save validation with predicted labels into dataset\n", + "import os\n", + "\n", + "# Try to use in-memory validation data if present; otherwise read from disk\n", + "try:\n", + " original_val = validation_data.copy()\n", + "except NameError:\n", + " original_val = pd.read_csv('dataset/validation_data.csv')\n", + "\n", + "# Ensure lengths match\n", + "assert len(original_val) == len(submission), 'Length mismatch between validation and predictions'\n", + "\n", + "labeled_val = original_val.copy()\n", + "labeled_val['label'] = submission['label'].values\n", + "\n", + "out_path = os.path.join('dataset', 'validation_data_labeled.csv')\n", + "labeled_val.to_csv(out_path, index=False)\n", + "print(f\"Saved labeled validation to: {out_path}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2.2 embeddings_classifier.ipynb b/2.2 embeddings_classifier.ipynb new file mode 100644 index 0000000..e6df594 --- /dev/null +++ b/2.2 embeddings_classifier.ipynb @@ -0,0 +1,611 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sure! Here's the English translation:\n", + "\n", + "# Embeddings-based Fake News Classifier\n", + "\n", + "## Overview\n", + "This notebook builds a fake news classifier using sentence embeddings (Sentence-Transformers) and a simple linear classifier. Its structure is similar to `enhanced_classifier.ipynb`, but without complex text preprocessing.\n", + "\n", + "Pipeline:\n", + "- Installation and import of libraries \n", + "- Data loading \n", + "- Input text formation (title + text) \n", + "- Embedding generation (all-MiniLM-L6-v2) \n", + "- Train/test split \n", + "- Logistic Regression training \n", + "- Quality evaluation \n", + "- Prediction generation for validation and saving to CSV \n", + "\n", + "If you'd like, I can help you expand this into a full project description or even turn it into a presentation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sergej/.pyenv/versions/3.11.8/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Environment ready\n" + ] + } + ], + "source": [ + "# Setup and imports\n", + "import sys\n", + "!{sys.executable} -m pip install -q sentence-transformers\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "from sentence_transformers import SentenceTransformer\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import classification_report, accuracy_score\n", + "\n", + "print('Environment ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(39942, 5) (4956, 5)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
labeltitletextsubjectdate
01As U.S. budget fight looms, Republicans flip t...WASHINGTON (Reuters) - The head of a conservat...politicsNewsDecember 31, 2017
11U.S. military to accept transgender recruits o...WASHINGTON (Reuters) - Transgender people will...politicsNewsDecember 29, 2017
\n", + "
" + ], + "text/plain": [ + " label title \\\n", + "0 1 As U.S. budget fight looms, Republicans flip t... \n", + "1 1 U.S. military to accept transgender recruits o... \n", + "\n", + " text subject \\\n", + "0 WASHINGTON (Reuters) - The head of a conservat... politicsNews \n", + "1 WASHINGTON (Reuters) - Transgender people will... politicsNews \n", + "\n", + " date \n", + "0 December 31, 2017 \n", + "1 December 29, 2017 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load data\n", + "train_df = pd.read_csv('dataset/data.csv')\n", + "val_df = pd.read_csv('dataset/validation_data.csv')\n", + "print(train_df.shape, val_df.shape)\n", + "train_df.head(2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Samples: 39942 Labels: (39942,)\n", + "As U.S. budget fight looms, Republicans flip their fiscal script WASHINGTON (Reuters) - The head of a conservative Republican faction in the U.S. Congress, who voted this month for a huge expansion of\n" + ] + } + ], + "source": [ + "# Build input texts (title + text)\n", + "train_texts = (train_df['title'].fillna('') + ' ' + train_df['text'].fillna('')).tolist()\n", + "val_texts = (val_df['title'].fillna('') + ' ' + val_df['text'].fillna('')).tolist()\n", + "y = train_df['label'].values\n", + "\n", + "print('Samples:', len(train_texts), 'Labels:', y.shape)\n", + "print(train_texts[0][:200])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Batches: 100%|██████████| 125/125 [04:39<00:00, 2.24s/it]\n", + "Batches: 100%|██████████| 32/32 [01:22<00:00, 2.59s/it]\n", + "Batches: 100%|██████████| 20/20 [00:55<00:00, 2.75s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "((31953, 384), (7989, 384), (4956, 384))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Encode embeddings\n", + "embedder = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')\n", + "\n", + "# Train/test split indices\n", + "idx = np.arange(len(train_texts))\n", + "train_idx, test_idx = train_test_split(idx, test_size=0.2, random_state=42, stratify=y)\n", + "\n", + "X_train = embedder.encode([train_texts[i] for i in train_idx], batch_size=256, convert_to_numpy=True, show_progress_bar=True)\n", + "X_test = embedder.encode([train_texts[i] for i in test_idx], batch_size=256, convert_to_numpy=True, show_progress_bar=True)\n", + "y_train = y[train_idx]\n", + "y_test = y[test_idx]\n", + "\n", + "X_val = embedder.encode(val_texts, batch_size=256, convert_to_numpy=True, show_progress_bar=True)\n", + "\n", + "X_train.shape, X_test.shape, X_val.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9480535736637877\n", + " precision recall f1-score support\n", + "\n", + " Fake 0.95 0.94 0.95 3989\n", + " Real 0.94 0.96 0.95 4000\n", + "\n", + " accuracy 0.95 7989\n", + " macro avg 0.95 0.95 0.95 7989\n", + "weighted avg 0.95 0.95 0.95 7989\n", + "\n" + ] + } + ], + "source": [ + "# Train classifier\n", + "clf = LogisticRegression(max_iter=2000)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "y_pred = clf.predict(X_test)\n", + "print('Accuracy:', accuracy_score(y_test, y_pred))\n", + "print(classification_report(y_test, y_pred, target_names=['Fake','Real']))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, accuracy_score, classification_report\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Confusion matrix\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "\n", + "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Fake', 'Real'])\n", + "disp.plot(cmap=plt.cm.Blues)\n", + "plt.title('Confusion Matrix')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogReg accuracy: 0.9481\n", + "RandomForest accuracy: 0.9270\n", + "LinearSVM accuracy: 0.9567\n", + "\n", + "Best embeddings model: LinearSVM (0.9567)\n" + ] + } + ], + "source": [ + "# Compare models on embeddings\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.svm import SVC\n", + "\n", + "rf = RandomForestClassifier(n_estimators=300, random_state=42, n_jobs=-1)\n", + "svm = SVC(kernel='linear', probability=True, random_state=42)\n", + "\n", + "models = {\n", + " 'LogReg': clf, # already fitted above\n", + " 'RandomForest': rf,\n", + " 'LinearSVM': svm\n", + "}\n", + "\n", + "results = {}\n", + "preds = {}\n", + "probas = {}\n", + "\n", + "for name, m in models.items():\n", + " if name != 'LogReg':\n", + " m.fit(X_train, y_train)\n", + " y_pred = m.predict(X_test)\n", + " results[name] = accuracy_score(y_test, y_pred)\n", + " preds[name] = y_pred\n", + " if hasattr(m, 'predict_proba'):\n", + " probas[name] = m.predict_proba(X_test)\n", + " else:\n", + " # SVC without probas (if probability=False), but here True\n", + " probas[name] = None\n", + " print(f\"{name} accuracy: {results[name]:.4f}\")\n", + "\n", + "best_name = max(results, key=results.get)\n", + "best_model = models[best_name]\n", + "print(f\"\\nBest embeddings model: {best_name} ({results[best_name]:.4f})\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved to embeddings_fake_news_predictions_linearsvm.csv\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlabelprobability_fakeprobability_real
0015.634485e-070.999999
1116.812508e-030.993187
2211.413487e-050.999986
3318.410532e-030.991589
4418.643167e-060.999991
\n", + "
" + ], + "text/plain": [ + " id label probability_fake probability_real\n", + "0 0 1 5.634485e-07 0.999999\n", + "1 1 1 6.812508e-03 0.993187\n", + "2 2 1 1.413487e-05 0.999986\n", + "3 3 1 8.410532e-03 0.991589\n", + "4 4 1 8.643167e-06 0.999991" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Predict on validation using best model and save\n", + "val_pred_best = best_model.predict(X_val)\n", + "val_proba_best = best_model.predict_proba(X_val) if hasattr(best_model, 'predict_proba') else None\n", + "\n", + "submission_best = pd.DataFrame({\n", + " 'id': range(len(val_df)),\n", + " 'label': val_pred_best\n", + "})\n", + "\n", + "if val_proba_best is not None:\n", + " submission_best['probability_fake'] = val_proba_best[:, 0]\n", + " submission_best['probability_real'] = val_proba_best[:, 1]\n", + "\n", + "out_path = f'embeddings_fake_news_predictions_{best_name.lower()}.csv'\n", + "submission_best.to_csv(out_path, index=False)\n", + "print(f'Saved to {out_path}')\n", + "submission_best.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved to embeddings_fake_news_predictions.csv\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlabelprobability_fakeprobability_real
0010.0100440.989956
1110.0351590.964841
2210.0147080.985292
3310.0324490.967551
4410.0091780.990822
\n", + "
" + ], + "text/plain": [ + " id label probability_fake probability_real\n", + "0 0 1 0.010044 0.989956\n", + "1 1 1 0.035159 0.964841\n", + "2 2 1 0.014708 0.985292\n", + "3 3 1 0.032449 0.967551\n", + "4 4 1 0.009178 0.990822" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Predict on validation and save\n", + "val_pred = clf.predict(X_val)\n", + "val_proba = clf.predict_proba(X_val)\n", + "\n", + "submission = pd.DataFrame({\n", + " 'id': range(len(val_df)),\n", + " 'label': val_pred,\n", + " 'probability_fake': val_proba[:, 0],\n", + " 'probability_real': val_proba[:, 1]\n", + "})\n", + "\n", + "submission.to_csv('embeddings_fake_news_predictions.csv', index=False)\n", + "print('Saved to embeddings_fake_news_predictions.csv')\n", + "submission.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved labeled validation to: dataset/validation_data_labeled_embeddings.csv\n" + ] + } + ], + "source": [ + "# Save validation with predicted labels into dataset\n", + "import os\n", + "\n", + "# Try to use in-memory validation data if present; otherwise read from disk\n", + "try:\n", + " original_val = validation_data.copy()\n", + "except NameError:\n", + " original_val = pd.read_csv('dataset/validation_data.csv')\n", + "\n", + "# Ensure lengths match\n", + "assert len(original_val) == len(submission), 'Length mismatch between validation and predictions'\n", + "\n", + "labeled_val = original_val.copy()\n", + "labeled_val['label'] = submission['label'].values\n", + "\n", + "out_path = os.path.join('dataset', 'validation_data_labeled_embeddings.csv')\n", + "labeled_val.to_csv(out_path, index=False)\n", + "print(f\"Saved labeled validation to: {out_path}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2.3 embeddings_advanced_classifier.ipynb b/2.3 embeddings_advanced_classifier.ipynb new file mode 100644 index 0000000..a7d4176 --- /dev/null +++ b/2.3 embeddings_advanced_classifier.ipynb @@ -0,0 +1,629 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Advanced Embeddings-based Classifier\n", + "\n", + "## Goals\n", + "- Stronger embeddings (`all-mpnet-base-v2`) + baseline (`all-MiniLM-L6-v2`)\n", + "- Tune LogReg / Linear SVM (C)\n", + "- Add simple MLP head over embeddings\n", + "- Baseline TF-IDF + LR and soft ensemble with embeddings\n", + "- Predict validation and save CSV\n", + "\n", + "Run top-to-bottom.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sergej/.pyenv/versions/3.11.8/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete\n" + ] + } + ], + "source": [ + "# Setup\n", + "import sys\n", + "!{sys.executable} -m pip install -q sentence-transformers scikit-learn\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sentence_transformers import SentenceTransformer\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import accuracy_score, classification_report\n", + "from sklearn.neural_network import MLPClassifier\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "\n", + "print('Setup complete')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(31953, 7989, 4956)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load data and build texts\n", + "train_df = pd.read_csv('dataset/data.csv')\n", + "val_df = pd.read_csv('dataset/validation_data.csv')\n", + "\n", + "train_texts = (train_df['title'].fillna('') + ' ' + train_df['text'].fillna('')).tolist()\n", + "val_texts = (val_df['title'].fillna('') + ' ' + val_df['text'].fillna('')).tolist()\n", + "y = train_df['label'].values\n", + "\n", + "idx = np.arange(len(train_texts))\n", + "train_idx, test_idx = train_test_split(idx, test_size=0.2, random_state=42, stratify=y)\n", + "\n", + "y_train, y_test = y[train_idx], y[test_idx]\n", + "texts_train = [train_texts[i] for i in train_idx]\n", + "texts_test = [train_texts[i] for i in test_idx]\n", + "\n", + "len(texts_train), len(texts_test), len(val_texts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Batches: 100%|██████████| 125/125 [04:25<00:00, 2.12s/it]\n", + "Batches: 100%|██████████| 32/32 [01:18<00:00, 2.44s/it]\n", + "Batches: 100%|██████████| 20/20 [00:47<00:00, 2.39s/it]\n", + "Batches: 100%|██████████| 500/500 [51:53<00:00, 6.23s/it] \n", + "Batches: 100%|██████████| 125/125 [14:08<00:00, 6.79s/it]\n", + "Batches: 100%|██████████| 78/78 [12:07<00:00, 9.33s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "((31953, 384), (31953, 768))" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Encode embeddings (MiniLM + MPNet)\n", + "mini = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')\n", + "mpnet = SentenceTransformer('sentence-transformers/all-mpnet-base-v2')\n", + "\n", + "X_train_mini = mini.encode(texts_train, batch_size=256, convert_to_numpy=True, show_progress_bar=True)\n", + "X_test_mini = mini.encode(texts_test, batch_size=256, convert_to_numpy=True, show_progress_bar=True)\n", + "X_val_mini = mini.encode(val_texts, batch_size=256, convert_to_numpy=True, show_progress_bar=True)\n", + "\n", + "X_train_mp = mpnet.encode(texts_train, batch_size=64, convert_to_numpy=True, show_progress_bar=True)\n", + "X_test_mp = mpnet.encode(texts_test, batch_size=64, convert_to_numpy=True, show_progress_bar=True)\n", + "X_val_mp = mpnet.encode(val_texts, batch_size=64, convert_to_numpy=True, show_progress_bar=True)\n", + "\n", + "X_train_mini.shape, X_train_mp.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MiniLM | LR acc=0.9569 (C=5), SVM acc=0.9597 (C=5)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n", + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MPNet | LR acc=0.9740 (C=5), SVM acc=0.9795 (C=5)\n" + ] + }, + { + "data": { + "text/plain": [ + "{'MiniLM_LR': (0.9569407935911879, LogisticRegression(C=5, max_iter=3000)),\n", + " 'MiniLM_SVM': (0.9596945800475654,\n", + " SVC(C=5, kernel='linear', probability=True)),\n", + " 'MPNet_LR': (0.973964200776067, LogisticRegression(C=5, max_iter=3000)),\n", + " 'MPNet_SVM': (0.9794717736888221,\n", + " SVC(C=5, kernel='linear', probability=True))}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Tune LogReg and Linear SVM on embeddings\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "results = {}\n", + "\n", + "def fit_and_eval(X_train, X_test, name):\n", + " # Logistic Regression\n", + " lr = GridSearchCV(LogisticRegression(max_iter=3000),\n", + " param_grid={'C':[0.1, 0.5, 1, 2, 5]},\n", + " cv=5, n_jobs=-1)\n", + " lr.fit(X_train, y_train)\n", + " pred_lr = lr.predict(X_test)\n", + " acc_lr = accuracy_score(y_test, pred_lr)\n", + "\n", + " # Linear SVM (probability=True для совместимости ансамбля)\n", + " svm = GridSearchCV(SVC(kernel='linear', probability=True),\n", + " param_grid={'C':[0.1, 0.5, 1, 2, 5]},\n", + " cv=5, n_jobs=-1)\n", + " svm.fit(X_train, y_train)\n", + " pred_svm = svm.predict(X_test)\n", + " acc_svm = accuracy_score(y_test, pred_svm)\n", + "\n", + " results[f'{name}_LR'] = (acc_lr, lr.best_estimator_)\n", + " results[f'{name}_SVM'] = (acc_svm, svm.best_estimator_)\n", + " print(f'{name} | LR acc={acc_lr:.4f} (C={lr.best_params_[\"C\"]}), SVM acc={acc_svm:.4f} (C={svm.best_params_[\"C\"]})')\n", + "\n", + "fit_and_eval(X_train_mini, X_test_mini, 'MiniLM')\n", + "fit_and_eval(X_train_mp, X_test_mp, 'MPNet')\n", + "\n", + "results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLP (MPNet) acc: 0.9833521091500813\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sergej/.pyenv/versions/3.11.8/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:781: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (30) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "{'MiniLM_LR': (0.9569407935911879, LogisticRegression(C=5, max_iter=3000)),\n", + " 'MiniLM_SVM': (0.9596945800475654,\n", + " SVC(C=5, kernel='linear', probability=True)),\n", + " 'MPNet_LR': (0.973964200776067, LogisticRegression(C=5, max_iter=3000)),\n", + " 'MPNet_SVM': (0.9794717736888221,\n", + " SVC(C=5, kernel='linear', probability=True)),\n", + " 'MPNet_MLP': (0.9833521091500813,\n", + " MLPClassifier(batch_size=256, hidden_layer_sizes=(256,), max_iter=30,\n", + " random_state=42))}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# MLP head over embeddings (MPNet)\n", + "mlp = MLPClassifier(hidden_layer_sizes=(256,), activation='relu', solver='adam',\n", + " alpha=1e-4, batch_size=256, max_iter=30, random_state=42)\n", + "mlp.fit(X_train_mp, y_train)\n", + "\n", + "pred_mlp = mlp.predict(X_test_mp)\n", + "acc_mlp = accuracy_score(y_test, pred_mlp)\n", + "print('MLP (MPNet) acc:', acc_mlp)\n", + "\n", + "results['MPNet_MLP'] = (acc_mlp, mlp)\n", + "results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TF-IDF+LR acc: 0.9888596820628364\n", + "Best embeddings model: TFIDF_LR acc=0.9889\n", + "Soft ensemble acc: 0.9888596820628364\n" + ] + }, + { + "data": { + "text/plain": [ + "{'MiniLM_LR': (0.9569407935911879, LogisticRegression(C=5, max_iter=3000)),\n", + " 'MiniLM_SVM': (0.9596945800475654,\n", + " SVC(C=5, kernel='linear', probability=True)),\n", + " 'MPNet_LR': (0.973964200776067, LogisticRegression(C=5, max_iter=3000)),\n", + " 'MPNet_SVM': (0.9794717736888221,\n", + " SVC(C=5, kernel='linear', probability=True)),\n", + " 'MPNet_MLP': (0.9833521091500813,\n", + " MLPClassifier(batch_size=256, hidden_layer_sizes=(256,), max_iter=30,\n", + " random_state=42)),\n", + " 'TFIDF_LR': (0.9888596820628364,\n", + " (TfidfVectorizer(max_df=0.8, max_features=5000, min_df=3, ngram_range=(1, 2)),\n", + " LogisticRegression(max_iter=3000))),\n", + " 'SOFT_ENSEMBLE': (0.9888596820628364, ('ensemble', 'TFIDF_LR'))}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# TF-IDF + LR baseline and soft ensemble with best embedding model\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# TF-IDF baseline (на train/test)\n", + "vectorizer = TfidfVectorizer(max_features=5000, ngram_range=(1,2), min_df=3, max_df=0.8)\n", + "X_train_tf = vectorizer.fit_transform(texts_train)\n", + "X_test_tf = vectorizer.transform(texts_test)\n", + "\n", + "lr_tf = LogisticRegression(max_iter=3000)\n", + "lr_tf.fit(X_train_tf, y_train)\n", + "\n", + "pred_tf = lr_tf.predict(X_test_tf)\n", + "acc_tf = accuracy_score(y_test, pred_tf)\n", + "print('TF-IDF+LR acc:', acc_tf)\n", + "\n", + "results['TFIDF_LR'] = (acc_tf, (vectorizer, lr_tf))\n", + "\n", + "# Выбор лучшей embeddings-модели\n", + "best_name = max(results, key=lambda k: results[k][0])\n", + "best_acc, best_est = results[best_name]\n", + "print(f'Best embeddings model: {best_name} acc={best_acc:.4f}')\n", + "\n", + "# Подготовим вероятности для soft-ensemble (если модель умеет probas)\n", + "def get_proba(est, X):\n", + " if isinstance(est, LogisticRegression) or isinstance(est, SVC):\n", + " return est.predict_proba(X)\n", + " if isinstance(est, MLPClassifier):\n", + " return est.predict_proba(X)\n", + " # (vectorizer, lr) пара\n", + " if isinstance(est, tuple) and isinstance(est[1], LogisticRegression):\n", + " vec, lrm = est\n", + " return lrm.predict_proba(vec.transform(texts_test))\n", + " return None\n", + "\n", + "'''\n", + "# Вероятности\n", + "# Для embeddings лучшую модель применим на соответствующем X_test\n", + "if 'MPNet' in best_name:\n", + " proba_emb = best_est.predict_proba(X_test_mp)\n", + "else:\n", + " proba_emb = best_est.predict_proba(X_test_mini)\n", + "'''\n", + "\n", + "if 'MPNet' in best_name:\n", + " proba_emb = get_proba(best_est, X_test_mp)\n", + "else:\n", + " proba_emb = get_proba(best_est, X_test_mini)\n", + "\n", + "\n", + "\n", + "proba_tf = lr_tf.predict_proba(X_test_tf)\n", + "\n", + "# Soft-average ансамбль\n", + "proba_ens = 0.5 * proba_emb + 0.5 * proba_tf\n", + "pred_ens = np.argmax(proba_ens, axis=1)\n", + "acc_ens = accuracy_score(y_test, pred_ens)\n", + "print('Soft ensemble acc:', acc_ens)\n", + "\n", + "results['SOFT_ENSEMBLE'] = (acc_ens, ('ensemble', best_name))\n", + "results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best overall: TFIDF_LR 0.9888596820628364\n", + "Saved to advanced_embeddings_predictions_TFIDF_LR.csv\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlabelprobability_fakeprobability_real
0000.8154720.184528
1100.7539690.246031
2210.4956470.504353
3300.5369330.463067
4400.7078620.292138
\n", + "
" + ], + "text/plain": [ + " id label probability_fake probability_real\n", + "0 0 0 0.815472 0.184528\n", + "1 1 0 0.753969 0.246031\n", + "2 2 1 0.495647 0.504353\n", + "3 3 0 0.536933 0.463067\n", + "4 4 0 0.707862 0.292138" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Pick best overall and predict validation\n", + "best_overall = max(results, key=lambda k: results[k][0])\n", + "best_overall_acc, best_overall_est = results[best_overall]\n", + "print('Best overall:', best_overall, best_overall_acc)\n", + "\n", + "# Build validation predictions\n", + "if best_overall.startswith('MiniLM_'):\n", + " proba_val = best_overall_est.predict_proba(X_val_mini)\n", + "elif best_overall.startswith('MPNet_'):\n", + " proba_val = best_overall_est.predict_proba(X_val_mp)\n", + "elif best_overall == 'MPNet_MLP':\n", + " proba_val = best_overall_est.predict_proba(X_val_mp)\n", + "elif best_overall == 'TFIDF_LR':\n", + " proba_val = best_overall_est[1].predict_proba(TfidfVectorizer(max_features=5000, ngram_range=(1,2), min_df=3, max_df=0.8).fit(train_texts).transform(val_texts))\n", + "elif best_overall == 'SOFT_ENSEMBLE':\n", + " # ensemble = 0.5 * best embedding + 0.5 * TF-IDF LR\n", + " if 'MPNet' in best_name:\n", + " proba_emb_val = best_est.predict_proba(X_val_mp)\n", + " else:\n", + " proba_emb_val = best_est.predict_proba(X_val_mini)\n", + " proba_tf_val = lr_tf.predict_proba(TfidfVectorizer(max_features=5000, ngram_range=(1,2), min_df=3, max_df=0.8).fit(train_texts).transform(val_texts))\n", + " proba_val = 0.5 * proba_emb_val + 0.5 * proba_tf_val\n", + "else:\n", + " raise ValueError('Unknown best model key')\n", + "\n", + "pred_val = np.argmax(proba_val, axis=1)\n", + "sub = pd.DataFrame({\n", + " 'id': range(len(val_df)),\n", + " 'label': pred_val,\n", + " 'probability_fake': proba_val[:,0],\n", + " 'probability_real': proba_val[:,1]\n", + "})\n", + "\n", + "out_path = f'advanced_embeddings_predictions_{best_overall}.csv'\n", + "sub.to_csv(out_path, index=False)\n", + "print('Saved to', out_path)\n", + "sub.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved labeled validation to: dataset/validation_data_labeled_embeddings_advanced.csv\n" + ] + } + ], + "source": [ + "# Save validation with predicted labels into dataset\n", + "import os\n", + "\n", + "# Try to use in-memory validation data if present; otherwise read from disk\n", + "try:\n", + " original_val = val_df.copy()\n", + "except NameError:\n", + " original_val = pd.read_csv('dataset/validation_data.csv')\n", + "\n", + "# Ensure lengths match\n", + "assert len(original_val) == len(sub), 'Length mismatch between validation and predictions'\n", + "\n", + "labeled_val = original_val.copy()\n", + "labeled_val['label'] = sub['label'].values\n", + "\n", + "out_path = os.path.join('dataset', 'validation_data_labeled_embeddings_advanced.csv')\n", + "labeled_val.to_csv(out_path, index=False)\n", + "print(f\"Saved labeled validation to: {out_path}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2.4 enhanced_classifier_minus_reuters.ipynb b/2.4 enhanced_classifier_minus_reuters.ipynb new file mode 100644 index 0000000..60126aa --- /dev/null +++ b/2.4 enhanced_classifier_minus_reuters.ipynb @@ -0,0 +1,732 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Enhanced Fake News Classifier\n", + "\n", + "## Overview\n", + "This notebook implements an enhanced fake news classifier with:\n", + "- Robust text preprocessing (cleaning, stopword removal, lemmatization)\n", + "- Advanced feature engineering (length, punctuation, lexical diversity, subject, dates)\n", + "- TF-IDF vectorization and numerical feature scaling\n", + "- Multiple models (Logistic Regression, Random Forest, Gradient Boosting, SVM)\n", + "- Soft-voting ensemble and cross-validation\n", + "- Predictions on validation set with confidence scores\n", + "\n", + "Run cells top-to-bottom.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package wordnet to /Users/sergej/nltk_data...\n", + "[nltk_data] Package wordnet is already up-to-date!\n" + ] + } + ], + "source": [ + "# Imports and setup\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Text processing\n", + "import re\n", + "from collections import Counter\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.stem import WordNetLemmatizer\n", + "\n", + "# ML\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, VotingClassifier\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import classification_report, accuracy_score\n", + "from sklearn.preprocessing import StandardScaler\n", + "from scipy.sparse import hstack\n", + "\n", + "# NLTK data\n", + "for pkg, path in [('punkt','tokenizers/punkt'),('stopwords','corpora/stopwords'),('wordnet','corpora/wordnet')]:\n", + " try:\n", + " nltk.data.find(path)\n", + " except LookupError:\n", + " nltk.download(pkg)\n", + "\n", + "print('Setup complete')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading data...\n", + "Training: (39942, 10), Validation: (4956, 10)\n" + ] + } + ], + "source": [ + "# Load data\n", + "print('Loading data...')\n", + "train_data = pd.read_csv('dataset/processed_training_data.csv')\n", + "validation_data = pd.read_csv('dataset/processed_validation_data.csv')\n", + "print(f'Training: {train_data.shape}, Validation: {validation_data.shape}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "train_data = train_data.drop('subject', axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preprocessing functions ready\n" + ] + } + ], + "source": [ + "# Preprocessing functions\n", + "def clean_text(text):\n", + " if pd.isna(text):\n", + " return ''\n", + " text = text.lower()\n", + " text = re.sub(r'[^a-zA-Z\\s]', '', text)\n", + " text = ' '.join(text.split())\n", + " return text\n", + "\n", + "def remove_stopwords(text):\n", + " if pd.isna(text):\n", + " return ''\n", + " \n", + " # remove reuters news\n", + " try:\n", + " text = re.sub(r'\\(\\s*reuters\\s*\\)', '', text, flags=re.IGNORECASE)\n", + " except Exception as e:\n", + " pass\n", + "\n", + "\n", + " try:\n", + " stop_words = set(stopwords.words('english'))\n", + " stop_words.add('reuters') \n", + " \n", + " text = re.sub(r'\\breuters\\b', '', text, flags=re.IGNORECASE)\n", + " words = word_tokenize(text)\n", + " return ' '.join([w for w in words if w.lower() not in stop_words])\n", + " except:\n", + " return text\n", + "\n", + "def lemmatize_text(text):\n", + " if pd.isna(text):\n", + " return ''\n", + " try:\n", + " lemmatizer = WordNetLemmatizer()\n", + " words = word_tokenize(text)\n", + " return ' '.join([lemmatizer.lemmatize(w) for w in words])\n", + " except:\n", + " return text\n", + "\n", + "def preprocess_text(text):\n", + " text = clean_text(text)\n", + " text = remove_stopwords(text)\n", + " text = lemmatize_text(text)\n", + " return text\n", + "\n", + "print('Preprocessing functions ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date parser ready\n" + ] + } + ], + "source": [ + "# Advanced date parsing\n", + "\n", + "def parse_dates_robust(date_series):\n", + " formats = ['%B %d, %Y', '%d-%b-%y', '%Y-%m-%d', '%m/%d/%Y', '%d/%m/%Y']\n", + " parsed_dates = pd.Series([pd.NaT] * len(date_series), index=date_series.index)\n", + " for fmt in formats:\n", + " try:\n", + " temp = pd.to_datetime(date_series, format=fmt, errors='coerce')\n", + " mask = parsed_dates.isna() & temp.notna()\n", + " parsed_dates[mask] = temp[mask]\n", + " except:\n", + " continue\n", + " return parsed_dates\n", + "\n", + "print('Date parser ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Engineering features...\n", + "Features ready\n" + ] + } + ], + "source": [ + "# Feature engineering\n", + "print('Engineering features...')\n", + "\n", + "# Process text\n", + "data = train_data.copy()\n", + "data['text_processed'] = data['text'].apply(preprocess_text)\n", + "data['title_processed'] = data['title'].apply(preprocess_text)\n", + "\n", + "# Basic lengths\n", + "data['text_length'] = data['text'].str.len()\n", + "data['title_length'] = data['title'].str.len()\n", + "data['word_count'] = data['text'].str.split().str.len()\n", + "data['title_word_count'] = data['title'].str.split().str.len()\n", + "\n", + "# Advanced text features\n", + "data['avg_word_length'] = data['text'].str.split().str.join(' ').str.len() / data['word_count']\n", + "data['title_avg_word_length'] = data['title'].str.split().str.join(' ').str.len() / data['title_word_count']\n", + "\n", + "# Punctuation features (escape regex)\n", + "data['exclamation_count'] = data['text'].str.count(r'!')\n", + "data['question_count'] = data['text'].str.count(r'\\?')\n", + "data['quote_count'] = data['text'].str.count(r'\"')\n", + "data['capital_ratio'] = data['text'].str.count(r'[A-Z]') / data['text_length']\n", + "\n", + "# Lexical diversity\n", + "data['unique_words_ratio'] = data['text_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "data['title_unique_words_ratio'] = data['title_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "\n", + "# Subject encoding\n", + "'''\n", + "from sklearn.preprocessing import LabelEncoder\n", + "le = LabelEncoder()\n", + "data['subject_encoded'] = le.fit_transform(data['subject'])\n", + "subject_mapping = dict(zip(le.classes_, le.transform(le.classes_)))\n", + "DEFAULT_SUBJECT = 0\n", + "\n", + "''' \n", + "\n", + "\n", + "# Date features\n", + "data['date_clean'] = data['date'].str.strip()\n", + "data['date_parsed'] = parse_dates_robust(data['date_clean'])\n", + "data['year'] = data['date_parsed'].dt.year\n", + "data['month'] = data['date_parsed'].dt.month\n", + "data['day_of_week'] = data['date_parsed'].dt.dayofweek\n", + "data['is_weekend'] = data['day_of_week'].isin([5, 6]).astype(int)\n", + "\n", + "numerical_features = [\n", + " 'text_length','title_length', # 'word_count','title_word_count',\n", + " 'avg_word_length','title_avg_word_length',\n", + " 'exclamation_count','question_count','quote_count','capital_ratio',\n", + " 'unique_words_ratio','title_unique_words_ratio', # 'subject_encoded',\n", + " 'day_of_week','is_weekend' #'year','month'\n", + "]\n", + "\n", + "print('Features ready')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vectorization and scaling complete\n" + ] + } + ], + "source": [ + "# Train/test split and vectorization\n", + "X_text = data['text_processed']\n", + "X_num = data[numerical_features].fillna(0)\n", + "y = data['label']\n", + "\n", + "X_train_text, X_test_text, X_train_num, X_test_num, y_train, y_test = train_test_split(\n", + " X_text, X_num, y, test_size=0.2, random_state=42, stratify=y\n", + ")\n", + "\n", + "# TF-IDF\n", + "tfidf_vectorizer = TfidfVectorizer(\n", + " max_features=8000,\n", + " ngram_range=(1,3),\n", + " min_df=3,\n", + " max_df=0.8,\n", + " sublinear_tf=True\n", + ")\n", + "X_train_tfidf = tfidf_vectorizer.fit_transform(X_train_text)\n", + "X_test_tfidf = tfidf_vectorizer.transform(X_test_text)\n", + "\n", + "# Scale numerical features\n", + "scaler = StandardScaler()\n", + "X_train_num_scaled = scaler.fit_transform(X_train_num)\n", + "X_test_num_scaled = scaler.transform(X_test_num)\n", + "\n", + "# Combine\n", + "from scipy.sparse import hstack\n", + "X_train_combined = hstack([X_train_tfidf, X_train_num_scaled])\n", + "X_test_combined = hstack([X_test_tfidf, X_test_num_scaled])\n", + "\n", + "print('Vectorization and scaling complete')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random Forest: 0.9875\n", + "\n", + "Best model: Random Forest (0.9875)\n" + ] + } + ], + "source": [ + "# Train models\n", + "lr_model = LogisticRegression(random_state=42, max_iter=2000, C=1.0)\n", + "rf_model = RandomForestClassifier(n_estimators=200, random_state=42, max_depth=20)\n", + "gb_model = GradientBoostingClassifier(n_estimators=100, random_state=42)\n", + "svm_model = SVC(random_state=42, probability=True, kernel='rbf')\n", + "ensemble_model = VotingClassifier(\n", + " estimators=[('lr', lr_model), ('rf', rf_model), ('gb', gb_model), ('svm', svm_model)],\n", + " voting='soft'\n", + ")\n", + "\n", + "models = {\n", + " # 'Logistic Regression': lr_model,\n", + " 'Random Forest': rf_model\n", + " # , 'Gradient Boosting': gb_model\n", + " # , 'SVM': svm_model \n", + " #, 'Ensemble': ensemble_model\n", + "}\n", + "\n", + "results = {}\n", + "for name, model in models.items():\n", + " model.fit(X_train_combined, y_train)\n", + " y_pred = model.predict(X_test_combined)\n", + " acc = accuracy_score(y_test, y_pred)\n", + " results[name] = acc\n", + " print(f\"{name}: {acc:.4f}\")\n", + "\n", + "best_model_name = max(results, key=results.get)\n", + "best_model = models[best_model_name]\n", + "print(f\"\\nBest model: {best_model_name} ({results[best_model_name]:.4f})\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CV scores: [0.98857769 0.98967298 0.9906118 0.99045383 0.9885759 ]\n", + "CV mean: 0.9895784393595356 +/- 0.0017549183989109174\n" + ] + } + ], + "source": [ + "# Cross-validation\n", + "cv_scores = cross_val_score(best_model, X_train_combined, y_train, cv=5)\n", + "print('CV scores:', cv_scores)\n", + "print('CV mean:', cv_scores.mean(), '+/-', cv_scores.std()*2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Evaluation of the best model (Random Forest):\n", + "Accuracy: 0.9874827888346477\n", + " precision recall f1-score support\n", + "\n", + " Fake 0.99 0.98 0.99 3989\n", + " Real 0.98 0.99 0.99 4000\n", + "\n", + " accuracy 0.99 7989\n", + " macro avg 0.99 0.99 0.99 7989\n", + "weighted avg 0.99 0.99 0.99 7989\n", + "\n" + ] + } + ], + "source": [ + "y_pred_best = best_model.predict(X_test_combined)\n", + "\n", + "print(f\"\\nEvaluation of the best model ({best_model_name}):\")\n", + "print('Accuracy:', accuracy_score(y_test, y_pred_best))\n", + "print(classification_report(y_test, y_pred_best, target_names=['Fake','Real']))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, accuracy_score, classification_report\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Confusion matrix\n", + "cm = confusion_matrix(y_test, y_pred_best)\n", + "\n", + "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Fake', 'Real'])\n", + "disp.plot(cmap=plt.cm.Blues)\n", + "plt.title(f'Confusion Matrix for {best_model_name}')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top text features:\n", + "video: 0.0099\n", + "president donald trump: 0.0115\n", + "president donald: 0.0130\n", + "like: 0.0140\n", + "washington: 0.0143\n", + "minister: 0.0149\n", + "image via: 0.0180\n", + "image: 0.0304\n", + "via: 0.0327\n", + "said: 0.0350\n", + "\n", + "Numerical features:\n", + "text_length: 0.0114\n", + "title_length: 0.0685\n", + "avg_word_length: 0.0183\n", + "title_avg_word_length: 0.0005\n", + "exclamation_count: 0.0185\n", + "question_count: 0.0278\n", + "quote_count: 0.0007\n", + "capital_ratio: 0.0035\n", + "unique_words_ratio: 0.0028\n", + "title_unique_words_ratio: 0.0028\n", + "day_of_week: 0.0343\n", + "is_weekend: 0.0003\n" + ] + } + ], + "source": [ + "# Feature importance (if available)\n", + "if hasattr(best_model, 'feature_importances_'):\n", + " importances = best_model.feature_importances_\n", + " text_size = X_train_tfidf.shape[1]\n", + " text_imps = importances[:text_size]\n", + " top_idx = np.argsort(text_imps)[-10:]\n", + " top_feats = [tfidf_vectorizer.get_feature_names_out()[i] for i in top_idx]\n", + " print('Top text features:')\n", + " for f, w in zip(top_feats, text_imps[top_idx]):\n", + " print(f'{f}: {w:.4f}')\n", + " num_imps = importances[text_size:]\n", + " print('\\nNumerical features:')\n", + " for f, w in zip(numerical_features, num_imps):\n", + " print(f'{f}: {w:.4f}')\n", + "else:\n", + " print('Model has no feature_importances_ attribute')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlabelprobability_fakeprobability_realconfidence
0010.1689780.8310220.831022
1110.3765230.6234770.623477
2210.1765690.8234310.823431
3310.1079700.8920300.892030
4410.1792640.8207360.820736
\n", + "
" + ], + "text/plain": [ + " id label probability_fake probability_real confidence\n", + "0 0 1 0.168978 0.831022 0.831022\n", + "1 1 1 0.376523 0.623477 0.623477\n", + "2 2 1 0.176569 0.823431 0.823431\n", + "3 3 1 0.107970 0.892030 0.892030\n", + "4 4 1 0.179264 0.820736 0.820736" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Predict on validation data\n", + "val = validation_data.copy()\n", + "val['text_processed'] = val['text'].apply(preprocess_text)\n", + "val['title_processed'] = val['title'].apply(preprocess_text)\n", + "val['text_length'] = val['text'].str.len()\n", + "val['title_length'] = val['title'].str.len()\n", + "val['word_count'] = val['text'].str.split().str.len()\n", + "val['title_word_count'] = val['title'].str.split().str.len()\n", + "val['avg_word_length'] = val['text'].str.split().str.join(' ').str.len() / val['word_count']\n", + "val['title_avg_word_length'] = val['title'].str.split().str.join(' ').str.len() / val['title_word_count']\n", + "val['exclamation_count'] = val['text'].str.count(r'!')\n", + "val['question_count'] = val['text'].str.count(r'\\?')\n", + "val['quote_count'] = val['text'].str.count(r'\"')\n", + "val['capital_ratio'] = val['text'].str.count(r'[A-Z]') / val['text_length']\n", + "val['unique_words_ratio'] = val['text_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "val['title_unique_words_ratio'] = val['title_processed'].str.split().apply(lambda x: len(set(x)) / len(x) if len(x) > 0 else 0)\n", + "\n", + "# Subject encoding with unseen handling\n", + "# val['subject_encoded'] = val['subject'].map(subject_mapping).fillna(DEFAULT_SUBJECT).astype(int)\n", + "\n", + "# Date features\n", + "val['date_clean'] = val['date'].str.strip()\n", + "val['date_parsed'] = parse_dates_robust(val['date_clean'])\n", + "#val['year'] = val['date_parsed'].dt.year\n", + "#val['month'] = val['date_parsed'].dt.month\n", + "val['day_of_week'] = val['date_parsed'].dt.dayofweek\n", + "val['is_weekend'] = val['day_of_week'].isin([5, 6]).astype(int)\n", + "\n", + "X_val_text = val['text_processed']\n", + "X_val_num = val[numerical_features].fillna(0)\n", + "X_val_num_scaled = scaler.transform(X_val_num)\n", + "X_val_tfidf = tfidf_vectorizer.transform(X_val_text)\n", + "X_val_combined = hstack([X_val_tfidf, X_val_num_scaled])\n", + "\n", + "val_pred = best_model.predict(X_val_combined)\n", + "val_proba = best_model.predict_proba(X_val_combined)\n", + "\n", + "submission = pd.DataFrame({\n", + " 'id': range(len(val)),\n", + " 'label': val_pred,\n", + " 'probability_fake': val_proba[:, 0],\n", + " 'probability_real': val_proba[:, 1],\n", + " 'confidence': np.max(val_proba, axis=1)\n", + "})\n", + "\n", + "submission.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved to enhanced_fake_news_predictions.csv\n", + "Distribution:\n", + "label\n", + "fake 0.64427\n", + "real 0.35573\n", + "Name: proportion, dtype: float64\n" + ] + } + ], + "source": [ + "# Save predictions\n", + "submission.to_csv('enhanced_fake_news_predictions.csv', index=False)\n", + "print(\"Saved to enhanced_fake_news_predictions.csv\")\n", + "print('Distribution:')\n", + "print(submission['label'].value_counts(normalize=True).rename({0:'fake',1:'real'}))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved labeled validation to: dataset/validation_data_labeled_minus_reuters.csv\n" + ] + } + ], + "source": [ + "# Save validation with predicted labels into dataset\n", + "import os\n", + "\n", + "# Try to use in-memory validation data if present; otherwise read from disk\n", + "try:\n", + " original_val = validation_data.copy()\n", + "except NameError:\n", + " original_val = pd.read_csv('dataset/validation_data.csv')\n", + "\n", + "# Ensure lengths match\n", + "assert len(original_val) == len(submission), 'Length mismatch between validation and predictions'\n", + "\n", + "labeled_val = original_val.copy()\n", + "labeled_val['label'] = submission['label'].values\n", + "\n", + "out_path = os.path.join('dataset', 'validation_data_labeled_minus_reuters.csv')\n", + "labeled_val.to_csv(out_path, index=False)\n", + "print(f\"Saved labeled validation to: {out_path}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2.5 Final_classifier_and_XGBoost.ipynb b/2.5 Final_classifier_and_XGBoost.ipynb new file mode 100644 index 0000000..d19b848 --- /dev/null +++ b/2.5 Final_classifier_and_XGBoost.ipynb @@ -0,0 +1,1311 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comprehensive Fake News Classifier with Validation\n", + "\n", + "This notebook contains a complete data analysis, training of various machine learning models for fake news classification, and validation on a separate dataset.\n", + "\n", + "## Work Plan:\n", + "1. Data loading and duplicate removal\n", + "2. NLP preprocessing with creation of additional features (including bracket difference)\n", + "3. Vectorization using TF-IDF\n", + "4. Train/test split\n", + "5. Model training and comparison (RandomForest, XGBoost)\n", + "6. Best model selection and saving\n", + "7. Training on full dataset\n", + "8. Feature importance analysis\n", + "9. Predictions on validation data and saving results\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Libraries successfully imported!\n" + ] + } + ], + "source": [ + "# Import necessary libraries\n", + "import pandas as pd\n", + "import numpy as np\n", + "import re\n", + "import string\n", + "from collections import Counter\n", + "import joblib\n", + "import pickle\n", + "\n", + "# NLP libraries\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.tokenize import word_tokenize\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "\n", + "# Machine learning models\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n", + "import xgboost as xgb\n", + "\n", + "# Additional libraries\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Download stopwords\n", + "try:\n", + " nltk.data.find('tokenizers/punkt')\n", + "except LookupError:\n", + " nltk.download('punkt')\n", + "\n", + "try:\n", + " nltk.data.find('corpora/stopwords')\n", + "except LookupError:\n", + " nltk.download('stopwords')\n", + "\n", + "print(\"Libraries successfully imported!\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Data Loading and Duplicate Removal\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading data...\n", + "Main dataset (data.csv): (39942, 5)\n", + "Columns: ['label', 'title', 'text', 'subject', 'date']\n", + "Validation dataset: (4956, 5)\n", + "Columns: ['label', 'title', 'text', 'subject', 'date']\n", + "\n", + "Duplicates in main dataset: 201\n", + "Main dataset size after removing duplicates: (39741, 5)\n", + "✅ train_data has all required columns!\n", + "✅ validation_data has all required columns!\n", + "\n", + "First 3 rows of main dataset:\n", + " label title \\\n", + "0 1 As U.S. budget fight looms, Republicans flip t... \n", + "1 1 U.S. military to accept transgender recruits o... \n", + "2 1 Senior U.S. Republican senator: 'Let Mr. Muell... \n", + "\n", + " text subject \\\n", + "0 WASHINGTON (Reuters) - The head of a conservat... politicsNews \n", + "1 WASHINGTON (Reuters) - Transgender people will... politicsNews \n", + "2 WASHINGTON (Reuters) - The special counsel inv... politicsNews \n", + "\n", + " date \n", + "0 December 31, 2017 \n", + "1 December 29, 2017 \n", + "2 December 31, 2017 \n", + "\n", + "First 3 rows of validation dataset:\n", + " label title \\\n", + "0 2 UK's May 'receiving regular updates' on London... \n", + "1 2 UK transport police leading investigation of L... \n", + "2 2 Pacific nations crack down on North Korean shi... \n", + "\n", + " text subject \\\n", + "0 LONDON (Reuters) - British Prime Minister Ther... worldnews \n", + "1 LONDON (Reuters) - British counter-terrorism p... worldnews \n", + "2 WELLINGTON (Reuters) - South Pacific island na... worldnews \n", + "\n", + " date \n", + "0 September 15, 2017 \n", + "1 September 15, 2017 \n", + "2 September 15, 2017 \n" + ] + } + ], + "source": [ + "# Load data\n", + "print(\"Loading data...\")\n", + "\n", + "# Load main dataset\n", + "train_data = pd.read_csv('dataset/data.csv')\n", + "print(f\"Main dataset (data.csv): {train_data.shape}\")\n", + "print(f\"Columns: {list(train_data.columns)}\")\n", + "\n", + "# Load validation data\n", + "validation_data = pd.read_csv('dataset/validation_data.csv')\n", + "print(f\"Validation dataset: {validation_data.shape}\")\n", + "print(f\"Columns: {list(validation_data.columns)}\")\n", + "\n", + "# Check for duplicates in main dataset\n", + "print(f\"\\nDuplicates in main dataset: {train_data.duplicated().sum()}\")\n", + "train_data = train_data.drop_duplicates()\n", + "print(f\"Main dataset size after removing duplicates: {train_data.shape}\")\n", + "\n", + "# Check for required columns\n", + "required_columns = ['title', 'text', 'label']\n", + "for dataset_name, dataset in [('train_data', train_data), ('validation_data', validation_data)]:\n", + " missing_columns = [col for col in required_columns if col not in dataset.columns]\n", + " if missing_columns:\n", + " print(f\"❌ {dataset_name} is missing columns: {missing_columns}\")\n", + " else:\n", + " print(f\"✅ {dataset_name} has all required columns!\")\n", + "\n", + "print(\"\\nFirst 3 rows of main dataset:\")\n", + "print(train_data.head(3))\n", + "print(\"\\nFirst 3 rows of validation dataset:\")\n", + "print(validation_data.head(3))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. NLP Preprocessing and Additional Feature Creation\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Text processing functions created!\n" + ] + } + ], + "source": [ + "# Text cleaning function\n", + "def clean_text(text):\n", + " \"\"\"Clean text from extra characters and convert to lowercase\"\"\"\n", + " if pd.isna(text):\n", + " return \"\"\n", + " \n", + " # Convert to string and lowercase\n", + " text = str(text).lower()\n", + " \n", + " # Remove extra spaces\n", + " text = re.sub(r'\\s+', ' ', text)\n", + " \n", + " # Remove extra characters but preserve punctuation for counting\n", + " text = text.strip()\n", + " \n", + " return text\n", + "\n", + "# Function to count special characters (including bracket difference)\n", + "def count_special_chars(text):\n", + " \"\"\"Count special characters in text\"\"\"\n", + " if pd.isna(text):\n", + " return 0, 0, 0, 0\n", + " \n", + " text = str(text)\n", + " \n", + " # Count opening brackets\n", + " open_brackets = text.count('(') + text.count('[') + text.count('{')\n", + " \n", + " # Count closing brackets\n", + " closed_brackets = text.count(')') + text.count(']') + text.count('}')\n", + " \n", + " # Count exclamation marks\n", + " exclamation_marks = text.count('!')\n", + " \n", + " # Count question marks\n", + " question_marks = text.count('?')\n", + " \n", + " return open_brackets, closed_brackets, exclamation_marks, question_marks\n", + "\n", + "# Function to count characters\n", + "def count_characters(text):\n", + " \"\"\"Count number of characters in text\"\"\"\n", + " if pd.isna(text):\n", + " return 0\n", + " return len(str(text))\n", + "\n", + "# Function for vectorization preparation\n", + "def preprocess_for_vectorization(text):\n", + " \"\"\"Prepare text for vectorization with stopword removal\"\"\"\n", + " if pd.isna(text) or text == \"\":\n", + " return \"\"\n", + " \n", + " # Tokenization\n", + " tokens = word_tokenize(str(text))\n", + " \n", + " # Get stopwords\n", + " stop_words = set(stopwords.words('english'))\n", + " \n", + " # Remove stopwords and short words\n", + " filtered_tokens = [word for word in tokens \n", + " if word.lower() not in stop_words \n", + " and len(word) > 2 \n", + " and word.isalpha()]\n", + " \n", + " return ' '.join(filtered_tokens)\n", + "\n", + "print(\"✅ Text processing functions created!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing main dataset (data.csv)...\n", + "Cleaning text data...\n", + "Creating additional features...\n", + "Preparing texts for vectorization...\n", + "✅ Main dataset prepared!\n", + "New columns: ['title_clean', 'text_clean', 'open_brackets', 'closed_brackets', 'exclamation_marks', 'question_marks', 'bracket_difference', 'text_char_count', 'title_char_count', 'title_processed', 'text_processed', 'combined_text']\n", + "\n", + "Statistics for new features:\n", + " open_brackets closed_brackets bracket_difference exclamation_marks \\\n", + "count 39741.000000 39741.000000 39741.00000 39741.000000 \n", + "mean 1.824086 1.821796 0.00229 0.412118 \n", + "std 7.067190 7.052449 0.36591 1.483599 \n", + "min 0.000000 0.000000 -16.00000 0.000000 \n", + "25% 1.000000 1.000000 0.00000 0.000000 \n", + "50% 1.000000 1.000000 0.00000 0.000000 \n", + "75% 2.000000 2.000000 0.00000 0.000000 \n", + "max 1110.000000 1108.000000 34.00000 133.000000 \n", + "\n", + " question_marks text_char_count title_char_count \n", + "count 39741.000000 39741.000000 39741.000000 \n", + "mean 0.643240 2382.079288 79.840970 \n", + "std 1.746128 1766.137489 24.841118 \n", + "min 0.000000 1.000000 8.000000 \n", + "25% 0.000000 1255.000000 63.000000 \n", + "50% 0.000000 2195.000000 73.000000 \n", + "75% 1.000000 3065.000000 90.000000 \n", + "max 94.000000 49705.000000 286.000000 \n" + ] + } + ], + "source": [ + "# Prepare main dataset\n", + "print(\"Preparing main dataset (data.csv)...\")\n", + "\n", + "# Clean text data\n", + "print(\"Cleaning text data...\")\n", + "train_data['title_clean'] = train_data['title'].apply(clean_text)\n", + "train_data['text_clean'] = train_data['text'].apply(clean_text)\n", + "\n", + "# Create additional features\n", + "print(\"Creating additional features...\")\n", + "\n", + "# Count special characters in text\n", + "special_chars = train_data['text'].apply(count_special_chars)\n", + "train_data['open_brackets'] = [x[0] for x in special_chars]\n", + "train_data['closed_brackets'] = [x[1] for x in special_chars]\n", + "train_data['exclamation_marks'] = [x[2] for x in special_chars]\n", + "train_data['question_marks'] = [x[3] for x in special_chars]\n", + "\n", + "# New feature: difference between opening and closing brackets\n", + "train_data['bracket_difference'] = train_data['open_brackets'] - train_data['closed_brackets']\n", + "\n", + "# Count characters\n", + "train_data['text_char_count'] = train_data['text'].apply(count_characters)\n", + "train_data['title_char_count'] = train_data['title'].apply(count_characters)\n", + "\n", + "# Prepare for vectorization\n", + "print(\"Preparing texts for vectorization...\")\n", + "train_data['title_processed'] = train_data['title_clean'].apply(preprocess_for_vectorization)\n", + "train_data['text_processed'] = train_data['text_clean'].apply(preprocess_for_vectorization)\n", + "\n", + "# Combine title and text for vectorization\n", + "train_data['combined_text'] = train_data['title_processed'] + ' ' + train_data['text_processed']\n", + "\n", + "print(\"✅ Main dataset prepared!\")\n", + "print(f\"New columns: {[col for col in train_data.columns if col not in ['title', 'text', 'label', 'subject', 'date']]}\")\n", + "\n", + "# Statistics for new features\n", + "print(\"\\nStatistics for new features:\")\n", + "feature_cols = ['open_brackets', 'closed_brackets', 'bracket_difference', 'exclamation_marks', 'question_marks', 'text_char_count', 'title_char_count']\n", + "print(train_data[feature_cols].describe())\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing validation dataset...\n", + "Cleaning text data...\n", + "Creating additional features...\n", + "Preparing texts for vectorization...\n", + "✅ Validation dataset prepared!\n", + "Validation dataset size: (4956, 17)\n", + "\n", + "Statistics for new features (validation):\n", + " open_brackets closed_brackets bracket_difference exclamation_marks \\\n", + "count 4956.000000 4956.000000 4956.000000 4956.000000 \n", + "mean 2.403753 2.410815 -0.007062 0.385997 \n", + "std 4.888734 4.891715 0.287216 1.239168 \n", + "min 0.000000 0.000000 -16.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 \n", + "50% 1.000000 1.000000 0.000000 0.000000 \n", + "75% 3.000000 3.000000 0.000000 0.000000 \n", + "max 88.000000 88.000000 1.000000 33.000000 \n", + "\n", + " question_marks text_char_count title_char_count \n", + "count 4956.000000 4956.000000 4956.000000 \n", + "mean 0.983253 3149.895278 82.826069 \n", + "std 2.146671 4131.961782 29.426493 \n", + "min 0.000000 1.000000 17.000000 \n", + "25% 0.000000 1130.250000 63.000000 \n", + "50% 0.000000 2053.500000 76.000000 \n", + "75% 1.000000 3530.000000 98.000000 \n", + "max 27.000000 51794.000000 286.000000 \n" + ] + } + ], + "source": [ + "# Prepare validation dataset\n", + "print(\"Preparing validation dataset...\")\n", + "\n", + "# Clean text data\n", + "print(\"Cleaning text data...\")\n", + "validation_data['title_clean'] = validation_data['title'].apply(clean_text)\n", + "validation_data['text_clean'] = validation_data['text'].apply(clean_text)\n", + "\n", + "# Create additional features\n", + "print(\"Creating additional features...\")\n", + "\n", + "# Count special characters in text\n", + "special_chars_val = validation_data['text'].apply(count_special_chars)\n", + "validation_data['open_brackets'] = [x[0] for x in special_chars_val]\n", + "validation_data['closed_brackets'] = [x[1] for x in special_chars_val]\n", + "validation_data['exclamation_marks'] = [x[2] for x in special_chars_val]\n", + "validation_data['question_marks'] = [x[3] for x in special_chars_val]\n", + "\n", + "# New feature: difference between opening and closing brackets\n", + "validation_data['bracket_difference'] = validation_data['open_brackets'] - validation_data['closed_brackets']\n", + "\n", + "# Count characters\n", + "validation_data['text_char_count'] = validation_data['text'].apply(count_characters)\n", + "validation_data['title_char_count'] = validation_data['title'].apply(count_characters)\n", + "\n", + "# Prepare for vectorization\n", + "print(\"Preparing texts for vectorization...\")\n", + "validation_data['title_processed'] = validation_data['title_clean'].apply(preprocess_for_vectorization)\n", + "validation_data['text_processed'] = validation_data['text_clean'].apply(preprocess_for_vectorization)\n", + "\n", + "# Combine title and text for vectorization\n", + "validation_data['combined_text'] = validation_data['title_processed'] + ' ' + validation_data['text_processed']\n", + "\n", + "print(\"✅ Validation dataset prepared!\")\n", + "print(f\"Validation dataset size: {validation_data.shape}\")\n", + "\n", + "# Statistics for new features in validation\n", + "print(\"\\nStatistics for new features (validation):\")\n", + "print(validation_data[feature_cols].describe())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. TF-IDF Vectorization\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Applying TF-IDF vectorization...\n", + "TF-IDF matrix size: (39741, 5000)\n", + "Number of features: 5000\n", + "✅ TF-IDF vectorization completed!\n" + ] + } + ], + "source": [ + "# TF-IDF vectorization\n", + "print(\"Applying TF-IDF vectorization...\")\n", + "\n", + "# Create TF-IDF vectorizer\n", + "tfidf_vectorizer = TfidfVectorizer(\n", + " max_features=5000, # Maximum number of features\n", + " ngram_range=(1, 2), # Unigrams and bigrams\n", + " min_df=2, # Minimum document frequency\n", + " max_df=0.95, # Maximum document frequency\n", + " stop_words='english'\n", + ")\n", + "\n", + "# Apply vectorization to combined text of main dataset\n", + "tfidf_matrix = tfidf_vectorizer.fit_transform(train_data['combined_text'])\n", + "\n", + "print(f\"TF-IDF matrix size: {tfidf_matrix.shape}\")\n", + "print(f\"Number of features: {len(tfidf_vectorizer.get_feature_names_out())}\")\n", + "\n", + "# Create DataFrame with TF-IDF features\n", + "tfidf_df = pd.DataFrame(\n", + " tfidf_matrix.toarray(),\n", + " columns=[f'tfidf_{i}' for i in range(tfidf_matrix.shape[1])]\n", + ")\n", + "\n", + "print(\"✅ TF-IDF vectorization completed!\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Data Preparation for Training\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing features for training...\n", + "Feature matrix size: (39741, 5007)\n", + "Target variable size: (39741,)\n", + "Class distribution: [19940 19801]\n", + "Training set size: (31792, 5007)\n", + "Test set size: (7949, 5007)\n", + "✅ Data prepared for training!\n" + ] + } + ], + "source": [ + "# Prepare features for training\n", + "print(\"Preparing features for training...\")\n", + "\n", + "# Select additional features (including new bracket_difference feature)\n", + "additional_features = ['open_brackets', 'closed_brackets', 'bracket_difference', 'exclamation_marks', 'question_marks', 'text_char_count', 'title_char_count']\n", + "\n", + "# Combine TF-IDF features with additional features\n", + "X_tfidf = tfidf_df.values\n", + "X_additional = train_data[additional_features].values\n", + "\n", + "# Combine all features\n", + "X_combined = np.hstack([X_tfidf, X_additional])\n", + "\n", + "# Target variable\n", + "y = train_data['label'].values\n", + "\n", + "print(f\"Feature matrix size: {X_combined.shape}\")\n", + "print(f\"Target variable size: {y.shape}\")\n", + "print(f\"Class distribution: {np.bincount(y)}\")\n", + "\n", + "# Train/test split\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X_combined, y, \n", + " test_size=0.2, \n", + " random_state=42, \n", + " stratify=y\n", + ")\n", + "\n", + "print(f\"Training set size: {X_train.shape}\")\n", + "print(f\"Test set size: {X_test.shape}\")\n", + "print(\"✅ Data prepared for training!\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Model Training and Comparison\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Models defined:\n", + "- RandomForest: RandomForestClassifier\n", + "- XGBoost: XGBClassifier\n" + ] + } + ], + "source": [ + "# Define models with different parameters (only Random Forest and XGBoost)\n", + "models = {\n", + " 'RandomForest': RandomForestClassifier(\n", + " n_estimators=200,\n", + " max_depth=15,\n", + " min_samples_split=5,\n", + " random_state=42,\n", + " n_jobs=-1\n", + " ),\n", + " 'XGBoost': xgb.XGBClassifier(\n", + " n_estimators=200,\n", + " max_depth=8,\n", + " learning_rate=0.05,\n", + " subsample=0.8,\n", + " random_state=42,\n", + " n_jobs=-1\n", + " )\n", + "}\n", + "\n", + "print(\"Models defined:\")\n", + "for name, model in models.items():\n", + " print(f\"- {name}: {type(model).__name__}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training and evaluating models...\n", + "==================================================\n", + "\n", + "Training model: RandomForest\n", + "Test accuracy: 0.9965\n", + "Cross-validation (mean ± std): 0.9961 ± 0.0007\n", + "\n", + "Training model: XGBoost\n", + "Test accuracy: 0.9984\n", + "Cross-validation (mean ± std): 0.9974 ± 0.0012\n", + "\n", + "==================================================\n", + "✅ Training of all models completed!\n" + ] + } + ], + "source": [ + "# Train and evaluate models\n", + "results = {}\n", + "\n", + "print(\"Training and evaluating models...\")\n", + "print(\"=\" * 50)\n", + "\n", + "for name, model in models.items():\n", + " print(f\"\\nTraining model: {name}\")\n", + " \n", + " # Train model\n", + " model.fit(X_train, y_train)\n", + " \n", + " # Predictions\n", + " y_pred = model.predict(X_test)\n", + " \n", + " # Calculate accuracy\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " \n", + " # Cross-validation\n", + " cv_scores = cross_val_score(model, X_train, y_train, cv=5, scoring='accuracy')\n", + " \n", + " # Save results\n", + " results[name] = {\n", + " 'model': model,\n", + " 'accuracy': accuracy,\n", + " 'cv_mean': cv_scores.mean(),\n", + " 'cv_std': cv_scores.std(),\n", + " 'predictions': y_pred\n", + " }\n", + " \n", + " print(f\"Test accuracy: {accuracy:.4f}\")\n", + " print(f\"Cross-validation (mean ± std): {cv_scores.mean():.4f} ± {cv_scores.std():.4f}\")\n", + "\n", + "print(\"\\n\" + \"=\" * 50)\n", + "print(\"✅ Training of all models completed!\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Confusion Matrices and Model Comparison\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model comparison results:\n", + "============================================================\n", + " Model Test_Accuracy CV_Mean CV_Std\n", + " XGBoost 0.9984 0.9974 0.0012\n", + "RandomForest 0.9965 0.9961 0.0007\n", + "\n", + "🏆 Best model: XGBoost\n", + "Accuracy: 0.9984\n", + "Model type: XGBClassifier\n", + "\n", + "Detailed report for XGBoost:\n", + "========================================\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 3988\n", + " 1 1.00 1.00 1.00 3961\n", + "\n", + " accuracy 1.00 7949\n", + " macro avg 1.00 1.00 1.00 7949\n", + "weighted avg 1.00 1.00 1.00 7949\n", + "\n" + ] + } + ], + "source": [ + "# Create comparison table of results\n", + "results_df = pd.DataFrame({\n", + " 'Model': list(results.keys()),\n", + " 'Test_Accuracy': [results[name]['accuracy'] for name in results.keys()],\n", + " 'CV_Mean': [results[name]['cv_mean'] for name in results.keys()],\n", + " 'CV_Std': [results[name]['cv_std'] for name in results.keys()]\n", + "})\n", + "\n", + "# Sort by test accuracy\n", + "results_df = results_df.sort_values('Test_Accuracy', ascending=False)\n", + "\n", + "print(\"Model comparison results:\")\n", + "print(\"=\" * 60)\n", + "print(results_df.to_string(index=False, float_format='%.4f'))\n", + "\n", + "# Select best model\n", + "best_model_name = results_df.iloc[0]['Model']\n", + "best_model = results[best_model_name]['model']\n", + "best_accuracy = results_df.iloc[0]['Test_Accuracy']\n", + "\n", + "print(f\"\\n🏆 Best model: {best_model_name}\")\n", + "print(f\"Accuracy: {best_accuracy:.4f}\")\n", + "print(f\"Model type: {type(best_model).__name__}\")\n", + "\n", + "# Detailed report for best model\n", + "print(f\"\\nDetailed report for {best_model_name}:\")\n", + "print(\"=\" * 40)\n", + "y_pred_best = results[best_model_name]['predictions']\n", + "print(classification_report(y_test, y_pred_best))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Confusion Matrix Details:\n", + "==================================================\n", + "\n", + "RandomForest:\n", + "True Negatives (Real News correctly classified): 3964\n", + "False Positives (Real News misclassified as Fake): 24\n", + "False Negatives (Fake News misclassified as Real): 4\n", + "True Positives (Fake News correctly classified): 3957\n", + "Precision: 0.9940\n", + "Recall: 0.9990\n", + "F1-Score: 0.9965\n", + "\n", + "XGBoost:\n", + "True Negatives (Real News correctly classified): 3983\n", + "False Positives (Real News misclassified as Fake): 5\n", + "False Negatives (Fake News misclassified as Real): 8\n", + "True Positives (Fake News correctly classified): 3953\n", + "Precision: 0.9987\n", + "Recall: 0.9980\n", + "F1-Score: 0.9984\n" + ] + } + ], + "source": [ + "# Create confusion matrices for both models\n", + "fig, axes = plt.subplots(1, 2, figsize=(15, 6))\n", + "\n", + "for i, (name, result) in enumerate(results.items()):\n", + " # Calculate confusion matrix\n", + " cm = confusion_matrix(y_test, result['predictions'])\n", + " \n", + " # Plot confusion matrix\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[i])\n", + " axes[i].set_title(f'Confusion Matrix - {name}\\nAccuracy: {result[\"accuracy\"]:.4f}')\n", + " axes[i].set_xlabel('Predicted')\n", + " axes[i].set_ylabel('Actual')\n", + " \n", + " # Add class labels\n", + " axes[i].set_xticklabels(['Real News', 'Fake News'])\n", + " axes[i].set_yticklabels(['Real News', 'Fake News'])\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print confusion matrix details\n", + "print(\"Confusion Matrix Details:\")\n", + "print(\"=\" * 50)\n", + "for name, result in results.items():\n", + " cm = confusion_matrix(y_test, result['predictions'])\n", + " print(f\"\\n{name}:\")\n", + " print(f\"True Negatives (Real News correctly classified): {cm[0,0]}\")\n", + " print(f\"False Positives (Real News misclassified as Fake): {cm[0,1]}\")\n", + " print(f\"False Negatives (Fake News misclassified as Real): {cm[1,0]}\")\n", + " print(f\"True Positives (Fake News correctly classified): {cm[1,1]}\")\n", + " \n", + " # Calculate additional metrics\n", + " precision = cm[1,1] / (cm[1,1] + cm[0,1]) if (cm[1,1] + cm[0,1]) > 0 else 0\n", + " recall = cm[1,1] / (cm[1,1] + cm[1,0]) if (cm[1,1] + cm[1,0]) > 0 else 0\n", + " f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", + " \n", + " print(f\"Precision: {precision:.4f}\")\n", + " print(f\"Recall: {recall:.4f}\")\n", + " print(f\"F1-Score: {f1:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Training on Full Dataset\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training best model (XGBoost) on full dataset...\n", + "Full feature matrix size: (39741, 5007)\n", + "Target variable size: (39741,)\n", + "Class distribution: [19940 19801]\n", + "Training model...\n", + "✅ Model trained on full dataset!\n" + ] + } + ], + "source": [ + "# Train best model on full dataset\n", + "print(f\"Training best model ({best_model_name}) on full dataset...\")\n", + "\n", + "# Prepare full dataset\n", + "X_full = X_combined\n", + "y_full = y\n", + "\n", + "print(f\"Full feature matrix size: {X_full.shape}\")\n", + "print(f\"Target variable size: {y_full.shape}\")\n", + "print(f\"Class distribution: {np.bincount(y_full)}\")\n", + "\n", + "# Create new model with same parameters\n", + "if best_model_name == 'XGBoost':\n", + " full_model = xgb.XGBClassifier(**best_model.get_params())\n", + "else:\n", + " full_model = RandomForestClassifier(**best_model.get_params())\n", + "\n", + "# Train model on full dataset\n", + "print(\"Training model...\")\n", + "full_model.fit(X_full, y_full)\n", + "\n", + "print(\"✅ Model trained on full dataset!\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Feature Importance Analysis\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature importance analysis...\n", + "Top-20 most important features:\n", + " feature importance\n", + "3757 tfidf_3757 0.458675\n", + "5000 open_brackets 0.008268\n", + "1576 tfidf_1576 0.005496\n", + "411 tfidf_411 0.005359\n", + "2419 tfidf_2419 0.005231\n", + "1952 tfidf_1952 0.004854\n", + "3761 tfidf_3761 0.004222\n", + "1830 tfidf_1830 0.004162\n", + "1886 tfidf_1886 0.004020\n", + "2292 tfidf_2292 0.003933\n", + "3959 tfidf_3959 0.003515\n", + "1623 tfidf_1623 0.003495\n", + "65 tfidf_65 0.003129\n", + "412 tfidf_412 0.003011\n", + "5006 title_char_count 0.002945\n", + "3477 tfidf_3477 0.002854\n", + "3487 tfidf_3487 0.002835\n", + "4995 tfidf_4995 0.002822\n", + "1729 tfidf_1729 0.002754\n", + "2949 tfidf_2949 0.002634\n", + "\n", + "Importance of additional features:\n", + " feature importance\n", + "5000 open_brackets 0.008268\n", + "5006 title_char_count 0.002945\n", + "5004 question_marks 0.001684\n", + "5003 exclamation_marks 0.001666\n", + "5005 text_char_count 0.001269\n", + "5001 closed_brackets 0.000415\n", + "5002 bracket_difference 0.000000\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAMWCAYAAAAgRDUeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuf1JREFUeJzs3QlcVHX7x/1LRBAXRBFEiyAiQRHTLEpMtCytrGxfTcvtxiwrK4sWxDaMtMV/q2X7ZouVFWZRYblk5pJWZFliG4pUIpYi6jyv6/c85zwzMCDDchD4vF+vc8/MOWfO+c3WHd+u33VauFwulwAAAAAAAAAO8nPyZAAAAAAAAIAilAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAECz9Nxzz0mLFi3k66+/buihAADQLBFKAQDQjOgf4NVZcnNz630sn3zyiYwZM0a6d+8ubdq0kZiYGBk3bpwUFBR43X/ZsmVywgknmH0jIiJk8uTJsnPnzirPMXjw4Gq93oyMDLN/dHR0pfvs3r27ynPpMXS/oqIie90VV1zhcYx27dqZ13n++efLW2+9Jfv37/dpzD/88EOVY6jsefp+1Yf//vvPvG4nvi+NmX4P9LNvrPicAQD1xb/ejgwAAA46L774osfjF154QT7++OMK63v06FHvY7n55pvl77//lgsuuECOPPJI+eWXX+SRRx6R999/X9auXesRpOjjIUOGmHE98MAD8vvvv8vMmTPlp59+koULF1Z6jttuu80EXZaVK1fK7Nmz5dZbb/V4jb1797bv9+nTR2644YYKxwoICKjR6wwMDJSnn37a3N+1a5ds3rxZ3nvvPRNMaQD17rvvSnBwsMdzDj30UMnMzKxwrG7duh3wfKeccoqMGjXKY11QUJDUV1gxffp0c19fC5omPmcAQH0hlAIAoBkZOXKkx+Mvv/zShFLl1ztBwyWtfPLz+/8Lt0899VQZNGiQCafuvvtue72GSB07djSVGlaAo1VN48ePl48++kiGDh1aaUDjrnXr1iaU0vWV/XF9yCGH1On74e/vX+F4+tpmzJghaWlp5jXMmzfPY3uHDh1qPAatPGuIz7Mu7d2711SR1TQIRN3Qz2DPnj0NPQwAQBPG9D0AAODh33//NZVCkZGRpsonLi7OVCW5XC6P/XRa2NVXXy0vv/yy2UcDn379+snnn39erfOkpKR4BFLWuk6dOkleXp69bseOHXZw5l5RpNVAOiXq9ddfl8bolltuMWHaG2+8IT/++KNj5/3jjz/MtMkuXbqYzzchIUGeeeYZj300iEhPTzefpwZkbdu2lYEDB8pnn31m75Ofny9hYWHmvlbRlJ8KqaGft+BPp7JpoOh+HH2efsceeughOeKII8y4vv/+e7NdpyxqVZl+L/Q7dswxx8iCBQs8jllWVmbGoBV3uk9oaKgJPPV7U91KoP/973/mefod0+/WP//8Y28fPXq0dO7c2ZynPP0M9fvvK30PzjjjDBO06mvSarbExER7itz8+fPNY+t3tWbNGq9TArXCcNiwYeYz0kq6O++8s8JvtSa/af1e6L5PPPFElZ/zunXrzFh0WqqOVSsc9fv1119/eZ3eunHjRrN/SEiI+W5deeWV5v0v76WXXpKkpCQzXVcDaf1ngwbQ7rRKUr+X+trbt28vw4cPl++++87nzwIA0HColAIAADb9I/Wss84y4cPYsWPNVLZFixbJTTfdZMKMBx980GP/xYsXmyof7e+kf8A+9thjptrpq6++kl69evl8fu0RpYsGAJb169ebyhn9w92dVtHo+Mr/sV5bGjy494VS+oexLnXt8ssvN39oa3iiFU6Wffv2VRiD/sFfnb5E2vuq/HP1D3b9fLZu3SrHH3+8HT5o2KB/2OtnreHfddddZ/bX+zrl8JJLLjGVXCUlJTJ37lwTfuhnq++7Pvfxxx+XiRMnyjnnnCPnnntuhamQvnj22WfN2CdMmGDGqiGUBgwDBgww1Wsa4mn4oCHk2WefbXpy6XmtwEOnO+pUTQ0ydPzavHz16tUVquW80fdCQxI9zoYNG8zr0mmWGhDpe6Wfk0511d+CBkmWLVu2yKeffirTpk2r0WvWgObSSy81gZiGrhoUnXnmmSYI0urAq666yuynr+3CCy80Y3MPcvV7or83/UyzsrLkww8/NGPR34uGUzX5Tevr0fdY3xP9HR511FFVfs763dVgTMMlDaT0M5szZ4651UpMff/c6es4/PDDzWvSz0e/Z+Hh4XLffffZ+2j4pZ9FcnKyeR36W1+xYoUZm1UVqVOONSzU76Q+V4MtHaeGkfrPBPfgEwBwEHMBAIBma9KkSVoqYT9+5513zOO7777bY7/zzz/f1aJFC9fGjRvtdbqfLl9//bW9bvPmza7WrVu7zjnnnBqN56677jLH/OSTT+x1b7zxhln3+eefV9j/ggsucEVERFT7+NaxPvvsM6/bo6Ki7NflvkybNu2Ax9Z9dN9t27bZ60aPHu1q27Ztpc9Zs2aNec71119vrxs0aJDXMeixDsTb83R59tlnzfaxY8e6unbt6ioqKvJ43sUXX+zq0KGD67///jOP9+7d6yotLfXY559//nF16dLFNWbMGHudvtbK3h99HbqUp69D32fLpk2bzDGCg4NdhYWFHvsOGTLElZiY6Nq9e7e9bv/+/a7k5GTXkUceaa876qijXMOHD3f5St8XPXe/fv1ce/bssddnZWWZ9e+++655vG/fPtehhx7quuiiizye/8ADD5jfxS+//FLlebx9D6zv2rJly+x1ixYtMuuCgoLMb8ny5JNPVvje6jF13TXXXOPx3uj7EBAQYH8Pff1N+/n5ub777juPfav6nK3vjLtXX321wm/W+n24f3+U/rMiNDTUfvzTTz+ZMeh6fd/d6etTJSUlrpCQENf48eM9tm/ZssV8j8uvBwAcvJi+BwAAbNnZ2dKyZUtT+eROp/7o36zlm4r379/fTC2yHHbYYTJixAhTiaFVHL7QaX9aIaGVFCeddJK9XpuDK62eKU+rh6ztdeW4444z1R/uS/nG4XXFqnzSSiR3WuVRfgxTp06t1jH1/S//XK0m0c9Pq4u0EkfvazWVtej24uJiU7mi9Dtg9XPSvkLakN6qVrP2qWvnnXeePU1M6Tm1Mka/D/r+WGPVaWE6Xm1yr5U+SquctDJH19WEVme1atXKfqxVQdoLTH8PSquTLrvsMjNt0P2z0mluWs2jlT810bNnT/Mbcv/uKf3+62+p/HqtSCpPK5osVgWcTr/Mycmp0W9ae7rpuKrLvYm+VaWnlVvK23clNTXV47FOv9PPVKvb1DvvvGO+czp9tPz0XqvqSr/T27dvN5V87t9jfZ36XrlPMwUAHNyYvgcAAGw6ZUn70uh0L3fWlep0uzvt4VOeTkPTqTTbtm0zU7A0XHCnwYP+8ehO+wbp1CCd8mddqa78H72lpaUVzqV/BNf1leV0ytLJJ5/sdZv+sV+d11NdOlVRlX+/dZpaZWM4EL1yn7fnFhYWmj/kdWqVLt7oPpbnn39eZs2aZT4b915KNQ1gDqT8cXVqm4Ymd9xxh1kqG69O7dMpXhrG6XdPv0M6pU2n3FV3KmH577GGhV27djX9riwaTOo0sbffftvc16l0q1atMlPtaso9eFLaY0lp7ydv6937XCkNbbSXkztrGqg1dl9/075+vvp70DD5tdde8/j+KA06D/SatV+U9dq0n9fPP/9sXldVwZgVPrqH1+7KX80SAHDwIpQCAAD1ZtmyZXLiiSd6rNu0aZNHv5fffvvN9InRP7y1qqP8H88aDqiCgoIKx9d1+gf3wfR6fPHtt9+a29jYWKlvWn2itHeR9uLxxgpxtMm0NqPW3k3ae0h7/mjwpn2ANDSoDq1qKd9IW1VWQVc+XLTGe+ONN5rKKG+s902bYOu43n33XdOjS4NN7ZWkgZH2maoLGpJoVaC+NxpK6a1Wk2klV01VFmZWtt7b+1nXfA159fXr70K/J9qvSgM9/ew0GLQ+w7p+bdZxta+U9rEqT6vcAACNA//EBgAAtqioKDPtR6couYdDWi1jbXfnbbqUXklOm4JrBZFOuSt/BTT3PyJ12o4GUloF9cknn9gBlDutfNE/MrVxtXsAoFVLa9eurVUo4Ctt+lzV6/GV/lGt4U11mnHXln4e+plqKHSgKqw333zTVODoFeDcG1WXb+hdvol1+QoYb9PNylfmVMaqANJpddWpGtOqPG22rYtWoGlQpc2yqxNK6ffYPWzU52vgefrpp3vsp2HUlClTzLZXXnnFXO3NqvRpCBrO6Hvs3iTfupKjFZT6+pv2prLPWaub9HerlVI63c5S02mUSq++qK9Lr76oIVdl+ygNS2taUQgAODjQUwoAANj0j3ANLR555BGP9Vp1on+YnnbaaR7rly9f7tE3RquetFpFgyatiNA/2PWPRvdF+0BZl6nX82lfIK2Q8jYVUGkFlT5PK1Pc+/looKPhwQUXXCBOqer1+GrGjBmmqueiiy6q9LXXJf08tG+T9pWyKrTc6XRL933LV6/o1c/083ZnXZFQpwV6Cw40+HA/7jfffCNLly6t1ng1cBg8eLA8+eSTXqvk3I+r4aY7rdbRKipvUz690emM7lMU9Spu2kOr/Pddexjp7+Daa681YZBWnTU099+qfl76WIO8IUOG1Og37U1ln7O374l66KGHavx6tDpPp+/plMzylVbWebRyTqfo3XvvvR6fm7fvBgDg4EalFAAAsGkTbK0Yue2220xPGq0M0uBEg6brrrvOrlBwr2LSPxC1ibJWRT322GNmvVZOHIg2jv7qq69kzJgxkpeXZxb3UEH/OLXcc889pqG0NmHWptS///676Xek4ZdOEzqYabihgZrVA0srhbRh9rp168x7XVl/p/qgQZg2gdZm0OPHjzdT0rQnkAaLWk1j9cs644wzTJWU9vnSaiCdoqhT4XR/qw+WNdVL182bN89U62i1kn4ndNHP9YEHHjDfj7Fjx5p+Q3qMhIQEu6n1gTz66KNywgknSGJiohmvVk9t3brVhGP6HdCQS+kYNMDS6XU6Bq2q02ov9ybgVdGqOw1xtOpOe0Xp91jPe9ZZZ1WoNtPv2xtvvGGaq+t705A0EP3www/NdEz9TLVp+QcffCC33nqr3TTe19+0N1V9zlqRlpWVZcIh7e+lx9bvS01pmKhjveuuu0wT9HPPPdf8s2XlypVmqq5OIdVASoND7Rt29NFHy8UXX2xe76+//mpe/4ABAyqEcACAg1RDX/4PAAA0nEmTJpnLtLvTy61ff/31rm7durlatWrlOvLII13333+/fTl2iz5Pn//SSy+ZfQIDA119+/b1uGx9VaKioswxvC26rbwvvvjClZyc7GrdurUrLCzMnHvHjh0+vd433njDHL+yMep5hw8f7qoJ65L327Zts9eNHj3a43W1adPGFR0d7TrvvPNcb775ZoVL3qtBgwa5EhISajQG6zOpytatW80+kZGR5vONiIhwDRkyxDVnzhx7H/2s7733XvN+WJ/r+++/b15P+c9m2bJlrn79+rkCAgLM+fV9sOh3IyYmxmzr06ePa9GiRRWOsWnTJvM8/Y558/PPP7tGjRplxqnjPeSQQ1xnnHGGef8sd999tyspKckVEhLiCgoKcsXHx7vuuece1549e6p8L5599llz7sWLF7smTJjg6tixo6tdu3auyy67zPXXX395fc7rr79unqP7V5e+5rZt21bru+btM/T2HlnH1Pdn6NCh5rvVpUsX8/6X/175+pv2prLP+ffff3edc8455r3v0KGD64ILLnD9+eefFb4L3n4f7p+BvkZ3zzzzjPne6fdPPxf9XXz88cce++jveNiwYea8+s+FI444wnXFFVe4vv76a6+vAQBw8Gmh/9PQwRgAAGh8dOrPpEmTqEhAs6IVRlrF9/nnn5tKnoaijei1Gsy9cg0AgMaGnlIAAABANT311FNmGqFO7wMAALVDTykAAADgAF577TXTB0x7Fj388MNVXnkQAABUD6EUAAAAcAB65T1twK9N26+66qqGHg4AAE0CPaUAAAAAAADgOHpKAQAAAAAAwHGEUgAAAAAAAHAcPaXgiP3798uff/4p7du3pzEoAAAAAABNmHaKKikpkW7duomfX+X1UIRScIQGUpGRkQ09DAAAAAAA4JDffvtNDj300Eq3E0rBEVohZX0hg4ODG3o4AAAAAACgnuzYscMUplhZQGUIpeAIa8qeBlKEUgAAAAAANH0Hat9Do3MAAAAAAAA4jlAKAAAAAAAAjiOUAgAAAAAAgOMIpQAAAAAAAOA4QikAAAAAAAA4jlAKAAAAAAAAjiOUAgAAAAAAgOMIpQAAAAAAAOA4QikAAAAAAAA4jlAKAAAAAAAAjiOUAgAAAAAAgOMIpQAAAAAAAOA4f+dPieas17RF4hfYpqGHAQAAAADAQSt/xnBpDqiUqmctWrSocsnIyJD8/Hyv20aOHFnpcXNzc80+27dv93isi5+fn3To0EH69u0rU6dOlYKCAo/n6jm9nS8nJ6fS8/36668yfPhwadOmjYSHh8tNN90ke/furcN3CgAAAAAANCdUStUz90Bo3rx5kp6eLhs2bLDXtWvXToqKisx9DYUSEhLsbUFBQT6fT48dHBwsO3bskNWrV0tWVpbMnTvXhFaJiYn2fnqe8iFUp06dvB5z3759JpCKiIiQZcuWmdc0atQoadWqldx7770+jxEAAAAAAIBQqp5pkGPR6iWtSHJfp6xQKjQ0tMI2X2kVU0hIiDlO9+7dZcSIEaZiauLEibJkyRJ7P39//2qf66OPPpLvv//ehFhdunSRPn36yF133SU333yzqboKCAio1ZgBAAAAAEDzw/S9Jk6rrVJTU2Xp0qVSWFhYo2MsX77cVFlpIGUZNmyYqcb67rvvvD6ntLTUbHdfAAAAAAAALIRSB5Hk5GQznc9a1qxZUyfHjY+PN7fau8qyfv16j3MlJSVV+vwtW7Z4BFLKeqzbvMnMzDSVYdYSGRlZJ68FAAAAAAA0DUzfO4hoz6kePXrYj60gR/s/bd682dwfOHCgLFy40Kfjulwuc6tTBy1xcXGyYMEC+3FgYKDUpbS0NJkyZYr9WCulCKYAAAAAAICFUOogoqFNbGxshfXZ2dlSVlZW4+bneXl55jY6Otpep32gvJ3LG+099dVXX3ms27p1q73NGw256jroAgAAAAAATQfT9xqBqKgoEyDpcsghh/j03F27dsmcOXMkJSVFwsLCanT+/v37m+l+7j2pPv74Y3OVv549e9bomAAAAAAAoHmjUqqJ0eBo9+7dUlJSIqtWrZKsrCxzdb/58+fX+JhDhw414dPll19ujqd9pG6//XaZNGkS1VAAAAAAAKBGCKWaGO0Vpb2jtHl5TEyMCZS0t1Nl0+yqo2XLlvL+++/LxIkTTdVU27ZtZfTo0XLnnXfW6dgBAAAAAEDz0cJldcEG6pE2Oter8BUXF5tpfwAAAAAAoHlnAPSUAgAAAAAAgOMIpQAAAAAAAOA4ekrBUb2mLRK/wDbV2jd/xvB6Hw8AAAAAAGgYVErVM206XtWSkZEh+fn5XreNHDmy0uPm5uaafbZv3+7xWBc/Pz8zd7Nv374ydepUKSgo8HiuntPb+XJycio93+TJk6Vfv37mant9+vSpw3cIAAAAAAA0R1RK1TP3QGjevHmSnp4uGzZssNfpVfKKiorMfQ2FEhIS7G1BQUE+n0+PrU3EtKnY6tWrJSsrS+bOnWtCq8TERHs/PU/5EKpTp05VHnvMmDGyYsUKWbdunc/jAgAAAAAAcEcoVc8iIiLs+1q9pBVJ7uuUFUqFhoZW2Oar8PBwCQkJMcfp3r27jBgxwlRMTZw4UZYsWWLv5+/v79O5Zs+ebW63bdtGKAUAAAAAAGqN6XtNnFZbpaamytKlS6WwsLChhwMAAAAAAGAQSh1EkpOTzXQ+a1mzZk2dHDc+Pt7cau8qy/r16z3OlZSUJHWptLTUTCF0XwAAAAAAACxM3zuIaM+pHj162I8jIyPt/k+bN2829wcOHCgLFy706bgul8vc6tRBS1xcnCxYsMB+rA3M61JmZqZMnz69To8JAAAAAACaDkKpg4iGULGxsRXWZ2dnS1lZWY2bn+fl5Znb6Ohoe11AQIDXc9WVtLQ0mTJliv1YK6WskA0AAAAAAIBQqhGIioqq8XN37dolc+bMkZSUFAkLCxOnaOVVXVdfAQAAAACApoNQqonRZua7d++WkpISWbVqlWRlZZmr+82fP79Wx924caPs3LlTtmzZYoKutWvXmvU9e/Y0VVcAAAAAAAC+IJRqYrRXlPaO0ublMTExMnToUDONLiIiolbHHTdunCxevNh+3LdvX3O7adMmj2mBAAAAAAAA1dHCZXXBBuqR9pTq0KGDFBcXS3BwcEMPBwAAAAAANHAG4FdfAwAAAAAAAAAqQygFAAAAAAAAx9FTCo7qNW2R+AW2OeB++TOGOzIeAAAAAADQMKiUqmfadLyqJSMjQ/Lz871uGzlyZKXHzc3NNfts377d47Eufn5+Zu6mNiOfOnWqFBQUeDxXz+ntfDk5OV7P9c0338gll1wikZGREhQUJD169JCHH364jt8pAAAAAADQnFApVc/cA6F58+ZJenq6bNiwwV6nV8krKioy9zUUSkhIsLdpAOQrPbY2EdOmYqtXr5asrCyZO3euCa0SExPt/fQ85UOoTp06eT3mqlWrJDw8XF566SUTTC1btkwmTJggLVu2lKuvvtrnMQIAAAAAABBK1bOIiAj7vlYvaUWS+zplhVKhoaEVtvlKw6OQkBBznO7du8uIESNMxdTEiRNlyZIl9n7+/v7VPteYMWM8HsfExMjy5ctl/vz5hFIAAAAAAKBGmL7XxGm1VWpqqixdulQKCwvr7Lh6WcfKKqsAAAAAAAAOhFDqIJKcnGym81nLmjVr6uS48fHx5lZ7V1nWr1/vca6kpKRqH0+n7+lURJ3CV5nS0lIzhdB9AQAAAAAAsDB97yCiQY82Ebdo/yar/9PmzZvN/YEDB8rChQt9Oq7L5TK3OnXQEhcXJwsWLLAfBwYGVutY3377rZkSOG3aNBk6dGil+2VmZsr06dN9GicAAAAAAGg+CKUOIhpCxcbGVlifnZ0tZWVlNW5+npeXZ26jo6PtdQEBAV7PVZXvv/9ehgwZYiqkbr/99ir3TUtLkylTptiPtVLKCtkAAAAAAAAIpRqBqKioGj93165dMmfOHElJSZGwsLAaH+e7776Tk046SUaPHi333HPPAffXyqvqVl8BAAAAAIDmh1CqidFm5rt375aSkhJZtWqVZGVlmav76ZXyakqn7GkgNWzYMFP9tGXLFrO+ZcuWtQq6AAAAAABA80Uo1cRoryjtHaXNy2NiYkzfJw2SIiIianzMN998U7Zt2yYvvfSSWdwruNybpwMAAAAAAFRXC5fVBRuoR9pTqkOHDhJ53eviF9jmgPvnzxjuyLgAAAAAAED9ZADFxcUSHBxc6X5USsFR304fVuUXEgAAAAAANA9+DT0AAAAAAAAAND9USsFRvaYtYvoeAAAAAACgUgoAAAAAAADOI5SqZ3olvKqWjIwMcwU7b9tGjhxZ6XFzc3PNPtu3b/d4rIufn59pKNa3b1+ZOnWqFBQUeDxXz+ntfDk5OV7P9ddff8mpp54q3bp1k8DAQImMjJSrr77aNC4DAAAAAACoCabv1TP3QGjevHmSnp4uGzZssNe1a9dOioqKzH0NhRISEuxtQUFBPp9Pj62NxDUwWr16tWRlZcncuXNNaJWYmGjvp+cpH0J16tTJ6zE15BoxYoTcfffdEhYWJhs3bpRJkybJ33//La+88orPYwQAAAAAACCUqmcRERH2fa1e0ook93XKCqVCQ0MrbPNVeHi4hISEmON0797dhElaMTVx4kRZsmSJvZ+/v3+1z9WxY0fzfEtUVJRcddVVcv/999dqrAAAAAAAoPli+l4Tp9VWqampsnTpUiksLKyTY/75558yf/58GTRoUKX7lJaWmmot9wUAAAAAAMBCKHUQSU5ONtP5rGXNmjV1ctz4+Hhzq72rLOvXr/c4V1JS0gGPc8kll0ibNm3kkEMOMVMEn3766Ur3zczMNJVh1qJ9qAAAAAAAACyEUgcR7Tm1du1ae+nZs6fd/8kKj0477TSfj+tyucytTh20xMXFeZzrrbfeOuBxHnzwQdOn6t1335Wff/5ZpkyZUum+aWlpUlxcbC+//fabz+MGAAAAAABNFz2lDiJaTRQbG1thfXZ2tpSVldW4+XleXp65jY6OttcFBAR4PVdVtAeVLlp5pU3RBw4cKHfccYd07dq1wr56lT5dAAAAAAAAvCGUagS0sXhN7dq1S+bMmSMpKSnmynl1Zf/+/XbvKAAAAAAAAF8RSjUx2sx89+7dUlJSIqtWrZKsrCxzdT9tTF5TWqm1detWOfbYY80Uwu+++05uuukmGTBggEf1FQAAAAAAQHURSjUx2itKe0dpeBQTEyNDhw41vZ902l1N6ZTBp556Sq6//npTGaXTDM8991y55ZZb6nTsAAAAAACg+WjhsrpgA/Vox44d5ip82vRcr9wHAAAAAACadwbA1fcAAAAAAADgOEIpAAAAAAAAOI6eUnBUr2mLxC+wTZX75M8Y7th4AAAAAABAw6BSqp5p0/GqloyMDMnPz/e6beTIkZUeNzc31+yzfft2j8e6+Pn5mbmbffv2lalTp0pBQYHHc/Wc3s6Xk5NzwNfz119/yaGHHupxbgAAAAAAAF9RKVXP3AOhefPmSXp6umzYsMFep1fJKyoqMvc1FEpISPC46p2v9NjaREybiq1evVqysrJk7ty5JrRKTEy099PzlA+hOnXqdMDjjx07Vnr37i1//PGHz2MDAAAAAACwEErVs4iICPu+Vi9phZH7OmWFUqGhoRW2+So8PFxCQkLMcbp37y4jRowwFVMTJ06UJUuW2Pv5+/v7fK7HH3/cVEdpsLZw4cJajRMAAAAAADRvTN9r4rTaKjU1VZYuXSqFhYU1Ps73338vd955p7zwwgtmeiAAAAAAAEBtkC4cRJKTk810PmtZs2ZNnRw3Pj7e3GrvKsv69es9zpWUlFTp80tLS+WSSy6R+++/Xw477LBqnVOfo1MI3RcAAAAAAAAL0/cOItpzqkePHvbjyMhIu//T5s2bzf2BAwf6PHXO5XKZW506aImLi5MFCxbYjwMDAyt9flpamhlXVY3Xy8vMzJTp06f7NE4AAAAAANB8EEodRDSEio2NrbA+OztbysrKatz8PC8vz9xGR0fb6wICAryey5tPP/3UVFa9+eabHiFX586d5bbbbvMaPmmQNWXKFPuxVkpZIRsAAAAAAAChVCMQFRVV4+fu2rVL5syZIykpKRIWFlajY7z11lvmOJaVK1fKmDFj5IsvvpAjjjjC63O08qqq6isAAAAAANC8EUo1MdrMfPfu3VJSUiKrVq2SrKwsc3W/+fPn1/iY5YMn62qBOqVPr/QHAAAAAADgK0KpJkZ7RWnvKG1eHhMTI0OHDjXT6CIiIhp6aAAAAAAAALYWLqtBEFCPtKdUhw4dpLi4WIKDgxt6OAAAAAAAoIEzAL/6GgAAAAAAAABQGUIpAAAAAAAAOI6eUnBUr2mLxC+wTaXb82cMd3Q8AAAAAACgYVApVc+06XhVS0ZGhuTn53vdNnLkyEqPm5uba/bZvn27x2Nd/Pz8zNzNvn37ytSpU6WgoMDjuXpOb+fLycnx6XW89tprdfhOAQAAAACA5oRKqXrmHgjNmzdP0tPTZcOGDfY6vUpeUVGRua+hUEJCgr0tKCjI5/PpsbWJmDYVW716tWRlZcncuXNNaJWYmGjvp+cpH0J16tSpymM/++yzcuqpp9qPQ0JCfB4fAAAAAACAIpSqZxEREfZ9rV7SCiP3dcoKpUJDQyts81V4eLgJi/Q43bt3lxEjRpiKqYkTJ8qSJUvs/fz9/X0+l3VcAAAAAACA2mL6XhOn1VapqamydOlSKSwsrNWxJk2aJJ07d5akpCR55plnxOVy1dk4AQAAAABA80Kl1EEkOTnZ9IOyfPHFF6bKqbbi4+PNrfau0koqtX79ejN10NKzZ0/56quvKj3GnXfeKSeddJK0adNGPvroI7nqqqtk586dMnnyZK/7l5aWmsWi0wkBAAAAAAAshFIHEe051aNHD/txZGSk3f9p8+bN5v7AgQNl4cKFPh3XqmjSqYOWuLg4WbBggf04MDCwymPccccd9n0Nyv7991+5//77Kw2lMjMzZfr06T6NEwAAAAAANB+EUgcRDaFiY2MrrM/OzpaysrIaNz/Py8szt9HR0fa6gIAAr+eqruOOO07uuusuUw3lLdBKS0uTKVOmeFRKWSEbAAAAAAAAoVQjEBUVVePn7tq1S+bMmSMpKSkSFhZWZ2Nau3atdOzYsdIKK11/oOorAAAAAADQfBFKNTHazHz37t1SUlIiq1atkqysLHN1v/nz59f4mO+9955s3bpVjj/+eGndurV8/PHHcu+998qNN95Yp2MHAAAAAADNB6FUE6O9orR3lDYxj4mJkaFDh5ppdBERETU+ZqtWreTRRx+V66+/3vSn0ml/DzzwgIwfP75Oxw4AAAAAAJqPFi6rCzZQj7SnVIcOHSTyutfFL7BNpfvlzxju6LgAAAAAAED9ZADFxcUSHBxc6X5USsFR304fVuUXEgAAAAAANA9+DT0AAAAAAAAAND9USsFRvaYtYvoeAAAAAACgUgoAAAAAAADOI5SqZ3olvKqWjIwMyc/P97pt5MiRlR43NzfX7LN9+3aPx7r4+fmZhmJ9+/aVqVOnSkFBgcdz9ZzezpeTk1Pla3nuueekd+/e0rp1awkPD5dJkybV0bsEAAAAAACaG6bv1TP3QGjevHmSnp4uGzZssNe1a9dOioqKzH0NhRISEuxtQUFBPp9Pj62NxLXT/erVqyUrK0vmzp1rQqvExER7Pz1P+RCqU6dOlR73gQcekFmzZsn9998vxx13nPz7778mTAMAAAAAAKgJQql6FhERYd/X6iWtSHJfp6xQKjQ0tMI2X2kFU0hIiDlO9+7dZcSIEaZiauLEibJkyRJ7P39//2qf659//pHbb79d3nvvPRkyZIi9XqumAAAAAAAAaoLpe02cVlulpqbK0qVLpbCwsEbH+Pjjj2X//v3yxx9/SI8ePeTQQw+VCy+8UH777bdKn1NaWmqqtdwXAAAAAAAAC6HUQSQ5OdlM57OWNWvW1Mlx4+Pjza37dLv169d7nCspKanS5//yyy8mlLr33nvloYcekjfffFP+/vtvOeWUU2TPnj1en5OZmWkqw6wlMjKyTl4LAAAAAABoGpi+dxDRnlNaiWSxghzt/7R582Zzf+DAgbJw4UKfjutyucytTh20xMXFyYIFC+zHgYGBlT5fA6mysjKZPXu2DB061Kx79dVXzfS/zz77TIYNG1bhOWlpaTJlyhT7sVZKEUwBAAAAAAALodRBREOb2NjYCuuzs7NNKFTT5ud5eXnmNjo62l4XEBDg9VzedO3a1dz27NnTXhcWFiadO3eWX3/91etzNOSqKugCAAAAAADNG6FUIxAVFVXj5+7atUvmzJkjKSkpJkiqiQEDBthX9tN+Ukqn72mD9tqMDQAAAAAANF+EUk2MNjPfvXu3lJSUyKpVqyQrK8uER/Pnz6/xMa2r+F177bUm4AoODjbT87RX1Yknnlin4wcAAAAAAM0DoVQTo72itHeUNi+PiYkxPaC0t5P2f6qNF154Qa6//noZPny4+Pn5yaBBg+TDDz+UVq1a1dnYAQAAAABA89HCZXXBBuqRNjrXq/AVFxebSisAAAAAANC8MwA/R0cFAAAAAAAAEEoBAAAAAACgIdBTCo7qNW2R+AW2qXR7/ozhjo4HAAAAAAA0DCql6pk2Ha9qycjIkPz8fK/bRo4cWelxc3NzzT7bt2/3eKyLNiLXuZt9+/aVqVOnSkFBgcdz9ZzezpeTk+P1XM8991yl49er/QEAAAAAAPiKSql65h4IzZs3T9LT02XDhg32Or1KXlFRkbmvoVBCQoK9LSgoyOfz6bG1iZg2FVu9erVkZWXJ3LlzTWiVmJho76fnKR9CderUyesxL7roIjn11FM91l1xxRWye/duCQ8P93mMAAAAAAAAhFL1LCIiwr6v1UtaXeS+TlmhVGhoaIVtvtKQKCQkxByne/fuMmLECFMxNXHiRFmyZIm9n7+/f7XPpeGYe0C2bds2+fTTT03YBQAAAAAAUBNM32viNExKTU2VpUuX1tlUuxdeeEHatGkj559/fqX7lJaWmmot9wUAAAAAAMBCKHUQSU5ONtP5rGXNmjV1ctz4+Hhzq72rLOvXr/c4V1JSUrWPpxVSl156aZXTCzMzM01lmLVERkbW8lUAAAAAAICmhOl7BxHtOdWjRw/7sRXkaP+nzZs3m/sDBw6UhQsX+nRcl8tlbnXqoCUuLk4WLFhgPw4MDKzWsZYvXy55eXny4osvVrlfWlqaTJkyxX6slVIEUwAAAAAAwEIodRDR0CY2NrbC+uzsbCkrK6tx83MNkVR0dLS9LiAgwOu5DuTpp5+WPn36SL9+/arcT0Ou6gZdAAAAAACg+SGUagSioqJq/Nxdu3bJnDlzJCUlRcLCwmo1jp07d8rrr79upuYBAAAAAADUBqFUE6PNzHfv3i0lJSWyatUqycrKMlf3mz9/fp1ML9y7d6+MHDmyTsYKAAAAAACaL0KpJkZ7RWnvKG1eHhMTI0OHDjW9nSIiImp9bG1wfu6550pISEidjBUAAAAAADRfLVxWF2ygHmmjc70KX3FxsQQHBzf0cAAAAAAAQANnAH71NQAAAAAAAACgMoRSAAAAAAAAcBw9peCoXtMWiV9gG6/b8mcMd3w8AAAAAACgYVApVc+06XhVS0ZGhuTn53vdVtVV7nJzc80+27dv93isi5+fn5m72bdvX5k6daoUFBR4PFfP6e18OTk5lZ5v5cqVMmTIENPkvGPHjjJs2DD55ptv6vCdAgAAAAAAzQmVUvXMPRCaN2+epKeny4YNG+x1epW8oqIic19DoYSEBHtbUFCQz+fTY2sTMW0qtnr1asnKyjJXzdPQKjEx0d5Pz1M+hOrUqZPXY+7cuVNOPfVUOeuss+Sxxx6TvXv3yrRp00ww9dtvv0mrVq18HicAAAAAAGjeCKXqWUREhH1fq5e0Isl9nbJCqdDQ0ArbfBUeHm6qmfQ43bt3lxEjRpiKqYkTJ8qSJUvs/fz9/at9rh9++EH+/vtvufPOOyUyMtKs01Cqd+/esnnzZomNja3VmAEAAAAAQPPD9L0mTqutUlNTZenSpVJYWFijY8TFxZnATCuu9uzZI7t27TL3e/ToIdHR0XU+ZgAAAAAA0PQRSh1EkpOTzXQ+a1mzZk2dHDc+Pt7cau8qy/r16z3OlZSUVOnz27dvb6b/vfTSSybk0v0//PBDWbhwoam48qa0tNRMIXRfAAAAAAAALEzfO4hozymtPrJYU+W0/5NOk1MDBw40YZAvXC6XudWpg+7VTwsWLLAfBwYGVvp8rYwaO3asDBgwQF599VXZt2+fzJw5U4YPH24aoHvrfZWZmSnTp0/3aZwAAAAAAKD5IJQ6iGgI5a0/U3Z2tpSVldW4+XleXp65dZ9qFxAQUO1eUK+88oqpslq+fLm5sp+1Tq/C9+6778rFF19c4TlpaWkyZcoU+7FWSlkhGwAAAAAAAKFUIxAVFVXj52qV05w5cyQlJUXCwsJqdIz//vvPhFHulVbW4/3793t9jlZeVVV9BQAAAAAAmjd6SjUx2sx8y5Yt8tNPP8lrr71mptzp1f0ef/zxGh/zlFNOkX/++UcmTZpkqq6+++47ufLKK00/qRNPPLFOxw8AAAAAAJoHKqWaGO0VpRVM2ow8JiZGhg4daqbRRURE1KpR+nvvvWd6RPXv399USfXt29c0O+/atWudjh8AAAAAADQPLVxWF2ygHmlPqQ4dOkjkda+LX2Abr/vkzxju+LgAAAAAAED9ZADFxcUSHBxc6X5USsFR304fVuUXEgAAAAAANA/0lAIAAAAAAIDjqJSCo3pNW+R1+h5T9wAAAAAAaF6olAIAAAAAAIDjCKXqmV4Jr6olIyND8vPzvW4bOXJkpcfNzc01+2zfvt3jsS56dTxtKKZXyJs6daoUFBR4PFfP6e18OTk5lZ7vk08+keTkZGnfvr25kt/NN98se/furcN3CgAAAAAANCdM36tn7oHQvHnzJD09XTZs2GCva9eunRQVFZn7GgolJCTY24KCgnw+nx5bG4lrp/vVq1dLVlaWzJ0714RWiYmJ9n56nvIhVKdOnbwe85tvvpHTTz9dbrvtNnnhhRfkjz/+kNTUVNm3b5/MnDnT5zECAAAAAAAQStUzrSqyaPWSViS5r1NWKBUaGlphm6/Cw8MlJCTEHKd79+4yYsQIUzE1ceJEWbJkib2fv79/tc+lYVrv3r1NoKZiY2NN2HXhhRfKtGnTTPUUAAAAAACAL5i+18RptZVWNS1dulQKCwtrdIzS0lJp3bp1hePu3r1bVq1aVelztFrLfQEAAAAAALAQSh1EtGeTTuezljVr1tTJcePj482t9q6yrF+/3uNcSUlJlT5/2LBhsmzZMnn11VfNlD2dvnfnnXeabeX7VVkyMzNNZZi1REZG1slrAQAAAAAATQOh1EFEp8mtXbvWXnr27Gn3f7LCo9NOO83n47pcLnOrUwctcXFxHud66623Kn3+0KFD5f777zcVV4GBgWZaoPaYUtpU3Zu0tDQpLi62l99++83ncQMAAAAAgKaLnlIHEa0m0n5N5WVnZ0tZWVmNm5/n5eWZ2+joaHtdQECA13NVZsqUKXL99debyqiOHTuaqisNnmJiYrzur+GVLgAAAAAAAN4QSjUCUVFRNX7url27ZM6cOZKSkiJhYWG1GodWWnXr1s3c16l8GqIdffTRtTomAAAAAABongilmhhtZq4NyEtKSkwTcr1Knl7db/78+bU6rk7fO/XUU810PT3WjBkz5PXXX5eWLVvW2dgBAAAAAEDzQSjVxGivKK1o0v5TOrVO+0Hp1LuIiIhaHXfhwoVyzz33mKvqHXXUUfLuu+/WqL8VAAAAAACAauGyumAD9WjHjh3mKnza9Dw4OLihhwMAAAAAABo4A+DqewAAAAAAAHAcoRQAAAAAAAAcR08pOKrXtEXiF9imwvr8GcMbZDwAAAAAAKBhUClVC9pQvKolIyND8vPzvW4bOXJkpcfNzc01+2zfvt3jsS569Tudl9m3b1+ZOnWqFBQUeDxXz+ntfDk5OZWeb/LkydKvXz8JDAyUPn36eN1n3bp1MnDgQGndurVERkaaq/oBAAAAAADUFJVSteAeCM2bN0/S09Nlw4YN9jq9Al5RUZG5r6FQQkKCvS0oKMjn8+mxtUGYNgxbvXq1CYbmzp1rQqvExER7Pz1P+RCqU6dOVR57zJgxsmLFChM+lafn06v4nXzyyfLEE0/I+vXrzf4hISEyYcIEn18HAAAAAAAAoVQtRERE2Pe1ekkrktzXKSuUCg0NrbDNV+Hh4SYI0uN0795dRowYYSqmJk6cKEuWLLH38/f39+lcs2fPNrfbtm3zGkq9/PLLsmfPHnnmmWckICDAhF5r166VBx54gFAKAAAAAADUCNP3GjGttkpNTZWlS5dKYWFhvZ1n+fLlkpKSYgIpy7Bhw0zl1j///OP1OaWlpabCyn0BAAAAAACwEEo5JDk52Uzns5Y1a9bUyXHj4+PNrfausuj0OvdzJSUl1eocW7ZskS5dunissx7rNm8yMzNN9Zi1aB8qAAAAAAAAC9P3HKI9p3r06GE/tkIanQq3efNmc18biS9cuNCn47pcLnOrUwctcXFxsmDBAvuxNjB3WlpamkyZMsV+rJVSBFMAAAAAAMBCKOUQDWRiY2MrrM/OzpaysrIaNz/Py8szt9HR0fY6nWbn7Vw1pf2ptm7d6rHOelxZ7yoNwhoiDAMAAAAAAI0DoVQDi4qKqvFzd+3aJXPmzDH9nsLCwqS+9O/fX2677TYTnrVq1cqs+/jjj01FVseOHevtvAAAAAAAoOmip1Qjos3MtYfTTz/9JK+99poMGDDAXN3v8ccfr9VxN27caK6mp8fWoEvv66JX3FOXXnqpqb4aO3asfPfdd2Yq4sMPP+wxPQ8AAAAAAMAXVEo1IlqZpL2jtHl5TEyMDB061ARDlU2hq65x48bJ4sWL7cd9+/Y1t5s2bTLTArVR+UcffSSTJk2Sfv36SefOnSU9PV0mTJhQ69cEAAAAAACapxYuq1M2UI+00bmGW8XFxRIcHNzQwwEAAAAAAA2cATB9DwAAAAAAAI4jlAIAAAAAAIDj6CkFR/Watkj8AttUWJ8/Y3iDjAcAAAAAADQMKqVqQZuOV7VkZGRIfn6+120jR46s9Li5ublmn+3bt3s81sXPz8/My9Rm5FOnTpWCggKP5+o5vZ0vJyen0vNNnjzZNDAPDAyUPn36VNi+e/duueKKKyQxMVH8/f3l7LPPrtX7BgAAAAAAQKVULbgHQvPmzTNXpNuwYYO9Tq+SV1RUZO5rKJSQkGBvCwoK8vl8emxtEKYNw1avXi1ZWVkyd+5cE1ppYGTR85QPoTp16lTlsceMGSMrVqyQdevWVdi2b98+M14Nr9566y2fxw0AAAAAAFAeoVQtRERE2Pe1ekkrktzXKSuUCg0NrbDNV+Hh4RISEmKO0717dxkxYoSpmJo4caIsWbLE3k+rmXw51+zZs83ttm3bvIZSbdu2lccff9zcX7p0qV3BBQAAAAAAUFNM32vEtHopNTXVBEWFhYUNPRwAAAAAAIBqI5RySHJyspnOZy1r1qypk+PGx8ebW+1dZVm/fr3HuZKSksRppaWlZpqh+wIAAAAAAGBh+p5DtOdUjx497MeRkZF2/6fNmzeb+wMHDpSFCxf6dFyXy2VudeqgJS4uThYsWGA/1gbmTsvMzJTp06c7fl4AAAAAANA4EEo5REOo2NjYCuuzs7OlrKysxs3P8/LyzG10dLS9LiAgwOu5nJSWliZTpkyxH2ullBXEAQAAAAAAEEo1sKioqBo/d9euXTJnzhxJSUmRsLAwOZhodVZDVGgBAAAAAIDGgVCqEdFm5rt375aSkhJZtWqVZGVlmav7zZ8/v1bH3bhxo+zcuVO2bNligq61a9ea9T179jRVV+r777+XPXv2yN9//23Ob+3Tp0+fOnhlAAAAAACguSGUakS0V5T2jtLm5TExMTJ06FAzRS4iIqJWxx03bpwsXrzYfty3b19zu2nTJnta4Omnn273vnLfx+ppBQAAAAAA4IsWLlIFOEB7SnXo0EGKi4slODi4oYcDAAAAAAAaOAPwq68BAAAAAAAAAJUhlAIAAAAAAIDj6CkFR/Watkj8Att4rMufMbzBxgMAAAAAABoGlVIAAAAAAABwHKFULeiV8KpaMjIyJD8/3+u2kSNHVnrc3Nxcs8/27ds9Huvi5+dnmoXp1e+mTp0qBQUFHs/Vc3o7X05OTqXnmzx5svTr108CAwOlT58+XsczYsQI6dq1q7Rt29bs8/LLL9fqvQMAAAAAAM0b0/dqwT0QmjdvnqSnp8uGDRvsde3atZOioiJzX0OhhIQEe1tQUJDP59Nja9d67WK/evVqycrKkrlz55rQKDEx0d5Pz1M+hOrUqVOVxx4zZoysWLFC1q1bV2HbsmXLpHfv3nLzzTdLly5d5P3335dRo0aZcOyMM87w+XUAAAAAAAAQStVCRESEfV8DGq1Icl+nrFAqNDS0wjZfhYeHS0hIiDlO9+7dTfWSVkxNnDhRlixZYu/n7+/v07lmz55tbrdt2+Y1lLr11ls9Hl977bXy0Ucfyfz58wmlAAAAAABAjTB9rxHTaqvU1FRZunSpFBYWOnru4uLiKquvSktLTUWX+wIAAAAAAGAhlHJIcnKymc5nLWvWrKmT48bHx5tb7V1lWb9+vce5kpKSpC69/vrrsnLlSrnyyisr3SczM9NUj1lLZGRknY4BAAAAAAA0bkzfc4j2nOrRo4f92ApptP/T5s2bzf2BAwfKwoULfTquy+Uytzp10BIXFycLFiywH2sD87ry2WefmTDqqaee8uiRVV5aWppMmTLFfqyVUgRTAAAAAADAQijlEA1kYmNjK6zPzs6WsrKyGjc/z8vLM7fR0dH2uoCAAK/nqq3FixfLmWeeKQ8++KBpdF4VDcLqMgwDAAAAAABNC6FUA4uKiqrxc3ft2iVz5syRlJQUCQsLk/qkV/jTpub33XefTJgwoV7PBQAAAAAAmj5CqUZEm5nv3r1bSkpKZNWqVZKVlWWu7qdXwauNjRs3ys6dO2XLli0m6Fq7dq1Z37NnT1N1pVP2NJDSq+6dd955Zj+l26pqdg4AAAAAAFAZQqlGRHtFae8obV4eExMjQ4cONX2bIiIianXccePGmal5lr59+5rbTZs2mWmBzz//vPz333+mebkulkGDBpkKKgAAAAAAAF+1cFmdsoF6pI3O9Sp8xcXFEhwc3NDDAQAAAAAADZwB+NXXAAAAAAAAAIDKEEoBAAAAAADAcfSUgqN6TVskfoFtPNblzxjeYOMBAAAAAAANg0qpWtCm41UtGRkZkp+f73XbyJEjKz2uNg/XfbZv3+7xWBc/Pz8zL1ObkU+dOlUKCgo8nqvn9Ha+nJycSs83efJk6devnwQGBkqfPn0qbN+wYYOceOKJ0qVLF2ndurVpsn777bdLWVlZrd4/AAAAAADQfFEpVQvugdC8efMkPT3dBDgWvUpeUVGRua+hUEJCgr0tKCjI5/PpsbVBmDYMW716tWRlZcncuXNNaJWYmGjvp+cpH0J16tSpymOPGTNGVqxYIevWrauwrVWrVjJq1Cg5+uijJSQkRL755hsZP3687N+/X+69916fXwcAAAAAAAChVC1ERETY97V6SSuS3NcpK5QKDQ2tsM1X4eHhJhTS43Tv3l1GjBhhKqYmTpwoS5Yssffz9/f36VyzZ882t9u2bfMaSmlllC6WqKgoE4R98cUXtXo9AAAAAACg+WL6XiOm1VapqamydOlSKSwsdOy8GzdulA8//FAGDRpU6T6lpaWmost9AQAAAAAAsBBKOSQ5OdlM57OWNWvW1Mlx4+Pjza32rrKsX7/e41xJSUl19hq0p9SRRx4pAwcOlDvvvLPSfTMzM031mLVERkbWyRgAAAAAAEDTwPQ9h2jPqR49etiPrZBG+z9t3rzZ3NegZ+HChT4d1+VymVudOmiJi4uTBQsW2I+1gXldvYaSkhLTU+qmm26SmTNnmmbr3qSlpcmUKVPsx1opRTAFAAAAAAAshFIO0UAmNja2wvrs7Gz7KnY1aX6el5dnbqOjo+11AQEBXs9VW1ao1LNnT9m3b59MmDBBbrjhBmnZsmWFfTUIq6swDAAAAAAAND2EUg1Mm4bX1K5du2TOnDmSkpIiYWFh4iS98p6GaXrrLZQCAAAAAACoCqFUI6LNzHfv3m2m0K1atUqysrLM1f3mz59f68blO3fulC1btpiga+3atXZFlFZdvfzyy9KqVStJTEw01U9ff/21mZ530UUXmfUAAAAAAAC+IpRqRLRXlPaO0ublMTExMnToUNO3KSIiolbHHTdunCxevNh+3LdvX3O7adMmMy3Q399f7rvvPvnxxx9NDyut7rr66qvl+uuvr/VrAgAAAAAAzVMLl9UpG6hH2uhcr8JXXFwswcHBDT0cAAAAAADQwBmAX30NAAAAAAAAAKgMoRQAAAAAAAAcR08pOKrXtEXiF9jGY13+jOENNh4AAAAAANAwqJSqBW06XtWSkZEh+fn5XreNHDmy0uPm5uaafbZv3+7xWBc/Pz8zL1ObkU+dOlUKCgo8nqvn9Ha+nJycSs83efJk6devn7myXp8+fQ54pb727dtLSEiIz+8XAAAAAACAhUqpWnAPhObNmyfp6emyYcMGe51eJa+oqMjc11AoISHB3hYUFOTz+fTY2iBMG4atXr1asrKyZO7cuSa0SkxMtPfT85QPoTp16lTlsceMGSMrVqyQdevWVbpPWVmZXHLJJTJw4EBZtmyZz+MHAAAAAACwEErVQkREhH1fq5e0Isl9nbJCqdDQ0ArbfBUeHm4qlPQ43bt3lxEjRpiKqYkTJ8qSJUvs/fz9/X061+zZs83ttm3bqgylbr/9domPj5chQ4YQSgEAAAAAgFph+l4jptVWqampsnTpUiksLKzXc3366afyxhtvyKOPPlqv5wEAAAAAAM0DoZRDkpOTzXQ+a1mzZk2dHFcrl5T2rrKsX7/e41xJSUm1Osdff/0lV1xxhTz33HNm+mB1lJaWmmmG7gsAAAAAAICF6XsO0Z5TPXr0sB9HRkba/Z82b95s7muvpoULF/p0XJfLZW516qAlLi5OFixYYD/WBua1MX78eLn00kslJSWl2s/JzMyU6dOn1+q8AAAAAACg6SKUcoiGULGxsRXWZ2dnmwbiNW1+npeXZ26jo6PtdQEBAV7PVZupexpyzZw50w7C9u/fb3pXzZkzxzRJLy8tLU2mTJliP9ZKKSuIAwAAAAAAIJRqYFFRUTV+7q5du0wopBVMYWFhUl+WL18u+/btsx+/++67ct9995lm54cccojX52h1Vm0rtAAAAAAAQNNFKNWIaDPz3bt3S0lJiaxatUqysrLM1f3mz59fq+Nu3LhRdu7cKVu2bDFB19q1a836nj17mqor92mH6uuvvxY/Pz/p1atXrc4LAAAAAACaL0KpRkR7RWnvKG1eHhMTI0OHDjVT5CIiImp13HHjxsnixYvtx3379jW3mzZt8pgWCAAAAAAAUFdauKxO2UA90p5SHTp0kOLi4mpfwQ8AAAAAADTdDMDP0VEBAAAAAAAAhFIAAAAAAABoCPSUgqN6TVskfoFtPNblzxjeYOMBAAAAAAANg0opAAAAAAAAOI5Qqhb0SnhVLRkZGZKfn+9128iRIys9bm5urtln+/btHo918fPzM83C9Ap5U6dOlYKCAo/n6jm9nS8nJ6fS802ePFn69esngYGB0qdPnwrbK3sNX375Za3ePwAAAAAA0Hwxfa8W3AOhefPmSXp6umzYsMFe165dOykqKjL3NRRKSEiwtwUFBfl8Pj22dq3XLvarV6+WrKwsmTt3rgmtEhMT7f30POVDqE6dOlV57DFjxsiKFStk3bp1le5T/jWEhob6/BoAAAAAAAAUoVQtRERE2Pe1ekmrh9zXKSuU0gCn/DZfhYeHS0hIiDlO9+7dZcSIEaZiauLEibJkyRJ7P39/f5/ONXv2bHO7bdu2KkOpungNAAAAAAAAiul7jZhWW6WmpsrSpUulsLCw3s931llnmWDshBNOkAULFlS5b2lpqanocl8AAAAAAAAshFIOSU5ONtP5rGXNmjV1ctz4+Hi775Nl/fr1HudKSkqq1Tn0GLNmzZI33nhDPvjgAxNKnX322VUGU5mZmaZ6zFoiIyNrNQYAAAAAANC0MH3PIdpzqkePHvZjK6TRHk2bN2829wcOHCgLFy706bgul8vc6tRBS1xcnEdgpA3Ma6Nz584yZcoU+/Gxxx4rf/75p9x///2mesqbtLQ0j+dopRTBFAAAAAAAsBBKOUQDmdjY2Arrs7OzpaysrMbNz/Py8sxtdHS0vS4gIMDruerScccdJx9//HGl2zUIq20YBgAAAAAAmi5CqQYWFRVV4+fu2rVL5syZIykpKRIWFiZOWrt2rXTt2tXRcwIAAAAAgKaDUKoR0Wbmu3fvlpKSElm1apVkZWWZq/vNnz+/VsfduHGj7Ny5U7Zs2WKCLg2cVM+ePU3V1fPPP29u9Up/Ss/3zDPPyNNPP10nrwsAAAAAADQ/hFKNiPaK0t5R2ng8JiZGhg4davo2RURE1Oq448aNk8WLF9uPrfBp06ZN9rTAu+66y/S+8vf3N83VtUfW+eefX8tXBAAAAAAAmqsWLqtTNlCPtNG5XoWvuLhYgoODG3o4AAAAAACggTMAv/oaAAAAAAAAAFAZQikAAAAAAAA4jp5ScFSvaYvEL7CNx7r8GcMbbDwAAAAAAKBhUClVC9p0vKolIyND8vPzvW4bOXJkpcfNzc01+2zfvt3jsS5+fn5mXqY2I586daoUFBR4PFfP6e18OTk5lZ5v8uTJ0q9fPwkMDJQ+ffp43Udbj82cOVO6d+9u9jvkkEPknnvuqfF7BwAAAAAAmjcqpWrBPRDSq9Glp6fLhg0b7HV6lbyioiJzX0OhhIQEe1tQUJDP59Nja4MwbRi2evVqycrKkrlz55rQKjEx0d5Pz1M+hOrUqVOVxx4zZoysWLFC1q1b53X7tddeKx999JEJpvRcf//9t1kAAAAAAABqglCqFiIiIuz7Wr2kFUnu65QVSoWGhlbY5qvw8HAJCQkxx9GKpREjRpiKqYkTJ8qSJUvs/fz9/X061+zZs83ttm3bvIZSeXl58vjjj8u3334rcXFxZt3hhx9eq9cCAAAAAACaN6bvNWJabZWamipLly6VwsLCejvPe++9JzExMfL++++bMCo6OlrGjRtXZaVUaWmpqehyXwAAAAAAACyEUg5JTk420/msZc2aNXVy3Pj4eHOrvass69ev9zhXUlJSrc7xyy+/yObNm+WNN96QF154QZ577jlZtWqVnH/++ZU+JzMz01SPWUtkZGStxgAAAAAAAJoWpu85RHtO9ejRw35shTTa/0kDHzVw4EBZuHChT8fVBuRKpw5adIrdggUL7MfamLw29u/fbyqfNJDSaYNKe1lpc3Ttc2VN6XOXlpYmU6ZMsR9rpRTBFAAAAAAAsBBKOUQDmdjY2Arrs7OzpaysrMbNz7Xfk9IpdZaAgACv56qprl27mj5VViClrIDt119/9RpKaRBW2zAMAAAAAAA0XYRSDSwqKqrGz921a5fMmTNHUlJSJCwsTOrLgAEDZO/evfLzzz/LEUccYdb9+OOPtR4/AAAAAABovgilGhFtZr57924pKSkxPZ2ysrLM1f3mz59fq+Nu3LhRdu7cKVu2bDFB19q1a836nj17mqqrk08+WY4++mgZM2aMPPTQQ2Y636RJk+SUU07xqJ4CAAAAAACoLkKpRkSnyWnvKG1erlfDGzp0qOnbFBERUavj6pX0Fi9ebD/u27evud20aZOZFujn52euwHfNNdeYqqy2bdvKaaedJrNmzar1awIAAAAAAM1TC5fVKRuoR9roXK/CV1xcLMHBwQ09HAAAAAAA0MAZgF99DQAAAAAAAACoDKEUAAAAAAAAHEdPKTiq17RF4hfYxmNd/ozhDTYeAAAAAADQMKiUqgVtOl7VkpGRIfn5+V63jRw5stLj5ubmmn22b9/u8VgXbTqu8zK1GfnUqVOloKDA47l6Tm/ny8nJqfR8kydPln79+klgYKD06dOnwvbKjqkNzwEAAAAAAGqCSqlacA+E5s2bJ+np6bJhwwZ7nV4lr6ioyNzXUCghIcHeFhQU5PP59NjaIEwbhq1evVqysrJk7ty5JrRKTEy099PzlA+hOnXqVOWxx4wZIytWrJB169ZV2HbjjTdKamqqx7ohQ4bIscce6/NrAAAAAAAAUIRStRAREWHf1+olrR5yX6esUCo0NLTCNl+Fh4dLSEiIOU737t1lxIgRpmJq4sSJsmTJEns/f39/n841e/Zsc7tt2zavoZSGa7pYvvnmG/n+++/liSeeqNXrAQAAAAAAzRfT9xoxrbbSCqalS5dKYWGhY+d9+umnTSg2cOBAx84JAAAAAACaFkIphyQnJ9sVR7qsWbOmTo4bHx9vbrV3lWX9+vUe50pKSpK6snv3bnn55Zdl7NixVe5XWlpqphm6LwAAAAAAABam7zlEe0716NHDfhwZGWn3f9q8ebO5r5VHCxcu9Om4LpfL3OrUQUtcXJwsWLDAfqwNzOvK22+/LSUlJTJ69Ogq98vMzJTp06fX2XkBAAAAAEDTQijlEA2hYmNjK6zPzs6WsrKyGjc/z8vLM7fR0dH2uoCAAK/nqqupe2eccYZ06dKlyv3S0tJkypQp9mOtlLKCOAAAAAAAAEKpBhYVFVXj5+7atUvmzJkjKSkpEhYWJvVt06ZN8tlnn3lUYVVGq7PqskILAAAAAAA0LYRSjYg2M9eeTjp9btWqVZKVlWWu7jd//vxaHXfjxo2yc+dO2bJliwm61q5da9b37NnTVF1ZnnnmGenataucdtpptX4tAAAAAACgeSOUakS0V5T2jtLm5TExMTJ06FAzRS4iIqJWxx03bpwsXrzYfty3b1+7MsqaFrh//3557rnn5IorrpCWLVvW8pUAAAAAAIDmroXL6pQN1CPtKdWhQwcpLi6W4ODghh4OAAAAAABo4AzAr74GAAAAAAAAAFSGUAoAAAAAAACOo6cUHNVr2iLxC2xjP86fMbxBxwMAAAAAABoGlVK1oE3Hq1oyMjIkPz/f67aRI0dWetzc3Fyzz/bt2z0e6+Ln52fmZWoz8qlTp0pBQYHHc/Wc3s6Xk5NT6fkmT54s/fr1k8DAQOnTp4/XfRYtWiTHH3+8tG/fXsLCwuS8884zrw0AAAAAAKAmqJSqBfdAaN68eZKeni4bNmyw1+lV8oqKisx9DYUSEhLsbUFBQT6fT4+tDcK0Ydjq1aslKytL5s6da0KrxMREez89T/kQqlOnTlUee8yYMbJixQpZt25dhW16Fb4RI0aYK/29/PLLplHZ9ddfL+eee64ZBwAAAAAAgK8IpWohIiLCvq/VS1qR5L5OWaFUaGhohW2+Cg8Pl5CQEHOc7t27m6BIK6YmTpwoS5Yssffz9/f36VyzZ882t9u2bfMaSq1atUr27dsnd999t6nUUjfeeKM5f1lZmbRq1apWrwsAAAAAADQ/TN9rxLTaKjU1VZYuXSqFhYX1dh6d2qdh1LPPPmvCKa2UevHFF+Xkk08mkAIAAAAAADVCKOWQ5ORkM53PWtasWVMnx42Pjze37v2d1q9f73GupKSkWp3j8MMPl48++khuvfVW03dKq7V+//13ef311yt9TmlpqZlm6L4AAAAAAABYCKUcoj2n1q5day89e/a0+z9Z4dFpp53m83FdLpe51amDlri4OI9zvfXWW7Ua+5YtW2T8+PEyevRoWblypSxevFgCAgLk/PPPt89fXmZmppnSaC2RkZG1GgMAAAAAAGha6CnlEA1lYmNjK6zPzs42fZlq2vw8Ly/P3EZHR9vrNDDydq6aevTRR02wpI3VLS+99JJ5TdocXa/KV15aWpppjG7RSimCKQAAAAAAYCGUamBRUVE1fu6uXbtkzpw5kpKSImFhYVJf/vvvP7vBuaVly5bmdv/+/V6fo9P8dAEAAAAAAPCG6XuNiDYz16l0P/30k7z22msyYMAAc3W/xx9/vFbH3bhxo5nmp8fWoMua9rdnzx6zffjw4Wba3p133mnOvXr1arnyyitNoKZX/wMAAAAAAPAVlVKNiPaK0t5R2n8qJiZGhg4daqbIRURE1Oq448aNM32iLFbQtGnTJjMt8KSTTpJXXnnFTN/TpU2bNtK/f3/58MMPazTlEAAAAAAAoIWrsk7VQB3SnlKm4fl1r4tfYBt7ff6M4Q06LgAAAAAAUD8ZQHFxsQQHB1e6H5VScNS304dV+YUEAAAAAADNAz2lAAAAAAAA4DhCKQAAAAAAADiO6XtwVK9pi+gpBQAAAAAAqJSqDb0SXlVLRkaG5Ofne902cuTISo+bm5tr9tm+fbvHY138/PxMszC9Qt7UqVOloKDA47l6Tm/ny8nJqfR8kydPln79+klgYKD06dPH6z6vv/662aZX3ouKipL777+/xu8bAAAAAAAAlVK14B4IzZs3T9LT02XDhg32unbt2klRUZG5r6FQQkKCvS0oKMjn8+mxtUm4drFfvXq1ZGVlydy5c01olZiYaO+n5ykfQnXq1KnKY48ZM0ZWrFgh69atq7Bt4cKFctlll8n//d//ydChQyUvL0/Gjx9vXsPVV1/t8+sAAAAAAAAglKqFiIgI+75WL2lFkvs6ZYVSoaGhFbb5Kjw8XEJCQsxxunfvLiNGjDAVUxMnTpQlS5bY+/n7+/t0rtmzZ5vbbdu2eQ2lXnzxRTn77LMlNTXVPI6JiZG0tDS57777ZNKkSeZ1AwAAAAAA+ILpe42YVippULR06VIpLCyst/OUlpZK69atK5z7999/l82bN1f6HK3ocl8AAAAAAAAshFIOSU5ONtP5rGXNmjV1ctz4+Hhzq72rLOvXr/c4V1JSUq3OMWzYMJk/f7588sknsn//fvnxxx9l1qxZZlv5nlaWzMxMUz1mLZGRkbUaAwAAAAAAaFqYvucQ7TnVo0cP+7EV0mj/J6vaaODAgaZ/ky9cLpe5dZ9CFxcXJwsWLLAfawPz2tD+UT///LOcccYZUlZWZvpaXXvttaapujZe90an902ZMsV+rJVSBFMAAAAAAMBCKOUQDWRiY2MrrM/OzjZBT02bn2vTcRUdHW2vCwgI8HqumtLAS/tH3XvvvbJlyxYJCwszVVNWfylvNAirbRgGAAAAAACaLkKpBhYVFVXj5+7atUvmzJkjKSkpJiiqby1btpRDDjnE3H/11Velf//+jpwXAAAAAAA0PYRSjYg2M9+9e7eUlJTIqlWrJCsry1zdT/s91cbGjRtl586dpgpKg661a9ea9T179jRVV3qON998UwYPHmzO/+yzz8obb7whixcvrqNXBgAAAAAAmhtCqUZEe0XpVDptXq7T5oYOHWr6NkVERNTquOPGjfMImPr27WtuN23aZE8LfP755+XGG280Pay0Qio3N7fWDdQBAAAAAEDz1cJldcoG6pE2Oter8BUXF5tG6QAAAAAAoHlnAN4vnQYAAAAAAADUI0IpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDj/J0/JZojl8tlbnfs2NHQQwEAAAAAAPXI+tvfygIqQygFR/z111/mNjIysqGHAgAAAAAAHFBSUiIdOnSodDuhFBzRqVMnc/vrr79W+YUEUP3/8qAh72+//SbBwcENPRyg0eM3BdQdfk9A3eI3hcZIK6Q0kOrWrVuV+xFKwRF+fv9v+zINpPgHKVB39PfEbwqoO/ymgLrD7wmoW/ym0NhUpyCFRucAAAAAAABwHKEUAAAAAAAAHEcoBUcEBgbKtGnTzC2A2uM3BdQtflNA3eH3BNQtflNoylq4DnR9PgAAAAAAAKCOUSkFAAAAAAAAxxFKAQAAAAAAwHGEUgAAAAAAAHAcoRQAAAAAAAAcRyiFOvPoo49KdHS0tG7dWo477jj56quvqtz/jTfekPj4eLN/YmKiZGdnOzZWoKn9pr777js577zzzP4tWrSQhx56yNGxAk3tN/XUU0/JwIEDpWPHjmY5+eSTD/j/a0Bz4svvaf78+XLMMcdISEiItG3bVvr06SMvvviio+MFmtrfUpbXXnvN/Lvf2WefXe9jBOoDoRTqxLx582TKlCnmUqWrV6+Wo446SoYNGyaFhYVe91+2bJlccsklMnbsWFmzZo35h6gu3377reNjB5rCb+q///6TmJgYmTFjhkRERDg+XqCp/aZyc3PN/0999tlnsnz5comMjJShQ4fKH3/84fjYgcb+e+rUqZPcdttt5re0bt06ufLKK82yaNEix8cONIXflCU/P19uvPFG8x9RgMaqhcvlcjX0IND4aZp/7LHHyiOPPGIe79+/3/wL/DXXXCO33HJLhf0vuugi+ffff+X999+31x1//PHmv5w98cQTjo4daAq/KXf6X9muu+46swCo/W9K7du3z1RM6fNHjRrlwIiBpvt7UkcffbQMHz5c7rrrrnoeLdA0f1P6/0spKSkyZswY+eKLL2T79u3yzjvvODxyoPaolEKt7dmzR1atWmWmNlj8/PzMY/0vYt7oevf9lf7XgMr2B5qTmvymANTvb0qrEcvKykzFB9Cc1fb3pP89/JNPPpENGzaYP6iB5q6mv6k777xTwsPDzcwToDHzb+gBoPErKioySX2XLl081uvjH374wetztmzZ4nV/XQ80dzX5TQGo39/UzTffLN26davwH1SA5qamv6fi4mI55JBDpLS0VFq2bCmPPfaYnHLKKQ6MGGh6v6klS5bI3LlzZe3atQ6NEqg/hFIAAABV0F5t2khW+0xpA1oAvmvfvr35A3rnzp2mUkr752gvxMGDBzf00IBGpaSkRC6//HJzQY7OnTs39HCAWiOUQq3pPwz1v3ht3brVY70+rqzhsq73ZX+gOanJbwpA/fymZs6caUKpnJwc6d27dz2PFGi6vyedjhQbG2vuaw/RvLw8yczMJJRCs+frb+rnn382Dc7PPPNMe532oFL+/v5mauwRRxzhwMiBukFPKdRaQECA9OvXz/xXL/d/MOrj/v37e32OrnffX3388ceV7g80JzX5TQGo+99UVlaWacL84YcfmsvZA6i7/4/S5+hUPqC58/U3FR8fL+vXrzeVh9Zy1llnyYknnmjua4N0oDGhUgp1QkuwR48ebf6lPSkpSR566CFzdT293K/SKxVpHwH9L2Lq2muvlUGDBsmsWbPMlVd0WsTXX38tc+bMaeBXAjTO35Q2yfz+++/t+3rZev0Xk3bt2tn/ZRpoznz9Td13332Snp4ur7zyirmipdXzUH9TugDNma+/J73VfbV6Q4Oo7OxsefHFF+Xxxx9v4FcCNL7flE4j79Wrl8fzQ0JCzG359UBjQCiFOnHRRRfJtm3bzL/A67+4a1m2/pdlq2Hfr7/+asq2LcnJyeZf9G+//Xa59dZb5cgjjzSXMOUfpEDNflN//vmn9O3b12PKkS4a/mofHKC58/U3pX8sa8B7/vnnexxn2rRpkpGR4fj4gcb8e9I/rq+66ir5/fffJSgoyFR6vPTSS+Y4AHz/TQFNSQuXXpcVAAAAAAAAcBBxKwAAAAAAABxHKAUAAAAAAADHEUoBAAAAAADAcYRSAAAAAAAAcByhFAAAAAAAABxHKAUAAAAAAADHEUoBAAAAAADAcYRSAAAAAAAAcByhFAAAAAAAABxHKAUAANAEXHHFFXL22WfLwSg/P19atGgha9eubeihAACAgwihFAAAAOrNnj17GnoIAADgIEUoBQAA0MQMHjxYrrnmGrnuuuukY8eO0qVLF3nqqafk33//lSuvvFLat28vsbGxsnDhQvs5ubm5pprpgw8+kN69e0vr1q3l+OOPl2+//dbj2G+99ZYkJCRIYGCgREdHy6xZszy267q77rpLRo0aJcHBwTJhwgQ5/PDDzba+ffuac+j41MqVK+WUU06Rzp07S4cOHWTQoEGyevVqj+Pp/k8//bScc8450qZNGznyyCNlwYIFHvt89913csYZZ5jz6WsbOHCg/Pzzz/Z2fX6PHj3Ma4qPj5fHHnusDt9tAABQU4RSAAAATdDzzz9vwp6vvvrKBFQTJ06UCy64QJKTk03wM3ToULn88svlv//+83jeTTfdZIImDYzCwsLkzDPPlLKyMrNt1apVcuGFF8rFF18s69evl4yMDLnjjjvkueee8zjGzJkz5aijjpI1a9aY7ToGlZOTIwUFBTJ//nzzuKSkREaPHi1LliyRL7/80gROp59+ulnvbvr06ea869atM9svu+wy+fvvv822P/74Q1JSUkxI9umnn5oxjhkzRvbu3Wu2v/zyy5Keni733HOP5OXlyb333mvGpO8PAABoWC1cLpergccAAACAOugptX37dnnnnXdMJdK+ffvkiy++MNv0vlYinXvuufLCCy+YdVu2bJGuXbvK8uXLTUWUVkqdeOKJ8tprr8lFF11k9tHg59BDDzWhk4ZCGgZt27ZNPvroI/u8U6dONdVVWq1kVUppRdTbb7/t0VNKq6U0pOrTp0+lr2H//v0SEhIir7zyiql8siqlbr/9dlN9pbTaq127dqbK69RTT5Vbb73VjHnDhg3SqlWrCsfUijB97iWXXGKvu/vuuyU7O1uWLVtW6/cdAADUHJVSAAAATZBOwbO0bNlSQkNDJTEx0V6nU/pUYWGhx/P69+9v3+/UqZPExcWZCiOltwMGDPDYXx//9NNPJviyHHPMMdUa49atW2X8+PGmQkpDM51+t3PnTvn1118rfS1t27Y1+1nj1ubpOl3PWyClAZZO4xs7dqwJsqxFQyn36X0AAKBh+DfQeQEAAFCPyoc0WnHkvk4fW9VJdU2Do+rQqXt//fWXPPzwwxIVFWWm4GkoVr45urfXYo07KCio0uNrwKW0n9Zxxx3nsU2DOgAA0LAIpQAAAGDT3k6HHXaYuf/PP//Ijz/+aJqEK71dunSpx/76uHv37lWGPAEBAebWvZrKeq42Hdc+Ueq3336ToqIin8arVVTaH0r7XpUPr7QarFu3bvLLL7+YqYcAAODgQigFAAAA25133mmm+mmgc9ttt5lm6WeffbbZdsMNN8ixxx5rejRp3yntR/XII48c8Gp24eHhpqLpww8/ND2q9Cp4Ol1Pp+29+OKLZrrfjh07TJP1qiqfvLn66qvl//7v/0zz9bS0NHNcDdaSkpLM1ENtkj558mSzXntQlZaWytdff20CtylTptTqvQIAALVDTykAAADYZsyYIddee63069fPNEN/77337Eqno48+Wl5//XXTWLxXr17mqnYaYmmT9ar4+/vL7Nmz5cknnzSVSyNGjDDr586da8IhPa5eCVDDIw2wfKEBml51T6fqDRo0yIxbp+tZVVPjxo2Tp59+Wp599lnTU0v30cbt2ngdAAA0LK6+BwAAAPvqexoS6RXwAAAA6huVUgAAAAAAAHAcoRQAAAAAAAAcx/Q9AAAAAAAAOI5KKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAABzUnnvuOWnRooXk5+cfcN/o6Gi54oor7Me5ubnmuXp7IHp83VfPdzAYPHiwWQAAAJoqQikAAOCIxx57zIQ+xx13XIOO45VXXpGHHnpImgoN4vR99bbs3r27Xs557733yjvvvCONkRU+zpw5Uxqr7OxsycjIaOhhAABQa/61PwQAAMCBvfzyyyZA+eqrr2Tjxo0SGxtb7+dMSUmRXbt2SUBAgEco9e2338p1113nsW9UVJTZt1WrVtLY9OnTR2644YYK691fd12HUueff76cffbZ9XJ8HDiUevTRRwmmAACNHqEUAACod5s2bZJly5bJ/Pnz5X//+58JqKZNm1bv5/Xz85PWrVtXa1+tnqnuvgebQw45REaOHCmN2f79+2XPnj2N9jNwwr///itt27Zt6GEAAFBnmL4HAADqnYZQHTt2lOHDh5sKG33szXfffScnnXSSBAUFyaGHHip33323CSvKc7lcZpvu06ZNGznxxBPNc8sr31NKezR98MEHsnnzZnuKm1ZvVdVT6tNPP5WBAweaMCAkJERGjBgheXl5HvtoxYo+VyvAtKeV7tehQwe58sor5b///vPY99lnnzWvMTw8XAIDA6Vnz57y+OOPS33avn27qQyLjIw059Qqtfvuu6/Ce6tT2pKTkyU0NNR8Bv369ZM333zTYx99nRqOPP/88/Z7aPXx0lvr/fT2/pQ/ztVXX22+CwkJCWZcH374odn2xx9/yJgxY6RLly5mvW5/5plnKhz3//7v/8w2/Q7o9+uYY44xlXA17Vu2ZMkSmTx5soSFhZnPUANUDcr0/Rs1apQ5hy5Tp04130FvUwIffPBBU3Wn79+gQYNMVV55vnynvv/+e7n00kvNeU844QTzHmuVlPUeWosvn6H7+6/TMHv16mW/z9Zn4E4/j7Fjx0q3bt3MfocffrhMnDjRvDe+fscAAHBHpRQAAKh3Gjyce+65ZjrZJZdcYkKYlStXyrHHHmvvs2XLFhMu7d27V2655RbzB/ucOXPMH9blpaenm1Dq9NNPN8vq1atl6NChHn8ke3PbbbdJcXGx/P777yY8UO3atat0/5ycHDnttNMkJibGhAQ6vU+DkAEDBphzlg9gLrzwQvMHe2Zmptn+9NNPm/BJ/zi36GvXP/7POuss8ff3l/fee0+uuuoq88f7pEmTpCbKysqkqKjIY50GNbpoKKbhiAYLGrIcdthhpmotLS1NCgoKPPprPfzww2Zcl112mXkvX3vtNbngggvk/fffN4GievHFF2XcuHGSlJQkEyZMMOuOOOKIGo1bw5nXX3/dhCOdO3c27+fWrVvl+OOPt0MTDYgWLlxoQpEdO3bY0y6feuopEyBpyHnttdea/lnr1q2TFStWmBCnJq655hqJiIiQ6dOny5dffmm+fxoa6ful75tOW9Spc/fff78JcjSocvfCCy9ISUmJ+Rx1PPp+agC5fv16E7DV5Dul7/+RRx5pzq1BWN++feXPP/+Ujz/+2HwW5VXnM7RoCKfVi/r9a9++vcyePVvOO+88+fXXX02opfRc+llr6KSfd3x8vPkuadCl3y39TfvyHQMAwIMLAACgHn399ddaUuL6+OOPzeP9+/e7Dj30UNe1117rsd91111n9luxYoW9rrCw0NWhQwezftOmTfa6gIAA1/Dhw82xLLfeeqvZb/To0fa6zz77zKzTW4s+LyoqqsI49fi677PPPmuv69Onjys8PNz1119/2eu++eYbl5+fn2vUqFH2umnTppnnjhkzxuOY55xzjis0NNRj3X///Vfh3MOGDXPFxMR4rBs0aJBZDkRfi567/KJjUnfddZerbdu2rh9//NHjebfccourZcuWrl9//bXSse3Zs8fVq1cv10knneSxXo/n/j5bdJ2399Z6f9zpY30fv/vuO4/1Y8eOdXXt2tVVVFTksf7iiy823wVrjCNGjHAlJCS4fGV9zvfff7+9Tj9zXaefg/t3qn///q4WLVq4UlNT7XV79+4131/3z8Y6ZlBQkOv333+31+t3Wddff/31Nf5OXXLJJRVew6RJkyq8n75+hvp8/R1t3LjRYxy6/v/+7//sdTomHdvKlSsrnMt6r3z5jgEA4I7pewAAoN6rpLRKRKuglFbAXHTRRaaCY9++ffZ+WoGiFTJalWHRKhmt+HCnlSZaAaJVLe7Tlso3Lq8trfBYu3atmS7VqVMne33v3r3llFNOMeMtLzU11eOxTtH666+/TIWPxb3yS6u2tMJJq0x++eUX87gm9IqGWjnjvlhVPG+88YYZh07/0nNZy8knn2ze/88//9zr2P755x8zHn2uVvDUB33dOn3RolnJW2+9JWeeeaa57z7eYcOGmfFYY9EKJq1404q7uqLVWO7fKX1fdRy63tKyZUszTVA/r/K08bv297Lod1mPYX1X6uI7dSC+fIb6HXCvctNxBAcH269Nq/d0ep9+Hvqay7PeK1++YwAAuGP6HgAAqDf6B6mGTxpIabNzi/6hPmvWLPnkk0/MtDulfZ50fXlxcXEej3U/pVOa3GmApX8U1xXrPOXPr3r06CGLFi2q0Hhapy25s8aj4YD+sa+WLl1qmrwvX768Qr8pDRC0F5WvdOqbBgDe/PTTT2Zam74/3hQWFtr3dYqXTovU4KS0tNReX74fVF3RqY7utm3bZqaJ6bQ5Xaoa780332wCSg1+tH+Rfo902p5Og6up8p+f9Vlon6Ty6/UzLa/8d1J1797dTFGs6Xeq/Ht0IL58huVfr/WdtV6bfh4aqOpUxar48h0DAMAdoRQAAKg32jNIq0M0mNLFWxWVFUo1BVpF443VFPvnn3+WIUOGmL48DzzwgAk7tCePVshoj6v6aAqtx9QqHG3O7Y2GJuqLL74wvYhSUlLksccek65du0qrVq1MY/bqNg+vLLxyr4hzV75fmPX69UqCo0eP9vocreaxQpwNGzaYEEabc2uFlY5b+41pT6i6/Py8rXdvdF6fvPVUq4yvn+GBvq91/R0DAKA8QikAAFBvNHTSRt/W1cLcaYPlt99+W5544gnzh7desUwrLsrT4MGd7qd0X20WbdGqDm/VK+VVt+rHOk/586sffvjBVCe5V7RUhzY11+qVBQsWeFSpfPbZZ1JfdHrWzp07K62ksmio07p1a1Oto1dPs2igUd33UKtstNKpPKtC6EC00kYbbmuIdaDxKn3/dSqoLjqlU5vp33PPPabBtr4Wp3n7/v7444928/K6+k5V9v778hlW9/PQCj9vVxCsyXcMAIDy6CkFAADqhV5VTIOnM844w1whrfyiV1bTK5VpQKP0Knp6xbOvvvrKI2jSYMud/uGr1R96xTL3io7qXuFL/+ivTu8mrTLp06ePPP/88x5Bi/6B/tFHH5nx+sqqTHEft46lpqFBdegVAXWqoAYV5enr0qsdWmPTsMO9qik/P9/0FPL2HnoLnzSc0NejU7ksWimn4WN16Bj06m8arngLQvT7YNFeXe604kz7U+l7q1cjbAj6XukV6Cz6XdarAerV9uryO2UFV+U/A18+w+rw8/MzfbI0TP36668rbLe+x9X9jgEAUB6VUgAAoF5o2KShk04n8kabmmslhoZOWumiU3/0EvennnqqXHvtteYPb+0rpNUl7iGHPufGG2+UzMxME3jpH/Jr1qyRhQsXmkqTA+nXr5/MmzdPpkyZIscee6y0a9fONHL25v777zeBQv/+/U2zaw3aNAzTnkIZGRk+vyc6VVHDEz3f//73P1Nd8tRTT5lqMg1v6sNNN91kPgt9r7TBtr5+7Vu0fv16efPNN01ooe/b8OHDzZRCff+1N5P2AdIKN+3X5P7+Kz2G9nPS/bt162b6Hmk/sIsvvtj0ejrnnHNk8uTJpmfW448/bqZvVbdZ+owZM0zlmB5v/PjxJmj6+++/zfP1nHrfei8jIiJMDyltpJ+XlyePPPKIeR1abdUQ9L064YQTZOLEiaYiToPS0NBQj2ltdfGd0vdf6XusDeA1jNL33pfPsLruvfdeE5hpU/oJEyaYaZP6XdXm5kuWLDEN56v7HQMAoAKPa/EBAADUkTPPPNPVunVr17///lvpPldccYWrVatWrqKiIvN43bp1rkGDBpnnHXLIIeZS83PnzjWXqd+0aZP9vH379rmmT5/u6tq1qysoKMg1ePBg17fffuuKiopyjR492t7vs88+M8/VW8vOnTtdl156qSskJMRs0+coPb4+fvbZZz3GmJOT4xowYIA5T3BwsHld33//vcc+06ZNM8/dtm2bx3o9VvmxL1iwwNW7d2/zGqOjo1333Xef65lnnqmwn74PuhyIjn/48OFV7lNSUuJKS0tzxcbGugICAlydO3d2JScnu2bOnOnas2ePvZ++10ceeaQrMDDQFR8fb8ZvvTZ3P/zwgyslJcW8J7rN/T3/6KOPXL169TLniYuLc7300ktej6GPJ02a5HW8W7duNdsiIyPN9yMiIsI1ZMgQ15w5c+x9nnzySTOG0NBQM94jjjjCddNNN7mKi4urfC+sz/n++++v8DmtXLmyWp+rvt62bdt6PeasWbPMuHVMAwcOdH3zzTcVxlCb75Tau3ev65prrnGFhYW5WrRo4fHeVvczrOz9L/8bUps3b3aNGjXKnE+PGxMTY55bWlrq83cMAAB3LfR/KkZVAAAAAKpDK4G0WkyroLSKDwAAVA89pQAAAAAAAOA4QikAAAAAAAA4jlAKAAAAAAAAjqOnFAAAAAAAABxHpRQAAAAAAAAcRygFAAAAAAAAxxFKAQAAAAAAwHH+zp8SzdH+/fvlzz//lPbt20uLFi0aejgAAAAAAKCeaPvykpIS6datm/j5VV4PRSgFR2ggFRkZ2dDDAAAAAAAADvntt9/k0EMPrXQ7oRQcoRVS1hcyODi4oYcDAAAAAADqyY4dO0xhipUFVIZQCo6wpuxpIEUoBQAAAABA03eg9j00OgcAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOM7f+VOiOes1bZH4BbZp6GEAAAAAAHDQyp8xXJoDKqUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5QCgAAAAAAAI4jlAIAAAAAAIDjCKUAAAAAAADgOEIpAAAAAAAAOI5Qqp7k5+dLixYtZO3atY6fOzc315x7+/btjp8bAAAAAACgOgilcFAFagAAAAAAoHkglDqIuFwu2bt3b0MPAwAAAAAAoN412lCqtLRUJk+eLOHh4dK6dWs54YQTZOXKlR7T1z744APp3bu32X788cfLt99+63GMJUuWyMCBAyUoKEgiIyPN8f799197e3R0tNx7770yZswYad++vRx22GEyZ84cn8b5ww8/SHJyshlDr169ZPHixfY2a5wLFy6Ufv36SWBgoBnTzz//LCNGjJAuXbpIu3bt5Nhjj5WcnJwKr//mm28249bnxcbGyty5c72O4b///pPTTjtNBgwYYE/pe/rpp6VHjx5mXPHx8fLYY4/Z+x9++OHmtm/fvmZ8gwcPtseblJQkbdu2lZCQEHO8zZs3+/R+AAAAAAAANOpQaurUqfLWW2/J888/L6tXrzahzLBhw+Tvv/+297nppptk1qxZJqwKCwuTM888U8rKysw2DX5OPfVUOe+882TdunUyb948EwhdffXVHufR5x9zzDGyZs0aueqqq2TixImyYcOGao9Tx3DDDTeY5/fv39+M4a+//vLY55ZbbpEZM2ZIXl6eCdF27twpp59+unzyySfmeTpOfd6vv/5qP2fUqFHy6quvyuzZs83znnzySRNglach1CmnnCL79++Xjz/+2IRJL7/8sqSnp8s999xjnqvB2x133GHeS/XVV1+ZWw3CCgoKZP78+aaC6+yzz5ZBgwaZ92v58uUyYcIEE1oBAAAAAAD4qoVL54w1MlrN1LFjR3nuuefk0ksvNes0bNLKpuuuu85UFp144ony2muvyUUXXWS2a1h16KGHmudceOGFMm7cOGnZsqUJcywaSmnoosfXCiI9nlZSvfjii2a7vlUREREyffp0SU1NPWBfJq040rBJK5qUBju67pprrjGhmlYe6TjfeecdUxlVFa2y0nNqaPbjjz9KXFycCZlOPvnkCvtax9XASV//kUceKa+88ooEBASY7Rrg3XXXXXLJJZfYz7n77rslOztbli1bZo9dA7E+ffrY719oaKg5tr5HB6KVXLpYduzYYaq6Iq97XfwC2xzw+QAAAAAANFf5M4ZLY6YZQIcOHaS4uFiCg4ObVqWUVjlpCKXTxyytWrUyU8s0iLFoZZKlU6dOJsixtn/zzTcmoNLqImvRSiutKNq0aZP9PK1csmhVkIZShYWF1R6r+xj8/f1N1ZX7GJWuc6eVUjfeeKOZXqeVTTo2fY5VKaUNyDVQO1A4pBVSGkBpFZgVSGngpu/f2LFjPV67hlK6vjL6/l1xxRXmPdKqrYcffthUUVUmMzPTfAGtRQMpAAAAAACARh1K1QUNfv73v/+ZgMdaNKj66aef5IgjjvAIu9xpMKXBVV3SHk3uNJB6++23zbS6L774wowtMTFR9uzZY7ZrD6zqGD58uHz++efy/fffe7xu9dRTT3m8du239eWXX1Z5vGeffdZM29MeWRp0de/evdLnpKWlmUTUWn777bdqjRkAAAAAADQPjTKU0tBIK3+WLl1qr9PKKe0d1bNnT3ude2Dyzz//mGlvWn2kjj76aBPWaCVR+cWqKqoL7mPQ6XurVq2yx1AZfV1alXTOOeeYMEqrs3RKnUXXaTDm3jTdG506OHr0aBkyZIgdTGnz9G7duskvv/xS4XVbDc6t179v374Kx9Tm5xo46TQ/nVKo0wK90ebrWqLnvgAAAAAAAFj8pRHSyiJtOK5NxHVamV4VLysry1xlTqelacWTuvPOO00fJA1ibrvtNuncubNp1q20z5NekU97NGl/KT2mBjfap+mRRx6ps7E++uijpqeTBlEPPvigCcf0an5V0f21ubhOk9PKLG1C7l6dpb2uNGzS42ij86OOOspcBU+nFWq/LHczZ8404dJJJ51k+kHplfa0J5ZeaVCn1WkTde399PXXX5uxTZkyxVzRUKuxPvzwQ9OHS/traU8pvfLgWWedZUItbfauVWXacB0AAAAAAKBZVEpZVUB65bzLL7/cVD1t3LhRFi1aZBqgu+9z7bXXSr9+/WTLli3y3nvv2VVA2itKK420ekqbmWsFkF6RTgOXuh6nLhocaSP1BQsWmHCsKg888IB5HTpNToMp7eOkr9Hd448/Lueff765IqAGTePHjzf9orzRMEzDKg2m9PVqCPf000+b6XhadaW9qbS/llUppb2vNOzSJvD6fmgT9jZt2sgPP/xg3nOdtqdX3ps0aZKZAgkAAAAAANAsrr53INbV57TyRxuF4+DpvM/V9wAAAAAAqBpX3wMAAAAAAADqCaFUDemV8dq1a+d1Oe200xp6eAAAAAAAAAe1Rtno/EAGDx4s9T0rMTU1tUJTcYs2CQcAAAAAAEAzC6WcoFf90wUAAAAAAAC+Y/oeAAAAAAAAHEcoBQAAAAAAAMcRSgEAAAAAAMBxhFIAAAAAAABwHKEUAAAAAAAAHEcoBQAAAAAAAMf5O39KNGffTh8mwcHBDT0MAAAAAADQwKiUAgAAAAAAgOMIpQAAAAAAAOA4QikAAAAAAAA4jlAKAAAAAAAAjiOUAgAAAAAAgOMIpQAAAAAAAOA4QikAAAAAAAA4jlAKAAAAAAAAjvN3/pRoznpNWyR+gW0aehgA0KTlzxje0EMAAAAADohKKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOO6hDqdzcXGnRooVs3769yv2io6PloYcecmRMTp4LAAAAAACgqTqoQqnBgwfLddddZz9OTk6WgoIC6dChg3n83HPPSUhISAOOsHnLz883IeHatWsbeigAAAAAAKCRO6hCqfICAgIkIiLCBCFN2Z49exp6CAAAAAAAAM0zlLriiitk8eLF8vDDD5sQShetjLKm7+lUviuvvFKKi4vt7RkZGV6PpfuPGzdOwsLCJDg4WE466ST55ptvqj2W9957T4499lhp3bq1dO7cWc455xyP7f/995+MGTNG2rdvL4cddpjMmTPHY/vNN98s3bt3lzZt2khMTIzccccdUlZWZm/Xcffp00eefvppOfzww815DmT//v2SlZUlsbGxEhgYaM57zz332NvXr19vXmdQUJCEhobKhAkTZOfOnZVWoamzzz7bvO/uUxPvvffeSl+bjlX17dvXvP96TAAAAAAAgEYdSmkY1b9/fxk/fryZsqdLZGSkx1Q+7eWkIZO1/cYbb/R6rAsuuEAKCwtl4cKFsmrVKjn66KNlyJAh8vfffx9wHB988IEJoU4//XRZs2aNfPLJJ5KUlOSxz6xZs+SYY44x26+66iqZOHGibNiwwd6ugY4Gat9//715XU899ZQ8+OCDHsfYuHGjvPXWWzJ//vxqTYdLS0uTGTNmmIBLj/vKK69Ily5dzLZ///1Xhg0bJh07dpSVK1fKG2+8ITk5OXL11VeLr6p6bV999ZW51WPr+69jr0xpaans2LHDYwEAAAAAALD4y0FC+0bpdD2tLtIpe+qHH36wt+s23UcrdKzt3ixZssSEJxpKaUWRmjlzprzzzjvy5ptvmgqiqmj10cUXXyzTp0+31x111FEe+2hgpYGNVRWlgdNnn30mcXFxZt3tt9/uUX2k4dlrr70mU6dO9Ziy98ILL5hqrgMpKSkx4dYjjzwio0ePNuuOOOIIOeGEE8x9Dah2795tjte2bVuzTvc988wz5b777rPDq+qo6rVZY9VKrKo+A5WZmenxHgIAAAAAAByUlVJ1Rafp6bQ1DU7atWtnL5s2bZKff/75gM/XqiWtqqpK79697ftWSKYhmGXevHkyYMAAs17PrSHVr7/+6nGMqKioagVSKi8vz1QeVTYu3a7BmRVIKT2/Tvlzr+CqjgO9turSyi6damktv/32m8/HAAAAAAAATddBUylVVzSQ6tq1q+lBVV51rtynPZkOpFWrVh6PNbzRAEgtX75cLrvsMlMlpFPqtLpLq6R0Wpw79wCpLsZ0IH5+fuJyuTzWufe5qs5r84VWqVmVagAAAAAAAAd1pZRO0du3b1+NtyvtH7Vlyxbx9/c3TcHdF21aXp1KIe0jVVPLli0zVVC33Xab6c105JFHyubNm6U29BgaTFU2rh49epgKMe0tZVm6dKkJoqwphVqVpX2gLPo+fvvttz6NQ99/67kAAAAAAABNJpTS/ksrVqyQ/Px8KSoqqlCho9u1EkrDGd2uV8Er7+STTzYN0/XKch999JE5lgZFGhJ9/fXXBxzDtGnT5NVXXzW3Oi1Or2qnfZl8CZB0qp5WR+l0wdmzZ8vbb78ttaFX59P+TtqTSvtG6XG//PJLmTt3rtmulVm6j/ab0qBJe0Bdc801cvnll9v9pPTKfNrEXRft1aUNzPUqhb4IDw834diHH34oW7duNdPyAAAAAAAAGn0opQ3BW7ZsKT179jSVPeX7MOkV+FJTU+Wiiy4y27OysiocQ6ebZWdnS0pKilx55ZXSvXt307hcq5Wq0/B78ODB5up1CxYskD59+pgwx7rqXHWcddZZcv3115sr3+nzNRDTK+bVlh7jhhtukPT0dFMZpe+B1etJm8MvWrTIXF3w2GOPlfPPP9/0n9Jm55YxY8aY0GrUqFEyaNAgiYmJkRNPPNGnMWj1mYZsTz75pHTr1k1GjBhR69cFAAAAAACapxau8o2GgHqwY8cO018r8rrXxS+wTUMPBwCatPwZwxt6CAAAAGjGdvx/GYDOsAoODm4clVIAAAAAAABoHppdKJWQkCDt2rXzurz88ssNMiadpljZmHQpP40RAAAAAACgsfOXZkb7TZWVlXndVp2eU/VB+zOtXbu2yu0AAAAAAABNSbMLpaKiouRgow3EY2NjG3oYAAAAAAAAjml20/cAAAAAAADQ8AilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4Dh/50+J5uzb6cMkODi4oYcBAAAAAAAaGJVSAAAAAAAAcByhFAAAAAAAABxHKAUAAAAAAADHEUoBAAAAAADAcYRSAAAAAAAAcByhFAAAAAAAABxHKAUAAAAAAADH+Tt/SjRnvaYtEr/ANg09DOCgkj9jeEMPAQAAAAAcR6UUAAAAAAAAHEcoBQAAAAAAAMcRSgEAAAAAAMBxhFIAAAAAAABwHKEUAAAAAAAAHEcoBQAAAAAAAMcRSgEAAAAAAMBxhFIAAAAAAABwHKEUAAAAAAAAHEcoBQAAAAAAAMcRSgEAAAAAAMBxhFI+aNGihbzzzjvSVDX11wcAAAAAAA4ehFJeZGRkSJ8+fSqsLygokNNOO61BxgQAAAAAANCU+Df0ABqTiIgIaYr27NkjAQEBDT0MAAAAAADQjByUlVL//vuvjBo1Stq1ayddu3aVWbNmyeDBg+W6666rdJpZSEiIPPfcc/bj3377TS688EKzvlOnTjJixAjJz8+3t+fm5kpSUpK0bdvW7DNgwADZvHmzOcb06dPlm2++MefRxTpu+fOuX79eTjrpJAkKCpLQ0FCZMGGC7Ny5095+xRVXyNlnny0zZ840r0P3mTRpkpSVlVXrfYiOjpa7777bfi+ioqJkwYIFsm3bNvN6dF3v3r3l66+/tp/z119/ySWXXCKHHHKItGnTRhITE+XVV1/1OK6+l1dffbV5Pzt37izDhg3zev5p06aZca9bt848fuyxx+TII4+U1q1bS5cuXeT888+v1usAAAAAAABoFKHUTTfdJIsXL5Z3331XPvroIxMgrV69utrP19BHg5b27dvLF198IUuXLjUBzqmnnmqqgvbu3WvCokGDBpnAZfny5SZQ0tDpoosukhtuuEESEhLMdD1ddJ234EzP0bFjR1m5cqW88cYbkpOTY8Ied5999pn8/PPP5vb55583AZd7eHYgDz74oAnM1qxZI8OHD5fLL7/chFQjR44078kRRxxhHrtcLrP/7t27pV+/fvLBBx/It99+a16XPuerr77yOK6ORauj9L154oknPLbpsa655hp54YUXzPtnBV+TJ0+WO++8UzZs2CAffvihpKSkVDru0tJS2bFjh8cCAAAAAABw0E7f00qjuXPnyksvvSRDhgyxA5RDDz202seYN2+e7N+/X55++mkTNKlnn33WVERpwHXMMcdIcXGxnHHGGSbUUT169LCfrwGWv79/ldP1XnnlFRMAaXCj1VbqkUcekTPPPFPuu+8+U0mkNLTS9S1btpT4+HgTLH3yyScyfvz4ar2W008/Xf73v/+Z++np6fL444/LscceKxdccIFZd/PNN0v//v1l69atZrxaIXXjjTfaz9dwadGiRfL666+byjCLVjxlZWVVOJ8Gdhp4aQi2ZMkSczz166+/mtep75mGfVq11bdv30rHnZmZaSrOAAAAAAAAGkWllFYVaTXTcccdZ6/T6XdxcXHVPoZOvdu4caMJTzRg0kWPoSGSHl/v69Q6rXTSEOnhhx82FVG+yMvLk6OOOsoOpJRWNGkYppVEFq240kDKotPhCgsLq30erVKyWEGXTskrv8465r59++Suu+4y++jr1NeuoZSGSu60msqb66+/XlasWCGff/65HUipU045xQRRMTExpvLq5Zdflv/++6/ScaelpZngz1p0OiUAAAAAAMBBG0pVh1Y/WdPVLO59mrTaSkOXtWvXeiw//vijXHrppXbllE7bS05ONpVV3bt3ly+//LLOx9qqVasKY9fgqibPt6q+vK2zjnn//febkE0rqHTKoL5uDd806HPnHqa50/Dpjz/+MEGWOw34dLqg9qfSYE2rtjSU2759u9fjBAYGSnBwsMcCAAAAAABw0IZSOp1OQxet1rH8888/JlCyhIWFeVQ2/fTTTx5VO0cffbRZFx4eLrGxsR5Lhw4d7P10+plW9Cxbtkx69eplpuQp7bWkFUdV0el+WpGlvaUs2p/Jz8/Pp6quuqZj0CboOgVPQyOtbHJ/7w7krLPOMu/DuHHj5LXXXvPYplMaTz75ZDPtT3txaeP4Tz/9tB5eBQAAAAAAaOoOulBKp5uNHTvWNDvXwEObdetUOw17LHrFO+3TpH2PtAF3amqqR/XQZZddZq4qp+GMNuretGmT6SWljbp///1381jDKK2U0ivuaTN1DbGsvlJ61TvdR6uMioqKTNPu8vQcehW60aNHmzFqVZL2b9KpbdaUuoagvaI+/vhjE7TpFEPtR6X9pnxxzjnnyIsvvihXXnmlvPnmm2bd+++/L7Nnzzbvib5n2ktLq7MaMoADAAAAAACN10HX6NyagqZT8LTfk04b06vhaV8iy6xZs0xgMnDgQOnWrZuZrrZq1Sp7e5s2bUxPJJ3Cdu6550pJSYnpj6SN03Ua2a5du+SHH34wDdT/+usvMx1t0qRJdkPx8847T+bPny8nnniimZ6mU/00GHOn59Apbtdee61pPK6P9XkPPPCANKTbb79dfvnlFzNlT8ekV9/TKw26v3/Vcf7555vQSUM2DQS16kzfk4yMDNObS8MvncqnPbMAAAAAAAB81cJVvjnTQWrw4MHSp08feeihhxp6KKiBHTt2mKmTkde9Ln6BbRp6OMBBJX/G8IYeAgAAAADUeQagBTJV9Zg+6KbvAQAAAAAAoOkjlGog2utK+2dVtgAAAAAAADRlB2VPKW+0UXlTcswxx5im4QAAAAAAAM1RowmlmpqgoCCJjY1t6GEAAAAAAAA0CKbvAQAAAAAAwHGEUgAAAAAAAHAcoRQAAAAAAAAcRygFAAAAAAAAxxFKAQAAAAAAwHGEUgAAAAAAAHCcv/OnRHP27fRhEhwc3NDDAAAAAAAADYxKKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4/ydPyWas17TFolfYJuGHgZwUMifMbyhhwAAAAAADYZKKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAACOI5QCAAAAAACA4wilAAAAAAAA4DhCKQAAAAAAADiOUAoAAAAAAADNO5SKjo6Whx56SA5WgwcPluuuu06aqqb++gAAAAAAwMHDv6EHcDDKzc2VE088Uf755x8JCQmx18+fP19atWrVoGMDAAAAAABoCgilfNCpUydpivbs2SMBAQENPQwAAAAAANCM+Dx9b//+/ZKZmSmHH364BAUFyVFHHSVvvvmmuFwuOfnkk2XYsGHmvvr777/l0EMPlfT0dPv57733nhx77LHSunVr6dy5s5xzzjmVnuuBBx6QxMREadu2rURGRspVV10lO3futLc/99xzppLp/fffl7i4OGnTpo2cf/758t9//8nzzz9vpgN27NhRJk+eLPv27bOf9+KLL8oxxxwj7du3l4iICLn00kulsLDQbMvPzzdVUkqf26JFC7niiiu8Tm/TSqpRo0aZ/fTcp512mvz0008Vxrdo0SLp0aOHtGvXTk499VQpKCio1nut5z377LPl3nvvlS5duphj3XnnnbJ371656aabTEim7++zzz7r8bybb75ZunfvbsYUExMjd9xxh5SVldnbMzIypE+fPvL000+bz1E/C28++OAD6dChg7z88st2BVlSUpL5PHQsAwYMkM2bN1frtQAAAAAAANQqlNJA6oUXXpAnnnhCvvvuO7n++utl5MiR8vnnn5sgaOXKlTJ79myzb2pqqhxyyCF2KKUhh4ZQp59+uqxZs0Y++eQTE3JUxs/PzxxLz6PH/vTTT2Xq1Kke+2gApfu89tpr8uGHH5rgRM+RnZ1tFg2gnnzySROcWTSgueuuu+Sbb76Rd955xwRRVvCk4ddbb71l7m/YsMEESA8//LDX8elzvv76a1mwYIEsX77chHH62twDIB3fzJkzzTj0Pfr111/lxhtvrPb7ra/5zz//NM/VkG7atGlyxhlnmCBsxYoV5j3+3//+J7///rv9HA3bNBD7/vvvzdifeuopefDBBz2Ou3HjRvM6dUri2rVrK5z3lVdekUsuucQEUpdddpkJwjQgGzRokKxbt8683gkTJpjQDgAAAAAAwFctXFZZUzWUlpaa6pycnBzp37+/vX7cuHEmfNEg44033jDVQ1pR9H//938mfDryyCPNfsnJyaZy56WXXvJ6fK1s0udV1mxbgyUNYYqKisxjDV6uvPJKE7AcccQRZp1u1wBo69atpjJJaXWSHluDNG80WNLqrZKSEvOcynpKaaWUVhhpM3atiNJqpKVLl5rXpf766y8TammAdsEFF3gd32OPPWaqnbZs2XLA91tDLx3LL7/8YgI6FR8fL+Hh4SakUloBptVMWvV08cUXez2OhmIa2unrtCqltPrqjz/+kLCwsAqvTz+v2267Td59910TQllVb6GhoWY81roDfVd0sezYscO8N5HXvS5+gW0O+HygOcifMbyhhwAAAAAAdU4zAM0qiouLJTg4uG56Smm4ouHTKaecUqEnUd++fc19DWPefvttmTFjhjz++ON2IKW0Imf8+PHVPp+GX1qZ9cMPP5gXpNU6u3fvNmPQqWlKb63AR+k0Nw2grEDKWmdNz1OrVq0ywYxWSmnwpFMSlVYx9ezZs1pjy8vLE39/fznuuOPsdRra6DRC3WYpP76uXbt6jOVAEhIS7EDKei29evWyH7ds2dKc1/2Y8+bNM9VjP//8s5nuqO9b+S9BVFSURyDlHvzpsTRs06DOomGkhmQ6PVM/f52qeeGFF5rX441+btOnT6/26wQAAAAAAM2LT9P3rH5OOg1PAyZr0Wli1vQ4DYw09NGwxL2/ktIeVNWlU+p0mlrv3r3NNDM95qOPPmqHYJbyV8PT6WTe1lnB07///muCFQ1pdGqaTjfUEK38ceuKt7H4UJzm8+vTaXU63U6nEWqvLa1U06qn8q9N+0J5o+GihlXPPPNMhXFq7yo9vlaGafCllWJffvml1+OkpaWZRNRafvvtt2q/ZgAAAAAA0PT5VCmlVUSBgYGmoqiyKVw33HCDqexZuHChCUaGDx8uJ510ktmmAZP2kdIpbQeiIZQGLbNmzbIrhV5//XWpLa260ml2Wsml08mUNa3NYl2Jzr05ennauFwrkLSvk/v0Pe1DVd1qq/qwbNkyUwWlQZTFl2bkWtWl77lO5dNg8ZFHHqkQWumioZNO4dQpm8cff3yF4+j3RBcAAAAAAIBah1LaQFubdGtzcw2MTjjhBFMFo1O9tPJIr6anFTZaTXP00UebK8SNHj3aNMbWxtzapHvIkCEm+ND+RxrqaDNyvVpcebGxsaZhuPalOvPMM805KusJ5YvDDjvMhE56XO0/9e2335qm5+401NHqI6000mBNK7zcpwMqnZY4YsQIMx1RG6nre3PLLbeYxu66vqHouDQ01B5SOv1Oq9qsSrDq0gqozz77zARTOkVRe2ht2rRJ5syZI2eddZZ069bNhG9aCaf9wwAAAAAAAOr96nsa4Nxxxx2mZ5BWC2kTcQ0+tI/T2LFjTa8mDaSU9hTSHkga/igNObQRul6tThtqawXVV1995fU8Rx11lLna3H333Wd6KOlUOz1nbenUNG1AruPQiiatmNJG4O40WNKxa8ik47/66qu9Hkuns/Xr189MM9SqIZ3upiFb+el1TtLQSENDHbO+x1o5pZ+Xr7Q3ll7579VXXzXVb9obS6vMzjvvPBNa6ZX3Jk2aZK78BwAAAAAAUK9X3wNq23mfq+8B/z+uvgcAAACgOV99z+dKKQAAAAAAAKC2CKUakPapqmz54osvGnp4AAAAAAAAB0ejc9SttWvXVrpN+1oBAAAAAAA0VYRSDUivMAgAAAAAANAcMX0PAAAAAAAAjiOUAgAAAAAAgOMIpQAAAAAAAOA4QikAAAAAAAA4jlAKAAAAAAAAjiOUAgAAAAAAgOP8nT8lmrNvpw+T4ODghh4GAAAAAABoYFRKAQAAAAAAwHGEUgAAAAAAAHAcoRQAAAAAAAAcRygFAAAAAAAAxxFKAQAAAAAAwHGEUgAAAAAAAHAcoRQAAAAAAAAcRygFAAAAAAAAx/k7f0o0Z72mLRK/wDYNPQw0Ifkzhjf0EAAAAAAANUClFAAAAAAAABxHKAUAAAAAAADHEUoBAAAAAADAcYRSAAAAAAAAcByhFAAAAAAAABxHKAUAAAAAAADHEUoBAAAAAADAcYRSAAAAAAAAcByhFAAAAAD8P+3dCZiN9fvH8XsYOzP2rew72bdoQSJkSxcl2RKphLTxsxOpbKWUKFuiRYnslJKdyJKGMEiWkLXsz/+67/91zjVnzIyZmnnOzDnv13Wd38x59u/z/Z1p5uP+fh8AgOsIpQAAAAAAAOA6QqkE6tSpk7Rs2dLflwEAAAAAAJCiJatQqm7dutK7d+9kf8xgVrhwYRk/fry/LwMAAAAAAKRwySqUClaO48i1a9f8fRkAAAAAAADBF0rpsLjvv/9e3nrrLQkJCbFXZGSk7Ny5Uxo3biyZM2eWPHnySPv27eXkyZO2z6pVqyRt2rSyevVq73HeeOMNyZ07txw/fjzWY97Krl27pGnTphIWFiZZsmSRe+65R/bt2+ezzejRoyVfvnySI0cOefbZZ+Xq1avedTNnzpRq1arZvnnz5pXHHntMTpw44V2v163XsnjxYqlataqkS5dOfvzxx1te14IFC6R69eqSPn16yZkzpzz00EPedX/99Zd06NBBsmXLJhkzZrR7tnfvXu/6IUOGSKVKlXyOpxVPWvkUfWhibG3TqrODBw/K888/772fAAAAAAAAKTqU0uCoVq1a0rVrVzl69Ki9NNS57777pHLlyrJ582ZZsmSJhU1t2rTxGZqnQdXZs2dl69atMnDgQJkyZYoFWDEds0CBAnFex5EjR+Tee++1oOjbb7+VLVu2yBNPPOFTyfTdd99ZSKVfp0+fLtOmTbOXh4Y4w4cPl59//lnmzZtnQZgGPtH17dtXRo0aJbt375YKFSrEeV0LFy60EKpJkybWzpUrV0qNGjW86/X4eo/mz58v69ats+or3TZqWBYfcbXtyy+/lNtvv12GDRvmvZ+xuXz5spw7d87nBQAAAAAA4BEqyUR4eLhVPWmVj1YXqVdffdUCqZEjR3q3++ijjyxY2rNnj5QsWdK2Wb58uXTr1s2qqjp27CjNmzeP9Zi38u6779p+c+bMkTRp0tgyPU9UWo30zjvvSOrUqaV06dLy4IMPWkik4ZfSEMujaNGi8vbbb1uF04ULF6ziy0PDnQYNGsTrukaMGCGPPvqoDB061LusYsWK9lUrojSMWrNmjdSuXduWzZo1y+6ThmKtW7eO1zlu1bbs2bPbck8FWFxee+01n2sFAAAAAABIlpVSMdFKI63Y0SDH89KgRHmG02nopAHM3Llz5dKlSzJu3Lj/dM5t27bZcD1PIBWTcuXKWTjjoUPdog7P0+qqZs2aScGCBS3AqVOnji0/dOiQz3F0iF9Crqt+/foxrtNKq9DQUKlZs6Z3mQ69K1WqlK1LiFu1Lb769etn1Wue1+HDhxN8DAAAAAAAELiSTaVUTLSySMOd119//aZ1GpZ4rF271r6ePn3aXpkyZfrX58yQIcMtt4keWOncSjdu3LDvL168KA888IC9NCzLlSuXhVH6/sqVKz77JeQ643NdcUmVKpUN6YsqpqF9cbUtIXT4o74AAAAAAACSfaWUVj1dv37d+75KlSo26bhOxl28eHGflyfQ0YopnXh78uTJVimkw/eihijRj3krOreTTpye0LmYPH799Vc5deqUzRWlFVda2fVvKo1iui4dRheTMmXK2JxXGzZs8C7Ta4iIiJCyZcvaew3Hjh075hNMafVVQiX0fgIAAAAAACT7UErDJw1WdGJwfcKePvlNK5/atm0rmzZtsgBq6dKl0rlzZwtG9PX4449bFZIumzp1qmzfvl3GjBkT6zFvVfXTo0cPm5Rb52/SicN1viZ9mp4GPPGhQ/Y0uJkwYYLs37/f5nrSSc//q8GDB8vs2bPtqw7J27Fjh7eCrESJEtKiRQub90mf4qfDHvW+3HbbbbbcMyn8n3/+aU8n1Puoc2fp0/8SSu/nDz/8YBPCe56CCAAAAAAAkKJDqRdffNHmM9LqHq3s0eFuOnm3hk8NGzaU8uXL29P2smbNasPRdPLvgwcPyqRJk7xD+j744AMZMGCABTMxHTP6vE7R6VxM+tQ9HTqoc0FVrVrVqrDimmMqKj2HPq3u888/t3NqxdTo0aP/873RUEmPqSFXpUqV7KmEGzdu9K7XQE6vtWnTpvbEQa2IWrRokfe6tZpq4sSJFkbpBOm6r96bhNLJ2TXgK1asmLUVAAAAAADg3whxok80BCQBrT7TpxoW6P2ZpEqX0d+XgwASOepBf18CAAAAACCGDEAffBYWFiYpolIKAAAAAAAAwSHoQqnu3btL5syZY3zpOn8pV65crNelT/EDAAAAAAAIJKESZHROpNjmUoqrpCyp6fxPsT3xL0+ePK5fDwAAAAAAQFIKulAqd+7c9kpuChUq5O9LAAAAAAAAcE3QDd8DAAAAAACA/xFKAQAAAAAAwHWEUgAAAAAAAHAdoRQAAAAAAABcRygFAAAAAAAA1xFKAQAAAAAAwHWh7p8SwWzn0AckLCzM35cBAAAAAAD8jEopAAAAAAAAuI5QCgAAAAAAAK4jlAIAAAAAAIDrCKUAAAAAAADgOkIpAAAAAAAAuI5QCgAAAAAAAK4jlAIAAAAAAIDrQt0/JYLZHYOXSqp0GSWlihz1oL8vAQAAAACAgEClFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcB2hFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcB2hFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdSkmlIqMjJSQkBDZtm1biriGVatW2bZnzpwRt02bNk2yZs3q+nkBAAAAAAACLpSCe/wZqAEAAAAAgOBAKJWMXL9+XW7cuOHvywAAAAAAAAi+UEpDmTfeeEOKFy8u6dKlk4IFC8qIESNi3Pb777+XGjVq2Hb58uWTvn37yrVr17zrv/jiCylfvrxkyJBBcuTIIffff79cvHjRu37KlClSpkwZSZ8+vZQuXVomTpzoc/yNGzdK5cqVbX21atVk69atCW7PmjVrpEKFCnaMO++8U3bu3HnTMLv58+dL2bJlrR2HDh2STZs2SYMGDSRnzpwSHh4uderUkZ9++snnuFrF9NRTT0mePHns2HfccYd88803MV7Dn3/+adf/0EMPyeXLl+0ev/baa1KkSBG7NxUrVrR75RmiWK9ePfs+W7ZsVjHVqVOneN1PAAAAAACA+AqVZKZfv34yefJkGTdunNx9991y9OhR+fXXX2/a7siRI9KkSRMLTGbMmGHbdO3a1QKaIUOG2H5t27a1gEvDmPPnz8vq1avFcRzbf9asWTJo0CB55513LHjSwEn3z5Qpk3Ts2FEuXLggTZs2tXDo448/lgMHDkivXr0S3J6XXnpJ3nrrLcmbN6/873//k2bNmsmePXskTZo0tv7vv/+W119/3QIyDXpy584t+/fvt2uYMGGCXe+YMWOsrXv37pUsWbJYqNS4cWNrk15bsWLF5JdffpHUqVPfdP7Dhw9bGzQQ+/DDD20bDfl0v/fff19KlCghP/zwgzz++OOSK1cuu+dz586Vhx9+WCIiIiQsLMxCqFvdz+g0/NKXx7lz5xJ87wAAAAAAQOBKVqGUBh0a4GhQpKGM0sBFgxKt4IlKq5oKFChg22o1j1Y6/fHHH/LKK69Y2KQhilZNtWrVSgoVKmT7aJWPx+DBgy3s0fVKq4Y02Jk0aZKd+5NPPrHwR4McDbrKlSsnv//+uzz99NMJapOeR0MhNX36dLn99tvlq6++kjZt2tiyq1evWlu0Wsnjvvvu8znGBx98YBVVWhmmQdmKFSusimv37t1SsmRJ26Zo0aI3nVtDJT23hkjjx4+3+6RB0ciRI+0YtWrV8u77448/Wtu1Kit79uy2XAMyz4Tp+/bti/N+RqeVWEOHDk3QvQIAAAAAAMEjWQ3f05BFQ5P69evHa1sNVTRo8bjrrruswknDIw159DganLRu3dqqr/766y/bToecacjSpUsXyZw5s/f16quv2nLP8T3D7jw8IU5CRN1Hw55SpUrZsT3Spk1r54nq+PHjVrWlVUw6fE+rlbRdOrRP6dP/NNzyBFIx+eeff+See+6xEEmDPs99+u2336w6S8OqqG3XajNP22MS1/2MreLt7Nmz3pdWbAEAAAAAACTLSikdJpZYdJja8uXLZe3atbJs2TIbCte/f3/ZsGGDZMyY0bbRYKVmzZo37ed2m6MGa0ortU6dOmVhklYl6VxTGm5duXLFu8+t6D4655POM6VDCG+77TZbruGWWrhwoXdZ1H3+zf3UKrOYzh/X8QAAAAAAQHBLVpVSWhmkgcvKlStvua1OUL5u3TqfOY10UnGdc0mriJSGPVo9pcPIdM4orUrSoXM6OXj+/Plt7iadUD3qyxOw6PG3b98uly5d8h5//fr1CW5T1H20skjnk9Jjx0Xb0bNnT5tHSocNarhz8uRJ73qtrNJqMD1WbFKlSiUzZ86UqlWr2sTlOrRRRZ1QPXrbdTik0vvkeRpgVLHdTwAAAAAAgBRdKaVD5XROqJdfftkCDw1A9Mlxu3btumlI3zPPPGPzJD333HPSo0cPmz9J52/q06ePBTJawaPhVsOGDW1uJH2vx/IEQhqsaPCjw+MaNWpkwwY3b95swZEe47HHHrNKIB1Gp0PRdE6r0aNHJ7hNw4YNswnMNQjT4+kT9Vq2bHnLcE4DJX1ink4QrpVOUaujdN6ne++91yYjHzt2rAVKOtG7hkbalqjVTTqhu05QrvNUrVq1yiZcf/HFF+X555+3ObN0vi4dXqdBmA4T1Cotrc7SY2mVlQZjem7tg7juJwAAAAAAQIqtlFIDBw6UF154wSYr18DjkUcekRMnTty0nQ49W7RokU34rfMdde/e3eaIGjBggK3XgEWfKqehis69pMt1YnN9ap168skn7Yl3U6dOtXmSNOiZNm2at1JK51lasGCB7Nixw57Op4GSPiUvoUaNGmVP7dOKpWPHjtkxPZVIsdHJ1TUcq1KlirRv397CMw2CotIn5FWvXt0CJ61+0iAvemWTCg0NldmzZ1vFlQZTei+HDx9u91knI9d7rEGWDufztF3vrYZ2ffv2tTBNQ79b3U8AAAAAAICECHGijn8DkohWfGlVWoHen0mqdP8/p1dKFDnqQX9fAgAAAAAAKSID0JFZWuSSYiqlAAAAAAAAEPgIpf4lHS6oQ/xieuk6AAAAAAAApJCJzlMSncBcJwyPSVylaQAAAAAAACCU+td04vHok48DAAAAAAAgfhi+BwAAAAAAANcRSgEAAAAAAMB1hFIAAAAAAABwHaEUAAAAAAAAXEcoBQAAAAAAANcRSgEAAAAAAMB1oe6fEsFs59AHJCwszN+XAQAAAAAA/IxKKQAAAAAAALiOUAoAAAAAAACuI5QCAAAAAACA6wilAAAAAAAA4DpCKQAAAAAAALiOUAoAAAAAAACuI5QCAAAAAACA6wilAAAAAAAA4DpCKQAAAAAAALiOUAoAAAAAAACuI5QCAAAAAACA6wilAAAAAAAA4DpCKQAAAAAAALiOUAoAAAAAAACuI5QCAAAAAACA6wilAAAAAAAA4DpCKQAAAAAAALiOUAoAAAAAAACuI5QCAAAAAABAygyl6tatK7179xa3FS5cWMaPHy/+tGrVKgkJCZEzZ87Y+2nTpknWrFl9tvnggw+kQIECkipVKu/1xrQMAAAAAAAgWAR1pVRShGmPPPKI7Nmzx/v+3Llz0qNHD3nllVfkyJEj0q1btxiXAQAAAAAABJNQf5z0ypUrkjZtWglEGTJksJfHoUOH5OrVq/Lggw9Kvnz5bNnOnTtvWvZv6DHSpEmTKNcNAAAAAACQIiulrl27ZtU/4eHhkjNnThk4cKA4juMdZjd8+HDp0KGDhIWFeSuDtFKoZMmSkjFjRilatKjto0FLVAsWLJDq1atL+vTp7bgPPfRQrNcwZcoUGzq3cuVKb/jTuHFjyZw5s+TJk0fat28vJ0+etHWdOnWS77//Xt566y0bfqevyMjIW7Zz0aJFds0aPNWrV++mfaIO39Pvy5cvb99r+/QcMS3zHOPrr7+WKlWqWFt13dChQ+2+eui27733njRv3lwyZcokI0aMiPd+em/03um9LlGihMyfP9/nunft2iVNmza1/smSJYvcc889sm/fPp97W6ZMGTtH6dKlZeLEibe8VwAAAAAAAEkeSk2fPl1CQ0Nl48aNFvSMHTvWggyP0aNHS8WKFWXr1q0WPikNPzSk+eWXX2yfyZMny7hx47z7LFy40IKUJk2a2H4aNtWoUSPG87/xxhvSt29fWbZsmdSvX9/meLrvvvukcuXKsnnzZlmyZIkcP35c2rRpY9vr+WrVqiVdu3aVo0eP2kvneIrL4cOHpVWrVtKsWTPZtm2bPPnkk3bOuIbyrVixwr7X+6LnaN269U3L9LyrV6+20K5Xr152PyZNmmT3xhM8eQwZMsTuyY4dO+SJJ56I934aVGnbt2/fbvezXbt2cvr0aVunQwjvvfdeSZcunXz77beyZcsWO7Yn2Jo1a5YMGjTIjrl7924ZOXKk9aH2eWwuX75swxSjvgAAAAAAALycRFCnTh2nTJkyzo0bN7zLXnnlFVumChUq5LRs2fKWx3nzzTedqlWret/XqlXLadeuXazb63HHjRvnvPzyy06+fPmcnTt3etcNHz7cadiwoc/2hw8f1tItJyIiwnvdvXr1inc7+/Xr55QtW9ZnmbZTj/nXX3/Z+6lTpzrh4eHe9Vu3brX1Bw4ciHNZ/fr1nZEjR/oce+bMmdYuD92nd+/ePtvEd78BAwZ431+4cMGWLV682NuuIkWKOFeuXImx3cWKFXM++eQTn2V6f7V/YjN48GA7R/TX2bNnY90HAAAAAACkfPq3f3wygESbU+rOO++0YWIeWoU0ZswYuX79ur2vVq3aTft8+umn8vbbb9swsQsXLlhljg4f89BqJK1kioue4+LFi1YNpUPXPH7++Wf57rvvbOhedHo+HYKXUFolVLNmTZ9l2s7EoNe7Zs0anwonvXeXLl2Sv//+24bdxXQf47tfhQoVvOt16J/e5xMnTnjvsw7Xi2l+Kr23er+6dOni0xfaVzpUMzb9+vWTPn36eN9rpdStKtEAAAAAAEDwcG2icw1Colq3bp0NIdNhZQ888IAFHHPmzLGQySPqhOGx0TBFh/l99tlnPkPpNOTSYXavv/76Tfv8l8nFk4per94LHR4Ync7jFNt9jO9+0QMnDRBv3Lhxy/usx1c6tDJ6IJc6depY99OhgPoCAAAAAABI0lBqw4YNPu/Xr19vE2rHFlysXbtWChUqJP379/cuO3jwoM82Wt2j80h17tw51vPqHFM6wXqjRo1sTqsXX3zRluvE33PnzrVJ1nV5TPQJgJ5KrvjQib6jTxCu7UwMer0RERFSvHhxV/aLfp91fqiYnuanE8Tnz59f9u/fbyEiAAAAAABAspro/NChQzZcSwOS2bNny4QJE2zy7dhoYKX7aHWUDg/TYXxfffWVzzaDBw+2Y+lXHTqnk3vHVPlUu3ZteyqeVgyNHz/elj377LM2kXfbtm1l06ZNdo6lS5dawOUJojSw0jBNn36nT+XzVA7Fpnv37rJ371556aWXrJ2ffPKJTSqeGHQi8RkzZlgb9El42l69NwMGDEiS/aLSUE+H1z366KM2DFLbOHPmTGuj0mO/9tpr1kd79uyxfpg6dapNZg8AAAAAAODXUEqfAPfPP/9Y5ZIGQhpIdevWLdbtmzdvLs8//7wFIpUqVbLKKc9T+Tzq1q0rn3/+uVUn6Tb6ND19Yl1M7r77bhvGp2GMBmJa3aNzLWkA1bBhQylfvrz07t1bsmbNKqlS/X+ztapKK7nKli0ruXLlspAsLgULFrTqq3nz5tmTBN9//317El1i0CGM33zzjT09sHr16jZHlz6JUKvJkmK/qHLkyGFP3dOhenXq1JGqVavacD1P1ZQ+ZVCfpKhBlN5H3UbDuCJFivzndgMAAAAAgOAUorOd+/siEPi0EkvnDTt79qzPZPYAAAAAACA4M4BEq5QCAAAAAAAA4otQKtqcUZkzZ47xpesAAAAAAACQOBi+F8WJEyesxCwmWm6WO3du168pUDB8DwAAAACA4HAunhlAqKtXlcxp6ETwBAAAAAAAkPQYvgcAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcB2hFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcB2hFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcB2hFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcB2hFAAAAAAAAFxHKAUAAAAAAADXEUoBAAAAAADAdYRSAAAAAAAAcF2o+6dEMHIcx76eO3fO35cCAAAAAACSkOdvf08WEBtCKbji1KlT9rVAgQL+vhQAAAAAAOCC8+fPS3h4eKzrCaXgiuzZs9vXQ4cOxfl/SKS89FuDxsOHD0tYWJi/LweJhH4NTPRrYKJfAxP9Gpjo18BEvwYu+va/0QopDaTy588f53aEUnBFqlT/P32ZBlJ8oAOP9in9Gnjo18BEvwYm+jUw0a+BiX4NTPRr4KJv/734FKQw0TkAAAAAAABcRygFAAAAAAAA1xFKwRXp0qWTwYMH21cEDvo1MNGvgYl+DUz0a2CiXwMT/RqY6NfARd+6I8S51fP5AAAAAAAAgERGpRQAAAAAAABcRygFAAAAAAAA1xFKAQAAAAAAwHWEUoiXd999VwoXLizp06eXmjVrysaNG+Pc/vPPP5fSpUvb9uXLl5dFixb5rNepzAYNGiT58uWTDBkyyP333y979+712eb06dPSrl07CQsLk6xZs0qXLl3kwoULSdK+YOWPfh0xYoTUrl1bMmbMaP2KlN+vkZGR9vksUqSIrS9WrJhNCnnlypUka2Mw8sfntXnz5lKwYEE7hm7Xvn17+eOPP5KkfcHKH/3qcfnyZalUqZKEhITItm3bErVd8E/f6vm0P6O+Ro0alSTtC1b++swuXLjQzqfbZMuWTVq2bJnobQtmbvfrqlWrbvqsel6bNm1KsnYGG398Xvfs2SMtWrSQnDlz2t+xd999t3z33XdJ0r6AoROdA3GZM2eOkzZtWuejjz5ydu3a5XTt2tXJmjWrc/z48Ri3X7NmjZM6dWrnjTfecH755RdnwIABTpo0aZwdO3Z4txk1apQTHh7uzJs3z/n555+d5s2bO0WKFHH++ecf7zaNGjVyKlas6Kxfv95ZvXq1U7x4cadt27autDkY+KtfBw0a5IwdO9bp06ePbYuU36+LFy92OnXq5CxdutTZt2+f8/XXXzu5c+d2XnjhBdfaHej89XnVz+q6deucyMhIO2atWrXshZTdrx49e/Z0GjdurA+8cbZu3ZqkbQ02/urbQoUKOcOGDXOOHj3qfV24cMGVNgcDf/XrF1984WTLls157733nIiICDv3p59+6kqbg4E/+vXy5cs+n1N9Pfnkk7bNjRs3XGt7IPPX57VEiRJOkyZNbP2ePXucZ555xsmYMaP1MWJGKIVbqlGjhvPss89631+/ft3Jnz+/89prr8W4fZs2bZwHH3zQZ1nNmjWdp556yr7XH7R58+Z13nzzTe/6M2fOOOnSpXNmz55t7/UHgf6SvGnTJu82+odvSEiIc+TIkURvYzDyR79GNXXqVEKpAOxXD/0Puv5HGoHVrxo46s/hK1euJEKr4M9+XbRokVO6dGn7RZ1QKnD6VkOpcePGJUGL4K9+vXr1qnPbbbc5U6ZMSaJWITn8N1b/u5orVy4LlZFy+/XPP/+0/6b+8MMP3m3OnTtny5YvX57obQwUDN9DnHT4zZYtW6w00SNVqlT2ft26dTHuo8ujbq8eeOAB7/YHDhyQY8eO+WwTHh5uJZWebfSrDu2qVq2adxvdXs+9YcOGRG9nsPFXvyJ4+vXs2bOSPXv2RGgVkku/6pDqWbNm2fDbNGnSJFLrgpc/+/X48ePStWtXmTlzpg2lRmB9ZnW4Xo4cOaRy5cry5ptvyrVr1xK5hcHJX/36008/yZEjR+xc2qc6bKhx48ayc+fOJGppcPH359Vj/vz5curUKencuXMitSy4+atf9WdvqVKlZMaMGXLx4kX7+Ttp0iTJnTu3VK1aNYlam/IRSiFOJ0+elOvXr0uePHl8lut7/VDGRJfHtb3n66220Q9vVKGhofZHbmznRfLvVwRHv/72228yYcIEeeqpp/5Te5A8+vWVV16RTJky2S9ahw4dkq+//jpR2hXs/NWvWiXfqVMn6d69u88//CAwPrM9e/aUOXPm2Pwl+jN45MiR8vLLLyda24KZv/p1//799nXIkCEyYMAA+eabb2xOqbp169o/FiBl/zfW48MPP7QA5Pbbb/9P7YF/+1XnBFuxYoVs3bpVsmTJYnNTjR07VpYsWWKfW8SMUAoAkGj0X3MbNWokrVu3tkoMpHwvvfSS/XK1bNkySZ06tXTo0MGCDaRMGhifP39e+vXr5+9LQRLo06ePhRUVKlSw4HHMmDHW5zqpPVKmGzdu2Nf+/fvLww8/bNUWU6dOtT9+dVJmpHy///67LF261B4ag5RNfz969tlnrbhi9erVNrG6PpSgWbNmcvToUX9fXrJFKIU46VMD9I8QLfWPSt/nzZs3xn10eVzbe77eapsTJ074rNfyR/0XodjOi+TfrwjsftWnstWrV8+Gd33wwQeJ0ib4v1/1/CVLlpQGDRpYBYY+iWb9+vWJ0rZg5q9+/fbbb22YQbp06awCuXjx4rZcq6Y6duyYiC0MXv7+zEalw0r09yd9SipSZr/qcD1VtmxZ73r9/BYtWtSqV5HyP68aMmo1sj7xFin/v7Fazai/L911111SpUoVmThxoj2pb/r06YnaxkBCKIU4pU2b1v5FZuXKlT7/YqPva9WqFeM+ujzq9mr58uXe7fWx8frBjbrNuXPnbK4ozzb69cyZMzYW2EM/5Hpu/QULKbNfEbj9qhVS+q/znn/B1XH7CLzPq+df7Km6SLn9+vbbb8vPP/8s27Zts5fncdeffvqpjBgxIknaGmyS02dW+1h/HkefEgEpp1/1nBpCRUREeLe5evWqBY2FChVK9HYGG39/XrWyRn9v0ipk5mtM+f36999/29fovwfre8/vUIiBv2daR8p4nKY+VWDatGn2VLxu3brZ4zSPHTtm69u3b+/07dvX53GaoaGhzujRo53du3c7gwcPjvFxmnoMfZLT9u3bnRYtWtz0OM1GjRo5lStXdjZs2OD8+OOP9njNtm3butz6wOWvfj148KA95Wno0KFO5syZ7Xt9nT9/3uU7EJj80a+///67U7x4cad+/fr2fdTHGyPl9uv69eudCRMm2OczMjLSWblypVO7dm2nWLFizqVLl/xwFwKPv34OR3XgwAGevhcgfbt27Vp78t62bducffv2OR9//LE9zatDhw5+uAOByV+f2V69etkT+JYuXer8+uuvTpcuXZzcuXM7p0+fdvkOBCZ//ixesWKF/QzW4yDl96s+fS9HjhxOq1at7GdxRESE8+KLL9px9D1iRiiFeNE/TAoWLOikTZvWHq+pf6x41KlTx+nYsaPP9p999plTsmRJ275cuXLOwoULfdbrIzUHDhzo5MmTx35Y6B+z+qGN6tSpUxZCaXARFhbmdO7cmeAiAPpVj6n/8Y3++u6775K4tcHD7X6dOnVqjH3Kv3uk7H7VX7bq1avnZM+e3dYXLlzY6d69uwWPSNk/h6MilAqcvt2yZYs9vjw8PNxJnz69U6ZMGWfkyJGEyAHwmb1y5YrzwgsvWBCVJUsW5/7773d27tyZxC0NLv76Wax/6+g/+CBw+nXTpk1Ow4YN7fcn/bzeeeedzqJFi5K4pSlbiP5PTBVUAAAAAAAAQFJh0g8AAAAAAAC4jlAKAAAAAAAAriOUAgAAAAAAgOsIpQAAAAAAAOA6QikAAAAAAAC4jlAKAAAAAAAAriOUAgAAAAAAgOsIpQAAAAAAAOA6QikAAAAAAAC4jlAKAAAgAHTq1ElatmwpyVFkZKSEhITItm3b/H0pAAAgGSGUAgAAQJK5cuWKvy8BAAAkU4RSAAAAAaZu3bry3HPPSe/evSVbtmySJ08emTx5sly8eFE6d+4sWbJkkeLFi8vixYu9+6xatcqqmRYuXCgVKlSQ9OnTy5133ik7d+70OfbcuXOlXLlyki5dOilcuLCMGTPGZ70uGz58uHTo0EHCwsKkW7duUqRIEVtXuXJlO4den9q0aZM0aNBAcubMKeHh4VKnTh356aeffI6n20+ZMkUeeughyZgxo5QoUULmz5/vs82uXbukadOmdj5t2z333CP79u3zrtf9y5QpY20qXbq0TJw4MRHvNgAA+LcIpQAAAALQ9OnTLezZuHGjBVRPP/20tG7dWmrXrm3BT8OGDaV9+/by999/++z30ksvWdCkgVGuXLmkWbNmcvXqVVu3ZcsWadOmjTz66KOyY8cOGTJkiAwcOFCmTZvmc4zRo0dLxYoVZevWrbZer0GtWLFCjh49Kl9++aW9P3/+vHTs2FF+/PFHWb9+vQVOTZo0seVRDR061M67fft2W9+uXTs5ffq0rTty5Ijce++9FpJ9++23do1PPPGEXLt2zdbPmjVLBg0aJCNGjJDdu3fLyJEj7Zr0/gAAAP8KcRzH8fM1AAAAIBHmlDpz5ozMmzfPKpGuX78uq1evtnX6vVYitWrVSmbMmGHLjh07Jvny5ZN169ZZRZRWStWrV0/mzJkjjzzyiG2jwc/tt99uoZOGQhoG/fnnn7Js2TLveV9++WWrrtJqJU+llFZEffXVVz5zSmm1lIZUlSpVirUNN27ckKxZs8onn3xilU+eSqkBAwZY9ZXSaq/MmTNblVejRo3kf//7n11zRESEpEmT5qZjakWY7tu2bVvvsldffVUWLVoka9eu/c/3HQAA/HtUSgEAAAQgHYLnkTp1asmRI4eUL1/eu0yH9KkTJ0747FerVi3v99mzZ5dSpUpZhZHSr3fddZfP9vp+7969Fnx5VKtWLV7XePz4cenatatVSGlopsPvLly4IIcOHYq1LZkyZbLtPNetk6frcL2YAikNsHQYX5cuXSzI8rw0lIo6vA8AAPhHqJ/OCwAAgCQUPaTRiqOoy/S9pzopsWlwFB86dO/UqVPy1ltvSaFChWwInoZi0SdHj6ktnuvOkCFDrMfXgEvpfFo1a9b0WadBHQAA8C9CKQAAAHjp3E4FCxa07//66y/Zs2ePTRKu9OuaNWt8ttf3JUuWjDPkSZs2rX2NWk3l2VcnHdd5otThw4fl5MmTCbperaLS+aF03qvo4ZVWg+XPn1/2799vQw8BAEDyQigFAAAAr2HDhtlQPw10+vfvb5Olt2zZ0ta98MILUr16dZujSeed0vmo3nnnnVs+zS537txW0bRkyRKbo0qfgqfD9XTY3syZM22437lz52yS9bgqn2LSo0cPmTBhgk2+3q9fPzuuBms1atSwoYc6SXrPnj1tuc5BdfnyZdm8ebMFbn369PlP9woAAPw3zCkFAAAAr1GjRkmvXr2katWqNhn6ggULvJVOVapUkc8++8wmFr/jjjvsqXYaYukk63EJDQ2Vt99+WyZNmmSVSy1atLDlH374oYVDelx9EqCGRxpgJYQGaPrUPR2qV6dOHbtuHa7nqZp68sknZcqUKTJ16lSbU0u30YnbdeJ1AADgXzx9DwAAAN6n72lIpE/AAwAASGpUSgEAAAAAAMB1hFIAAAAAAABwHcP3AAAAAAAA4DoqpQAAAAAAAOA6QikAAAAAAAC4jlAKAAAAAAAAriOUAgAAAAAAgOsIpQAAAAAAAOA6QikAAAAAAAC4jlAKAAAAAAAAriOUAgAAAAAAgOsIpQAAAAAAACBu+z8e/JN7M3lkHQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Feature importance analysis completed!\n" + ] + } + ], + "source": [ + "# Feature importance analysis\n", + "print(\"Feature importance analysis...\")\n", + "\n", + "# Get feature importance\n", + "feature_importance = full_model.feature_importances_\n", + "\n", + "# Create list of feature names\n", + "tfidf_feature_names = [f'tfidf_{i}' for i in range(tfidf_matrix.shape[1])]\n", + "all_feature_names = tfidf_feature_names + additional_features\n", + "\n", + "# Create DataFrame with feature importance\n", + "importance_df = pd.DataFrame({\n", + " 'feature': all_feature_names,\n", + " 'importance': feature_importance\n", + "}).sort_values('importance', ascending=False)\n", + "\n", + "print(\"Top-20 most important features:\")\n", + "print(importance_df.head(20))\n", + "\n", + "# Analyze importance of additional features\n", + "print(f\"\\nImportance of additional features:\")\n", + "additional_importance = importance_df[importance_df['feature'].isin(additional_features)]\n", + "print(additional_importance)\n", + "\n", + "# Visualize feature importance\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "# Top-20 TF-IDF features\n", + "top_tfidf = importance_df[importance_df['feature'].str.startswith('tfidf_')].head(20)\n", + "plt.subplot(2, 1, 1)\n", + "plt.barh(range(len(top_tfidf)), top_tfidf['importance'])\n", + "plt.yticks(range(len(top_tfidf)), [f\"TF-IDF {i}\" for i in range(len(top_tfidf))])\n", + "plt.xlabel('Importance')\n", + "plt.title('Top-20 TF-IDF Features by Importance')\n", + "plt.gca().invert_yaxis()\n", + "\n", + "# Additional features\n", + "plt.subplot(2, 1, 2)\n", + "plt.barh(range(len(additional_importance)), additional_importance['importance'])\n", + "plt.yticks(range(len(additional_importance)), additional_importance['feature'])\n", + "plt.xlabel('Importance')\n", + "plt.title('Additional Features Importance')\n", + "plt.gca().invert_yaxis()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"✅ Feature importance analysis completed!\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Validation Data Predictions\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing validation data for predictions...\n", + "Applying TF-IDF vectorization to validation data...\n", + "TF-IDF matrix size for validation: (4956, 5000)\n", + "Feature matrix size for validation: (4956, 5007)\n", + "✅ Feature sizes match!\n", + "✅ Validation data prepared for predictions!\n" + ] + } + ], + "source": [ + "# Prepare validation data for predictions\n", + "print(\"Preparing validation data for predictions...\")\n", + "\n", + "# Apply TF-IDF vectorization to validation data\n", + "print(\"Applying TF-IDF vectorization to validation data...\")\n", + "tfidf_matrix_val = tfidf_vectorizer.transform(validation_data['combined_text'])\n", + "\n", + "print(f\"TF-IDF matrix size for validation: {tfidf_matrix_val.shape}\")\n", + "\n", + "# Create DataFrame with TF-IDF features for validation\n", + "tfidf_df_val = pd.DataFrame(\n", + " tfidf_matrix_val.toarray(),\n", + " columns=[f'tfidf_{i}' for i in range(tfidf_matrix_val.shape[1])]\n", + ")\n", + "\n", + "# Prepare features for validation\n", + "X_tfidf_val = tfidf_df_val.values\n", + "X_additional_val = validation_data[additional_features].values\n", + "\n", + "# Combine all features for validation\n", + "X_combined_val = np.hstack([X_tfidf_val, X_additional_val])\n", + "\n", + "print(f\"Feature matrix size for validation: {X_combined_val.shape}\")\n", + "\n", + "# Check size compatibility\n", + "if X_combined_val.shape[1] != X_combined.shape[1]:\n", + " print(f\"⚠️ Warning: Feature sizes don't match!\")\n", + " print(f\"Training data: {X_combined.shape[1]} features\")\n", + " print(f\"Validation data: {X_combined_val.shape[1]} features\")\n", + "else:\n", + " print(\"✅ Feature sizes match!\")\n", + "\n", + "print(\"✅ Validation data prepared for predictions!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Making predictions on validation data...\n", + "Number of predictions: 4956\n", + "Predicted class distribution: [3501 1455]\n", + "✅ Predictions completed!\n", + "Final dataset size: (4956, 19)\n", + "\n", + "Prediction examples:\n", + " title \\\n", + "0 UK's May 'receiving regular updates' on London... \n", + "1 UK transport police leading investigation of L... \n", + "2 Pacific nations crack down on North Korean shi... \n", + "3 Three suspected al Qaeda militants killed in Y... \n", + "4 Chinese academics prod Beijing to consider Nor... \n", + "5 Flames raced along train at west London statio... \n", + "6 London police advise people to avoid area near... \n", + "7 London ambulance service sends hazardous area ... \n", + "8 Witness says injured in stampede at London sta... \n", + "9 UK says world will stand together against Nort... \n", + "\n", + " text label \\\n", + "0 LONDON (Reuters) - British Prime Minister Ther... 1 \n", + "1 LONDON (Reuters) - British counter-terrorism p... 1 \n", + "2 WELLINGTON (Reuters) - South Pacific island na... 1 \n", + "3 ADEN, Yemen (Reuters) - Three suspected al Qae... 1 \n", + "4 BEIJING (Reuters) - Chinese academics are publ... 1 \n", + "5 LONDON (Reuters) - Flames engulfed one carriag... 1 \n", + "6 LONDON (Reuters) - British police on Friday ad... 1 \n", + "7 LONDON (Reuters) - London s ambulance service ... 1 \n", + "8 LONDON (Reuters) - A woman at London s Parsons... 1 \n", + "9 LONDON (Reuters) - Britain said on Friday the ... 1 \n", + "\n", + " prediction_proba_0 prediction_proba_1 \n", + "0 0.000225 0.999775 \n", + "1 0.001080 0.998920 \n", + "2 0.000311 0.999689 \n", + "3 0.000137 0.999863 \n", + "4 0.000157 0.999843 \n", + "5 0.000090 0.999910 \n", + "6 0.000097 0.999903 \n", + "7 0.000137 0.999863 \n", + "8 0.000114 0.999886 \n", + "9 0.000159 0.999841 \n" + ] + } + ], + "source": [ + "# Make predictions on validation data\n", + "print(\"Making predictions on validation data...\")\n", + "\n", + "# Predictions\n", + "predictions = full_model.predict(X_combined_val)\n", + "prediction_proba = full_model.predict_proba(X_combined_val)\n", + "\n", + "print(f\"Number of predictions: {len(predictions)}\")\n", + "print(f\"Predicted class distribution: {np.bincount(predictions)}\")\n", + "\n", + "# Create copy of validation data with predictions\n", + "validation_labeled = validation_data.copy()\n", + "validation_labeled['label'] = predictions\n", + "validation_labeled['prediction_proba_0'] = prediction_proba[:, 0]\n", + "validation_labeled['prediction_proba_1'] = prediction_proba[:, 1]\n", + "\n", + "print(\"✅ Predictions completed!\")\n", + "print(f\"Final dataset size: {validation_labeled.shape}\")\n", + "\n", + "# Show prediction examples\n", + "print(\"\\nPrediction examples:\")\n", + "sample_predictions = validation_labeled[['title', 'text', 'label', 'prediction_proba_0', 'prediction_proba_1']].head(10)\n", + "print(sample_predictions)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. Save Results\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving best model: XGBoost\n", + "✅ Model saved to file: best_fake_news_classifier_xgboost.pkl\n", + "✅ Model information saved to model_info.txt\n", + "\n", + "Model ready for use! File: best_fake_news_classifier_xgboost.pkl\n" + ] + } + ], + "source": [ + "# Save best model and necessary components\n", + "print(f\"Saving best model: {best_model_name}\")\n", + "\n", + "# Create dictionary with model and components\n", + "model_package = {\n", + " 'model': full_model,\n", + " 'tfidf_vectorizer': tfidf_vectorizer,\n", + " 'model_name': best_model_name,\n", + " 'accuracy': best_accuracy,\n", + " 'feature_names': additional_features,\n", + " 'preprocessing_functions': {\n", + " 'clean_text': clean_text,\n", + " 'count_special_chars': count_special_chars,\n", + " 'count_characters': count_characters,\n", + " 'preprocess_for_vectorization': preprocess_for_vectorization\n", + " }\n", + "}\n", + "\n", + "# Save model\n", + "model_filename = f'best_fake_news_classifier_{best_model_name.lower()}.pkl'\n", + "joblib.dump(model_package, model_filename)\n", + "\n", + "print(f\"✅ Model saved to file: {model_filename}\")\n", + "\n", + "# Create model information file\n", + "model_info = f\"\"\"\n", + "Information about saved model:\n", + "================================\n", + "Model name: {best_model_name}\n", + "Model type: {type(full_model).__name__}\n", + "Test accuracy: {best_accuracy:.4f}\n", + "Creation date: {pd.Timestamp.now()}\n", + "\n", + "Model parameters:\n", + "{full_model.get_params()}\n", + "\n", + "Used features:\n", + "- TF-IDF vectorization (5000 features)\n", + "- Number of opening brackets\n", + "- Number of closing brackets\n", + "- Difference between opening and closing brackets (NEW FEATURE)\n", + "- Number of exclamation marks \n", + "- Number of question marks\n", + "- Number of characters in text\n", + "- Number of characters in title\n", + "\n", + "Model file: {model_filename}\n", + "\"\"\"\n", + "\n", + "with open('model_info.txt', 'w', encoding='utf-8') as f:\n", + " f.write(model_info)\n", + "\n", + "print(\"✅ Model information saved to model_info.txt\")\n", + "print(f\"\\nModel ready for use! File: {model_filename}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saving validation results...\n", + "✅ Validation data with predictions saved to file: dataset/validation_XGBoost_labeled_data.csv\n", + "✅ Feature importance analysis saved to file: feature_importance_analysis.csv\n", + "✅ Summary report saved to file: XGBoost_training_report.txt\n", + "\n", + "============================================================\n", + "🎉 ALL TASKS COMPLETED SUCCESSFULLY!\n", + "============================================================\n", + "📁 Main result: dataset/validation_XGBoost_labeled_data.csv\n", + "📊 Feature analysis: feature_importance_analysis.csv\n", + "🤖 Model: best_fake_news_classifier_xgboost.pkl\n", + "📋 Report: XGBoost_training_report.txt\n", + "============================================================\n" + ] + } + ], + "source": [ + "# Save validation results\n", + "print(\"Saving validation results...\")\n", + "\n", + "# Save validation data with predictions in correct format\n", + "output_filename = f'dataset/validation_{best_model_name}_labeled_data.csv'\n", + "\n", + "# Create final dataset with predictions, keeping only necessary columns\n", + "final_validation_data = validation_data[['label', 'title', 'text', 'subject', 'date']].copy()\n", + "final_validation_data['label'] = predictions # Replace original labels with predictions\n", + "\n", + "final_validation_data.to_csv(output_filename, index=False)\n", + "\n", + "print(f\"✅ Validation data with predictions saved to file: {output_filename}\")\n", + "\n", + "# Save feature importance information\n", + "importance_filename = 'feature_importance_analysis.csv'\n", + "importance_df.to_csv(importance_filename, index=False)\n", + "\n", + "print(f\"✅ Feature importance analysis saved to file: {importance_filename}\")\n", + "\n", + "# Create summary report\n", + "summary_report = f\"\"\"\n", + "Report on training {best_model_name} model on full dataset\n", + "==================================================\n", + "\n", + "Creation date: {pd.Timestamp.now()}\n", + "\n", + "Data:\n", + "- Main dataset (data.csv): {train_data.shape[0]} records\n", + "- Validation dataset: {validation_data.shape[0]} records\n", + "- Number of features: {X_combined.shape[1]}\n", + "\n", + "Model:\n", + "- Type: {type(full_model).__name__}\n", + "- Parameters: {full_model.get_params()}\n", + "\n", + "Results:\n", + "- Number of predictions: {len(predictions)}\n", + "- Class distribution: {dict(zip(*np.unique(predictions, return_counts=True)))}\n", + "\n", + "New features:\n", + "- Added 'bracket_difference' feature (difference between opening and closing brackets)\n", + "\n", + "Files:\n", + "- Validation with predictions: {output_filename}\n", + "- Feature importance analysis: {importance_filename}\n", + "- Model: {model_filename}\n", + "\n", + "Top-5 most important features:\n", + "{importance_df.head(5).to_string(index=False)}\n", + "\"\"\"\n", + "\n", + "# Save report\n", + "with open(f'{best_model_name}_training_report.txt', 'w', encoding='utf-8') as f:\n", + " f.write(summary_report)\n", + "\n", + "print(f\"✅ Summary report saved to file: {best_model_name}_training_report.txt\")\n", + "\n", + "print(\"\\n\" + \"=\"*60)\n", + "print(\"🎉 ALL TASKS COMPLETED SUCCESSFULLY!\")\n", + "print(\"=\"*60)\n", + "print(f\"📁 Main result: {output_filename}\")\n", + "print(f\"📊 Feature analysis: {importance_filename}\")\n", + "print(f\"🤖 Model: {model_filename}\")\n", + "print(f\"📋 Report: {best_model_name}_training_report.txt\")\n", + "print(\"=\"*60)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/3. models_comparison.ipynb b/3. models_comparison.ipynb new file mode 100644 index 0000000..87c408e --- /dev/null +++ b/3. models_comparison.ipynb @@ -0,0 +1,1040 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dataset Comparison and Metrics Analysis\n", + "\n", + "This notebook compares different validation datasets against the reference dataset (`df_correct_validation`) and calculates key performance metrics including precision, recall, F1-score, and confusion matrices.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.metrics import (\n", + " confusion_matrix, \n", + " classification_report, \n", + " precision_score, \n", + " recall_score, \n", + " f1_score, \n", + " accuracy_score,\n", + " roc_auc_score\n", + ")\n", + "from sklearn.metrics import ConfusionMatrixDisplay\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Set style for better plots\n", + "plt.style.use('default')\n", + "sns.set_palette(\"husl\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Reference Dataset\n", + "\n", + "The reference dataset (`df_correct_validation`) will be used as the ground truth for comparison.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference dataset shape: (4956, 5)\n", + "Reference dataset columns: ['label', 'title', 'text', 'subject', 'date']\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
labeltitletextsubjectdate
01UK's May 'receiving regular updates' on London...LONDON (Reuters) - British Prime Minister Ther...worldnewsSeptember 15, 2017
11UK transport police leading investigation of L...LONDON (Reuters) - British counter-terrorism p...worldnewsSeptember 15, 2017
21Pacific nations crack down on North Korean shi...WELLINGTON (Reuters) - South Pacific island na...worldnewsSeptember 15, 2017
31Three suspected al Qaeda militants killed in Y...ADEN, Yemen (Reuters) - Three suspected al Qae...worldnewsSeptember 15, 2017
41Chinese academics prod Beijing to consider Nor...BEIJING (Reuters) - Chinese academics are publ...worldnewsSeptember 15, 2017
\n", + "
" + ], + "text/plain": [ + " label title \\\n", + "0 1 UK's May 'receiving regular updates' on London... \n", + "1 1 UK transport police leading investigation of L... \n", + "2 1 Pacific nations crack down on North Korean shi... \n", + "3 1 Three suspected al Qaeda militants killed in Y... \n", + "4 1 Chinese academics prod Beijing to consider Nor... \n", + "\n", + " text subject \\\n", + "0 LONDON (Reuters) - British Prime Minister Ther... worldnews \n", + "1 LONDON (Reuters) - British counter-terrorism p... worldnews \n", + "2 WELLINGTON (Reuters) - South Pacific island na... worldnews \n", + "3 ADEN, Yemen (Reuters) - Three suspected al Qae... worldnews \n", + "4 BEIJING (Reuters) - Chinese academics are publ... worldnews \n", + "\n", + " date \n", + "0 September 15, 2017 \n", + "1 September 15, 2017 \n", + "2 September 15, 2017 \n", + "3 September 15, 2017 \n", + "4 September 15, 2017 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load reference dataset\n", + "df_correct_validation = pd.read_csv(\"dataset/validation_data_simple_labeled.csv\")\n", + "print(f\"Reference dataset shape: {df_correct_validation.shape}\")\n", + "print(f\"Reference dataset columns: {df_correct_validation.columns.tolist()}\")\n", + "df_correct_validation.head()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load All Validation Datasets for Comparison\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First Classifier: (4956, 5)\n", + " Label distribution: {0: 3484, 1: 1472}\n", + "\n", + "Embeddings: (4956, 5)\n", + " Label distribution: {0: 3235, 1: 1721}\n", + "\n", + "Advanced Embeddings: (4956, 5)\n", + " Label distribution: {0: 4398, 1: 558}\n", + "\n", + "Minus Reuters: (4956, 10)\n", + " Label distribution: {0: 3193, 1: 1763}\n", + "\n", + "XGBoost: (4956, 5)\n", + " Label distribution: {0: 3501, 1: 1455}\n", + "\n" + ] + } + ], + "source": [ + "# Load all validation datasets\n", + "datasets = {\n", + " 'First Classifier': pd.read_csv(\"dataset/validation_data_labeled.csv\"),\n", + " 'Embeddings': pd.read_csv(\"dataset/validation_data_labeled_embeddings.csv\"),\n", + " 'Advanced Embeddings': pd.read_csv(\"dataset/validation_data_labeled_embeddings_advanced.csv\"),\n", + " 'Minus Reuters': pd.read_csv(\"dataset/validation_data_labeled_minus_reuters.csv\"),\n", + " 'XGBoost': pd.read_csv(\"dataset/validation_XGBoost_labeled_data.csv\")\n", + "}\n", + "\n", + "# Display dataset information\n", + "for name, df in datasets.items():\n", + " print(f\"{name}: {df.shape}\")\n", + " if 'label' in df.columns:\n", + " print(f\" Label distribution: {df['label'].value_counts().to_dict()}\")\n", + " print()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Label Distribution Visualization\n", + "\n", + "Create pie charts showing the distribution of labels (0 and 1) for each dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create pie charts for all datasets\n", + "fig, axes = plt.subplots(2, 3, figsize=(18, 12))\n", + "axes = axes.flatten()\n", + "\n", + "# Reference dataset\n", + "counts = df_correct_validation['label'].value_counts()\n", + "labels = ['0', '1']\n", + "sizes = [counts.get(0, 0), counts.get(1, 0)]\n", + "axes[0].pie(sizes, labels=labels, autopct='%1.1f%%', startangle=90, \n", + " colors=['lightcoral', 'lightblue'])\n", + "axes[0].set_title('Reference Dataset\\n(df_correct_validation)', fontsize=12, fontweight='bold')\n", + "\n", + "# Other datasets\n", + "dataset_names = list(datasets.keys())\n", + "for i, (name, df) in enumerate(datasets.items(), 1):\n", + " if 'label' in df.columns:\n", + " counts = df['label'].value_counts()\n", + " sizes = [counts.get(0, 0), counts.get(1, 0)]\n", + " axes[i].pie(sizes, labels=labels, autopct='%1.1f%%', startangle=90, \n", + " colors=['lightcoral', 'lightblue'])\n", + " axes[i].set_title(f'{name}', fontsize=12, fontweight='bold')\n", + " else:\n", + " axes[i].text(0.5, 0.5, 'No label column', ha='center', va='center', transform=axes[i].transAxes)\n", + " axes[i].set_title(f'{name}\\n(No labels)', fontsize=12, fontweight='bold')\n", + "\n", + "# Hide the last subplot if not needed\n", + "if len(datasets) < 5:\n", + " axes[-1].set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metrics Calculation Function\n", + "\n", + "Define a function to calculate all relevant metrics for comparison.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_metrics(y_true, y_pred, dataset_name):\n", + " \"\"\"\n", + " Calculate comprehensive metrics for model evaluation\n", + " \"\"\"\n", + " try:\n", + " # Ensure both arrays have the same length\n", + " min_len = min(len(y_true), len(y_pred))\n", + " y_true = y_true[:min_len]\n", + " y_pred = y_pred[:min_len]\n", + " \n", + " # Calculate metrics\n", + " accuracy = accuracy_score(y_true, y_pred)\n", + " precision = precision_score(y_true, y_pred, average='weighted', zero_division=0)\n", + " recall = recall_score(y_true, y_pred, average='weighted', zero_division=0)\n", + " f1 = f1_score(y_true, y_pred, average='weighted', zero_division=0)\n", + " \n", + " # Calculate per-class metrics\n", + " precision_0 = precision_score(y_true, y_pred, pos_label=0, zero_division=0)\n", + " recall_0 = recall_score(y_true, y_pred, pos_label=0, zero_division=0)\n", + " f1_0 = f1_score(y_true, y_pred, pos_label=0, zero_division=0)\n", + " \n", + " precision_1 = precision_score(y_true, y_pred, pos_label=1, zero_division=0)\n", + " recall_1 = recall_score(y_true, y_pred, pos_label=1, zero_division=0)\n", + " f1_1 = f1_score(y_true, y_pred, pos_label=1, zero_division=0)\n", + " \n", + " # Try to calculate AUC (might fail if only one class present)\n", + " try:\n", + " auc = roc_auc_score(y_true, y_pred)\n", + " except:\n", + " auc = np.nan\n", + " \n", + " return {\n", + " 'Dataset': dataset_name,\n", + " 'Accuracy': accuracy,\n", + " 'Precision (Weighted)': precision,\n", + " 'Recall (Weighted)': recall,\n", + " 'F1-Score (Weighted)': f1,\n", + " 'Precision (Class 0)': precision_0,\n", + " 'Recall (Class 0)': recall_0,\n", + " 'F1-Score (Class 0)': f1_0,\n", + " 'Precision (Class 1)': precision_1,\n", + " 'Recall (Class 1)': recall_1,\n", + " 'F1-Score (Class 1)': f1_1,\n", + " 'AUC': auc,\n", + " 'Total Samples': len(y_true)\n", + " }\n", + " except Exception as e:\n", + " print(f\"Error calculating metrics for {dataset_name}: {e}\")\n", + " return None\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Calculate Metrics for All Datasets\n", + "\n", + "Compare each dataset against the reference dataset and calculate comprehensive metrics.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating metrics for First Classifier...\n", + "Calculating metrics for Embeddings...\n", + "Calculating metrics for Advanced Embeddings...\n", + "Calculating metrics for Minus Reuters...\n", + "Calculating metrics for XGBoost...\n", + "\n", + "Metrics calculated successfully!\n" + ] + } + ], + "source": [ + "# Calculate metrics for all datasets\n", + "metrics_results = []\n", + "\n", + "# Get reference labels\n", + "reference_labels = df_correct_validation['label'].values\n", + "\n", + "for name, df in datasets.items():\n", + " if 'label' in df.columns:\n", + " print(f\"Calculating metrics for {name}...\")\n", + " dataset_labels = df['label'].values\n", + " \n", + " # Calculate metrics\n", + " metrics = calculate_metrics(reference_labels, dataset_labels, name)\n", + " if metrics:\n", + " metrics_results.append(metrics)\n", + " else:\n", + " print(f\"Skipping {name} - no 'label' column found\")\n", + "\n", + "# Create metrics DataFrame\n", + "if metrics_results:\n", + " metrics_df = pd.DataFrame(metrics_results)\n", + " print(\"\\nMetrics calculated successfully!\")\n", + "else:\n", + " print(\"No metrics could be calculated.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metrics Summary Table\n", + "\n", + "Display all calculated metrics in a comprehensive table.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "COMPREHENSIVE METRICS COMPARISON\n", + "================================================================================\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DatasetAccuracyPrecision (Weighted)Recall (Weighted)F1-Score (Weighted)Precision (Class 0)Recall (Class 0)F1-Score (Class 0)Precision (Class 1)Recall (Class 1)F1-Score (Class 1)AUCTotal Samples
0First Classifier0.98910.98950.98910.98921.00000.98470.99230.96331.00000.98130.99244956
1Embeddings0.92550.93690.92550.92750.98980.90500.94550.80480.97670.88240.94094956
2Advanced Embeddings0.71670.67680.71670.67040.74260.92310.82310.51250.20170.28950.56244956
3Minus Reuters0.92470.93860.92470.92690.99560.89850.94460.79640.99010.88270.94434956
4XGBoost0.99210.99230.99210.99220.99970.98930.99450.97390.99930.98640.99434956
\n", + "
" + ], + "text/plain": [ + " Dataset Accuracy Precision (Weighted) Recall (Weighted) \\\n", + "0 First Classifier 0.9891 0.9895 0.9891 \n", + "1 Embeddings 0.9255 0.9369 0.9255 \n", + "2 Advanced Embeddings 0.7167 0.6768 0.7167 \n", + "3 Minus Reuters 0.9247 0.9386 0.9247 \n", + "4 XGBoost 0.9921 0.9923 0.9921 \n", + "\n", + " F1-Score (Weighted) Precision (Class 0) Recall (Class 0) \\\n", + "0 0.9892 1.0000 0.9847 \n", + "1 0.9275 0.9898 0.9050 \n", + "2 0.6704 0.7426 0.9231 \n", + "3 0.9269 0.9956 0.8985 \n", + "4 0.9922 0.9997 0.9893 \n", + "\n", + " F1-Score (Class 0) Precision (Class 1) Recall (Class 1) \\\n", + "0 0.9923 0.9633 1.0000 \n", + "1 0.9455 0.8048 0.9767 \n", + "2 0.8231 0.5125 0.2017 \n", + "3 0.9446 0.7964 0.9901 \n", + "4 0.9945 0.9739 0.9993 \n", + "\n", + " F1-Score (Class 1) AUC Total Samples \n", + "0 0.9813 0.9924 4956 \n", + "1 0.8824 0.9409 4956 \n", + "2 0.2895 0.5624 4956 \n", + "3 0.8827 0.9443 4956 \n", + "4 0.9864 0.9943 4956 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Metrics saved to 'dataset_comparison_metrics.csv'\n" + ] + } + ], + "source": [ + "if 'metrics_df' in locals():\n", + " # Display the metrics table\n", + " print(\"\\n\" + \"=\"*80)\n", + " print(\"COMPREHENSIVE METRICS COMPARISON\")\n", + " print(\"=\"*80)\n", + " \n", + " # Round numeric columns for better readability\n", + " numeric_columns = metrics_df.select_dtypes(include=[np.number]).columns\n", + " metrics_df_display = metrics_df.copy()\n", + " metrics_df_display[numeric_columns] = metrics_df_display[numeric_columns].round(4)\n", + " \n", + " display(metrics_df_display)\n", + " \n", + " # Save to CSV\n", + " metrics_df.to_csv('dataset_comparison_metrics.csv', index=False)\n", + " print(\"\\nMetrics saved to 'dataset_comparison_metrics.csv'\")\n", + "else:\n", + " print(\"No metrics data available to display.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Confusion Matrices\n", + "\n", + "Create confusion matrices for each dataset comparison to visualize the classification performance.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create confusion matrices for all datasets\n", + "n_datasets = len([name for name, df in datasets.items() if 'label' in df.columns])\n", + "if n_datasets > 0:\n", + " fig, axes = plt.subplots(2, 3, figsize=(18, 12))\n", + " axes = axes.flatten()\n", + " \n", + " plot_idx = 0\n", + " \n", + " for name, df in datasets.items():\n", + " if 'label' in df.columns:\n", + " # Get labels\n", + " y_true = reference_labels\n", + " y_pred = df['label'].values\n", + " \n", + " # Ensure same length\n", + " min_len = min(len(y_true), len(y_pred))\n", + " y_true = y_true[:min_len]\n", + " y_pred = y_pred[:min_len]\n", + " \n", + " # Create confusion matrix\n", + " cm = confusion_matrix(y_true, y_pred)\n", + " \n", + " # Plot confusion matrix\n", + " disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['0', '1'])\n", + " disp.plot(ax=axes[plot_idx], cmap='Blues', values_format='d')\n", + " axes[plot_idx].set_title(f'{name}\\nvs Reference Dataset', fontweight='bold')\n", + " \n", + " plot_idx += 1\n", + " \n", + " # Hide unused subplots\n", + " for i in range(plot_idx, len(axes)):\n", + " axes[i].set_visible(False)\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + "else:\n", + " print(\"No datasets with 'label' column found for confusion matrix creation.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Detailed Classification Reports\n", + "\n", + "Generate detailed classification reports for each dataset comparison.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "CLASSIFICATION REPORT: First Classifier\n", + "============================================================\n", + " precision recall f1-score support\n", + "\n", + " Class 0 1.00 0.98 0.99 3538\n", + " Class 1 0.96 1.00 0.98 1418\n", + "\n", + " accuracy 0.99 4956\n", + " macro avg 0.98 0.99 0.99 4956\n", + "weighted avg 0.99 0.99 0.99 4956\n", + "\n", + "Total samples compared: 4956\n", + "Agreement rate: 0.9891\n", + "Total disagreements: 54 (1.09%)\n", + "\n", + "Disagreement breakdown:\n", + "Reference Predicted\n", + "0 1 54\n", + "\n", + "============================================================\n", + "CLASSIFICATION REPORT: Embeddings\n", + "============================================================\n", + " precision recall f1-score support\n", + "\n", + " Class 0 0.99 0.91 0.95 3538\n", + " Class 1 0.80 0.98 0.88 1418\n", + "\n", + " accuracy 0.93 4956\n", + " macro avg 0.90 0.94 0.91 4956\n", + "weighted avg 0.94 0.93 0.93 4956\n", + "\n", + "Total samples compared: 4956\n", + "Agreement rate: 0.9255\n", + "Total disagreements: 369 (7.45%)\n", + "\n", + "Disagreement breakdown:\n", + "Reference Predicted\n", + "0 1 336\n", + "1 0 33\n", + "\n", + "============================================================\n", + "CLASSIFICATION REPORT: Advanced Embeddings\n", + "============================================================\n", + " precision recall f1-score support\n", + "\n", + " Class 0 0.74 0.92 0.82 3538\n", + " Class 1 0.51 0.20 0.29 1418\n", + "\n", + " accuracy 0.72 4956\n", + " macro avg 0.63 0.56 0.56 4956\n", + "weighted avg 0.68 0.72 0.67 4956\n", + "\n", + "Total samples compared: 4956\n", + "Agreement rate: 0.7167\n", + "Total disagreements: 1404 (28.33%)\n", + "\n", + "Disagreement breakdown:\n", + "Reference Predicted\n", + "1 0 1132\n", + "0 1 272\n", + "\n", + "============================================================\n", + "CLASSIFICATION REPORT: Minus Reuters\n", + "============================================================\n", + " precision recall f1-score support\n", + "\n", + " Class 0 1.00 0.90 0.94 3538\n", + " Class 1 0.80 0.99 0.88 1418\n", + "\n", + " accuracy 0.92 4956\n", + " macro avg 0.90 0.94 0.91 4956\n", + "weighted avg 0.94 0.92 0.93 4956\n", + "\n", + "Total samples compared: 4956\n", + "Agreement rate: 0.9247\n", + "Total disagreements: 373 (7.53%)\n", + "\n", + "Disagreement breakdown:\n", + "Reference Predicted\n", + "0 1 359\n", + "1 0 14\n", + "\n", + "============================================================\n", + "CLASSIFICATION REPORT: XGBoost\n", + "============================================================\n", + " precision recall f1-score support\n", + "\n", + " Class 0 1.00 0.99 0.99 3538\n", + " Class 1 0.97 1.00 0.99 1418\n", + "\n", + " accuracy 0.99 4956\n", + " macro avg 0.99 0.99 0.99 4956\n", + "weighted avg 0.99 0.99 0.99 4956\n", + "\n", + "Total samples compared: 4956\n", + "Agreement rate: 0.9921\n", + "Total disagreements: 39 (0.79%)\n", + "\n", + "Disagreement breakdown:\n", + "Reference Predicted\n", + "0 1 38\n", + "1 0 1\n" + ] + } + ], + "source": [ + "# Generate detailed classification reports\n", + "for name, df in datasets.items():\n", + " if 'label' in df.columns:\n", + " print(f\"\\n{'='*60}\")\n", + " print(f\"CLASSIFICATION REPORT: {name}\")\n", + " print(f\"{'='*60}\")\n", + " \n", + " # Get labels\n", + " y_true = reference_labels\n", + " y_pred = df['label'].values\n", + " \n", + " # Ensure same length\n", + " min_len = min(len(y_true), len(y_pred))\n", + " y_true = y_true[:min_len]\n", + " y_pred = y_pred[:min_len]\n", + " \n", + " # Generate classification report\n", + " report = classification_report(y_true, y_pred, target_names=['Class 0', 'Class 1'])\n", + " print(report)\n", + " \n", + " # Additional statistics\n", + " print(f\"Total samples compared: {len(y_true)}\")\n", + " print(f\"Agreement rate: {accuracy_score(y_true, y_pred):.4f}\")\n", + " \n", + " # Count disagreements\n", + " disagreements = (y_true != y_pred).sum()\n", + " print(f\"Total disagreements: {disagreements} ({disagreements/len(y_true)*100:.2f}%)\")\n", + " \n", + " # Show disagreement breakdown\n", + " if disagreements > 0:\n", + " disagreement_df = pd.DataFrame({\n", + " 'Reference': y_true[y_true != y_pred],\n", + " 'Predicted': y_pred[y_true != y_pred]\n", + " })\n", + " print(\"\\nDisagreement breakdown:\")\n", + " print(disagreement_df.value_counts().to_string())\n", + " else:\n", + " print(f\"\\nSkipping {name} - no 'label' column found\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metrics Visualization\n", + "\n", + "Create visualizations to compare key metrics across datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if 'metrics_df' in locals() and len(metrics_df) > 0:\n", + " # Create metrics comparison plots\n", + " fig, axes = plt.subplots(2, 2, figsize=(15, 12))\n", + " \n", + " # Key metrics to plot\n", + " key_metrics = ['Accuracy', 'Precision (Class 1)', 'Recall (Class 1)', 'F1-Score (Class 1)']\n", + " \n", + " for i, metric in enumerate(key_metrics):\n", + " ax = axes[i//2, i%2]\n", + " \n", + " # Create bar plot\n", + " bars = ax.bar(metrics_df['Dataset'], metrics_df[metric], \n", + " color=plt.cm.viridis(np.linspace(0, 1, len(metrics_df))))\n", + " \n", + " ax.set_title(f'{metric} Comparison', fontweight='bold')\n", + " ax.set_ylabel(metric)\n", + " ax.set_ylim(0, 1)\n", + " \n", + " # Rotate x-axis labels for better readability\n", + " ax.tick_params(axis='x', rotation=45)\n", + " \n", + " # Add value labels on bars\n", + " for bar, value in zip(bars, metrics_df[metric]):\n", + " ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, \n", + " f'{value:.3f}', ha='center', va='bottom', fontsize=9)\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + " \n", + " # Create a heatmap of all metrics\n", + " plt.figure(figsize=(12, 8))\n", + " \n", + " # Select numeric columns for heatmap\n", + " heatmap_data = metrics_df.set_index('Dataset')[numeric_columns].T\n", + " \n", + " sns.heatmap(heatmap_data, annot=True, cmap='YlOrRd', fmt='.3f', \n", + " cbar_kws={'label': 'Metric Value'})\n", + " plt.title('Metrics Heatmap - All Datasets vs Reference', fontweight='bold', fontsize=14)\n", + " plt.xlabel('Dataset')\n", + " plt.ylabel('Metric')\n", + " plt.xticks(rotation=45)\n", + " plt.yticks(rotation=0)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "else:\n", + " print(\"No metrics data available for visualization.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary and Conclusions\n", + "\n", + "Based on the analysis above, we can draw the following conclusions:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "ANALYSIS SUMMARY\n", + "================================================================================\n", + "\n", + "Best performing dataset for each metric:\n", + " Accuracy: XGBoost (0.9921)\n", + " Precision (Weighted): XGBoost (0.9923)\n", + " Recall (Weighted): XGBoost (0.9921)\n", + " F1-Score (Weighted): XGBoost (0.9922)\n", + "\n", + "Overall ranking (by F1-Score):\n", + " 1. XGBoost: 0.9922\n", + " 2. First Classifier: 0.9892\n", + " 3. Embeddings: 0.9275\n", + " 4. Minus Reuters: 0.9269\n", + " 5. Advanced Embeddings: 0.6704\n", + "\n", + "Dataset with highest agreement with reference: XGBoost (0.9921)\n", + "\n", + "Average performance across all datasets:\n", + " Accuracy: 0.9096\n", + " Precision (Weighted): 0.9068\n", + " Recall (Weighted): 0.9096\n", + " F1-Score (Weighted): 0.9012\n", + "\n", + "================================================================================\n", + "Analysis completed successfully!\n", + "================================================================================\n" + ] + } + ], + "source": [ + "if 'metrics_df' in locals() and len(metrics_df) > 0:\n", + " print(\"\\n\" + \"=\"*80)\n", + " print(\"ANALYSIS SUMMARY\")\n", + " print(\"=\"*80)\n", + " \n", + " # Find best performing dataset for each metric\n", + " key_metrics = ['Accuracy', 'Precision (Weighted)', 'Recall (Weighted)', 'F1-Score (Weighted)']\n", + " \n", + " print(\"\\nBest performing dataset for each metric:\")\n", + " for metric in key_metrics:\n", + " best_idx = metrics_df[metric].idxmax()\n", + " best_dataset = metrics_df.loc[best_idx, 'Dataset']\n", + " best_value = metrics_df.loc[best_idx, metric]\n", + " print(f\" {metric}: {best_dataset} ({best_value:.4f})\")\n", + " \n", + " # Overall ranking based on F1-score\n", + " print(\"\\nOverall ranking (by F1-Score):\")\n", + " ranking = metrics_df.sort_values('F1-Score (Weighted)', ascending=False)\n", + " for i, (_, row) in enumerate(ranking.iterrows(), 1):\n", + " print(f\" {i}. {row['Dataset']}: {row['F1-Score (Weighted)']:.4f}\")\n", + " \n", + " # Dataset with highest agreement\n", + " best_accuracy_idx = metrics_df['Accuracy'].idxmax()\n", + " best_accuracy_dataset = metrics_df.loc[best_accuracy_idx, 'Dataset']\n", + " best_accuracy_value = metrics_df.loc[best_accuracy_idx, 'Accuracy']\n", + " \n", + " print(f\"\\nDataset with highest agreement with reference: {best_accuracy_dataset} ({best_accuracy_value:.4f})\")\n", + " \n", + " # Calculate average performance\n", + " avg_metrics = metrics_df[key_metrics].mean()\n", + " print(\"\\nAverage performance across all datasets:\")\n", + " for metric, value in avg_metrics.items():\n", + " print(f\" {metric}: {value:.4f}\")\n", + " \n", + " print(\"\\n\" + \"=\"*80)\n", + " print(\"Analysis completed successfully!\")\n", + " print(\"=\"*80)\n", + "else:\n", + " print(\"No analysis could be performed due to missing metrics data.\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md index a4ac7ab..76bacec 100644 --- a/README.md +++ b/README.md @@ -1,39 +1,104 @@ -![logo_ironhack_blue 7](https://user-images.githubusercontent.com/23629340/40541063-a07a0a8a-601a-11e8-91b5-2f13e4e6b441.png) +# NLP Challenge - Fake News Classification -# PROJECT | Natural Language Processing Challenge +A comprehensive project for fake news classification using various machine learning methods and natural language processing techniques. -## Introduction +## Project Structure -Learning how to process text is a skill required for Data Scientists/AI Engineers. +### Jupyter Notebooks +- `1. data_exploration.ipynb` - Data exploration and analysis +- `2.1 enhanced_classifier.ipynb` - Enhanced classifier implementation +- `2.2 embeddings_classifier.ipynb` - Classifier with word embeddings +- `2.3 embeddings_advanced_classifier.ipynb` - Advanced classifier with embeddings +- `2.4 enhanced_classifier_minus_reuters.ipynb` - Classifier excluding Reuters data +- `2.5 Final_classifier_and_XGBoost.ipynb` - Final classifier with XGBoost +- `3. models_comparison.ipynb` - Model comparison and evaluation -In this project, you will put these skills into practice to identify whether a news headline is real or fake news. +### Scripts +- `setup.sh` - Environment setup script +- `start_notebook.sh` - Jupyter Notebook startup script -## Project Overview +## Installation and Setup -In the file `dataset/data.csv`, you will find a dataset containing news articles with the following columns: +1. Clone the repository: +```bash +git clone +cd project-nlp-challenge +``` -- **`label`**: 0 if the news is fake, 1 if the news is real. -- **`title`**: The headline of the news article. -- **`text`**: The full content of the article. -- **`subject`**: The category or topic of the news. -- **`date`**: The publication date of the article. +2. Create a virtual environment: +```bash +python -m venv venv +source venv/bin/activate # On macOS/Linux +# or +venv\Scripts\activate # On Windows +``` -Your goal is to build a classifier that is able to distinguish between the two. +3. Install dependencies: +```bash +pip install -r requirements.txt +``` -Once you have a classifier built, then use it to predict the labels for `dataset/validation_data.csv`. Generate a new file -where the label `2` has been replaced by `0` (fake) or `1` (real) according to your model. Please respect the original file format, -do not include extra columns, and respect the column separator. +4. Start Jupyter Notebook: +```bash +jupyter notebook +``` -Please ensure to split the `data.csv` into **training** and **test** datasets before using it for model training or evaluation. +## Project Description -## Guidance +This project presents a comprehensive study of fake news classification methods, including: -Like in a real life scenario, you are able to make your own choices and text treatment. -Use the techniques you have learned and the common packages to process this data and classify the text. +- Text data analysis and preprocessing +- Feature extraction using TF-IDF +- Word embeddings implementation +- Application of various machine learning algorithms +- Performance comparison of different approaches -## Deliverables +## Key Features -1. **Python Code:** Provide well-documented Python code that conducts the analysis. -2. **Predictions:** A csv file in the same format as `validation_data.csv` but with the predicted labels (0 or 1) -3. **Accuracy estimation:** Provide the teacher with your estimation of how your model will perform. -4. **Presentation:** You will present your model in a 10-minute presentation. Your teacher will provide further instructions. +- **Data Exploration**: Comprehensive analysis of the dataset structure and characteristics +- **Feature Engineering**: Multiple approaches to text feature extraction +- **Model Variety**: Implementation of traditional ML and advanced techniques +- **Performance Evaluation**: Detailed comparison of model performance metrics +- **Reproducible Research**: Well-documented notebooks with clear methodology + +## Methodology + +The project follows a systematic approach: + +1. **Data Analysis**: Understanding the dataset structure and quality +2. **Preprocessing**: Text cleaning, tokenization, and normalization +3. **Feature Extraction**: TF-IDF, word embeddings, and custom features +4. **Model Training**: Multiple algorithms including Logistic Regression, SVM, and XGBoost +5. **Evaluation**: Comprehensive performance metrics and comparison + +## Results + +The project demonstrates various approaches to fake news classification and compares their effectiveness across different metrics including accuracy, precision, recall, and F1-score. + +## Technologies Used + +- **Python 3.x** - Core programming language +- **Jupyter Notebook** - Interactive development environment +- **scikit-learn** - Machine learning library +- **pandas** - Data manipulation and analysis +- **numpy** - Numerical computing +- **matplotlib & seaborn** - Data visualization +- **XGBoost** - Gradient boosting framework +- **NLTK** - Natural language processing toolkit +- **spaCy** - Advanced NLP library + +## Dataset + +The project uses a curated dataset of news articles labeled as real or fake, providing a solid foundation for training and evaluation of classification models. + +## Contributing + +This is a research project showcasing various NLP and ML techniques for fake news detection. Feel free to explore the notebooks and adapt the methods for your own use cases. + +## Author + +Sergej + +## License + +This project is for educational and research purposes. diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..8874dfd --- /dev/null +++ b/requirements.txt @@ -0,0 +1,28 @@ +# Основные библиотеки для машинного обучения +numpy>=1.21.0 +pandas>=1.3.0 +scikit-learn>=1.0.0 +matplotlib>=3.4.0 +seaborn>=0.11.0 + +# Jupyter Notebook +jupyter>=1.0.0 +ipykernel>=6.0.0 + +# NLP библиотеки +nltk>=3.6.0 +spacy>=3.4.0 + +# XGBoost +xgboost>=1.5.0 + +# Дополнительные утилиты +tqdm>=4.62.0 +requests>=2.25.0 + +# Обработка текста +wordcloud>=1.8.0 +textblob>=0.17.0 + +# Визуализация +plotly>=5.0.0 diff --git a/setup.sh b/setup.sh new file mode 100755 index 0000000..e234d15 --- /dev/null +++ b/setup.sh @@ -0,0 +1,49 @@ +#!/bin/bash +# Setup script for the NLP Challenge project + +echo "🚀 Setting up the NLP Challenge project..." + +# Check if virtual environment exists +if [ ! -d "venv" ]; then + echo "📦 Creating virtual environment..." + python3 -m venv venv +fi + +# Activate virtual environment +echo "🔧 Activating virtual environment..." +source venv/bin/activate + +# Install required packages +echo "📚 Installing required packages..." +pip install pandas numpy matplotlib scikit-learn nltk jupyter + +# Download NLTK data +echo "📥 Downloading NLTK data..." +python -c " +import nltk +try: + nltk.data.find('tokenizers/punkt') +except LookupError: + nltk.download('punkt') + +try: + nltk.data.find('corpora/stopwords') +except LookupError: + nltk.download('stopwords') + +try: + nltk.data.find('corpora/wordnet') +except LookupError: + nltk.download('wordnet') +print('NLTK data downloaded successfully!') +" + +echo "✅ Setup complete!" +echo "" +echo "📋 Next steps:" +echo "1. Activate the virtual environment: source venv/bin/activate" +echo "2. Start Jupyter: jupyter notebook" +echo "3. Open: data_exploration_fixed.ipynb" +echo "4. Run all cells to explore your dataset" +echo "" +echo "�� Happy exploring!" diff --git a/start_notebook.sh b/start_notebook.sh new file mode 100755 index 0000000..b54cf22 --- /dev/null +++ b/start_notebook.sh @@ -0,0 +1,34 @@ +#!/bin/bash +# Quick start script for the NLP Challenge + +echo "🚀 Starting NLP Challenge Data Exploration..." + +# Activate virtual environment +echo "🔧 Activating virtual environment..." +source venv/bin/activate + +# Download missing NLTK data +echo "📥 Downloading NLTK data..." +python -c " +import nltk +try: + nltk.data.find('corpora/wordnet') + print('WordNet already available') +except LookupError: + nltk.download('wordnet') + print('WordNet downloaded successfully') +" + +# Start Jupyter +echo "📊 Starting Jupyter Notebook..." +echo "🌐 Opening browser to Jupyter..." +echo "📁 Open: data_exploration_fixed_v3.ipynb" +echo "" +echo "💡 Tips:" +echo "- Run all cells sequentially from top to bottom" +echo "- Some cells may take time to execute" +echo "- All visualizations will be displayed automatically" +echo "" +echo "🎯 Happy exploring!" + +jupyter notebook