diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..b17f688 Binary files /dev/null and b/.DS_Store differ diff --git a/README.md b/README.md new file mode 100644 index 0000000..efaba39 --- /dev/null +++ b/README.md @@ -0,0 +1,49 @@ +# How people’s attitude towards COVID-19 has changed? +### Heather Chen + +#### 1. Research questions +My research project is basically a content analysis program that focuses on the changes in people’s attitudes during the period of covid-19. To be specific, using Global Database of Events, Language and Tone (GDELT), my research devotes to answering the following three questions:
+**1) How the volume of news about covid-19 has changed? Are there any breakpoints?**
+**2) Which countries report covid-19 news most often? Can we see a pattern here?**
+**3) Do countries differ in their focus about covid-19?**
+In the sections below, I will first introduce the dataset that I utilize in this project. In the third section, I will discuss the large-scale computing strategies that I employ and why they are necessary for the implementation of the project. In the fourth section, I will present general results that answer the research questions. In the last section, I will discuss shortly the limitations of my project and how it can be improved if possible.
+ +#### 2. Data and project description +The corpus that I am using in this project is a sub-database called “covid19.onlinenewsgeo” from GDELT. It extracts and updates news about covid-19 across the world every 15 minutes. The database contains the title, url, origin country, contextual content, and other important information about one individual news. I will only focus on several aspects in the following analysis.

