From 102f0567a203392990cbfc90e2046b8f40ff635c Mon Sep 17 00:00:00 2001 From: Charlie Zhang Date: Wed, 1 Nov 2023 11:06:05 -0400 Subject: [PATCH] update text assets. --- .../text/text_presentation.slides.html | 7925 +++++++++++++++++ docs/text/intro.md | 4 +- notebooks/text/text_classification.ipynb | 222 +- notebooks/text/word_embeddings.ipynb | 580 ++ 4 files changed, 8709 insertions(+), 22 deletions(-) create mode 100644 docs/images/interactive/text/text_presentation.slides.html create mode 100644 notebooks/text/word_embeddings.ipynb diff --git a/docs/images/interactive/text/text_presentation.slides.html b/docs/images/interactive/text/text_presentation.slides.html new file mode 100644 index 00000000..8aec62b8 --- /dev/null +++ b/docs/images/interactive/text/text_presentation.slides.html @@ -0,0 +1,7925 @@ + + + + + + + +text_presentation slides + + + + + + + + + + + + + + + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ + + diff --git a/docs/text/intro.md b/docs/text/intro.md index fdb25f78..f40592f6 100644 --- a/docs/text/intro.md +++ b/docs/text/intro.md @@ -1,5 +1,7 @@ # Introduction +An interactive presentation is aviliable at [here](https://worldbank.github.io/pacific-observatory/interactive/text/text_presentation.slides.html). + ## Economic Policy Uncertainty (EPU) Index Baker, Bloom, and Davis (2016) developed Economic Policy Uncertainty Index by exploiting the mention of economic, policy, and uncertainty group of terms on newspapers, and found that "innovations in policy uncertainty foreshadow declines in investment, output, and employment in the United States and … other 12 major economies."​ @@ -29,4 +31,4 @@ Sentiment analysis has been frequently employed in analyzing financial markets a ![Overview](../images/text/sib_econ_sentiment.png) Notes: Newspapers include Solomon Stars, Solomon Times, The Island Sun, Solomon Islands Broadcasting Corporation, ABC AU, and RNZ. ``` -```` +```` \ No newline at end of file diff --git a/notebooks/text/text_classification.ipynb b/notebooks/text/text_classification.ipynb index 3b1cd7f3..50a7d394 100644 --- a/notebooks/text/text_classification.ipynb +++ b/notebooks/text/text_classification.ipynb @@ -29,12 +29,13 @@ "from sklearn.metrics import classification_report, f1_score, accuracy_score, confusion_matrix\n", "from sklearn.metrics import roc_curve, auc, roc_auc_score\n", "\n", - "from imblearn.over_sampling import SMOTE" + "from imblearn.over_sampling import SMOTE\n", + "import tiktoken" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "60b1ecc2", "metadata": {}, "outputs": [], @@ -45,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "26c8eb34", "metadata": {}, "outputs": [], @@ -61,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "3d73c1e3", "metadata": {}, "outputs": [], @@ -74,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "32b07a50", "metadata": {}, "outputs": [], @@ -93,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "93a68f44", "metadata": {}, "outputs": [], @@ -103,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "628af224", "metadata": {}, "outputs": [], @@ -118,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "1465f259", "metadata": {}, "outputs": [], @@ -128,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "1d37d67e", "metadata": {}, "outputs": [ @@ -157,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "019004c5", "metadata": {}, "outputs": [], @@ -166,6 +167,16 @@ "news_df[\"texts\"] = news_df[\"texts\"].apply(lambda x: \" \".join(i for i in x))" ] }, + { + "cell_type": "code", + "execution_count": 21, + "id": "903c0680", + "metadata": {}, + "outputs": [], + "source": [ + "text_embeddings = [nlp(text).vector for text in news_df[\"texts\"]] " + ] + }, { "cell_type": "code", "execution_count": 11, @@ -366,7 +377,7 @@ }, { "cell_type": "markdown", - "id": "9ad09d10", + "id": "2c2ff213", "metadata": {}, "source": [ "## PNG" @@ -528,7 +539,7 @@ }, { "cell_type": "markdown", - "id": "62658bdd", + "id": "239c6876", "metadata": {}, "source": [ "## SIB" @@ -537,7 +548,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "26fc1f1a", + "id": "f06e3ffe", "metadata": {}, "outputs": [], "source": [ @@ -553,7 +564,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "4b7d0190", + "id": "0f607747", "metadata": {}, "outputs": [], "source": [ @@ -571,7 +582,7 @@ { "cell_type": "code", "execution_count": 34, - "id": "52a9b5bd", + "id": "d120f397", "metadata": {}, "outputs": [ { @@ -599,7 +610,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "53c1e3f0", + "id": "627457ec", "metadata": {}, "outputs": [], "source": [ @@ -611,7 +622,7 @@ { "cell_type": "code", "execution_count": 36, - "id": "aef30fe5", + "id": "37a1b8a9", "metadata": {}, "outputs": [], "source": [ @@ -622,7 +633,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "5eb5b059", + "id": "f21c1b57", "metadata": {}, "outputs": [], "source": [ @@ -633,7 +644,7 @@ { "cell_type": "code", "execution_count": 38, - "id": "f6cbf725", + "id": "78383223", "metadata": {}, "outputs": [], "source": [ @@ -650,7 +661,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "2b9bd362", + "id": "d21342dd", "metadata": {}, "outputs": [], "source": [ @@ -660,10 +671,179 @@ "sib_econ_sent = sib_econ.set_index(\"date\").groupby(pd.Grouper(freq=\"MS\"))[[\"sentiment\"]].mean().reset_index()" ] }, + { + "cell_type": "code", + "execution_count": 46, + "id": "20ecbb22", + "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", + "
datesentiment
912011-01-010.878500
922011-02-010.933483
932011-03-010.953929
942011-04-010.849688
952011-05-010.893327
962011-06-010.761678
972011-07-010.742758
982011-08-010.960333
992011-09-010.816700
1002011-10-010.817550
1012011-11-010.834325
1022011-12-010.948283
1032012-01-01-0.381800
1042012-02-010.689171
1052012-03-010.981733
1062012-04-010.369088
1072012-05-010.670069
1082012-06-010.659550
1092012-07-010.655968
1102012-08-010.484206
\n", + "
" + ], + "text/plain": [ + " date sentiment\n", + "91 2011-01-01 0.878500\n", + "92 2011-02-01 0.933483\n", + "93 2011-03-01 0.953929\n", + "94 2011-04-01 0.849688\n", + "95 2011-05-01 0.893327\n", + "96 2011-06-01 0.761678\n", + "97 2011-07-01 0.742758\n", + "98 2011-08-01 0.960333\n", + "99 2011-09-01 0.816700\n", + "100 2011-10-01 0.817550\n", + "101 2011-11-01 0.834325\n", + "102 2011-12-01 0.948283\n", + "103 2012-01-01 -0.381800\n", + "104 2012-02-01 0.689171\n", + "105 2012-03-01 0.981733\n", + "106 2012-04-01 0.369088\n", + "107 2012-05-01 0.670069\n", + "108 2012-06-01 0.659550\n", + "109 2012-07-01 0.655968\n", + "110 2012-08-01 0.484206" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sib_econ_sent[sib_econ_sent.date >= \"2011-01-01\"].head(20)" + ] + }, { "cell_type": "code", "execution_count": 42, - "id": "26d40d63", + "id": "2d75d3da", "metadata": {}, "outputs": [ { diff --git a/notebooks/text/word_embeddings.ipynb b/notebooks/text/word_embeddings.ipynb new file mode 100644 index 00000000..3d07d44a --- /dev/null +++ b/notebooks/text/word_embeddings.ipynb @@ -0,0 +1,580 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f7e0d625", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.chdir(\"../../\")\n", + "import pandas as pd\n", + "\n", + "import spacy\n", + "from nltk.corpus import stopwords\n", + "from src.text.epu import *\n", + "from src.text.utils import *\n", + "\n", + "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.model_selection import train_test_split, KFold, cross_validate, GridSearchCV\n", + "\n", + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.svm import LinearSVC\n", + "from xgboost import XGBClassifier\n", + "\n", + "from sklearn.metrics import classification_report, f1_score, accuracy_score, confusion_matrix\n", + "from sklearn.metrics import roc_curve, auc, roc_auc_score\n", + "\n", + "import tiktoken" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "62978b00", + "metadata": {}, + "outputs": [], + "source": [ + "folder = os.getcwd() + \"/data/text/abc_au/\"\n", + "file_lists = [folder + file for file in os.listdir(folder) if \"news\" in file]\n", + "\n", + "news_df = pd.DataFrame()\n", + "for file in file_lists:\n", + " df = pd.read_csv(file).drop(\"Unnamed: 0\", axis=1)\n", + " if news_df.empty:\n", + " news_df = df\n", + " else:\n", + " news_df = pd.concat([news_df, df], axis=0).reset_index(drop=True)\n", + " \n", + "news_df = news_df.dropna().reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c6d2d1f7", + "metadata": {}, + "outputs": [], + "source": [ + "econ_list = [\n", + " 'economy', 'economic', 'economics', 'business', 'commerce', 'finance',\n", + " 'industry', \"assistance\", \"science and technology\", \"trade\", \"mining and metals industry\"\n", + "]\n", + "news_df[\"econ\"] = news_df[\"tags\"].str.lower().apply(is_in_word_list, terms=econ_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "354823d7", + "metadata": {}, + "outputs": [], + "source": [ + "nlp = spacy.load('en_core_web_sm', disable=['parser', 'ner'])\n", + "spacy_stopwords = list(nlp.Defaults.stop_words)\n", + "\n", + "nltk_stopwords = stopwords.words(\"english\")\n", + "nltk_unique = [sw for sw in nltk_stopwords if sw not in spacy_stopwords]\n", + "spacy_stopwords.extend(nltk_unique)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9e6ef2ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stopwords has been done.\n" + ] + } + ], + "source": [ + "from src.text.utils import *\n", + "data = news_df.news.values.tolist()\n", + "data_words = list(sent_to_words(data))\n", + "\n", + "bigram = gensim.models.Phrases(data_words, min_count=20, threshold=100)\n", + "bigram_mod = gensim.models.phrases.Phraser(bigram)\n", + "\n", + "trigram = gensim.models.Phrases(bigram[data_words], min_count=20, threshold=100)\n", + "trigram_mod = gensim.models.phrases.Phraser(trigram)\n", + "\n", + "texts_preprocessed = preprocess_text(data_words, spacy_stopwords, bigram_mod,\n", + " trigram_mod, nlp)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "798a3dfd", + "metadata": {}, + "outputs": [], + "source": [ + "news_df[\"texts\"] = texts_preprocessed\n", + "news_df[\"texts\"] = news_df[\"texts\"].apply(lambda x: \" \".join(i for i in x))" + ] + }, + { + "cell_type": "markdown", + "id": "4e632757", + "metadata": {}, + "source": [ + "## Glove" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "984c86d4", + "metadata": {}, + "outputs": [], + "source": [ + "import gensim.downloader\n", + "# Download the \"glove-twitter-25\" embeddings\n", + "glove_vectors = gensim.downloader.load('word2vec-google-news-300')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "42cc393e", + "metadata": {}, + "outputs": [], + "source": [ + "def get_average_word_vectors(text, model):\n", + " words = text.split()\n", + " vectors = [model[word] for word in words if word in model]\n", + " if vectors:\n", + " return np.mean(vectors, axis=0)\n", + " else:\n", + " return np.zeros(model.vector_size)\n", + "\n", + "text_embeddings = [get_average_word_vectors(text, glove_vectors) for text in news_df[\"texts\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "c956582a", + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(\n", + " text_embeddings, \n", + " news_df['econ'].astype(int), \n", + " test_size=0.1, \n", + " random_state=42, \n", + " shuffle=True) " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "78f7c8fb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 0.94 0.98 0.96 1164\n", + " 1 0.88 0.66 0.75 208\n", + "\n", + " accuracy 0.93 1372\n", + " macro avg 0.91 0.82 0.86 1372\n", + "weighted avg 0.93 0.93 0.93 1372\n", + "\n" + ] + } + ], + "source": [ + "clf = XGBClassifier(tree_method=\"hist\", enable_categorical=True, random_state=42)\n", + "clf.fit(X_train, y_train)\n", + "y_predict = clf.predict(X_test)\n", + "print(classification_report(y_test, y_predict))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "89304d48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RandomForestClassifier: Mean Accuracy = 86.58%; Mean F1-macro = 58.19%; Mean recall-macro = 13.85%; Mean precision-macro = 83.43%\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/czhang/miniforge3/envs/po/lib/python3.9/site-packages/sklearn/svm/_classes.py:32: FutureWarning: The default value of `dual` will change from `True` to `'auto'` in 1.5. Set the value of `dual` explicitly to suppress the warning.\n", + " warnings.warn(\n", + "/Users/czhang/miniforge3/envs/po/lib/python3.9/site-packages/sklearn/svm/_classes.py:32: FutureWarning: The default value of `dual` will change from `True` to `'auto'` in 1.5. Set the value of `dual` explicitly to suppress the warning.\n", + " warnings.warn(\n", + "/Users/czhang/miniforge3/envs/po/lib/python3.9/site-packages/sklearn/svm/_classes.py:32: FutureWarning: The default value of `dual` will change from `True` to `'auto'` in 1.5. Set the value of `dual` explicitly to suppress the warning.\n", + " warnings.warn(\n", + "/Users/czhang/miniforge3/envs/po/lib/python3.9/site-packages/sklearn/svm/_classes.py:32: FutureWarning: The default value of `dual` will change from `True` to `'auto'` in 1.5. Set the value of `dual` explicitly to suppress the warning.\n", + " warnings.warn(\n", + "/Users/czhang/miniforge3/envs/po/lib/python3.9/site-packages/sklearn/svm/_classes.py:32: FutureWarning: The default value of `dual` will change from `True` to `'auto'` in 1.5. Set the value of `dual` explicitly to suppress the warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LinearSVC: Mean Accuracy = 88.79%; Mean F1-macro = 73.16%; Mean recall-macro = 41.38%; Mean precision-macro = 72.53%\n", + "LogisticRegression: Mean Accuracy = 88.27%; Mean F1-macro = 70.81%; Mean recall-macro = 36.23%; Mean precision-macro = 72.23%\n", + "XGBClassifier: Mean Accuracy = 92.60%; Mean F1-macro = 84.00%; Mean recall-macro = 63.87%; Mean precision-macro = 83.24%\n" + ] + } + ], + "source": [ + "models = [\n", + " RandomForestClassifier(n_estimators=1000, max_depth=5, random_state=42),\n", + " LinearSVC(random_state=42),\n", + " LogisticRegression(solver='liblinear', C=1, penalty='l2', random_state=42),\n", + " XGBClassifier(tree_method=\"hist\", enable_categorical=True, random_state=42)\n", + "]\n", + "\n", + "scoring = ['accuracy', 'f1_macro', 'recall', 'precision']\n", + "\n", + "for model in models:\n", + " model_name = model.__class__.__name__\n", + " result = cross_validate(model,\n", + " X_train,\n", + " y_train,\n", + " cv=5,\n", + " scoring=scoring)\n", + " print(\n", + " \"%s: Mean Accuracy = %.2f%%; Mean F1-macro = %.2f%%; Mean recall-macro = %.2f%%; Mean precision-macro = %.2f%%\"\n", + " % (model_name, result['test_accuracy'].mean() * 100,\n", + " result['test_f1_macro'].mean() * 100, result['test_recall'].mean() *\n", + " 100, result['test_precision'].mean() * 100))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "23593f88", + "metadata": {}, + "outputs": [], + "source": [ + "sib_files = [\n", + " os.getcwd() + \"/data/text/rnz/solomon_islands_rnz_news.csv\",\n", + " os.getcwd() + \"/data/text/abc_au/solomon_islands_abc_news.csv\",\n", + "]\n", + "\n", + "sib_folder = os.getcwd() + \"/data/text/solomon_islands/\"\n", + "sib_files.extend([sib_folder+file for file in os.listdir(sib_folder) if \"news\" in file])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "b91e72ee", + "metadata": {}, + "outputs": [], + "source": [ + "sib = pd.DataFrame()\n", + "for file in sib_files:\n", + " temp = pd.read_csv(file).drop(\"Unnamed: 0\", axis=1)\n", + " if sib.empty:\n", + " sib = temp\n", + " else:\n", + " sib = pd.concat([sib, temp], axis=0).reset_index(drop=True)\n", + "\n", + "sib = sib[sib.news.isna() != True].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "966d163b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stopwords has been done.\n" + ] + } + ], + "source": [ + "sib_data = sib.news.values.tolist()\n", + "sib_data_words = list(sent_to_words(sib_data))\n", + "\n", + "bigram = gensim.models.Phrases(sib_data_words, min_count=20, threshold=100)\n", + "bigram_mod = gensim.models.phrases.Phraser(bigram)\n", + "\n", + "trigram = gensim.models.Phrases(bigram[sib_data_words], min_count=20, threshold=100)\n", + "trigram_mod = gensim.models.phrases.Phraser(trigram)\n", + "\n", + "sib_texts = preprocess_text(sib_data_words, spacy_stopwords, bigram_mod,\n", + " trigram_mod, nlp)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "7c09981e", + "metadata": {}, + "outputs": [], + "source": [ + "sib[\"date\"] = pd.to_datetime(sib[\"date\"], format='mixed')\n", + "sib[\"texts\"] = sib_texts\n", + "sib[\"texts\"] = sib[\"texts\"].apply(lambda x: \" \".join(i for i in x))" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "8d85380f", + "metadata": {}, + "outputs": [], + "source": [ + "sib_pred = clf.predict([get_average_word_vectors(text, glove_vectors) for text in sib[\"texts\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "f9927dad", + "metadata": {}, + "outputs": [], + "source": [ + "sib[\"econ_pred\"] = sib_pred\n", + "sib_econ = sib[sib.econ_pred == 1].reset_index(drop=True)\n", + "\n", + "from nltk.sentiment.vader import SentimentIntensityAnalyzer\n", + "sent_df = pd.DataFrame()\n", + "for row in sib_econ.news:\n", + " sample = row.replace(\"\\n\", \" \").strip()\n", + " sid = SentimentIntensityAnalyzer()\n", + " ss = sid.polarity_scores(sample)\n", + " ss_temp = pd.DataFrame(ss, columns=ss.keys(), index=[0])\n", + " sent_df = pd.concat([sent_df, ss_temp], axis=0)\n", + " \n", + "sib_econ[\"sentiment\"] = sent_df[\"compound\"].tolist()\n", + "sib_econ[\"date\"] = [d.date() for d in sib_econ[\"date\"]]\n", + "sib_econ[\"date\"] = [pd.to_datetime(d) for d in sib_econ[\"date\"]]\n", + "sib_econ_sent = sib_econ.set_index(\"date\").groupby(pd.Grouper(freq=\"MS\"))[[\"sentiment\"]].mean().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "414cd674", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "sib_econ_sent.plot(x=\"date\", ax=ax);\n", + "plt.axhline(y=0, color=\"red\", linestyle=\"--\")\n", + "plt.xlabel(\"Date\")\n", + "plt.title(\"Economic-Related Sentiment in Solomon Islands\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "dcda0ef6", + "metadata": {}, + "source": [ + "## Embedding Layer + CNN" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "c529476d", + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.preprocessing.text import Tokenizer\n", + "from tensorflow.keras.preprocessing.sequence import pad_sequences\n", + "from tensorflow.keras.layers import Embedding, Conv1D, MaxPooling1D, Flatten, Dense\n", + "from tensorflow.keras.models import Sequential\n", + "import string\n", + "from nltk.tokenize import word_tokenize" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "6d8323b5", + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(\n", + " news_df[\"news\"], \n", + " news_df['econ'].astype(int), \n", + " test_size=0.1, \n", + " random_state=42, \n", + " shuffle=True) " + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "46b705e1", + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess(text):\n", + " text = text.lower()\n", + " text = ''.join([word for word in text if word not in string.punctuation])\n", + " tokens = word_tokenize(text)\n", + " tokens = [word for word in tokens if word not in spacy_stopwords]\n", + " return ' '.join(tokens)\n", + "\n", + "X_train = X_train.apply(preprocess)\n", + "X_test = X_test.apply(preprocess)" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "id": "c52523f2", + "metadata": {}, + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[122], line 18\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[38;5;66;03m# Create a weight matrix for the embedding layer\u001b[39;00m\n\u001b[1;32m 17\u001b[0m embedding_matrix \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros((vocab_size, \u001b[38;5;241m300\u001b[39m))\n\u001b[0;32m---> 18\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m word, i \u001b[38;5;129;01min\u001b[39;00m tokenizer\u001b[38;5;241m.\u001b[39mword_index\u001b[38;5;241m.\u001b[39mitems():\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m word \u001b[38;5;129;01min\u001b[39;00m glove_vectors\u001b[38;5;241m.\u001b[39mindex_to_key:\n\u001b[1;32m 20\u001b[0m embedding_matrix[i] \u001b[38;5;241m=\u001b[39m glove_vectors[word]\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# Tokenize the text data\n", + "tokenizer = Tokenizer()\n", + "tokenizer.fit_on_texts(X_train)\n", + "\n", + "X_train = tokenizer.texts_to_sequences(X_train)\n", + "X_test = tokenizer.texts_to_sequences(X_test)\n", + "\n", + "vocab_size = len(tokenizer.word_index) + 1\n", + "\n", + "# Pad the sequences to a fixed length\n", + "max_length = 300\n", + "X_train = pad_sequences(X_train, maxlen=max_length, padding='post')\n", + "X_test = pad_sequences(X_test, maxlen=max_length, padding='post')\n", + "\n", + "\n", + "# Create a weight matrix for the embedding layer\n", + "embedding_matrix = np.zeros((vocab_size, 300))\n", + "for word, i in tokenizer.word_index.items():\n", + " if word in glove_vectors.index_to_key:\n", + " embedding_matrix[i] = glove_vectors[word]\n", + "\n", + "# Define the CNN model\n", + "model = Sequential()\n", + "model.add(Embedding(vocab_size, 300, weights=[embedding_matrix], input_length=max_length, trainable=False))\n", + "model.add(Conv1D(128, 5, activation='relu'))\n", + "model.add(MaxPooling1D(5))\n", + "model.add(Conv1D(128, 5, activation='relu'))\n", + "model.add(MaxPooling1D(5))\n", + "model.add(Flatten())\n", + "model.add(Dense(128, activation='relu'))\n", + "model.add(Dense(1, activation='sigmoid'))\n", + "\n", + "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n", + "model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "2eb19e13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "43/43 [==============================] - 0s 3ms/step - loss: 0.6626 - accuracy: 0.9155\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.6626473665237427, 0.9154518842697144]" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.evaluate(X_test, y_test)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "po", + "language": "python", + "name": "po" + }, + "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.9.0" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}