dictionary-classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Digital Methods - Dictionary Classifier\n",
    "_____\n",
    "\n",
    "## Table of Content\n",
    "\n",
    "1. [Libraries](#libraries)\n",
    "2. [Load Data](#load-data)\n",
    "3. [Data Preprocessing](#preprocessing-of-the-data)\n",
    "4. [Set Up of Dictionary](#building-dictionary)\n",
    "5. [Classifier](#classifier)\n",
    "6. [Networks](#network-analysis)\n",
    "7. [Backtracking Uncategorized Comments](#tracking-uncategorized-comments)\n",
    "_____"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries\n",
    "\n",
    "All libraries which are needed to execute the code are listed here. Install the packages by using the `requirements.txt` file. \n",
    "\n",
    "The documentation can be found in the [README.md](README.md) file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import packages\n",
    "import pandas as pd \n",
    "from tqdm import tqdm\n",
    "import nltk\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk import word_tokenize, pos_tag\n",
    "from nltk.corpus import wordnet\n",
    "from nltk.stem.snowball import SnowballStemmer\n",
    "from nltk.util import ngrams\n",
    "from preprocessing_functions import *\n",
    "from collections import defaultdict\n",
    "import itertools\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "from googleapiclient.discovery import build\n",
    "\n",
    "#import script --- CREATING SCRIPT TO IMPORT YouTube API KEY ---\n",
    "from api_key import api_key_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data\n",
    "\n",
    "Load collected YouTube comments from the Data Collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data/comments_final.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# process data with using functions from functions.py\n",
    "processed_df = (\n",
    "    df.pipe(remove_users, 'text')\n",
    "      .pipe(lowercase_text, 'text')\n",
    "      .pipe(remove_whitespace, 'text')\n",
    "      .pipe(remove_punctuation, 'text')\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing of the Data\n",
    "\n",
    "- Stemming and Lemmatizing\n",
    "- Tokenization of the comments\n",
    "- Building N-grams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# text column to string\n",
    "processed_df['text'] = processed_df['text'].astype('str')\n",
    "processed_df['text'] = processed_df['text'].str.replace('\\'', '')\n",
    "\n",
    "# use stemming to reduce words to their root words\n",
    "processed_df = stem_words(processed_df, 'text')\n",
    "\n",
    "# use lemmatization to reduce words to their root form\n",
    "processed_df = lemmatize_words(processed_df, 'text')\n",
    "\n",
    "# convert date format\n",
    "processed_df = convert_date_format(processed_df, 'published_at')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dropping the na from lemmatized & stemmed text to avoid issues with creating n_grams\n",
    "processed_df.lemmatized_text = processed_df.lemmatized_text.apply(lambda x: '' if str(x) == 'nan' else x)\n",
    "processed_df.stemmed_text = processed_df.stemmed_text.apply(lambda x: '' if str(x) == 'nan' else x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tokenizing the lemmatized and stemmed text before creating n-grams\n",
    "def tokenize_words(text):\n",
    "    words = word_tokenize(text)\n",
    "    #words_with_quotes = [f\"'{word}'\" for word in words]\n",
    "    return words\n",
    "\n",
    "processed_df[\"stemmed_tokens\"] = processed_df[\"stemmed_text\"].apply(lambda x: tokenize_words(x))\n",
    "processed_df[\"lemmatized_tokens\"] = processed_df[\"lemmatized_text\"].apply(lambda x: tokenize_words(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96595/96595 [00:00<00:00, 146459.74it/s]\n",
      "100%|██████████| 96595/96595 [00:00<00:00, 126143.18it/s]\n",
      "100%|██████████| 96595/96595 [00:00<00:00, 124452.89it/s]\n",
      "100%|██████████| 96595/96595 [00:02<00:00, 40288.12it/s] \n",
      "100%|██████████| 96595/96595 [00:00<00:00, 128918.98it/s]\n",
      "100%|██████████| 96595/96595 [00:00<00:00, 128509.41it/s]\n"
     ]
    }
   ],
   "source": [
    "# Creating n-grams \n",
    "tqdm.pandas() #Creates a progress bar and below use \"progress_apply\" instead of \"apply\" to create a progress bar (This is more of a \"nice to have\" than a \"need to have\")\n",
    "\n",
    "#Defining a function that will create bigrams \n",
    "def bigrams(doc): # a doc is a list of tokens/unigrams in same order as in tweets \n",
    "    \n",
    "    bigrams = [] #Empty list to save the bigrams\n",
    "    \n",
    "    for bigram in list(nltk.bigrams(doc)):  #Creating bigrams as tuples with nltk.bigrams and iterating over these them\n",
    "        bigrams.append(\"_\".join(bigram))    #Joining each bigram-tuple pair with an underscore and saving to list\n",
    "    \n",
    "    return bigrams\n",
    "\n",
    "#Defining a function that will create bigrams \n",
    "def trigrams(doc): # a doc is a list of unigrams in same order as in tweets \n",
    "    \n",
    "    trigrams = [] #Empty list to save the bigrams\n",
    "    \n",
    "    for trigram in list(nltk.trigrams(doc)):  #Creating bigrams as tuples with nltk.bigrams and iterating over these them\n",
    "        trigrams.append(\"_\".join(trigram))    #Joining each bigram-tuple pair with an underscore and saving to list\n",
    "    \n",
    "    return trigrams\n",
    "\n",
    "#Defining a function that will create bigrams \n",
    "def fourgrams(doc): # a doc is a list of unigrams in same order as in tweets \n",
    "    \n",
    "    fourgrams = [] #Empty list to save the bigrams\n",
    "    \n",
    "    for fourgram in list(ngrams(doc, 4)):  #Creating bigrams as tuples with nltk.bigrams and iterating over these them\n",
    "        fourgrams.append(\"_\".join(fourgram))    #Joining each bigram-tuple pair with an underscore and saving to list\n",
    "    \n",
    "    return fourgrams\n",
    "\n",
    "#Creating a column with bigrams by applying function to column of unigrams\n",
    "processed_df['bigrams_lemma'] = processed_df[\"lemmatized_tokens\"].progress_apply(lambda x: bigrams(x))\n",
    "processed_df['trigrams_lemma'] = processed_df['lemmatized_tokens'].progress_apply(lambda x : trigrams(x))\n",
    "processed_df['fourgrams_lemma'] = processed_df['lemmatized_tokens'].progress_apply(lambda x : fourgrams(x))\n",
    "\n",
    "processed_df['bigrams_stem'] = processed_df[\"stemmed_tokens\"].progress_apply(lambda x: bigrams(x))\n",
    "processed_df['trigrams_stem'] = processed_df['stemmed_tokens'].progress_apply(lambda x : trigrams(x))\n",
    "processed_df['fourgrams_stem'] = processed_df['stemmed_tokens'].progress_apply(lambda x : fourgrams(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating one column with all n-grams (unigrams, bigrams, trigrams, fourgrams)\n",
    "processed_df[\"all_n_grams_lemmatized\"] = processed_df[\"lemmatized_tokens\"] + processed_df[\"bigrams_lemma\"] + processed_df[\"trigrams_lemma\"] + processed_df[\"fourgrams_lemma\"]\n",
    "processed_df[\"all_n_grams_stemmed\"] = processed_df[\"stemmed_tokens\"] + processed_df[\"bigrams_stem\"] + processed_df[\"trigrams_stem\"] + processed_df[\"fourgrams_stem\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows containing 'climate': 14821\n"
     ]
    }
   ],
   "source": [
    "def contains_climate(lst):\n",
    "    return 'climate' in lst\n",
    "\n",
    "# Applying the function to create a boolean mask\n",
    "climate_mask = processed_df['all_n_grams_lemmatized'].apply(contains_climate)\n",
    "\n",
    "# Summing the rows where the mask is True\n",
    "sum_rows_with_climate = climate_mask.sum()\n",
    "\n",
    "print(f\"Number of rows containing 'climate': {sum_rows_with_climate}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building Dictionary\n",
    "\n",
    "Building the Dictionary for the Classifier. This process is based on the qualitative research and Word2Vec Model + Topic Modelling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating Dictionary \n",
    "\n",
    "sc1_kw = ['no_climate_emergency', 'melting', 'arctic_ice', 'arctic_sea ice', 'sea_level_rise', 'extreme_weather', 'global_cooling', 'greenland_ice',\n",
    "          'ice_cap', 'arctic_ice', 'extreme_heat', 'extreme_cold' ]\n",
    "# unsure &  included: 'melting'\n",
    "# unsure & not included: 'glacier', 'wildfires', 'climate emergency', 'unproven', 'global warming'\n",
    "\n",
    "sc2_kw = ['natural_cycle', 'CO2_is_not_the_cause', 'greenhouse_gas', 'no_CO2_Greenhouse_Effect', 'no_effect', 'miniscule_effect', 'Man_has_no_control']\n",
    "# unsure & not included: 'natural process'\n",
    "\n",
    "sc3_kw = ['plant_food', 'plant_growth', 'thrive', 'carbon_element_is_essential', 'average_temperature_increase', '1_degree', \n",
    "          'more_fossil_fuels', 'no_co2', 'plant_food', 'not_pollution', '0.1C', 'ppm', 'not_a_pollutant']\n",
    "# unsure & not included: 'beneficial'\n",
    "\n",
    "sc4_kw = ['green_energy', 'renewable_energy', 'energy_production', 'windmills', 'solar_panel']\n",
    "# unsure &  included: 'renewable energy'\n",
    "\n",
    "sc5_kw = ['alarmism', 'catastrophist', 'doomsday_cult', 'climate_hysteric', 'unscientific', 'corrupt_politician', 'LIE_ABOUT_EVERYTHING',\n",
    "          'idiocy', 'lunatics', 'CLIMATE_Worship', 'Climatists', 'alarmists', 'compliant_media', 'climate_hysteria', 'climate_narrative', 'climate_cult',\n",
    "             'scientism', 'climate_science_myths', 'lying_in_science', 'climate_apocalypse', 'propaganda', 'doomsayers', 'clown_show', 'fake_climate',\n",
    "               'climate_change_agenda', 'money_made', 'fake_news', 'climate_terrorists']\n",
    "# unsure & not included: 'scientist', 'global warming scam' (could also be sc7), 'greta', 'john kerry'\n",
    "\n",
    "sc7_kw = ['globalist', 'globalist_elites', 'elitist', 'global_government', 'one_world', 'one_world_government', 'globalism', \n",
    "          'one_world_utopia', 'new_world_order', 'enriching_themselves', 'saving_the_planet', 'control_over_your_lives', \n",
    "          'tyranny', 'global_elite', 'wef', 'population_control']\n",
    "# unsure & included: 'tyranny', 'population control'\n",
    "# unsure & not included: 'totalitarian'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sc1_kw_lemmatized: ['no_climate_emergency', 'melt', 'arctic_ice', 'arctic_sea_ice', 'sea_level_rise', 'extreme_weather', 'global_cooling', 'greenland_ice', 'ice_cap', 'arctic_ice', 'extreme_heat', 'extreme_cold']\n",
      "sc2_kw_lemmatized: ['natural_cycle', 'co2_be_not_the_cause', 'greenhouse_gas', 'no_co2_greenhouse_effect', 'no_effect', 'miniscule_effect', 'man_have_no_control']\n",
      "sc3_kw_lemmatized: ['plant_food', 'plant_growth', 'thrive', 'carbon_element_be_essential', 'average_temperature_increase', '1_degree', 'more_fossil_fuel', 'no_co2', 'plant_food', 'not_pollution', '0.1c', 'ppm', 'not_a_pollutant']\n",
      "sc4_kw_lemmatized: ['green_energy', 'renewable_energy', 'energy_production', 'windmill', 'solar_panel']\n",
      "sc5_kw_lemmatized: ['alarmism', 'catastrophist', 'doomsday_cult', 'climate_hysteric', 'unscientific', 'corrupt_politician', 'lie_about_everything', 'idiocy', 'lunatic', 'climate_worship', 'climatists', 'alarmist', 'compliant_medium', 'climate_hysteria', 'climate_narrative', 'climate_cult', 'scientism', 'climate_science_myth', 'lie_in_science', 'climate_apocalypse', 'propaganda', 'doomsayers', 'clown_show', 'fake_climate', 'climate_change_agenda', 'money_make', 'fake_news', 'climate_terrorist']\n",
      "sc7_kw_lemmatized: ['globalist', 'globalist_elite', 'elitist', 'global_government', 'one_world', 'one_world_government', 'globalism', 'one_world_utopia', 'new_world_order', 'enrich_themselves', 'save_the_planet', 'control_over_your_life', 'tyranny', 'global_elite', 'wef', 'population_control']\n",
      "sc1_kw_stemmed: ['no_climat_emerg', 'melt', 'arctic_ice', 'arctic_sea_ice', 'sea_level_rise', 'extrem_weather', 'global_cool', 'greenland_ice', 'ice_cap', 'arctic_ice', 'extrem_heat', 'extrem_cold']\n",
      "sc2_kw_stemmed: ['natur_cycl', 'co2_is_not_the_caus', 'greenhous_gas', 'no_co2_greenhous_effect', 'no_effect', 'miniscul_effect', 'man_has_no_control']\n",
      "sc3_kw_stemmed: ['plant_food', 'plant_growth', 'thrive', 'carbon_element_is_essenti', 'averag_temperatur_increas', '1_degre', 'more_fossil_fuel', 'no_co2', 'plant_food', 'not_pollut', '0.1c', 'ppm', 'not_a_pollut']\n",
      "sc4_kw_stemmed: ['green_energi', 'renew_energi', 'energi_product', 'windmil', 'solar_panel']\n",
      "sc5_kw_stemmed: ['alarm', 'catastrophist', 'doomsday_cult', 'climat_hyster', 'unscientif', 'corrupt_politician', 'lie_about_everyth', 'idioci', 'lunat', 'climat_worship', 'climatist', 'alarmist', 'compliant_media', 'climat_hysteria', 'climat_narrat', 'climat_cult', 'scientism', 'climat_scienc_myth', 'lie_in_scienc', 'climat_apocalyps', 'propaganda', 'doomsay', 'clown_show', 'fake_climat', 'climat_chang_agenda', 'money_made', 'fake_news', 'climat_terrorist']\n",
      "sc7_kw_stemmed: ['globalist', 'globalist_elit', 'elitist', 'global_govern', 'one_world', 'one_world_govern', 'global', 'one_world_utopia', 'new_world_order', 'enrich_themselv', 'save_the_planet', 'control_over_your_live', 'tyranni', 'global_elit', 'wef', 'popul_control']\n"
     ]
    }
   ],
   "source": [
    "# lowercase and stemming/lemmatizing the keyword lists \n",
    "\n",
    "# Function to remove underscores and convert to lowercase\n",
    "def preprocess_keywords(keywords):\n",
    "    return [keyword.replace('_', ' ').lower() for keyword in keywords]\n",
    "\n",
    "# Stem words\n",
    "def stem_words(words):\n",
    "    stemmer = SnowballStemmer(language='english')\n",
    "    return [\" \".join([stemmer.stem(word) for word in word_tokenize(keyword)]) for keyword in words]\n",
    "\n",
    "# Lemmatize words\n",
    "def lemmatize_words(words):\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    \n",
    "    # Mapping NLTK POS tags to WordNet POS tags\n",
    "    tag_map = {\n",
    "        'J': wordnet.ADJ,\n",
    "        'V': wordnet.VERB,\n",
    "        'R': wordnet.ADV,\n",
    "        'N': wordnet.NOUN\n",
    "    }\n",
    "    \n",
    "    lemmatized_keywords = []\n",
    "    for keyword in words:\n",
    "        tokens = word_tokenize(keyword)\n",
    "        pos_tags = pos_tag(tokens)\n",
    "        lemmatized_tokens = [lemmatizer.lemmatize(word, tag_map.get(tag[0], wordnet.NOUN)) for word, tag in pos_tags]\n",
    "        lemmatized_keywords.append(\" \".join(lemmatized_tokens))\n",
    "    \n",
    "    return lemmatized_keywords\n",
    "\n",
    "\n",
    "# Replacing the whitespaces with underscores again to create n-grams\n",
    "def postprocess_keywords(keywords):\n",
    "    return [keyword.replace(' ', '_') for keyword in keywords]\n",
    "\n",
    "# Apply the preprocessing, stemming, and lemmatization\n",
    "sc1_kw_lemmatized = postprocess_keywords(lemmatize_words(preprocess_keywords(sc1_kw)))\n",
    "sc2_kw_lemmatized = postprocess_keywords(lemmatize_words(preprocess_keywords(sc2_kw)))\n",
    "sc3_kw_lemmatized = postprocess_keywords(lemmatize_words(preprocess_keywords(sc3_kw)))\n",
    "sc4_kw_lemmatized = postprocess_keywords(lemmatize_words(preprocess_keywords(sc4_kw)))\n",
    "sc5_kw_lemmatized = postprocess_keywords(lemmatize_words(preprocess_keywords(sc5_kw)))\n",
    "sc7_kw_lemmatized = postprocess_keywords(lemmatize_words(preprocess_keywords(sc7_kw)))\n",
    "\n",
    "sc1_kw_stemmed = postprocess_keywords(stem_words(preprocess_keywords(sc1_kw)))\n",
    "sc2_kw_stemmed = postprocess_keywords(stem_words(preprocess_keywords(sc2_kw)))\n",
    "sc3_kw_stemmed = postprocess_keywords(stem_words(preprocess_keywords(sc3_kw)))\n",
    "sc4_kw_stemmed = postprocess_keywords(stem_words(preprocess_keywords(sc4_kw)))\n",
    "sc5_kw_stemmed = postprocess_keywords(stem_words(preprocess_keywords(sc5_kw)))\n",
    "sc7_kw_stemmed = postprocess_keywords(stem_words(preprocess_keywords(sc7_kw)))\n",
    "\n",
    "# print lemmatized dictionary\n",
    "print(\"sc1_kw_lemmatized:\", sc1_kw_lemmatized)\n",
    "print(\"sc2_kw_lemmatized:\", sc2_kw_lemmatized)\n",
    "print(\"sc3_kw_lemmatized:\", sc3_kw_lemmatized)\n",
    "print(\"sc4_kw_lemmatized:\", sc4_kw_lemmatized)\n",
    "print(\"sc5_kw_lemmatized:\", sc5_kw_lemmatized)\n",
    "print(\"sc7_kw_lemmatized:\", sc7_kw_lemmatized)\n",
    "\n",
    "# print stemmed dictionary\n",
    "print(\"sc1_kw_stemmed:\", sc1_kw_stemmed)\n",
    "print(\"sc2_kw_stemmed:\", sc2_kw_stemmed)\n",
    "print(\"sc3_kw_stemmed:\", sc3_kw_stemmed)\n",
    "print(\"sc4_kw_stemmed:\", sc4_kw_stemmed)\n",
    "print(\"sc5_kw_stemmed:\", sc5_kw_stemmed)\n",
    "print(\"sc7_kw_stemmed:\", sc7_kw_stemmed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ['no_climate_emergency', 'melt', 'arctic_ice', 'arctic_sea_ice', 'sea_level_rise', 'extreme_weather', 'global_cooling', 'greenland_ice', 'ice_cap', 'arctic_ice', 'extreme_heat', 'extreme_cold'], 2: ['natural_cycle', 'co2_be_not_the_cause', 'greenhouse_gas', 'no_co2_greenhouse_effect', 'no_effect', 'miniscule_effect', 'man_have_no_control'], 3: ['plant_food', 'plant_growth', 'thrive', 'carbon_element_be_essential', 'average_temperature_increase', '1_degree', 'more_fossil_fuel', 'no_co2', 'plant_food', 'not_pollution', '0.1c', 'ppm', 'not_a_pollutant'], 4: ['green_energy', 'renewable_energy', 'energy_production', 'windmill', 'solar_panel'], 5: ['alarmism', 'catastrophist', 'doomsday_cult', 'climate_hysteric', 'unscientific', 'corrupt_politician', 'lie_about_everything', 'idiocy', 'lunatic', 'climate_worship', 'climatists', 'alarmist', 'compliant_medium', 'climate_hysteria', 'climate_narrative', 'climate_cult', 'scientism', 'climate_science_myth', 'lie_in_science', 'climate_apocalypse', 'propaganda', 'doomsayers', 'clown_show', 'fake_climate', 'climate_change_agenda', 'money_make', 'fake_news', 'climate_terrorist'], 6: ['globalist', 'globalist_elite', 'elitist', 'global_government', 'one_world', 'one_world_government', 'globalism', 'one_world_utopia', 'new_world_order', 'enrich_themselves', 'save_the_planet', 'control_over_your_life', 'tyranny', 'global_elite', 'wef', 'population_control']}\n",
      "{1: ['no_climat_emerg', 'melt', 'arctic_ice', 'arctic_sea_ice', 'sea_level_rise', 'extrem_weather', 'global_cool', 'greenland_ice', 'ice_cap', 'arctic_ice', 'extrem_heat', 'extrem_cold'], 2: ['natur_cycl', 'co2_is_not_the_caus', 'greenhous_gas', 'no_co2_greenhous_effect', 'no_effect', 'miniscul_effect', 'man_has_no_control'], 3: ['plant_food', 'plant_growth', 'thrive', 'carbon_element_is_essenti', 'averag_temperatur_increas', '1_degre', 'more_fossil_fuel', 'no_co2', 'plant_food', 'not_pollut', '0.1c', 'ppm', 'not_a_pollut'], 4: ['green_energi', 'renew_energi', 'energi_product', 'windmil', 'solar_panel'], 5: ['alarm', 'catastrophist', 'doomsday_cult', 'climat_hyster', 'unscientif', 'corrupt_politician', 'lie_about_everyth', 'idioci', 'lunat', 'climat_worship', 'climatist', 'alarmist', 'compliant_media', 'climat_hysteria', 'climat_narrat', 'climat_cult', 'scientism', 'climat_scienc_myth', 'lie_in_scienc', 'climat_apocalyps', 'propaganda', 'doomsay', 'clown_show', 'fake_climat', 'climat_chang_agenda', 'money_made', 'fake_news', 'climat_terrorist'], 6: ['globalist', 'globalist_elit', 'elitist', 'global_govern', 'one_world', 'one_world_govern', 'global', 'one_world_utopia', 'new_world_order', 'enrich_themselv', 'save_the_planet', 'control_over_your_live', 'tyranni', 'global_elit', 'wef', 'popul_control']}\n"
     ]
    }
   ],
   "source": [
    "# Creating the dictionaries for the classifier\n",
    "keyword_dict_lemmatized = {\n",
    "    1: sc1_kw_lemmatized,\n",
    "    2: sc2_kw_lemmatized,\n",
    "    3: sc3_kw_lemmatized,\n",
    "    4: sc4_kw_lemmatized,\n",
    "    5: sc5_kw_lemmatized,\n",
    "    6: sc7_kw_lemmatized\n",
    "}\n",
    "\n",
    "\n",
    "keyword_dict_stemmed = {\n",
    "    1: sc1_kw_stemmed,\n",
    "    2: sc2_kw_stemmed,\n",
    "    3: sc3_kw_stemmed,\n",
    "    4: sc4_kw_stemmed,\n",
    "    5: sc5_kw_stemmed,\n",
    "    6: sc7_kw_stemmed\n",
    "}\n",
    "\n",
    "keyword_dict_lemmatized_valid = {\n",
    "    1: ['climate'],\n",
    "    2: ['climate_change']\n",
    "}\n",
    "\n",
    "#print keyword dictionaries\n",
    "print(keyword_dict_lemmatized)\n",
    "print(keyword_dict_stemmed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classifier\n",
    "\n",
    "Classification of YouTube comments related to each claim, based on the text of the comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classifiying the comments into categories\n",
    "def classify_comments(comments, keyword_dict):\n",
    "    classifications = [] #initialize empty list of classifications\n",
    "    \n",
    "    for comment in comments: #loop through each comment of the df \n",
    "        categories = [] #initialize empty list of categories\n",
    "        comment_str = \",\".join(comment)  # Join the tokens of one comement into a single string for easier matching\n",
    "        \n",
    "        for category, keywords in keyword_dict.items(): #iterating through each key-value pair of the dictionary\n",
    "            for keyword in keywords: #for each category: iterate through list of keywords. Check if each keyword is present in comment_str\n",
    "                if keyword in comment_str:\n",
    "                    categories.append(category) #if a keyworrd is found, the category is appended to list.\n",
    "                    break  # Stop checking more keywords for this category\n",
    "        \n",
    "        if not categories:\n",
    "            categories = ['uncategorized']\n",
    "        \n",
    "        classifications.append(categories)\n",
    "    \n",
    "    return classifications\n",
    "\n",
    "# Apply classifier to lemmatized comments \n",
    "processed_df['category_lemmatized_comments'] = classify_comments(processed_df['all_n_grams_lemmatized'], keyword_dict_lemmatized)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "category_lemmatized_comments\n",
       "[uncategorized]    88626\n",
       "[5]                 2957\n",
       "[6]                 1891\n",
       "[1]                 1083\n",
       "[4]                  580\n",
       "[3]                  571\n",
       "[2]                  296\n",
       "[5, 6]               141\n",
       "[1, 5]                72\n",
       "[3, 5]                51\n",
       "[1, 3]                42\n",
       "[2, 3]                38\n",
       "[3, 6]                30\n",
       "[4, 5]                28\n",
       "[1, 6]                28\n",
       "[1, 2]                25\n",
       "[2, 5]                18\n",
       "[1, 4]                18\n",
       "[4, 6]                16\n",
       "[3, 4]                11\n",
       "[2, 4]                10\n",
       "[1, 3, 5]              9\n",
       "[1, 2, 3, 5]           7\n",
       "[2, 6]                 7\n",
       "[1, 5, 6]              5\n",
       "[1, 2, 3]              5\n",
       "[2, 3, 5]              5\n",
       "[1, 2, 5]              4\n",
       "[2, 3, 5, 6]           4\n",
       "[1, 3, 6]              3\n",
       "[1, 3, 4, 6]           3\n",
       "[1, 2, 6]              2\n",
       "[2, 5, 6]              1\n",
       "[1, 2, 4]              1\n",
       "[3, 5, 6]              1\n",
       "[1, 2, 3, 4, 5]        1\n",
       "[2, 3, 4]              1\n",
       "[1, 3, 4, 5]           1\n",
       "[1, 2, 3, 5, 6]        1\n",
       "[3, 4, 6]              1\n",
       "[2, 4, 5]              1\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Categories Count of Lemmatized Unigrams\n",
    "processed_df['category_lemmatized_comments'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "category_lemmatized_comments_validated\n",
      "[uncategorized]    81518\n",
      "[1]                 7795\n",
      "[1, 2]              7282\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Categories of Validation with Climate and Climate Change\n",
    "processed_df['category_lemmatized_comments_validated'] = classify_comments(processed_df['all_n_grams_lemmatized'], keyword_dict_lemmatized_valid)\n",
    "print(processed_df['category_lemmatized_comments_validated'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network Analysis\n",
    "\n",
    "Building a network for the interconnected Claims based on the Fruchterman-Reingold algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filter interconnected claims\n",
    "processed_df_network = processed_df[['category_lemmatized_comments','author', 'video_id']]\n",
    "processed_df_network = processed_df_network[~processed_df_network['category_lemmatized_comments'].apply(lambda x: 'uncategorized' in x)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a dictionary to hold co-occurrence counts\n",
    "co_occurrence = defaultdict(int)\n",
    "\n",
    "# Iterate over the DataFrame\n",
    "for categories in processed_df_network['category_lemmatized_comments']:\n",
    "    for category_pair in itertools.combinations(categories, 2):\n",
    "        co_occurrence[tuple(sorted(category_pair))] += 1\n",
    "\n",
    "# Convert the co-occurrence dictionary to a DataFrame (adjacency matrix)\n",
    "adj_matrix = pd.DataFrame.from_dict(co_occurrence, orient='index', columns=['weight'])\n",
    "adj_matrix = adj_matrix.reset_index()\n",
    "adj_matrix[['category1', 'category2']] = pd.DataFrame(adj_matrix['index'].tolist(), index=adj_matrix.index)\n",
    "adj_matrix = adj_matrix.drop(columns='index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 3, 5, 6, 2]\n",
      "[(1, 4, {'weight': 24}), (1, 3, {'weight': 72}), (1, 6, {'weight': 42}), (1, 2, {'weight': 46}), (1, 5, {'weight': 100}), (4, 5, {'weight': 31}), (4, 6, {'weight': 20}), (4, 3, {'weight': 18}), (4, 2, {'weight': 14}), (3, 5, {'weight': 80}), (3, 6, {'weight': 43}), (3, 2, {'weight': 62}), (5, 6, {'weight': 153}), (5, 2, {'weight': 42}), (6, 2, {'weight': 15})]\n"
     ]
    }
   ],
   "source": [
    "# Create the graph\n",
    "G = nx.Graph()\n",
    "\n",
    "# Add edges with weights\n",
    "for _, row in adj_matrix.iterrows():\n",
    "    G.add_edge(row['category1'], row['category2'], weight=row['weight'])\n",
    "\n",
    "# Optional: Add nodes for categories with no edges\n",
    "for category in processed_df_network['category_lemmatized_comments'].explode().unique():\n",
    "    if category not in G:\n",
    "        G.add_node(category)\n",
    "\n",
    "print(G.nodes())\n",
    "print(G.edges(data=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute positions using the Fruchterman-Reingold algorithm\n",
    "pos = nx.spring_layout(G, seed=42)  # seed for reproducibility\n",
    "\n",
    "# Extract edge weights\n",
    "edge_weights = [d['weight'] for u, v, d in G.edges(data=True)]\n",
    "\n",
    "# Normalize edge weights for better visualization\n",
    "max_weight = max(edge_weights)\n",
    "edge_widths = [w / max_weight * 5 for w in edge_weights]  # Scaling factor (5) can be adjusted as needed\n",
    "\n",
    "# Draw the graph\n",
    "plt.figure(figsize=(8, 8))  # Adjust the figure size as needed\n",
    "nx.draw(G, pos, with_labels=True, node_size=700, node_color='lightblue', font_size=10, font_weight='bold', \n",
    "        width=edge_widths, edge_color='gray')  # Specify edge width\n",
    "\n",
    "plt.axis('off')  # Turn off axis\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tracking Uncategorized Comments\n",
    "\n",
    "to find out why many of the comments are uncategorized we backtrack them to the channel to see if there is any relationship.\n",
    "Based on the video id which we have for each comment we can use the YouTube API to get the channel name.\n",
    "\n",
    "> **Important**: Insert your API Key in the Script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/0t/kqk1ph5n4ds0_g7v6gyknwdh0000gn/T/ipykernel_40937/581894756.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  processed_df['category'] = processed_df['category_lemmatized_comments'].apply(lambda x: ', '.join(map(str, x)))\n"
     ]
    }
   ],
   "source": [
    "processed_df = processed_df[['category_lemmatized_comments', 'video_id']]\n",
    "processed_df['category'] = processed_df['category_lemmatized_comments'].apply(lambda x: ', '.join(map(str, x)))\n",
    "processed_df = processed_df[processed_df['category'] == 'uncategorized']\n",
    "processed_df = processed_df.groupby('video_id')['category'].value_counts().reset_index(name='Category_Count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replace with your API key\n",
    "API_KEY = api_key_1\n",
    "def get_channel_name(video_id):\n",
    "    # Build the YouTube service object\n",
    "    youtube = build('youtube', 'v3', developerKey=API_KEY)\n",
    "    \n",
    "    try:\n",
    "        # Request video details\n",
    "        video_response = youtube.videos().list(\n",
    "            part='snippet',\n",
    "            id=video_id\n",
    "        ).execute()\n",
    "        \n",
    "        # Extract channel ID from video details\n",
    "        channel_id = video_response['items'][0]['snippet']['channelId']\n",
    "        \n",
    "        # Request channel details\n",
    "        channel_response = youtube.channels().list(\n",
    "            part='snippet',\n",
    "            id=channel_id\n",
    "        ).execute()\n",
    "        \n",
    "        # Extract channel name from channel details\n",
    "        channel_name = channel_response['items'][0]['snippet']['title']\n",
    "        \n",
    "        return channel_name\n",
    "    \n",
    "    except:\n",
    "        return None  # Return None if there's an error\n",
    "\n",
    "# Function to get channel name for each video ID\n",
    "def get_channel_names(row):\n",
    "    return get_channel_name(row['video_id'])\n",
    "\n",
    "# Apply the function to each row in the DataFrame\n",
    "processed_df['channel_name'] = processed_df.apply(get_channel_names, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>channel_name</th>\n",
       "      <th>Category_Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Tony Heller</td>\n",
       "      <td>30334</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>PowerfulJRE</td>\n",
       "      <td>12177</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>BlazeTV</td>\n",
       "      <td>11373</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Redacted</td>\n",
       "      <td>8306</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Tom Nelson</td>\n",
       "      <td>7138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>PragerU</td>\n",
       "      <td>7032</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Jordan B Peterson</td>\n",
       "      <td>6802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>ReasonTV</td>\n",
       "      <td>1768</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Blaze News</td>\n",
       "      <td>1577</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Newsmax</td>\n",
       "      <td>1175</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Lex Clips</td>\n",
       "      <td>669</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         channel_name  Category_Count\n",
       "10        Tony Heller           30334\n",
       "5         PowerfulJRE           12177\n",
       "1             BlazeTV           11373\n",
       "8            Redacted            8306\n",
       "9          Tom Nelson            7138\n",
       "6             PragerU            7032\n",
       "2   Jordan B Peterson            6802\n",
       "7            ReasonTV            1768\n",
       "0          Blaze News            1577\n",
       "4             Newsmax            1175\n",
       "3           Lex Clips             669"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "processed_df = processed_df.groupby('channel_name')['Category_Count'].sum().reset_index()\n",
    "processed_df.sort_values('Category_Count',ascending=False,inplace=True)\n",
    "processed_df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}