proquest_corpus_documentation.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"fhy63rjAwZgc"},"source":["## Import Packages"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":9590,"status":"ok","timestamp":1689358696993,"user":{"displayName":"muchen wang","userId":"10267862332018942613"},"user_tz":240},"id":"pgFTLKRF0jPG","outputId":"fbdbd4b8-73e2-41ab-8a2c-e5d60c3fd2bb"},"outputs":[{"name":"stdout","output_type":"stream","text":["Collecting fuzzywuzzy\n","  Downloading fuzzywuzzy-0.18.0-py2.py3-none-any.whl (18 kB)\n","Installing collected packages: fuzzywuzzy\n","Successfully installed fuzzywuzzy-0.18.0\n"]}],"source":["!pip install fuzzywuzzy"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":18517,"status":"ok","timestamp":1689358715502,"user":{"displayName":"muchen wang","userId":"10267862332018942613"},"user_tz":240},"id":"BKWPt09be0rl","outputId":"931380f1-8082-4bf9-8d3e-2145b5684932"},"outputs":[{"name":"stdout","output_type":"stream","text":["Mounted at /content/drive\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4621,"status":"ok","timestamp":1689358720113,"user":{"displayName":"muchen wang","userId":"10267862332018942613"},"user_tz":240},"id":"EePtTAYcBbHj","outputId":"2fbe79fb-76ed-4d50-83a5-e3c023cfe9c0"},"outputs":[{"name":"stderr","output_type":"stream","text":["[nltk_data] Downloading package stopwords to /root/nltk_data...\n","[nltk_data]   Unzipping corpora/stopwords.zip.\n","[nltk_data] Downloading package wordnet to /root/nltk_data...\n","/usr/local/lib/python3.10/dist-packages/fuzzywuzzy/fuzz.py:11: UserWarning: Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning\n","  warnings.warn('Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning')\n"]}],"source":["import os\n","import gensim\n","import numpy as np\n","import nltk\n","nltk.download('stopwords')\n","nltk.download('wordnet')\n","from nltk.corpus import stopwords\n","from nltk.tokenize import word_tokenize\n","from nltk.stem import PorterStemmer\n","from nltk.stem import WordNetLemmatizer\n","import re\n","from collections import Counter\n","import matplotlib.pyplot as plt\n","from itertools import chain\n","import string\n","from pprint import pprint\n","from gensim.models.coherencemodel import CoherenceModel\n","from gensim.models.phrases import Phrases, Phraser\n","from datetime import datetime\n","import logging\n","logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)\n","from dateutil import parser\n","import pandas as pd\n","from fuzzywuzzy import fuzz"]},{"cell_type":"markdown","metadata":{"id":"0C0aeUYnXAVC"},"source":["# Import Data"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"NXlqkyOzJkPC"},"outputs":[],"source":["root_dir = '/content/drive/MyDrive/audace_trial/corpus/english_modern/canadian_newstream'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TGy2NsZhqITz"},"outputs":[],"source":["out_dir = \"/content/drive/MyDrive/audace_trial/cleaned_corpus/english_modern/\""]},{"cell_type":"markdown","metadata":{"id":"48MRuLZbXYY6"},"source":["# Data Cleaning Functions"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"7WJRqX8gJw_V"},"outputs":[],"source":["def get_files(root_dir):\n","  # Define a list to store the text\n","  file_list = []\n","\n","  # Recursively search for files in the root directory and its subdirectories\n","  for subdir, dirs, files in os.walk(root_dir):\n","      for fil in files:\n","          obj = {}\n","          file_path = os.path.join(subdir, fil)\n","          seg = subdir.split('/')\n","          obj['term'] = seg[-1]\n","          f = open(file_path, 'r')\n","          text = f.read()\n","          obj['text'] = text\n","          f.close\n","          file_list.append(obj)\n","  return file_list"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"AuO-rMNDYZhq"},"outputs":[],"source":["def extract_doc (file_list):\n","  regex_pattern = \"(.*?)Database:\"\n","  doc_list = []\n","  for obj in file_list:\n","    matches = re.finditer(regex_pattern, obj['text'], re.DOTALL)\n","    for mat in matches:\n","      doc = {}\n","      extracted_text = mat.group(1).strip()\n","      doc['text'] = extracted_text\n","      doc['term'] = obj['term']\n","      doc_list.append(doc)\n","  return doc_list"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"99w7uiN4iQFJ"},"outputs":[],"source":["def documentation(doc_list):\n","  cont_list = []\n","  pattern0 = r\"Full text:(.*?)Location:\"\n","  pattern1 = r\"document ID:(.*?)\\n\"\n","  pattern2 = r\"Source type:(.*?)\\n\"\n","  pattern3 = r\"Publication date:(.*?)\\n\"\n","  pattern4 = r\"^.*?Subject:.*?$\"\n","  pattern5 = r\"^.*?Business indexing term:.*?$\"\n","  subject_pattern = r\"Subject:(.*?)\\n\"\n","  subject = [\"NA\"]\n","  source = \"NA\"\n","  date = \"NA\"\n","  for doc in doc_list:\n","    t = {}\n","    m0 = re.search(pattern0, doc['text'], re.DOTALL)\n","    cont = m0.group(1).strip()\n","    m1 = re.search(pattern1, doc['text'], re.DOTALL)\n","    id = m1.group(1).strip()\n","    m2 = re.search(pattern2, doc['text'], re.DOTALL)\n","    if m2:\n","      source = m2.group(1).strip()\n","    m3 = re.search(pattern3, doc['text'], re.DOTALL)\n","    if m3:\n","      date = m3.group(1).strip()\n","    m6 = re.search(subject_pattern, doc['text'], re.DOTALL)\n","    if m6:\n","      subject = m6.group(1).strip()\n","      subject = subject.split(\"; \")\n","    m4 = re.search(pattern4, cont, re.DOTALL)\n","    m5 = re.search(pattern5, cont, re.DOTALL)\n","    if m5:\n","      cont = re.sub(pattern5, \"\", cont, flags=re.MULTILINE)\n","    if m4:\n","      cont = re.sub(pattern4, \"\", cont, flags=re.MULTILINE)\n","    t['term'] = doc['term']\n","    t['full_text'] = cont\n","    t['date'] = date\n","    t['source'] = source\n","    t['id'] = id\n","    t['subject'] = subject\n","    cont_list.append(t)\n","  return cont_list\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1VvjOvGpbdxV"},"outputs":[],"source":["def rm_duplicates(cont_list):\n","  unique_data = []\n","  seen_texts = set()\n","  for entry in cont_list:\n","      full_text = entry['full_text'][:100]\n","      if full_text not in seen_texts:\n","          unique_data.append(entry)\n","          seen_texts.add(full_text)\n","  return unique_data"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"YOWT9nADIwjq"},"outputs":[],"source":["def remove_links(text):\n","    pattern = r'\\( https?://[^\\s()]+ \\)'\n","    text_without_links = re.sub(pattern, '', text)\n","    return text_without_links"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LQQL7OVzbKpn"},"outputs":[],"source":["def export_cont(out_dir, unique_list):\n","    for f in unique_list:\n","      source = f['source']\n","      term = f['term']\n","      date = f['date']\n","      if '/'in date:\n","        date = f['date'].replace('/', '-')\n","      id = f['id']\n","      cont = f['full_text']\n","      file_name = out_dir + source + \"_\" + term + \"_\" + date + \"_\" + id + \".txt\"\n","      print(file_name)\n","      f = open(file_name, \"w\")\n","      f.write(cont)\n","      f.close"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"gqXwbRv10Lyj"},"outputs":[],"source":["def remove_duplicates(text_list, similarity_threshold):\n","    unique_texts = []\n","    seen_texts = set()\n","\n","    group_size = 20  # Adjust the group size as per your requirements\n","    groups = [text_list[i:i+group_size] for i in range(0, len(text_list), group_size)]\n","    i = 1\n","    for group in groups:\n","        print(\"group No. \" + str(i))\n","        for text in group:\n","            text_content = text['full_text']\n","            if text_content not in seen_texts:\n","                is_duplicate = any(fuzz.ratio(text_content, seen_text) >= similarity_threshold for seen_text in seen_texts)\n","                if not is_duplicate:\n","                    unique_texts.append(text)\n","                    seen_texts.add(text_content)\n","        i+=1\n","    return unique_texts"]},{"cell_type":"markdown","metadata":{"id":"wAOEge0vGu2f"},"source":["# Cleaning"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Hwd9NN5OXoYo"},"outputs":[],"source":["file_list = get_files(root_dir)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"m7DqjRLQr4jV"},"outputs":[],"source":["doc_list = extract_doc(file_list)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"yvsaW9Gsq0E-"},"outputs":[],"source":["cont_list = documentation(doc_list)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"background_save":true,"base_uri":"https://localhost:8080/"},"id":"UAAr6ht01m0c","outputId":"12924549-4a6e-4ba8-f7bc-612ffb7b58a4"},"outputs":[{"name":"stdout","output_type":"stream","text":["group No. 1\n","group No. 2\n","group No. 3\n","group No. 4\n","group No. 5\n","group No. 6\n","group No. 7\n","group No. 8\n","group No. 9\n","group No. 10\n","group No. 11\n","group No. 12\n","group No. 13\n","group No. 14\n","group No. 15\n","group No. 16\n","group No. 17\n","group No. 18\n","group No. 19\n","group No. 20\n","group No. 21\n","group No. 22\n","group No. 23\n","group No. 24\n","group No. 25\n","group No. 26\n","group No. 27\n","group No. 28\n","group No. 29\n","group No. 30\n","group No. 31\n","group No. 32\n","group No. 33\n","group No. 34\n","group No. 35\n","group No. 36\n","group No. 37\n","group No. 38\n","group No. 39\n","group No. 40\n","group No. 41\n","group No. 42\n","group No. 43\n","group No. 44\n","group No. 45\n","group No. 46\n","group No. 47\n","group No. 48\n","group No. 49\n","group No. 50\n","group No. 51\n","group No. 52\n","group No. 53\n","group No. 54\n","group No. 55\n","group No. 56\n","group No. 57\n","group No. 58\n","group No. 59\n","group No. 60\n","group No. 61\n","group No. 62\n","group No. 63\n","group No. 64\n","group No. 65\n","group No. 66\n","group No. 67\n","group No. 68\n","group No. 69\n"]}],"source":["similarity_threshold = 90\n","unique_list = remove_duplicates(cont_list, similarity_threshold)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"fYPoLzpz4ike"},"outputs":[],"source":["unique_list[100]"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"7_P4Mp3XKN0a"},"outputs":[],"source":["len(unique_list)"]},{"cell_type":"markdown","metadata":{"id":"NZIlx6pa09ko"},"source":["## Export"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"v_jrrNO5HnlR"},"outputs":[],"source":["export_cont(out_dir, unique_list)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"AagL3In8LiDG"},"outputs":[],"source":["file_list = os.listdir(out_dir)\n","len(file_list)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"JTghmEY_Q3cp"},"outputs":[],"source":["unique_list[1555]"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"A2tR-71jO4py"},"outputs":[],"source":["df = pd.DataFrame()\n","\n","# Iterate over each dictionary in the list\n","for item in unique_list:\n","    # Extract the keys and values from the dictionary\n","    data = {k.capitalize(): v if k != 'subject' else ', '.join(v) for k, v in item.items()}\n","\n","    # Append the dictionary as a new row to the dataframe\n","    df = df.append(data, ignore_index=True)\n","\n","# Print the resulting dataframe\n","print(df)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"aIEunRVQPNBy"},"outputs":[],"source":["df"]},{"cell_type":"markdown","metadata":{"id":"ja4IkKpsML3f"},"source":["# Visualization"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"3LlKT0XYG0ip"},"outputs":[],"source":["def vis_source(unique_list):\n","  # Extract the values of the \"source\" key into a separate list\n","  source_list = [d[\"source\"] for d in unique_list]\n","\n","  # Count the occurrences of each value\n","  counts = Counter(source_list)\n","\n","  # Get the unique sources and their counts\n","  sources = list(counts.keys())\n","  counts = list(counts.values())\n","\n","  print(sources)\n","  print(counts)\n","\n","  # Create a bar chart\n","  plt.bar(sources, counts)\n","  plt.xlabel(\"Source\")\n","  plt.ylabel(\"Count\")\n","  plt.title(\"Occurrences of Sources\")\n","  for i, count in enumerate(counts):\n","    plt.text(i, count, str(count), ha=\"center\", va=\"bottom\")\n","  plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"7y278GjpI8vp"},"outputs":[],"source":["def vis_term(unique_list):\n","  # Extract the values of the \"source\" key into a separate list\n","  source_list = [d[\"term\"] for d in unique_list]\n","\n","  # Count the occurrences of each value\n","  counts = Counter(source_list)\n","\n","  # Get the unique sources and their counts\n","  sources = list(counts.keys())\n","  counts = list(counts.values())\n","\n","  print(sources)\n","  print(counts)\n","\n","  # Create a bar chart\n","  plt.bar(sources, counts)\n","  plt.xlabel(\"Term\")\n","  plt.ylabel(\"Count\")\n","  plt.title(\"Occurrences of Terms\")\n","  for i, count in enumerate(counts):\n","    plt.text(i, count, str(count), ha=\"center\", va=\"bottom\")\n","  plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"hnVpnMjUKu9Q"},"outputs":[],"source":["def vis_date(data):\n","    # Extract the date strings from the list of dictionaries\n","    date_strings = [d['date'] for d in data]\n","\n","    # Function to parse the date strings\n","    def parse_date(date_str):\n","        try:\n","            # Attempt to parse the date string using dateutil.parser\n","            return parser.parse(date_str)\n","        except ValueError:\n","            # Ignore the \"May/Jun 2003\" format and return None\n","            return None\n","\n","    # Parse the date strings and convert them into datetime objects\n","    dates = [parse_date(date_str) for date_str in date_strings]\n","\n","    # Remove None values (for \"May/Jun 2003\" format) from the dates list and corresponding dictionaries\n","    valid_dates = [date for date in dates if date is not None]\n","    valid_data = [d for d, date in zip(data, dates) if date is not None]\n","\n","    # Sort the list of dictionaries based on the parsed date values\n","    sorted_data = [d for _, d in sorted(zip(valid_dates, valid_data), key=lambda x: x[0])]\n","\n","    # Extract the sorted dates\n","    sorted_dates = [date.strftime('%b %d, %Y') for date in valid_dates]\n","\n","    # Count the frequency of each date\n","    date_counts = Counter(sorted_dates)\n","\n","    # Get the unique sorted dates and their frequencies\n","    unique_dates = list(date_counts.keys())\n","    frequencies = list(date_counts.values())\n","\n","    # Sort the unique dates in chronological order\n","    unique_dates_sorted = sorted(unique_dates, key=lambda x: parser.parse(x))\n","\n","    # Get the frequencies in the same order as the sorted dates\n","    frequencies_sorted = [date_counts[date] for date in unique_dates_sorted]\n","\n","    # Plot the timeline as a scatter plot\n","    fig, ax = plt.subplots(figsize=(20, 10))\n","    ax.scatter(unique_dates_sorted, frequencies_sorted, color='blue', s=50)\n","    ax.set_xlabel('Date')\n","    ax.set_ylabel('Frequency')\n","    ax.set_title('Timeline Visualization')\n","    ax.set_xticks([unique_dates_sorted[0], unique_dates_sorted[-1]])\n","    plt.xticks(rotation=45, ha='right')\n","    plt.tight_layout()\n","    plt.show()"]},{"cell_type":"markdown","metadata":{"id":"2FBo5tcLJE8T"},"source":["# Data Analysis"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":527},"executionInfo":{"elapsed":689,"status":"ok","timestamp":1686196705400,"user":{"displayName":"muchen wang","userId":"10267862332018942613"},"user_tz":240},"id":"6Dpaq-4mDH8Q","outputId":"49402da0-fa80-43c9-c9e9-500f84aa881b"},"outputs":[{"name":"stdout","output_type":"stream","text":["['Blog, Podcast, or W ebsite', 'Wire Feed', 'Blog, Podcast, or Website', 'Newspaper', 'Magazine', 'Blog, P odcast, or Website', 'Blog, Pod cast, or Website', 'Blog, Podcast , or Website', 'Blog, Podc ast, or Website', 'Blog, Podcast, or We bsite', 'Blog, Podcas t, or Website', 'Blog, Podcast, or Websi te']\n","[1, 5, 1089, 452, 1, 2, 3, 1, 2, 1, 1, 1]\n"]},{"data":{"image/png":"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\n","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["vis_source(unique_list)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":507},"executionInfo":{"elapsed":398,"status":"ok","timestamp":1686196685566,"user":{"displayName":"muchen wang","userId":"10267862332018942613"},"user_tz":240},"id":"rIX2v9FEHjBs","outputId":"0d3ed9ff-e86b-4579-c6da-6cc80dc6b8f3"},"outputs":[{"name":"stdout","output_type":"stream","text":["['flood', 'forestfire', 'blizzard', 'heatwave', 'freezing_rain', 'storm']\n","[138, 197, 186, 424, 373, 241]\n"]},{"data":{"image/png":"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\n","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["vis_term(unique_list)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":752},"executionInfo":{"elapsed":1733,"status":"ok","timestamp":1686199652810,"user":{"displayName":"muchen wang","userId":"10267862332018942613"},"user_tz":240},"id":"baTuvZVZK-G2","outputId":"cc3e48f3-eaf8-4a2a-dc32-2050d93c066b"},"outputs":[{"data":{"image/png":"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\n","text/plain":["<Figure size 2000x1000 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["vis_date(unique_list)"]}],"metadata":{"colab":{"collapsed_sections":["fhy63rjAwZgc","0C0aeUYnXAVC","ja4IkKpsML3f"],"provenance":[],"authorship_tag":"ABX9TyMyv17E2sq9eLoC3fskdPtw"},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}