+Also, given the huge volume of covid-19 news, I only select news from January 7th to March 31st. On January 7th, the Chinese government officially reported (or acknowledged) the disease for the first time, so it is a reasonable start point. The length of three months gives us enough time to track changes in attitudes. Therefore, data from January 7th to March 31st is the optimal choice given the limited computing power (which I will discuss in detail later in the fifth section).
+ +#### 3. Parallelism or large-scale computing strategy +I mainly utilize two large-scale computing strategies in this project: Amazon S3 for data storage and PySpark on EMR cluster for data analysis.
+**1) Amazon S3 bucket**
+I use Amazon S3 bucket for data storage because the daily news data (in csv format) is too large to save and process on local machine. The 85-days-corpus takes over 50 GBs of storage. Uploading them onto S3 bucket also makes them available for future processing on EMR cluster.
+**2) PySpark on EMR cluster**
+To do exploratory analysis and topic modeling on the corpus, I employ PySpark on EMR cluster. Exploratory data analysis involves selecting and filtering data of given criterion. I create an EMR cluster of 2 instances since this part does not require much computing power. However, topic modeling requires more complex machine learning methods, including Tokenizer, StopwordRemover, TF-IDF, CountVectorizer, as well as Latent Dirichlet Allocation. Therefore, an 8-instances cluster is created especially for this part.
+ +#### 4. Results +Here in this section, I will present the results of my project in the order of research questions. final_project.ipynb contains most of the information in exploratory analysis. final_project2.ipynb does all of topic modeling.
+ +**1) How the volume of news about covid-19 has changed?**
+![Figure 1.1](https://github.com/heathercchen/LSC_projects/graphs/1.1.jpg)
+![Figure 1.2](https://github.com/heathercchen/LSC_projects/graphs/1.2.jpg)
+To answer this question, I make a graph using data size against time and another graph using the amount of news against time. These two graphs show very similar trends. The news of covid-19 surged at around January 17th for the first time. The second outbreak happens at around March 5th. From then on, there are more than 600,000 of news every day about covid-19.
+ +**2) Which countries report covid-19 news most often? Can we see a pattern here?**
+![Figure 2.1](https://github.com/lsc4ss-a20/final-project-heathercchen/blob/master/graphs/2.1.jpg)
+From the graph above we can see that, different countries have different trend when reporting the news about covid-19. Here I only select 5 countries, China, America, the United Kingdom, Brazil, and India. The peak of news from China appears around the end of January, which is different from any other countries here. The U.S. reports few news about the pandemic at the beginning, just like other western countries. However, people’s attention tremendously increases at around the beginning of March. (From my experience, it is when the cases in the U.S. begin to spread across the states.)
+ +**3) Do countries differ in their focus about covid-19?**
+In topic modeling part, I only select China and the U.S. as two countries of example. In each of the three months, I extract 5 topics and top 10 words from these topics. Below are the results from China in January, Febuary, and March.
+![Figure 3.1.1](https://github.com/heathercchen/LSC_projects/graphs/3.1.1.jpg)
+![Figure 3.1.2](https://github.com/heathercchen/LSC_projects/graphs/3.1.2.jpg)
+![Figure 3.1.3](https://github.com/heathercchen/LSC_projectsgraphs/3.1.3.jpg)
+Results in January reveal no clear patterns. While in Febuary, the second topic contains words like “li”, “wenliang”, and “media”, which clearly illustrates the story of China’s whistle-blower Wenliang Li. His warnings against the virus were suppressed by officials. His death brought nationwide sorrow, respectfulness, and anger. Topics in March contain more information on people’s daily lives, such as lockdown, quarantine, and restrictions. The names of political leaders also appear in topic 3.
+![Figure 3.2.1](https://github.com/heathercchen/LSC_projects/graphs/3.2.1.jpg)
+![Figure 3.2.2](https://github.com/heathercchen/LSC_projectsgraphs/3.2.2.jpg)
+![Figure 3.2.3](https://github.com/heathercchen/LSC_projectsgraphs/3.2.3.jpg)
+At the same time in the U.S., the media’s focus is somewhat different. As we can see in January, there are many names of locations such as “alaska”, “chicago”, “san francisco”, and “los angeles”. States in the U.S. begin to report their first cases. In Febuary, we can see similar names of places, while there are more political terms such as “trump”, “white house”, “president”, and “cdc”. In March, besides reporting new cases in several states, we can see in topic 1 words like “economic” and “package”. They are not found in any of the topics in China.
+ +Summarized from the above, from this simple topic modeling, we can clearly get a sense of what these two countries are looking at during the three months. There are some similarities between their focuses, while we cannot conclude for sure about their preferences on certain well-structured topics (E.g., Americans focus more on economic topics regarding covid).
+ +#### 5. Discussions (Further advancements for better results) +Having all the results, to some degree, what we get in content analysis captures what happened in real lives.

+ However, my project has a lot of space for future improvements. Due to the speed of using VPN to access AWS (I am in China right now), I am not able to run on larger datasets and employ more complicated machine learning techniques. If time and computing power permits, I would include more enhanced techniques on the corpus, including lemmatizing and normalizing the tokens.
diff --git a/final_project.ipynb b/final_project.ipynb new file mode 100644 index 0000000..cf1a735 --- /dev/null +++ b/final_project.ipynb @@ -0,0 +1,970 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Final Project \n", + "### Heather Chen\n", + "#### 1. Import the data uploaded on S3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "spark" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d42b8dc66c3248328e4a5ba7e8a99f23", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Spark application\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
IDYARN Application IDKindStateSpark UIDriver logCurrent session?
0application_1607702121291_0001pysparkidleLinkLink✔
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SparkSession available as 'spark'.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting boto3\n", + " Downloading https://files.pythonhosted.org/packages/2f/f5/aeb4d65266f7712a627674bd19994cee3e1c66ff588adbc4db3fc0bbbf97/boto3-1.16.34-py2.py3-none-any.whl (129kB)\n", + "Collecting s3transfer<0.4.0,>=0.3.0 (from boto3)\n", + " Downloading https://files.pythonhosted.org/packages/69/79/e6afb3d8b0b4e96cefbdc690f741d7dd24547ff1f94240c997a26fa908d3/s3transfer-0.3.3-py2.py3-none-any.whl (69kB)\n", + "Requirement already satisfied: jmespath<1.0.0,>=0.7.1 in /usr/local/lib/python3.7/site-packages (from boto3)\n", + "Collecting botocore<1.20.0,>=1.19.34 (from boto3)\n", + " Downloading https://files.pythonhosted.org/packages/03/ef/e35e41d6e445f472ac8f4fca8dd22726d8c6dc19ab06317164a222d13599/botocore-1.19.34-py2.py3-none-any.whl (7.0MB)\n", + "Collecting python-dateutil<3.0.0,>=2.1 (from botocore<1.20.0,>=1.19.34->boto3)\n", + " Downloading https://files.pythonhosted.org/packages/d4/70/d60450c3dd48ef87586924207ae8907090de0b306af2bce5d134d78615cb/python_dateutil-2.8.1-py2.py3-none-any.whl (227kB)\n", + "Collecting urllib3<1.27,>=1.25.4; python_version != \"3.4\" (from botocore<1.20.0,>=1.19.34->boto3)\n", + " Downloading https://files.pythonhosted.org/packages/f5/71/45d36a8df68f3ebb098d6861b2c017f3d094538c0fb98fa61d4dc43e69b9/urllib3-1.26.2-py2.py3-none-any.whl (136kB)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/site-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.20.0,>=1.19.34->boto3)\n", + "Installing collected packages: python-dateutil, urllib3, botocore, s3transfer, boto3\n", + "Successfully installed boto3-1.16.34 botocore-1.19.34 python-dateutil-2.8.1 s3transfer-0.3.3 urllib3-1.26.2" + ] + } + ], + "source": [ + "sc.install_pypi_package(\"boto3\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1aedc1b8069f4310a2300230c8832898", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2020-12-07 14:46:28+00:00 \t 4 MB\t gdelt_data/bq-results-0107.csv \n", + "\n", + "2020-12-07 14:45:53+00:00 \t 4 MB\t gdelt_data/bq-results-0108.csv \n", + "\n", + "2020-12-07 14:47:16+00:00 \t 9 MB\t gdelt_data/bq-results-0109.csv \n", + "\n", + "2020-12-07 14:46:30+00:00 \t 6 MB\t gdelt_data/bq-results-0110.csv \n", + "\n", + "2020-12-07 14:46:04+00:00 \t 6 MB\t gdelt_data/bq-results-0111.csv \n", + "\n", + "2020-12-07 14:49:53+00:00 \t 2 MB\t gdelt_data/bq-results-0112.csv \n", + "\n", + "2020-12-07 14:50:25+00:00 \t 7 MB\t gdelt_data/bq-results-0113.csv \n", + "\n", + "2020-12-07 14:50:13+00:00 \t 6 MB\t gdelt_data/bq-results-0114.csv \n", + "\n", + "2020-12-07 14:50:22+00:00 \t 6 MB\t gdelt_data/bq-results-0115.csv \n", + "\n", + "2020-12-07 14:51:03+00:00 \t 10 MB\t gdelt_data/bq-results-0116.csv \n", + "\n", + "2020-12-07 14:49:21+00:00 \t 20 MB\t gdelt_data/bq-results-0117.csv \n", + "\n", + "2020-12-07 14:50:40+00:00 \t 17 MB\t gdelt_data/bq-results-0118.csv \n", + "\n", + "2020-12-07 14:50:24+00:00 \t 10 MB\t gdelt_data/bq-results-0119.csv \n", + "\n", + "2020-12-07 14:49:22+00:00 \t 41 MB\t gdelt_data/bq-results-0120.csv \n", + "\n", + "2020-12-07 14:49:21+00:00 \t 99 MB\t gdelt_data/bq-results-0121.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 129 MB\t gdelt_data/bq-results-0122.csv \n", + "\n", + "2020-12-07 14:56:08+00:00 \t 151 MB\t gdelt_data/bq-results-0123.csv \n", + "\n", + "2020-12-07 14:56:08+00:00 \t 185 MB\t gdelt_data/bq-results-0124.csv \n", + "\n", + "2020-12-07 14:56:09+00:00 \t 148 MB\t gdelt_data/bq-results-0125.csv \n", + "\n", + "2020-12-07 14:56:09+00:00 \t 167 MB\t gdelt_data/bq-results-0126.csv \n", + "\n", + "2020-12-07 14:56:09+00:00 \t 203 MB\t gdelt_data/bq-results-0127.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 255 MB\t gdelt_data/bq-results-0128.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 296 MB\t gdelt_data/bq-results-0129.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 316 MB\t gdelt_data/bq-results-0130.csv \n", + "\n", + "2020-12-08 17:29:14+00:00 \t 324 MB\t gdelt_data/bq-results-0131.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 210 MB\t gdelt_data/bq-results-0201.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 225 MB\t gdelt_data/bq-results-0202.csv \n", + "\n", + "2020-12-07 15:13:07+00:00 \t 292 MB\t gdelt_data/bq-results-0203.csv \n", + "\n", + "2020-12-07 15:13:07+00:00 \t 274 MB\t gdelt_data/bq-results-0204.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 272 MB\t gdelt_data/bq-results-0205.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 254 MB\t gdelt_data/bq-results-0206.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 247 MB\t gdelt_data/bq-results-0207.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 161 MB\t gdelt_data/bq-results-0208.csv \n", + "\n", + "2020-12-07 16:02:50+00:00 \t 155 MB\t gdelt_data/bq-results-0209.csv \n", + "\n", + "2020-12-07 16:02:50+00:00 \t 210 MB\t gdelt_data/bq-results-0210.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 201 MB\t gdelt_data/bq-results-0211.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 193 MB\t gdelt_data/bq-results-0212.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 217 MB\t gdelt_data/bq-results-0213.csv \n", + "\n", + "2020-12-07 16:09:59+00:00 \t 177 MB\t gdelt_data/bq-results-0214.csv \n", + "\n", + "2020-12-07 16:09:59+00:00 \t 128 MB\t gdelt_data/bq-results-0215.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 130 MB\t gdelt_data/bq-results-0216.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 186 MB\t gdelt_data/bq-results-0217.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 209 MB\t gdelt_data/bq-results-0218.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 191 MB\t gdelt_data/bq-results-0219.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 198 MB\t gdelt_data/bq-results-0220.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 257 MB\t gdelt_data/bq-results-0221.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 155 MB\t gdelt_data/bq-results-0222.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 173 MB\t gdelt_data/bq-results-0223.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 274 MB\t gdelt_data/bq-results-0224.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 302 MB\t gdelt_data/bq-results-0225.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 333 MB\t gdelt_data/bq-results-0226.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 371 MB\t gdelt_data/bq-results-0227.csv \n", + "\n", + "2020-12-07 16:53:44+00:00 \t 367 MB\t gdelt_data/bq-results-0228.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 276 MB\t gdelt_data/bq-results-0229.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 255 MB\t gdelt_data/bq-results-0301.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 405 MB\t gdelt_data/bq-results-0302.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 379 MB\t gdelt_data/bq-results-0303.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 389 MB\t gdelt_data/bq-results-0304.csv \n", + "\n", + "2020-12-07 17:18:38+00:00 \t 422 MB\t gdelt_data/bq-results-0305.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 424 MB\t gdelt_data/bq-results-0306.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 317 MB\t gdelt_data/bq-results-0307.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 333 MB\t gdelt_data/bq-results-0308.csv \n", + "\n", + "2020-12-07 17:18:38+00:00 \t 539 MB\t gdelt_data/bq-results-0309.csv \n", + "\n", + "2020-12-07 17:18:39+00:00 \t 626 MB\t gdelt_data/bq-results-0310.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 674 MB\t gdelt_data/bq-results-0311.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 773 MB\t gdelt_data/bq-results-0312.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 807 MB\t gdelt_data/bq-results-0313.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 583 MB\t gdelt_data/bq-results-0314.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 587 MB\t gdelt_data/bq-results-0315.csv \n", + "\n", + "2020-12-08 12:07:45+00:00 \t 754 MB\t gdelt_data/bq-results-0316.csv \n", + "\n", + "2020-12-08 12:07:47+00:00 \t 852 MB\t gdelt_data/bq-results-0317.csv \n", + "\n", + "2020-12-08 12:07:46+00:00 \t 918 MB\t gdelt_data/bq-results-0318.csv \n", + "\n", + "2020-12-08 12:07:46+00:00 \t 925 MB\t gdelt_data/bq-results-0319.csv \n", + "\n", + "2020-12-08 12:07:47+00:00 \t 865 MB\t gdelt_data/bq-results-0320.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 682 MB\t gdelt_data/bq-results-0321.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 677 MB\t gdelt_data/bq-results-0322.csv \n", + "\n", + "2020-12-08 13:30:22+00:00 \t 863 MB\t gdelt_data/bq-results-0323.csv \n", + "\n", + "2020-12-08 13:30:22+00:00 \t 891 MB\t gdelt_data/bq-results-0324.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 901 MB\t gdelt_data/bq-results-0325.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 886 MB\t gdelt_data/bq-results-0326.csv \n", + "\n", + "2020-12-08 15:06:24+00:00 \t 870 MB\t gdelt_data/bq-results-0327.csv \n", + "\n", + "2020-12-08 15:06:24+00:00 \t 603 MB\t gdelt_data/bq-results-0328.csv \n", + "\n", + "2020-12-08 15:06:24+00:00 \t 625 MB\t gdelt_data/bq-results-0329.csv \n", + "\n", + "2020-12-08 15:45:47+00:00 \t 801 MB\t gdelt_data/bq-results-0330.csv \n", + "\n", + "2020-12-08 15:45:47+00:00 \t 834 MB\t gdelt_data/bq-results-0331.csv" + ] + } + ], + "source": [ + "#Get the names and sizes of these data files using Amazon boto3\n", + "import boto3\n", + "\n", + "s3 = boto3.resource('s3')\n", + "bucket = 'aws-emr-resources-787469208957-us-east-1'\n", + "bucket_resource = s3.Bucket(bucket)\n", + "file_sizes = []\n", + "file_names = []\n", + "\n", + "for obj in bucket_resource.objects.all():\n", + " if 'gdelt_data' in obj.key and 'bq-results' in obj.key:\n", + " print(obj.last_modified,\"\\t\", round(obj.size * 1e-6), \"MB\\t\",\n", + " obj.key, \"\\n\")\n", + " file_sizes.append(obj.size * 1e-6)\n", + " file_names.append(obj.key)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f540339ef8ea4014a3baed4a699af3ea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Then read these data files to spark dataframe\n", + "df_list = []\n", + "for filename in file_names:\n", + " df = spark.read.csv('s3://aws-emr-resources-787469208957-us-east-1/' + filename, header=True)\n", + " df_list.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac79297f28a041d2937d5ed2cc8631bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- DateTime: string (nullable = true)\n", + " |-- URL: string (nullable = true)\n", + " |-- Title: string (nullable = true)\n", + " |-- SharingImage: string (nullable = true)\n", + " |-- LangCode: string (nullable = true)\n", + " |-- DocTone: string (nullable = true)\n", + " |-- DomainCountryCode: string (nullable = true)\n", + " |-- Location: string (nullable = true)\n", + " |-- Lat: string (nullable = true)\n", + " |-- Lon: string (nullable = true)\n", + " |-- CountryCode: string (nullable = true)\n", + " |-- Adm1Code: string (nullable = true)\n", + " |-- Adm2Code: string (nullable = true)\n", + " |-- GeoType: string (nullable = true)\n", + " |-- ContextualText: string (nullable = true)\n", + " |-- GeoCoord: string (nullable = true)" + ] + } + ], + "source": [ + "#Show the structure of these data files\n", + "df_list[0].printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2. How the volume of news about covid-19 has changed?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb1d67f1801d4373a9d5a6cbcbe081ae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting pandas\n", + " Downloading https://files.pythonhosted.org/packages/fd/70/e8eee0cbddf926bf51958c7d6a86bc69167c300fa2ba8e592330a2377d1b/pandas-1.1.5-cp37-cp37m-manylinux1_x86_64.whl (9.5MB)\n", + "Requirement already satisfied: numpy>=1.15.4 in /usr/local/lib64/python3.7/site-packages (from pandas)\n", + "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/site-packages (from pandas)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /mnt/tmp/1607702376424-0/lib/python3.7/site-packages (from pandas)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/site-packages (from python-dateutil>=2.7.3->pandas)\n", + "Installing collected packages: pandas\n", + "Successfully installed pandas-1.1.5" + ] + } + ], + "source": [ + "#If looking at the size of these data files\n", + "#First import pandas\n", + "sc.install_pypi_package(\"pandas\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "43726ed0dafb40259979cb7526021f4d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib\n", + " Downloading https://files.pythonhosted.org/packages/30/f2/10c822cb0ca5ebec58bd1892187bc3e3db64a867ac26531c6204663fc218/matplotlib-3.3.3-cp37-cp37m-manylinux1_x86_64.whl (11.6MB)\n", + "Requirement already satisfied: numpy>=1.15 in /usr/local/lib64/python3.7/site-packages (from matplotlib)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /mnt/tmp/1607702376424-0/lib/python3.7/site-packages (from matplotlib)\n", + "Collecting pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 (from matplotlib)\n", + " Downloading https://files.pythonhosted.org/packages/8a/bb/488841f56197b13700afd5658fc279a2025a39e22449b7cf29864669b15d/pyparsing-2.4.7-py2.py3-none-any.whl (67kB)\n", + "Collecting pillow>=6.2.0 (from matplotlib)\n", + " Downloading https://files.pythonhosted.org/packages/af/fa/c1302a26d5e1a17fa8e10e43417b6cf038b0648c4b79fcf2302a4a0c5d30/Pillow-8.0.1-cp37-cp37m-manylinux1_x86_64.whl (2.2MB)\n", + "Collecting cycler>=0.10 (from matplotlib)\n", + " Downloading https://files.pythonhosted.org/packages/f7/d2/e07d3ebb2bd7af696440ce7e754c59dd546ffe1bbe732c8ab68b9c834e61/cycler-0.10.0-py2.py3-none-any.whl\n", + "Collecting kiwisolver>=1.0.1 (from matplotlib)\n", + " Downloading https://files.pythonhosted.org/packages/d2/46/231de802ade4225b76b96cffe419cf3ce52bbe92e3b092cf12db7d11c207/kiwisolver-1.3.1-cp37-cp37m-manylinux1_x86_64.whl (1.1MB)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/site-packages (from python-dateutil>=2.1->matplotlib)\n", + "Installing collected packages: pyparsing, pillow, cycler, kiwisolver, matplotlib\n", + "Successfully installed cycler-0.10.0 kiwisolver-1.3.1 matplotlib-3.3.3 pillow-8.0.1 pyparsing-2.4.7" + ] + } + ], + "source": [ + "sc.install_pypi_package(\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5ff56bb60751498fa9ed5f3d91402460", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "from datetime import datetime\n", + "import matplotlib.pyplot as plt\n", + "\n", + "date_range = pd.date_range(start=\"2020-01-07\",end=\"2020-03-31\")\n", + "plt.plot(date_range, file_sizes)\n", + "plt.title(\"The volume of covid-19 data from 01/07 to 03/31 using file sizes (in MBs)\")\n", + "plt.locator_params(axis='x', nbins=20)\n", + "plt.xticks(rotation='45', size='7.5')\n", + "plt.show()\n", + "%matplot plt" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d94b068c73bc41c3a02289be198bbacd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#If looking at the number of news within each datafile\n", + "num_news = []\n", + "for file in df_list:\n", + " num_news.append(file.count())\n", + "\n", + "plt.close()\n", + "plt.plot(date_range, num_news)\n", + "plt.title(\"The volume of covid-19 data from 01/07 to 03/31 using no. of news\")\n", + "plt.locator_params(axis='x', nbins=20)\n", + "plt.xticks(rotation='45', size='7.5')\n", + "plt.show()\n", + "%matplot plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3. Which countries report covid-19 news most often?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f190918961543ada1f6fa5fb7d3c648", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Get the count of countries within each datafile\n", + "country_df_list = []\n", + "no_countries = []\n", + "for file in df_list:\n", + " country_df = file.groupby('CountryCode').count()\n", + " country_df_list.append(country_df)\n", + " no_countries.append(country_df.count())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "12630d0dc71e4bcab13e1c3fd6bb15f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot the number of countries\n", + "plt.close()\n", + "plt.plot(date_range, no_countries)\n", + "plt.title(\"The no. of countries reporting covid-19 news from 01/07 to 03/31\")\n", + "plt.locator_params(axis='x', nbins=20)\n", + "plt.xticks(rotation='45', size='7.5')\n", + "plt.show()\n", + "%matplot plt" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "11d8a21702f94ba29384b6802626a032", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Now select some countries of interest to see their number of reporting news\n", + "#Here we select CH(China), US, UK, JP(Japan), BR(Brazil), and IN(India)\n", + "def get_num_news_for_country(country):\n", + " country_newsNo = []\n", + " for file in country_df_list:\n", + " try:\n", + " no_news = file.filter(file.CountryCode==country).collect()[0]['count']\n", + " country_newsNo.append(no_news)\n", + " except IndexError:\n", + " country_newsNo.append(0)\n", + " return country_newsNo" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf0325af747345538625cbb85a3a6efd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CH_newsNo = get_num_news_for_country('CH')\n", + "US_newsNo = get_num_news_for_country('US')\n", + "UK_newsNo = get_num_news_for_country('UK')\n", + "BR_newsNo = get_num_news_for_country('BR')\n", + "IN_newsNo = get_num_news_for_country('IN')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c708bdba0cc74814b53ed45e442a2b83", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot the number of news for each countries\n", + "plt.close()\n", + "plt.plot(date_range, CH_newsNo, label='CH')\n", + "plt.plot(date_range, US_newsNo, label='US')\n", + "plt.plot(date_range, UK_newsNo, label='UK')\n", + "plt.plot(date_range, BR_newsNo, label='BR')\n", + "plt.plot(date_range, IN_newsNo, label='IN')\n", + "plt.legend()\n", + "plt.title(\"The no. of countries reporting covid-19 news from 01/07 to 03/31\")\n", + "plt.locator_params(axis='x', nbins=20)\n", + "plt.xticks(rotation='45', size='7.5')\n", + "plt.show()\n", + "%matplot plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "PySpark", + "language": "", + "name": "pysparkkernel" + }, + "language_info": { + "codemirror_mode": { + "name": "python", + "version": 2 + }, + "mimetype": "text/x-python", + "name": "pyspark", + "pygments_lexer": "python2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/final_project2.ipynb b/final_project2.ipynb new file mode 100644 index 0000000..8f5df4a --- /dev/null +++ b/final_project2.ipynb @@ -0,0 +1,1405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Final Project Notebook 2\n", + "### Heather Chen\n", + "#### 4. Topic modeling using Pyspark" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45c4cc7a7d04425c8c9f57dba506b93e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Spark application\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
IDYARN Application IDKindStateSpark UIDriver logCurrent session?
0application_1607674079580_0001pysparkidleLinkLink✔
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SparkSession available as 'spark'.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "" + ] + } + ], + "source": [ + "spark" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0e7aa1f78b6d436a894526191f069911", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting boto3\n", + " Downloading https://files.pythonhosted.org/packages/2f/f5/aeb4d65266f7712a627674bd19994cee3e1c66ff588adbc4db3fc0bbbf97/boto3-1.16.34-py2.py3-none-any.whl (129kB)\n", + "Collecting s3transfer<0.4.0,>=0.3.0 (from boto3)\n", + " Downloading https://files.pythonhosted.org/packages/69/79/e6afb3d8b0b4e96cefbdc690f741d7dd24547ff1f94240c997a26fa908d3/s3transfer-0.3.3-py2.py3-none-any.whl (69kB)\n", + "Requirement already satisfied: jmespath<1.0.0,>=0.7.1 in /usr/local/lib/python3.7/site-packages (from boto3)\n", + "Collecting botocore<1.20.0,>=1.19.34 (from boto3)\n", + " Downloading https://files.pythonhosted.org/packages/03/ef/e35e41d6e445f472ac8f4fca8dd22726d8c6dc19ab06317164a222d13599/botocore-1.19.34-py2.py3-none-any.whl (7.0MB)\n", + "Collecting python-dateutil<3.0.0,>=2.1 (from botocore<1.20.0,>=1.19.34->boto3)\n", + " Downloading https://files.pythonhosted.org/packages/d4/70/d60450c3dd48ef87586924207ae8907090de0b306af2bce5d134d78615cb/python_dateutil-2.8.1-py2.py3-none-any.whl (227kB)\n", + "Collecting urllib3<1.27,>=1.25.4; python_version != \"3.4\" (from botocore<1.20.0,>=1.19.34->boto3)\n", + " Downloading https://files.pythonhosted.org/packages/f5/71/45d36a8df68f3ebb098d6861b2c017f3d094538c0fb98fa61d4dc43e69b9/urllib3-1.26.2-py2.py3-none-any.whl (136kB)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/site-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.20.0,>=1.19.34->boto3)\n", + "Installing collected packages: python-dateutil, urllib3, botocore, s3transfer, boto3\n", + "Successfully installed boto3-1.16.34 botocore-1.19.34 python-dateutil-2.8.1 s3transfer-0.3.3 urllib3-1.26.2" + ] + } + ], + "source": [ + "sc.install_pypi_package(\"boto3\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9a56b5777794dbdbf8e0a596cb9b5fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2020-12-07 14:46:28+00:00 \t 4 MB\t gdelt_data/bq-results-0107.csv \n", + "\n", + "2020-12-07 14:45:53+00:00 \t 4 MB\t gdelt_data/bq-results-0108.csv \n", + "\n", + "2020-12-07 14:47:16+00:00 \t 9 MB\t gdelt_data/bq-results-0109.csv \n", + "\n", + "2020-12-07 14:46:30+00:00 \t 6 MB\t gdelt_data/bq-results-0110.csv \n", + "\n", + "2020-12-07 14:46:04+00:00 \t 6 MB\t gdelt_data/bq-results-0111.csv \n", + "\n", + "2020-12-07 14:49:53+00:00 \t 2 MB\t gdelt_data/bq-results-0112.csv \n", + "\n", + "2020-12-07 14:50:25+00:00 \t 7 MB\t gdelt_data/bq-results-0113.csv \n", + "\n", + "2020-12-07 14:50:13+00:00 \t 6 MB\t gdelt_data/bq-results-0114.csv \n", + "\n", + "2020-12-07 14:50:22+00:00 \t 6 MB\t gdelt_data/bq-results-0115.csv \n", + "\n", + "2020-12-07 14:51:03+00:00 \t 10 MB\t gdelt_data/bq-results-0116.csv \n", + "\n", + "2020-12-07 14:49:21+00:00 \t 20 MB\t gdelt_data/bq-results-0117.csv \n", + "\n", + "2020-12-07 14:50:40+00:00 \t 17 MB\t gdelt_data/bq-results-0118.csv \n", + "\n", + "2020-12-07 14:50:24+00:00 \t 10 MB\t gdelt_data/bq-results-0119.csv \n", + "\n", + "2020-12-07 14:49:22+00:00 \t 41 MB\t gdelt_data/bq-results-0120.csv \n", + "\n", + "2020-12-07 14:49:21+00:00 \t 99 MB\t gdelt_data/bq-results-0121.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 129 MB\t gdelt_data/bq-results-0122.csv \n", + "\n", + "2020-12-07 14:56:08+00:00 \t 151 MB\t gdelt_data/bq-results-0123.csv \n", + "\n", + "2020-12-07 14:56:08+00:00 \t 185 MB\t gdelt_data/bq-results-0124.csv \n", + "\n", + "2020-12-07 14:56:09+00:00 \t 148 MB\t gdelt_data/bq-results-0125.csv \n", + "\n", + "2020-12-07 14:56:09+00:00 \t 167 MB\t gdelt_data/bq-results-0126.csv \n", + "\n", + "2020-12-07 14:56:09+00:00 \t 203 MB\t gdelt_data/bq-results-0127.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 255 MB\t gdelt_data/bq-results-0128.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 296 MB\t gdelt_data/bq-results-0129.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 316 MB\t gdelt_data/bq-results-0130.csv \n", + "\n", + "2020-12-08 17:29:14+00:00 \t 324 MB\t gdelt_data/bq-results-0131.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 210 MB\t gdelt_data/bq-results-0201.csv \n", + "\n", + "2020-12-07 15:13:06+00:00 \t 225 MB\t gdelt_data/bq-results-0202.csv \n", + "\n", + "2020-12-07 15:13:07+00:00 \t 292 MB\t gdelt_data/bq-results-0203.csv \n", + "\n", + "2020-12-07 15:13:07+00:00 \t 274 MB\t gdelt_data/bq-results-0204.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 272 MB\t gdelt_data/bq-results-0205.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 254 MB\t gdelt_data/bq-results-0206.csv \n", + "\n", + "2020-12-07 15:48:44+00:00 \t 247 MB\t gdelt_data/bq-results-0207.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 161 MB\t gdelt_data/bq-results-0208.csv \n", + "\n", + "2020-12-07 16:02:50+00:00 \t 155 MB\t gdelt_data/bq-results-0209.csv \n", + "\n", + "2020-12-07 16:02:50+00:00 \t 210 MB\t gdelt_data/bq-results-0210.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 201 MB\t gdelt_data/bq-results-0211.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 193 MB\t gdelt_data/bq-results-0212.csv \n", + "\n", + "2020-12-07 16:09:58+00:00 \t 217 MB\t gdelt_data/bq-results-0213.csv \n", + "\n", + "2020-12-07 16:09:59+00:00 \t 177 MB\t gdelt_data/bq-results-0214.csv \n", + "\n", + "2020-12-07 16:09:59+00:00 \t 128 MB\t gdelt_data/bq-results-0215.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 130 MB\t gdelt_data/bq-results-0216.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 186 MB\t gdelt_data/bq-results-0217.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 209 MB\t gdelt_data/bq-results-0218.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 191 MB\t gdelt_data/bq-results-0219.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 198 MB\t gdelt_data/bq-results-0220.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 257 MB\t gdelt_data/bq-results-0221.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 155 MB\t gdelt_data/bq-results-0222.csv \n", + "\n", + "2020-12-07 16:28:42+00:00 \t 173 MB\t gdelt_data/bq-results-0223.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 274 MB\t gdelt_data/bq-results-0224.csv \n", + "\n", + "2020-12-07 16:28:43+00:00 \t 302 MB\t gdelt_data/bq-results-0225.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 333 MB\t gdelt_data/bq-results-0226.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 371 MB\t gdelt_data/bq-results-0227.csv \n", + "\n", + "2020-12-07 16:53:44+00:00 \t 367 MB\t gdelt_data/bq-results-0228.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 276 MB\t gdelt_data/bq-results-0229.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 255 MB\t gdelt_data/bq-results-0301.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 405 MB\t gdelt_data/bq-results-0302.csv \n", + "\n", + "2020-12-07 16:53:43+00:00 \t 379 MB\t gdelt_data/bq-results-0303.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 389 MB\t gdelt_data/bq-results-0304.csv \n", + "\n", + "2020-12-07 17:18:38+00:00 \t 422 MB\t gdelt_data/bq-results-0305.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 424 MB\t gdelt_data/bq-results-0306.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 317 MB\t gdelt_data/bq-results-0307.csv \n", + "\n", + "2020-12-07 17:46:22+00:00 \t 333 MB\t gdelt_data/bq-results-0308.csv \n", + "\n", + "2020-12-07 17:18:38+00:00 \t 539 MB\t gdelt_data/bq-results-0309.csv \n", + "\n", + "2020-12-07 17:18:39+00:00 \t 626 MB\t gdelt_data/bq-results-0310.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 674 MB\t gdelt_data/bq-results-0311.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 773 MB\t gdelt_data/bq-results-0312.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 807 MB\t gdelt_data/bq-results-0313.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 583 MB\t gdelt_data/bq-results-0314.csv \n", + "\n", + "2020-12-08 11:13:06+00:00 \t 587 MB\t gdelt_data/bq-results-0315.csv \n", + "\n", + "2020-12-08 12:07:45+00:00 \t 754 MB\t gdelt_data/bq-results-0316.csv \n", + "\n", + "2020-12-08 12:07:47+00:00 \t 852 MB\t gdelt_data/bq-results-0317.csv \n", + "\n", + "2020-12-08 12:07:46+00:00 \t 918 MB\t gdelt_data/bq-results-0318.csv \n", + "\n", + "2020-12-08 12:07:46+00:00 \t 925 MB\t gdelt_data/bq-results-0319.csv \n", + "\n", + "2020-12-08 12:07:47+00:00 \t 865 MB\t gdelt_data/bq-results-0320.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 682 MB\t gdelt_data/bq-results-0321.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 677 MB\t gdelt_data/bq-results-0322.csv \n", + "\n", + "2020-12-08 13:30:22+00:00 \t 863 MB\t gdelt_data/bq-results-0323.csv \n", + "\n", + "2020-12-08 13:30:22+00:00 \t 891 MB\t gdelt_data/bq-results-0324.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 901 MB\t gdelt_data/bq-results-0325.csv \n", + "\n", + "2020-12-08 14:11:26+00:00 \t 886 MB\t gdelt_data/bq-results-0326.csv \n", + "\n", + "2020-12-08 15:06:24+00:00 \t 870 MB\t gdelt_data/bq-results-0327.csv \n", + "\n", + "2020-12-08 15:06:24+00:00 \t 603 MB\t gdelt_data/bq-results-0328.csv \n", + "\n", + "2020-12-08 15:06:24+00:00 \t 625 MB\t gdelt_data/bq-results-0329.csv \n", + "\n", + "2020-12-08 15:45:47+00:00 \t 801 MB\t gdelt_data/bq-results-0330.csv \n", + "\n", + "2020-12-08 15:45:47+00:00 \t 834 MB\t gdelt_data/bq-results-0331.csv" + ] + } + ], + "source": [ + "#Get the names and sizes of these data files using Amazon boto3\n", + "import boto3\n", + "\n", + "s3 = boto3.resource('s3')\n", + "bucket = 'aws-emr-resources-787469208957-us-east-1'\n", + "bucket_resource = s3.Bucket(bucket)\n", + "file_sizes = []\n", + "file_names = []\n", + "\n", + "for obj in bucket_resource.objects.all():\n", + " if 'gdelt_data' in obj.key and 'bq-results' in obj.key:\n", + " print(obj.last_modified,\"\\t\", round(obj.size * 1e-6), \"MB\\t\",\n", + " obj.key, \"\\n\")\n", + " file_sizes.append(obj.size * 1e-6)\n", + " file_names.append(obj.key)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4208d15079884c238ac1a4dc926fd172", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Then read these data files to spark dataframe\n", + "df_list = []\n", + "for filename in file_names:\n", + " df = spark.read.csv('s3://aws-emr-resources-787469208957-us-east-1/' + filename, header=True)\n", + " df_list.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9eb6e332aa1478e8620d0655dea42c0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#First divide these dataframes to January, Febuary, and March\n", + "jan_dfs = df_list[0:25]\n", + "feb_dfs = df_list[25:54]\n", + "march_dfs = df_list[54:85]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9034f7aa841846d7b3cf4f9c12fc0697", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Given the large volume of our data, we only select China and the U.S to see how their focused topics change over the\n", + "#three months\n", + "def collect_country_data(df_list, country):\n", + " indx = 0\n", + " for df in df_list:\n", + " df = df.filter(df.CountryCode==country)\n", + " if indx == 0:\n", + " ori_df = df\n", + " indx = indx + 1\n", + " continue\n", + " else:\n", + " curr_df = df\n", + " ori_df = ori_df.union(curr_df)\n", + " indx = indx + 1\n", + " return ori_df" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a88520353ba54b478d00586c866fd6cb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Collect data from China and from US\n", + "CH_jan_df = collect_country_data(jan_dfs, 'CH')\n", + "CH_feb_df = collect_country_data(feb_dfs, 'CH')\n", + "CH_march_df = collect_country_data(march_dfs, 'CH')\n", + "\n", + "US_jan_df = collect_country_data(jan_dfs, 'US')\n", + "US_feb_df = collect_country_data(feb_dfs, 'US')\n", + "US_march_df = collect_country_data(march_dfs, 'US')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d8124aceffc944f387e8842b27320d52", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Do basic data cleaning jobs for these dataframes\n", + "#(Since our text data is already lowercased, we only do basic regular expressions)\n", + "from pyspark.sql.functions import regexp_replace\n", + "from pyspark.ml.feature import Tokenizer\n", + "\n", + "def reg_clean_df(df):\n", + " # Remove punctuation (REGEX provided) and numbers\n", + " wrangled = df.withColumn('text', regexp_replace(df.ContextualText, '[_():;,.!?\\\\-]', ' '))\n", + " wrangled = wrangled.withColumn('text', regexp_replace(wrangled.text, '[0-9]', ' '))\n", + "\n", + " # Merge multiple spaces and drop null values here\n", + " wrangled = wrangled.withColumn('text', regexp_replace(wrangled.text, ' +', ' '))\n", + " wrangled = wrangled.na.drop()\n", + " \n", + " return wrangled\n", + "\n", + "CH_jan_cleaned_df = reg_clean_df(CH_jan_df)\n", + "CH_feb_cleaned_df = reg_clean_df(CH_feb_df)\n", + "CH_mar_cleaned_df = reg_clean_df(CH_march_df)\n", + "\n", + "US_jan_cleaned_df = reg_clean_df(US_jan_df)\n", + "US_feb_cleaned_df = reg_clean_df(US_feb_df)\n", + "US_mar_cleaned_df = reg_clean_df(US_march_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eb8bb802c56142e6843758effb42f61e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Define a function to do the following job before topic modeling\n", + "from pyspark.ml.feature import Tokenizer, StopWordsRemover, IDF, CountVectorizer\n", + "\n", + "def pre_analysis(df):\n", + " tokenized_df = Tokenizer(inputCol='text', outputCol='words').transform(df)\n", + " tokenized_df = tokenized_df.na.drop()\n", + " \n", + " # Remove stop words.\n", + " removeStopwords_df = StopWordsRemover(inputCol='words', outputCol='terms').transform(tokenized_df)\n", + "\n", + " tf_model = CountVectorizer(inputCol=\"terms\", outputCol=\"features\", vocabSize=40000, minDF=5).fit(removeStopwords_df)\n", + " vectorizer = tf_model.transform(removeStopwords_df)\n", + " \n", + " idfizer = IDF(inputCol='features', outputCol='tf_idf_features')\n", + " idf_model = idfizer.fit(vectorizer)\n", + " tfidf_result = idf_model.transform(vectorizer)\n", + " \n", + " #Return a tuple for results and td model\n", + " return tfidf_result, tf_model;" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c883e7c4154d40878ad1ab3ad9d0912a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Do pre-analysis country by country, month by month\n", + "CH_jan_result_df, CH_jan_tf_model = pre_analysis(CH_jan_cleaned_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c34d8657caeb442680a90a974b584a92", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+--------------------+\n", + "| tf_idf_features|\n", + "+--------------------+\n", + "|(26826,[0,1,3,19,...|\n", + "|(26826,[0,1,4,7,8...|\n", + "|(26826,[0,1,4,7,8...|\n", + "|(26826,[0,1,4,7,8...|\n", + "|(26826,[0,1,2,4,8...|\n", + "+--------------------+\n", + "only showing top 5 rows" + ] + } + ], + "source": [ + "#Show how these tf_idf features look like\n", + "CH_jan_result_df.select('tf_idf_features').show(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "15bbdac9111744bfbde14318d0e9999c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CH_feb_result_df, CH_feb_tf_model = pre_analysis(CH_feb_cleaned_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d4a6f99fda844dd299963f898cdfd45c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CH_mar_result_df, CH_mar_tf_model = pre_analysis(CH_mar_cleaned_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d0c17c108a034946a54e6e9fa161dd84", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "US_jan_result_df, US_jan_tf_model = pre_analysis(US_jan_cleaned_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a593af36f3894879b5f9aa9aae17a58e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "US_feb_result_df, US_feb_tf_model = pre_analysis(US_feb_cleaned_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "74df5c49449843279c38b61c103f1586", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "US_mar_result_df, US_mar_tf_model = pre_analysis(US_mar_cleaned_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c0a4f999fd294d93927b564541021e07", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pyspark.ml.feature import IDF\n", + "from pyspark.ml.clustering import LDA\n", + "import pyspark.sql.functions as F\n", + "import pyspark.sql.types as T\n", + "\n", + "def get_words(token_list):\n", + " return [vocab[token_id] for token_id in token_list]\n", + "\n", + "#Set the number of topics=5\n", + "num_topics = 5\n", + "max_iter = 10\n", + "num_top_words = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "28883bae0f2f46ff90dc0e4b0bd4550e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+--------------------------------------------------------------------------------------------+\n", + "|topic| topicWords|\n", + "+-----+--------------------------------------------------------------------------------------------+\n", + "| 0| [flight, citizens, said, hubei, kingdom, province, travel, health, british, government]|\n", + "| 1| [cities, million, travel, flights, measures, government, hubei, people, city, beijing]|\n", + "| 2| [cases, human, new, confirmed, market, reported, people, year, sars, chinese]|\n", + "| 3| [case, confirmed, man, cases, health, said, woman, united, people, hospital]|\n", + "| 4|[hospital, airport, staff, coronavirus, international, health, new, medical, patients, sars]|\n", + "+-----+--------------------------------------------------------------------------------------------+" + ] + } + ], + "source": [ + "#Do topic modeling and get the topic words \n", + "#China January\n", + "lda = LDA(k=num_topics, maxIter=max_iter, featuresCol='tf_idf_features')\n", + "lda_model = lda.fit(CH_jan_result_df)\n", + " \n", + "vocab = CH_jan_tf_model.vocabulary\n", + "udf_to_words = F.udf(get_words, T.ArrayType(T.StringType()))\n", + " \n", + "CH_jan_topics = lda_model.describeTopics(num_top_words).withColumn('topicWords', udf_to_words(F.col('termIndices')))\n", + "CH_jan_topics.select('topic', 'topicWords').show(truncate=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fc0b7d2063484f9592f2cc4d1f8fb13f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+------------------------------------------------------------------------------------+\n", + "|topic| topicWords|\n", + "+-----+------------------------------------------------------------------------------------+\n", + "| 0| [new, said, beijing, people, outbreak, health, u, ship, china, coronavirus]|\n", + "| 1|[li, hospital, party, media, patients, january, wuhan, medical, officials, wenliang]|\n", + "| 2| [people, said, cities, city, cases, government, chinese, million, one, flight]|\n", + "| 3| [cases, two, united, u, quarantine, health, citizens, south, said, confirmed]|\n", + "| 4| [cases, deaths, new, hubei, confirmed, province, reported, number, mainland, novel]|\n", + "+-----+------------------------------------------------------------------------------------+" + ] + } + ], + "source": [ + "#China Febuary\n", + "lda = LDA(k=num_topics, maxIter=max_iter, featuresCol='tf_idf_features')\n", + "lda_model = lda.fit(CH_feb_result_df)\n", + " \n", + "vocab = CH_feb_tf_model.vocabulary\n", + "udf_to_words = F.udf(get_words, T.ArrayType(T.StringType()))\n", + " \n", + "CH_feb_topics = lda_model.describeTopics(num_top_words).withColumn('topicWords', udf_to_words(F.col('termIndices')))\n", + "CH_feb_topics.select('topic', 'topicWords').show(truncate=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a480cd582a8244daaa8b64ec1aab15fd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+----------------------------------------------------------------------------------------+\n", + "|topic| topicWords|\n", + "+-----+----------------------------------------------------------------------------------------+\n", + "| 0| [people, said, city, virus, cases, beijing, chinese, province, new, hotel]|\n", + "| 1| [city, hubei, people, province, said, restrictions, outbreak, new, lockdown, beijing]|\n", + "| 2|[coronavirus, people, us, masks, hospital, said, quarantine, symptoms, beijing, wearing]|\n", + "| 3| [cases, president, chinese, new, xi, virus, trump, first, world, people]|\n", + "| 4| [cases, new, reported, read, hubei, imported, health, deaths, infections, confirmed]|\n", + "+-----+----------------------------------------------------------------------------------------+" + ] + } + ], + "source": [ + "#China March\n", + "lda = LDA(k=num_topics, maxIter=max_iter, featuresCol='tf_idf_features')\n", + "lda_model = lda.fit(CH_mar_result_df)\n", + " \n", + "vocab = CH_mar_tf_model.vocabulary\n", + "udf_to_words = F.udf(get_words, T.ArrayType(T.StringType()))\n", + " \n", + "CH_mar_topics = lda_model.describeTopics(num_top_words).withColumn('topicWords', udf_to_words(F.col('termIndices')))\n", + "CH_mar_topics.select('topic', 'topicWords').show(truncate=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a1f935fac6be489ab47124528d9e02a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+---------------------------------------------------------------------------------------------+\n", + "|topic| topicWords|\n", + "+-----+---------------------------------------------------------------------------------------------+\n", + "| 0| [plane, base, flight, anchorage, alaska, passengers, nearby, citizens, wednesday, reserve]|\n", + "| 1| [flights, china, cases, airlines, coronavirus, confirmed, white, house, next, trump]|\n", + "| 2| [case, states, confirmed, reported, first, u, cases, woman, health, chicago]|\n", + "| 3|[international, airport, airports, passengers, screening, san, francisco, angeles, los, year]|\n", + "| 4| [county, university, patient, orange, base, department, student, health, local, cdc]|\n", + "+-----+---------------------------------------------------------------------------------------------+" + ] + } + ], + "source": [ + "#U.S. January\n", + "lda = LDA(k=num_topics, maxIter=max_iter, featuresCol='tf_idf_features')\n", + "lda_model = lda.fit(US_jan_result_df)\n", + " \n", + "vocab = US_jan_tf_model.vocabulary\n", + "udf_to_words = F.udf(get_words, T.ArrayType(T.StringType()))\n", + " \n", + "US_jan_topics = lda_model.describeTopics(num_top_words).withColumn('topicWords', udf_to_words(F.col('termIndices')))\n", + "US_jan_topics.select('topic', 'topicWords').show(truncate=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a40f6c01a0d34e8e8ec59eccb445037a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+-------------------------------------------------------------------------------------------+\n", + "|topic| topicWords|\n", + "+-----+-------------------------------------------------------------------------------------------+\n", + "| 0| [house, white, trump, billion, county, president, outbreak, funding, health, new]|\n", + "| 1| [base, air, passengers, force, quarantine, san, travis, california, ship, evacuees]|\n", + "| 2| [county, trump, patient, health, officials, case, medical, cdc, school, sacramento]|\n", + "| 3| [county, cases, santa, woman, clara, health, officials, state, case, confirmed]|\n", + "| 4|[boston, china, washington, president, trump, massachusetts, coronavirus, said, also, city]|\n", + "+-----+-------------------------------------------------------------------------------------------+" + ] + } + ], + "source": [ + "#U.S. Febuary\n", + "lda = LDA(k=num_topics, maxIter=max_iter, featuresCol='tf_idf_features')\n", + "lda_model = lda.fit(US_feb_result_df)\n", + " \n", + "vocab = US_feb_tf_model.vocabulary\n", + "udf_to_words = F.udf(get_words, T.ArrayType(T.StringType()))\n", + " \n", + "US_feb_topics = lda_model.describeTopics(num_top_words).withColumn('topicWords', udf_to_words(F.col('termIndices')))\n", + "US_feb_topics.select('topic', 'topicWords').show(truncate=100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6385fdf491c2491faaa2906a64531fae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+----------------------------------------------------------------------------+\n", + "|topic| topicWords|\n", + "+-----+----------------------------------------------------------------------------+\n", + "| 0| [county, cases, confirmed, march, positive, case, covid, health, state, m]|\n", + "| 1|[trump, house, white, president, county, package, u, economic, donald, said]|\n", + "| 2| [county, people, health, houston, city, order, chicago, said, cases, covid]|\n", + "| 3| [county, cases, ship, new, san, state, washington, cruise, virus, said]|\n", + "| 4| [new, school, seattle, york, said, city, home, march, county, schools]|\n", + "+-----+----------------------------------------------------------------------------+" + ] + } + ], + "source": [ + "#U.S. March\n", + "lda = LDA(k=num_topics, maxIter=max_iter, featuresCol='tf_idf_features')\n", + "lda_model = lda.fit(US_mar_result_df)\n", + " \n", + "vocab = US_mar_tf_model.vocabulary\n", + "udf_to_words = F.udf(get_words, T.ArrayType(T.StringType()))\n", + " \n", + "US_mar_topics = lda_model.describeTopics(num_top_words).withColumn('topicWords', udf_to_words(F.col('termIndices')))\n", + "US_mar_topics.select('topic', 'topicWords').show(truncate=100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "PySpark", + "language": "", + "name": "pysparkkernel" + }, + "language_info": { + "codemirror_mode": { + "name": "python", + "version": 2 + }, + "mimetype": "text/x-python", + "name": "pyspark", + "pygments_lexer": "python2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/graphs/.DS_Store b/graphs/.DS_Store new file mode 100644 index 0000000..4a2367a Binary files /dev/null and b/graphs/.DS_Store differ diff --git a/graphs/1.1.jpg b/graphs/1.1.jpg new file mode 100644 index 0000000..0a87480 Binary files /dev/null and b/graphs/1.1.jpg differ diff --git a/graphs/1.2.jpg b/graphs/1.2.jpg new file mode 100644 index 0000000..84ab9f5 Binary files /dev/null and b/graphs/1.2.jpg differ diff --git a/graphs/2.1.jpg b/graphs/2.1.jpg new file mode 100644 index 0000000..9b1836a Binary files /dev/null and b/graphs/2.1.jpg differ diff --git a/graphs/3.1.1.jpg b/graphs/3.1.1.jpg new file mode 100644 index 0000000..6e443f7 Binary files /dev/null and b/graphs/3.1.1.jpg differ diff --git a/graphs/3.1.2.jpg b/graphs/3.1.2.jpg new file mode 100644 index 0000000..fbeb225 Binary files /dev/null and b/graphs/3.1.2.jpg differ diff --git a/graphs/3.1.3.jpg b/graphs/3.1.3.jpg new file mode 100644 index 0000000..49eac2c Binary files /dev/null and b/graphs/3.1.3.jpg differ diff --git a/graphs/3.2.1.jpg b/graphs/3.2.1.jpg new file mode 100644 index 0000000..81234f9 Binary files /dev/null and b/graphs/3.2.1.jpg differ diff --git a/graphs/3.2.2.jpg b/graphs/3.2.2.jpg new file mode 100644 index 0000000..33d17d2 Binary files /dev/null and b/graphs/3.2.2.jpg differ diff --git a/graphs/3.2.3.jpg b/graphs/3.2.3.jpg new file mode 100644 index 0000000..e245d2c Binary files /dev/null and b/graphs/3.2.3.jpg differ