Upload homework1_Analyze_the_news_headlines_dataset_colab.ipynb

homework1_Analyze_the_news_headlines_dataset_colab.ipynb

@@ -0,0 +1,967 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "WW6kJjTQiQOX"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 1: install and import packages\n",
+        "!pip -q install nltk seaborn scikit-learn tqdm\n",
+        "\n",
+        "import os\n",
+        "import re\n",
+        "import warnings\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "import nltk\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import seaborn as sns\n",
+        "\n",
+        "from IPython.display import display\n",
+        "from nltk.sentiment.vader import SentimentIntensityAnalyzer\n",
+        "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
+        "from tqdm.auto import tqdm\n",
+        "\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "nltk.download(\"vader_lexicon\", quiet=True)\n",
+        "\n",
+        "tqdm.pandas()\n",
+        "pd.set_option(\"display.max_colwidth\", 180)\n",
+        "sns.set_theme(style=\"whitegrid\")"
+      ],
+      "id": "WW6kJjTQiQOX"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "CQnl5bndiQOZ",
+        "outputId": "db42c827-b972-4519-c835-9c4c67916aed"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Required files already found.\n",
+            "\n",
+            "Optional: upload labeled_data.csv too if you want accuracy and misclassification analysis.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Cell 2: upload files if they are not already in /content\n",
+        "from google.colab import files\n",
+        "\n",
+        "required_files = [\n",
+        "    \"news_data.csv\",\n",
+        "    \"Loughran-McDonald_MasterDictionary_1993-2024.csv\",\n",
+        "]\n",
+        "\n",
+        "missing_required = [\n",
+        "    filename\n",
+        "    for filename in required_files\n",
+        "    if not os.path.exists(f\"/content/{filename}\") and not os.path.exists(filename)\n",
+        "]\n",
+        "\n",
+        "if missing_required:\n",
+        "    print(\"Please upload these required files:\", missing_required)\n",
+        "    uploaded = files.upload()\n",
+        "else:\n",
+        "    print(\"Required files already found.\")\n",
+        "\n",
+        "print(\"\\nOptional: upload labeled_data.csv too if you want accuracy and misclassification analysis.\")"
+      ],
+      "id": "CQnl5bndiQOZ"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MrDaboNQiQOa",
+        "outputId": "6c30ce9c-150b-4027-e4f9-b670279696e0"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "news_data.csv: /content/news_data.csv\n",
+            "LM dictionary: /content/Loughran-McDonald_MasterDictionary_1993-2024.csv\n",
+            "optional labeled_data.csv: None\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Cell 3: locate files\n",
+        "def find_file(filename):\n",
+        "    candidates = [\n",
+        "        f\"/content/{filename}\",\n",
+        "        filename,\n",
+        "        f\"/content/drive/MyDrive/{filename}\",\n",
+        "    ]\n",
+        "    for path in candidates:\n",
+        "        if os.path.exists(path):\n",
+        "            return path\n",
+        "    return None\n",
+        "\n",
+        "news_path = find_file(\"news_data.csv\")\n",
+        "lm_path = find_file(\"Loughran-McDonald_MasterDictionary_1993-2024.csv\")\n",
+        "labeled_path = find_file(\"labeled_data.csv\")\n",
+        "\n",
+        "if news_path is None:\n",
+        "    raise FileNotFoundError(\"news_data.csv was not found. Please upload it first.\")\n",
+        "if lm_path is None:\n",
+        "    raise FileNotFoundError(\"Loughran-McDonald_MasterDictionary_1993-2024.csv was not found. Please upload it first.\")\n",
+        "\n",
+        "print(\"news_data.csv:\", news_path)\n",
+        "print(\"LM dictionary:\", lm_path)\n",
+        "print(\"optional labeled_data.csv:\", labeled_path)"
+      ],
+      "id": "MrDaboNQiQOa"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "hLiughDAiQOb"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 4: read data\n",
+        "news = pd.read_csv(news_path, low_memory=False)\n",
+        "lm = pd.read_csv(lm_path, low_memory=False)\n",
+        "\n",
+        "print(\"News data shape:\", news.shape)\n",
+        "print(\"LM dictionary shape:\", lm.shape)\n",
+        "\n",
+        "print(\"\\nNews columns:\")\n",
+        "print(news.columns.tolist())\n",
+        "\n",
+        "display(news.head())"
+      ],
+      "id": "hLiughDAiQOb"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Ewt04Mj8iQOb"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 5: inspect missing values, duplicates, dates, tickers, and English filter\n",
+        "quality = pd.DataFrame({\n",
+        "    \"dtype\": news.dtypes.astype(str),\n",
+        "    \"missing_count\": news.isna().sum(),\n",
+        "    \"missing_pct\": news.isna().mean().round(4),\n",
+        "    \"unique_count\": news.nunique(dropna=True),\n",
+        "})\n",
+        "display(quality)\n",
+        "\n",
+        "print(\"Duplicate full rows:\", news.duplicated().sum())\n",
+        "\n",
+        "if {\"time\", \"ticker\", \"headline\"}.issubset(news.columns):\n",
+        "    print(\"Duplicate time-ticker-headline rows:\", news.duplicated([\"time\", \"ticker\", \"headline\"]).sum())\n",
+        "\n",
+        "if \"headline\" in news.columns:\n",
+        "    print(\"Duplicate headlines:\", news.duplicated([\"headline\"]).sum())\n",
+        "\n",
+        "if \"cleaned_text_nltk\" in news.columns:\n",
+        "    print(\"Duplicate cleaned_text_nltk:\", news.duplicated([\"cleaned_text_nltk\"]).sum())\n",
+        "\n",
+        "news[\"time\"] = pd.to_datetime(news[\"time\"], errors=\"coerce\")\n",
+        "news[\"date\"] = news[\"time\"].dt.date.astype(str)\n",
+        "\n",
+        "print(\"\\nDate range:\")\n",
+        "print(news[\"time\"].min(), \"to\", news[\"time\"].max())\n",
+        "\n",
+        "print(\"\\nNumber of tickers:\", news[\"ticker\"].nunique())\n",
+        "\n",
+        "print(\"\\nTop 15 tickers by headline count:\")\n",
+        "display(news[\"ticker\"].value_counts().head(15))\n",
+        "\n",
+        "print(\"\\nEnglish flag distribution:\")\n",
+        "display(news[\"is_english\"].value_counts(dropna=False))\n",
+        "\n",
+        "print(\"\\nDoes news_data.csv have label/returns columns?\")\n",
+        "print(\"label\" in news.columns, \"returns\" in news.columns)"
+      ],
+      "id": "Ewt04Mj8iQOb"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "IKZBFA4jiQOc"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 6: filter English headlines and clean text\n",
+        "df = news.copy()\n",
+        "\n",
+        "required_columns = [\"time\", \"date\", \"ticker\", \"headline\", \"is_english\"]\n",
+        "missing_columns = [c for c in required_columns if c not in df.columns]\n",
+        "if missing_columns:\n",
+        "    raise ValueError(f\"Missing required columns: {missing_columns}\")\n",
+        "\n",
+        "df = df[df[\"is_english\"] == True].copy()\n",
+        "df = df.dropna(subset=[\"time\", \"ticker\", \"headline\"])\n",
+        "df = df.drop_duplicates(subset=[\"time\", \"ticker\", \"headline\"]).copy()\n",
+        "\n",
+        "def clean_text(text):\n",
+        "    text = str(text).lower()\n",
+        "    text = re.sub(r\"http\\S+|www\\S+\", \" \", text)\n",
+        "    text = re.sub(r\"[^a-zA-Z\\s]\", \" \", text)\n",
+        "    text = re.sub(r\"\\s+\", \" \", text).strip()\n",
+        "    return text\n",
+        "\n",
+        "df[\"clean_text\"] = df[\"headline\"].apply(clean_text)\n",
+        "df = df[df[\"clean_text\"].str.len() > 0].copy()\n",
+        "\n",
+        "print(\"Prepared news data shape:\", df.shape)\n",
+        "display(df[[\"time\", \"ticker\", \"headline\", \"clean_text\"]].head())"
+      ],
+      "id": "IKZBFA4jiQOc"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "vuCp3ZJwiQOd"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 7: optional speed setting\n",
+        "# Keep RUN_ON_SAMPLE = False for the final homework result.\n",
+        "# Set it to True only if you want a quick test run first.\n",
+        "\n",
+        "RUN_ON_SAMPLE = False\n",
+        "SAMPLE_N = 50000\n",
+        "\n",
+        "if RUN_ON_SAMPLE:\n",
+        "    work_df = df.sample(n=min(SAMPLE_N, len(df)), random_state=42).copy()\n",
+        "    print(\"Running on sample:\", work_df.shape)\n",
+        "else:\n",
+        "    work_df = df.copy()\n",
+        "    print(\"Running on full dataset:\", work_df.shape)"
+      ],
+      "id": "vuCp3ZJwiQOd"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "6sYDy5UEiQOd"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 8: VADER baseline\n",
+        "sia = SentimentIntensityAnalyzer()\n",
+        "\n",
+        "def vader_score(text):\n",
+        "    return sia.polarity_scores(str(text))[\"compound\"]\n",
+        "\n",
+        "def vader_label(score):\n",
+        "    if score >= 0.05:\n",
+        "        return \"Positive\"\n",
+        "    if score <= -0.05:\n",
+        "        return \"Negative\"\n",
+        "    return \"Neutral\"\n",
+        "\n",
+        "# Use raw headline for VADER because VADER can use punctuation and capitalization.\n",
+        "work_df[\"vader_score\"] = work_df[\"headline\"].progress_apply(vader_score)\n",
+        "work_df[\"vader_sentiment\"] = work_df[\"vader_score\"].apply(vader_label)\n",
+        "\n",
+        "display(work_df[[\"headline\", \"vader_score\", \"vader_sentiment\"]].head())\n",
+        "display(work_df[\"vader_sentiment\"].value_counts(normalize=True).rename(\"share\"))"
+      ],
+      "id": "6sYDy5UEiQOd"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "0JzpbFrAiQOe"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 9: inspect LM dictionary fields\n",
+        "sentiment_cols = [\n",
+        "    \"Negative\",\n",
+        "    \"Positive\",\n",
+        "    \"Uncertainty\",\n",
+        "    \"Litigious\",\n",
+        "    \"Strong_Modal\",\n",
+        "    \"Weak_Modal\",\n",
+        "    \"Constraining\",\n",
+        "    \"Complexity\",\n",
+        "]\n",
+        "\n",
+        "print(\"LM columns:\")\n",
+        "print(lm.columns.tolist())\n",
+        "\n",
+        "lm_summary = []\n",
+        "for col in sentiment_cols:\n",
+        "    lm_summary.append({\n",
+        "        \"field\": col,\n",
+        "        \"nonzero_word_count\": int((lm[col] != 0).sum()),\n",
+        "        \"examples\": \", \".join(lm.loc[lm[col] != 0, \"Word\"].dropna().astype(str).head(10)),\n",
+        "    })\n",
+        "\n",
+        "display(pd.DataFrame(lm_summary))"
+      ],
+      "id": "0JzpbFrAiQOe"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "evPOQo0wiQOe"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 10: Loughran-McDonald scoring\n",
+        "lm_clean = lm.dropna(subset=[\"Word\"]).copy()\n",
+        "lm_clean[\"Word\"] = lm_clean[\"Word\"].astype(str).str.upper()\n",
+        "\n",
+        "lm_positive = set(lm_clean.loc[lm_clean[\"Positive\"] != 0, \"Word\"])\n",
+        "lm_negative = set(lm_clean.loc[lm_clean[\"Negative\"] != 0, \"Word\"])\n",
+        "lm_uncertainty = set(lm_clean.loc[lm_clean[\"Uncertainty\"] != 0, \"Word\"])\n",
+        "lm_litigious = set(lm_clean.loc[lm_clean[\"Litigious\"] != 0, \"Word\"])\n",
+        "\n",
+        "def tokenize_upper(text):\n",
+        "    return re.findall(r\"[A-Za-z]+\", str(text).upper())\n",
+        "\n",
+        "def lm_score_tuple(text):\n",
+        "    tokens = tokenize_upper(text)\n",
+        "    total = len(tokens)\n",
+        "    if total == 0:\n",
+        "        return (0.0, 0, 0, 0, 0, 0)\n",
+        "\n",
+        "    pos_count = sum(t in lm_positive for t in tokens)\n",
+        "    neg_count = sum(t in lm_negative for t in tokens)\n",
+        "    uncertainty_count = sum(t in lm_uncertainty for t in tokens)\n",
+        "    litigious_count = sum(t in lm_litigious for t in tokens)\n",
+        "    score = (pos_count / total) - (neg_count / total)\n",
+        "\n",
+        "    return (score, pos_count, neg_count, uncertainty_count, litigious_count, total)\n",
+        "\n",
+        "lm_values = work_df[\"clean_text\"].progress_apply(lm_score_tuple)\n",
+        "lm_values = pd.DataFrame(\n",
+        "    lm_values.tolist(),\n",
+        "    columns=[\n",
+        "        \"lm_score\",\n",
+        "        \"lm_pos_count\",\n",
+        "        \"lm_neg_count\",\n",
+        "        \"lm_uncertainty_count\",\n",
+        "        \"lm_litigious_count\",\n",
+        "        \"lm_token_count\",\n",
+        "    ],\n",
+        "    index=work_df.index,\n",
+        ")\n",
+        "\n",
+        "work_df = pd.concat([work_df, lm_values], axis=1)\n",
+        "\n",
+        "def lm_label(score):\n",
+        "    if score > 0:\n",
+        "        return \"Positive\"\n",
+        "    if score < 0:\n",
+        "        return \"Negative\"\n",
+        "    return \"Neutral\"\n",
+        "\n",
+        "work_df[\"lm_sentiment\"] = work_df[\"lm_score\"].apply(lm_label)\n",
+        "\n",
+        "display(work_df[[\n",
+        "    \"headline\",\n",
+        "    \"lm_score\",\n",
+        "    \"lm_pos_count\",\n",
+        "    \"lm_neg_count\",\n",
+        "    \"lm_uncertainty_count\",\n",
+        "    \"lm_litigious_count\",\n",
+        "    \"lm_sentiment\",\n",
+        "]].head())\n",
+        "\n",
+        "display(work_df[\"lm_sentiment\"].value_counts(normalize=True).rename(\"share\"))"
+      ],
+      "id": "evPOQo0wiQOe"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "OB8MirpTiQOe"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 11: custom unigram/bigram lexicon\n",
+        "custom_unigram_weights = {\n",
+        "    # positive / bullish terms\n",
+        "    \"gain\": 1.2,\n",
+        "    \"gains\": 1.2,\n",
+        "    \"gained\": 1.1,\n",
+        "    \"rise\": 1.2,\n",
+        "    \"rises\": 1.2,\n",
+        "    \"rose\": 1.2,\n",
+        "    \"rising\": 1.1,\n",
+        "    \"jump\": 1.5,\n",
+        "    \"jumps\": 1.5,\n",
+        "    \"jumped\": 1.5,\n",
+        "    \"surge\": 1.8,\n",
+        "    \"surges\": 1.8,\n",
+        "    \"surged\": 1.8,\n",
+        "    \"rally\": 1.6,\n",
+        "    \"rallies\": 1.6,\n",
+        "    \"rallied\": 1.6,\n",
+        "    \"beat\": 1.5,\n",
+        "    \"beats\": 1.5,\n",
+        "    \"beating\": 1.4,\n",
+        "    \"upgrade\": 1.6,\n",
+        "    \"upgrades\": 1.6,\n",
+        "    \"upgraded\": 1.6,\n",
+        "    \"outperform\": 1.5,\n",
+        "    \"buy\": 1.2,\n",
+        "    \"bullish\": 1.8,\n",
+        "    \"record\": 1.0,\n",
+        "    \"strong\": 1.2,\n",
+        "    \"growth\": 1.1,\n",
+        "    \"profit\": 1.2,\n",
+        "    \"profits\": 1.2,\n",
+        "    \"approval\": 1.0,\n",
+        "    \"approved\": 1.0,\n",
+        "    \"accretive\": 1.3,\n",
+        "    \"expands\": 1.0,\n",
+        "    \"expand\": 1.0,\n",
+        "    \"wins\": 1.1,\n",
+        "    \"raises\": 1.5,\n",
+        "    \"raised\": 1.5,\n",
+        "\n",
+        "    # negative / bearish terms\n",
+        "    \"loss\": -1.4,\n",
+        "    \"losses\": -1.4,\n",
+        "    \"decline\": -1.3,\n",
+        "    \"declines\": -1.3,\n",
+        "    \"declined\": -1.3,\n",
+        "    \"drop\": -1.3,\n",
+        "    \"drops\": -1.3,\n",
+        "    \"dropped\": -1.3,\n",
+        "    \"fall\": -1.2,\n",
+        "    \"falls\": -1.2,\n",
+        "    \"fell\": -1.2,\n",
+        "    \"plunge\": -1.9,\n",
+        "    \"plunges\": -1.9,\n",
+        "    \"plunged\": -1.9,\n",
+        "    \"slump\": -1.7,\n",
+        "    \"slumps\": -1.7,\n",
+        "    \"slumped\": -1.7,\n",
+        "    \"miss\": -1.5,\n",
+        "    \"misses\": -1.5,\n",
+        "    \"missed\": -1.5,\n",
+        "    \"downgrade\": -1.7,\n",
+        "    \"downgrades\": -1.7,\n",
+        "    \"downgraded\": -1.7,\n",
+        "    \"underperform\": -1.5,\n",
+        "    \"sell\": -1.2,\n",
+        "    \"bearish\": -1.8,\n",
+        "    \"lawsuit\": -1.4,\n",
+        "    \"probe\": -1.2,\n",
+        "    \"investigation\": -1.2,\n",
+        "    \"bankruptcy\": -2.2,\n",
+        "    \"default\": -2.0,\n",
+        "    \"warning\": -1.4,\n",
+        "    \"recall\": -1.3,\n",
+        "    \"recession\": -1.9,\n",
+        "    \"weak\": -1.2,\n",
+        "    \"cuts\": -1.2,\n",
+        "    \"cut\": -1.0,\n",
+        "    \"lower\": -0.9,\n",
+        "    \"lowers\": -1.2,\n",
+        "}\n",
+        "\n",
+        "custom_bigram_weights = {\n",
+        "    # positive / bullish phrases\n",
+        "    \"raises target\": 2.0,\n",
+        "    \"raised target\": 2.0,\n",
+        "    \"price target\": 0.0,\n",
+        "    \"beats estimates\": 2.0,\n",
+        "    \"beats expectations\": 2.0,\n",
+        "    \"beat estimates\": 2.0,\n",
+        "    \"strong earnings\": 1.8,\n",
+        "    \"record high\": 1.7,\n",
+        "    \"new high\": 1.3,\n",
+        "    \"fda approval\": 1.4,\n",
+        "    \"wins contract\": 1.4,\n",
+        "    \"stock rises\": 1.4,\n",
+        "    \"shares rise\": 1.4,\n",
+        "    \"shares jump\": 1.7,\n",
+        "    \"shares surge\": 1.9,\n",
+        "    \"buy rating\": 1.3,\n",
+        "    \"upgraded to\": 1.4,\n",
+        "\n",
+        "    # negative / bearish phrases\n",
+        "    \"cuts target\": -2.0,\n",
+        "    \"cut target\": -2.0,\n",
+        "    \"lowers target\": -2.0,\n",
+        "    \"lowered target\": -2.0,\n",
+        "    \"misses estimates\": -2.0,\n",
+        "    \"misses expectations\": -2.0,\n",
+        "    \"weak earnings\": -1.8,\n",
+        "    \"profit warning\": -1.8,\n",
+        "    \"stock falls\": -1.4,\n",
+        "    \"shares fall\": -1.4,\n",
+        "    \"shares drop\": -1.5,\n",
+        "    \"shares plunge\": -2.0,\n",
+        "    \"sell rating\": -1.3,\n",
+        "    \"downgraded to\": -1.4,\n",
+        "    \"files bankruptcy\": -2.2,\n",
+        "    \"sec probe\": -1.6,\n",
+        "}\n",
+        "\n",
+        "neutral_unigrams = {\n",
+        "    \"dow\",\n",
+        "    \"jones\",\n",
+        "    \"selected\",\n",
+        "    \"stock\",\n",
+        "    \"stocks\",\n",
+        "    \"nyse\",\n",
+        "    \"nasdaq\",\n",
+        "    \"reg\",\n",
+        "    \"plc\",\n",
+        "    \"inc\",\n",
+        "    \"corp\",\n",
+        "    \"company\",\n",
+        "    \"companies\",\n",
+        "    \"net\",\n",
+        "    \"asset\",\n",
+        "    \"value\",\n",
+        "    \"shares\",\n",
+        "    \"share\",\n",
+        "    \"market\",\n",
+        "    \"markets\",\n",
+        "    \"update\",\n",
+        "    \"brief\",\n",
+        "    \"rpt\",\n",
+        "}\n",
+        "\n",
+        "def tokenize_lower(text):\n",
+        "    return re.findall(r\"[a-z]+\", str(text).lower())\n",
+        "\n",
+        "def custom_score_tuple(text):\n",
+        "    tokens = [t for t in tokenize_lower(text) if t not in neutral_unigrams]\n",
+        "    if not tokens:\n",
+        "        return (0.0, 0, 0, 0)\n",
+        "\n",
+        "    bigrams = [f\"{tokens[i]} {tokens[i + 1]}\" for i in range(len(tokens) - 1)]\n",
+        "\n",
+        "    raw_score = 0.0\n",
+        "    unigram_hits = 0\n",
+        "    bigram_hits = 0\n",
+        "\n",
+        "    for token in tokens:\n",
+        "        weight = custom_unigram_weights.get(token, 0.0)\n",
+        "        if weight != 0:\n",
+        "            raw_score += weight\n",
+        "            unigram_hits += 1\n",
+        "\n",
+        "    for bigram in bigrams:\n",
+        "        weight = custom_bigram_weights.get(bigram, 0.0)\n",
+        "        if weight != 0:\n",
+        "            raw_score += weight\n",
+        "            bigram_hits += 1\n",
+        "\n",
+        "    normalized_score = raw_score / np.sqrt(len(tokens))\n",
+        "    return (normalized_score, raw_score, unigram_hits, bigram_hits)\n",
+        "\n",
+        "custom_values = work_df[\"clean_text\"].progress_apply(custom_score_tuple)\n",
+        "custom_values = pd.DataFrame(\n",
+        "    custom_values.tolist(),\n",
+        "    columns=[\"custom_score\", \"custom_raw_score\", \"custom_unigram_hits\", \"custom_bigram_hits\"],\n",
+        "    index=work_df.index,\n",
+        ")\n",
+        "\n",
+        "work_df = pd.concat([work_df, custom_values], axis=1)\n",
+        "\n",
+        "def custom_label(score):\n",
+        "    if score >= 0.05:\n",
+        "        return \"Positive\"\n",
+        "    if score <= -0.05:\n",
+        "        return \"Negative\"\n",
+        "    return \"Neutral\"\n",
+        "\n",
+        "work_df[\"custom_sentiment\"] = work_df[\"custom_score\"].apply(custom_label)\n",
+        "\n",
+        "display(work_df[[\n",
+        "    \"headline\",\n",
+        "    \"custom_score\",\n",
+        "    \"custom_raw_score\",\n",
+        "    \"custom_unigram_hits\",\n",
+        "    \"custom_bigram_hits\",\n",
+        "    \"custom_sentiment\",\n",
+        "]].head())\n",
+        "\n",
+        "display(work_df[\"custom_sentiment\"].value_counts(normalize=True).rename(\"share\"))"
+      ],
+      "id": "OB8MirpTiQOe"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "hPq4-qZHiQOf"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 12: compare sentiment distributions\n",
+        "sentiment_columns = [\"vader_sentiment\", \"lm_sentiment\", \"custom_sentiment\"]\n",
+        "\n",
+        "distribution_tables = []\n",
+        "for col in sentiment_columns:\n",
+        "    temp = work_df[col].value_counts(normalize=True).rename(\"share\").reset_index()\n",
+        "    temp.columns = [\"sentiment\", \"share\"]\n",
+        "    temp[\"model\"] = col.replace(\"_sentiment\", \"\")\n",
+        "    distribution_tables.append(temp)\n",
+        "\n",
+        "sentiment_distribution = pd.concat(distribution_tables, ignore_index=True)\n",
+        "display(sentiment_distribution)\n",
+        "\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "ax = sns.barplot(data=sentiment_distribution, x=\"model\", y=\"share\", hue=\"sentiment\")\n",
+        "ax.set_title(\"Sentiment Distribution by Lexicon Model\")\n",
+        "ax.set_xlabel(\"Model\")\n",
+        "ax.set_ylabel(\"Share of Headlines\")\n",
+        "ax.set_ylim(0, 1)\n",
+        "plt.show()"
+      ],
+      "id": "hPq4-qZHiQOf"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sE1s_vLTiQOf"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 13: compare average sentiment by ticker\n",
+        "ticker_summary = (\n",
+        "    work_df.groupby(\"ticker\")\n",
+        "    .agg(\n",
+        "        headline_count=(\"headline\", \"size\"),\n",
+        "        vader_mean=(\"vader_score\", \"mean\"),\n",
+        "        lm_mean=(\"lm_score\", \"mean\"),\n",
+        "        custom_mean=(\"custom_score\", \"mean\"),\n",
+        "    )\n",
+        "    .sort_values(\"headline_count\", ascending=False)\n",
+        ")\n",
+        "\n",
+        "print(\"Most covered tickers:\")\n",
+        "display(ticker_summary.head(20))\n",
+        "\n",
+        "print(\"Most positive tickers by custom score, minimum 100 headlines:\")\n",
+        "display(ticker_summary[ticker_summary[\"headline_count\"] >= 100].sort_values(\"custom_mean\", ascending=False).head(20))\n",
+        "\n",
+        "print(\"Most negative tickers by custom score, minimum 100 headlines:\")\n",
+        "display(ticker_summary[ticker_summary[\"headline_count\"] >= 100].sort_values(\"custom_mean\", ascending=True).head(20))"
+      ],
+      "id": "sE1s_vLTiQOf"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zAkNKh0yiQOf"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 14: compare average sentiment over time\n",
+        "daily_summary = (\n",
+        "    work_df.groupby(\"date\")\n",
+        "    .agg(\n",
+        "        headline_count=(\"headline\", \"size\"),\n",
+        "        vader_mean=(\"vader_score\", \"mean\"),\n",
+        "        lm_mean=(\"lm_score\", \"mean\"),\n",
+        "        custom_mean=(\"custom_score\", \"mean\"),\n",
+        "    )\n",
+        "    .reset_index()\n",
+        ")\n",
+        "\n",
+        "daily_summary[\"date\"] = pd.to_datetime(daily_summary[\"date\"])\n",
+        "\n",
+        "plt.figure(figsize=(12, 5))\n",
+        "plt.plot(daily_summary[\"date\"], daily_summary[\"vader_mean\"], label=\"VADER\")\n",
+        "plt.plot(daily_summary[\"date\"], daily_summary[\"lm_mean\"], label=\"Loughran-McDonald\")\n",
+        "plt.plot(daily_summary[\"date\"], daily_summary[\"custom_mean\"], label=\"Custom\")\n",
+        "plt.axhline(0, color=\"black\", linewidth=1)\n",
+        "plt.title(\"Average Daily Sentiment\")\n",
+        "plt.xlabel(\"Date\")\n",
+        "plt.ylabel(\"Average Sentiment Score\")\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ],
+      "id": "zAkNKh0yiQOf"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "lQ4wrZhLiQOf"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 15: review strongest positive/negative examples\n",
+        "print(\"Most positive by custom lexicon:\")\n",
+        "display(work_df.sort_values(\"custom_score\", ascending=False)[[\n",
+        "    \"time\", \"ticker\", \"headline\", \"vader_score\", \"lm_score\", \"custom_score\",\n",
+        "    \"vader_sentiment\", \"lm_sentiment\", \"custom_sentiment\"\n",
+        "]].head(20))\n",
+        "\n",
+        "print(\"Most negative by custom lexicon:\")\n",
+        "display(work_df.sort_values(\"custom_score\", ascending=True)[[\n",
+        "    \"time\", \"ticker\", \"headline\", \"vader_score\", \"lm_score\", \"custom_score\",\n",
+        "    \"vader_sentiment\", \"lm_sentiment\", \"custom_sentiment\"\n",
+        "]].head(20))"
+      ],
+      "id": "lQ4wrZhLiQOf"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "AILWhbsBiQOg"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 16: review model disagreement examples\n",
+        "disagreement = work_df[\n",
+        "    (work_df[\"vader_sentiment\"] != work_df[\"lm_sentiment\"])\n",
+        "    | (work_df[\"vader_sentiment\"] != work_df[\"custom_sentiment\"])\n",
+        "    | (work_df[\"lm_sentiment\"] != work_df[\"custom_sentiment\"])\n",
+        "].copy()\n",
+        "\n",
+        "disagreement[\"score_spread\"] = disagreement[[\"vader_score\", \"lm_score\", \"custom_score\"]].max(axis=1) - disagreement[[\n",
+        "    \"vader_score\", \"lm_score\", \"custom_score\"\n",
+        "]].min(axis=1)\n",
+        "\n",
+        "print(\"Number of disagreement rows:\", len(disagreement))\n",
+        "display(disagreement.sort_values(\"score_spread\", ascending=False)[[\n",
+        "    \"time\", \"ticker\", \"headline\",\n",
+        "    \"vader_score\", \"lm_score\", \"custom_score\",\n",
+        "    \"vader_sentiment\", \"lm_sentiment\", \"custom_sentiment\",\n",
+        "]].head(30))"
+      ],
+      "id": "AILWhbsBiQOg"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "yNuexF8giQOg"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 17: explain custom lexicon score for one headline\n",
+        "def explain_custom_prediction(text):\n",
+        "    tokens = [t for t in tokenize_lower(text) if t not in neutral_unigrams]\n",
+        "    bigrams = [f\"{tokens[i]} {tokens[i + 1]}\" for i in range(len(tokens) - 1)]\n",
+        "\n",
+        "    rows = []\n",
+        "    for token in tokens:\n",
+        "        weight = custom_unigram_weights.get(token, 0.0)\n",
+        "        if weight != 0:\n",
+        "            rows.append({\"term\": token, \"type\": \"unigram\", \"weight\": weight})\n",
+        "\n",
+        "    for bigram in bigrams:\n",
+        "        weight = custom_bigram_weights.get(bigram, 0.0)\n",
+        "        if weight != 0:\n",
+        "            rows.append({\"term\": bigram, \"type\": \"bigram\", \"weight\": weight})\n",
+        "\n",
+        "    return pd.DataFrame(rows).sort_values(\"weight\", ascending=False)\n",
+        "\n",
+        "example_row = work_df.sort_values(\"custom_score\", ascending=False).iloc[0]\n",
+        "print(\"Example headline:\")\n",
+        "print(example_row[\"headline\"])\n",
+        "display(explain_custom_prediction(example_row[\"headline\"]))"
+      ],
+      "id": "yNuexF8giQOg"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "kRt--hVQiQOg"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 18: optional merge with labeled_data.csv for accuracy evaluation\n",
+        "if labeled_path is None:\n",
+        "    print(\"labeled_data.csv not found. Skipping accuracy evaluation.\")\n",
+        "    eval_df = None\n",
+        "else:\n",
+        "    labeled = pd.read_csv(labeled_path, low_memory=False)\n",
+        "    labeled[\"date\"] = pd.to_datetime(labeled[\"time\"], errors=\"coerce\").dt.date.astype(str)\n",
+        "    labeled[\"label_int\"] = labeled[\"label\"].astype(int)\n",
+        "\n",
+        "    daily_by_ticker = (\n",
+        "        work_df.groupby([\"ticker\", \"date\"])\n",
+        "        .agg(\n",
+        "            headline_count=(\"headline\", \"size\"),\n",
+        "            vader_score=(\"vader_score\", \"mean\"),\n",
+        "            lm_score=(\"lm_score\", \"mean\"),\n",
+        "            custom_score=(\"custom_score\", \"mean\"),\n",
+        "            combined_headlines=(\"headline\", lambda x: \" | \".join(x.astype(str).head(5))),\n",
+        "        )\n",
+        "        .reset_index()\n",
+        "    )\n",
+        "\n",
+        "    eval_df = labeled.merge(\n",
+        "        daily_by_ticker,\n",
+        "        on=[\"ticker\", \"date\"],\n",
+        "        how=\"inner\",\n",
+        "        suffixes=(\"_labeled\", \"_news\"),\n",
+        "    )\n",
+        "\n",
+        "    print(\"Merged evaluation shape:\", eval_df.shape)\n",
+        "    display(eval_df.head())"
+      ],
+      "id": "kRt--hVQiQOg"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "R_5cto-iiQOg"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 19: optional accuracy metrics\n",
+        "if eval_df is None or len(eval_df) == 0:\n",
+        "    print(\"No evaluation data available.\")\n",
+        "    evaluation_results = None\n",
+        "else:\n",
+        "    def score_to_binary_label(score):\n",
+        "        return np.where(score >= 0, 1, -1)\n",
+        "\n",
+        "    eval_df[\"vader_pred\"] = score_to_binary_label(eval_df[\"vader_score\"])\n",
+        "    eval_df[\"lm_pred\"] = score_to_binary_label(eval_df[\"lm_score\"])\n",
+        "    eval_df[\"custom_pred\"] = score_to_binary_label(eval_df[\"custom_score\"])\n",
+        "\n",
+        "    evaluation_results = []\n",
+        "\n",
+        "    def evaluate_binary_model(name, pred_col):\n",
+        "        y_true = eval_df[\"label_int\"]\n",
+        "        y_pred = eval_df[pred_col]\n",
+        "        acc = accuracy_score(y_true, y_pred)\n",
+        "        evaluation_results.append({\"model\": name, \"accuracy\": acc})\n",
+        "\n",
+        "        print(\"=\" * 70)\n",
+        "        print(name)\n",
+        "        print(f\"Accuracy: {acc:.4f}\")\n",
+        "        print(\"Confusion matrix, rows=true labels, columns=predicted labels:\")\n",
+        "        print(confusion_matrix(y_true, y_pred, labels=[-1, 1]))\n",
+        "        print(classification_report(y_true, y_pred, labels=[-1, 1], target_names=[\"SELL/-1\", \"BUY/1\"]))\n",
+        "\n",
+        "    evaluate_binary_model(\"VADER daily average\", \"vader_pred\")\n",
+        "    evaluate_binary_model(\"Loughran-McDonald daily average\", \"lm_pred\")\n",
+        "    evaluate_binary_model(\"Custom daily average\", \"custom_pred\")\n",
+        "\n",
+        "    evaluation_results = pd.DataFrame(evaluation_results).sort_values(\"accuracy\", ascending=False)\n",
+        "    display(evaluation_results)"
+      ],
+      "id": "R_5cto-iiQOg"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "fhRmDyCXiQOg"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 20: optional misclassification analysis\n",
+        "if eval_df is None or len(eval_df) == 0 or evaluation_results is None:\n",
+        "    print(\"No misclassification analysis available without labeled_data.csv.\")\n",
+        "else:\n",
+        "    best_eval_model = evaluation_results.iloc[0][\"model\"]\n",
+        "    pred_col_map = {\n",
+        "        \"VADER daily average\": \"vader_pred\",\n",
+        "        \"Loughran-McDonald daily average\": \"lm_pred\",\n",
+        "        \"Custom daily average\": \"custom_pred\",\n",
+        "    }\n",
+        "    best_pred_col = pred_col_map[best_eval_model]\n",
+        "\n",
+        "    eval_df[\"best_pred\"] = eval_df[best_pred_col]\n",
+        "    eval_df[\"is_misclassified\"] = eval_df[\"label_int\"] != eval_df[\"best_pred\"]\n",
+        "\n",
+        "    misclassified = eval_df[eval_df[\"is_misclassified\"]].copy()\n",
+        "\n",
+        "    print(\"Best evaluation model:\", best_eval_model)\n",
+        "    print(\"Misclassified rows:\", len(misclassified))\n",
+        "    print(\"Misclassification rate:\", len(misclassified) / len(eval_df))\n",
+        "\n",
+        "    display(misclassified[[\n",
+        "        \"ticker\", \"date\", \"combined_headlines\", \"returns\", \"label_int\",\n",
+        "        \"best_pred\", \"vader_score\", \"lm_score\", \"custom_score\", \"headline_count\"\n",
+        "    ]].head(30))"
+      ],
+      "id": "fhRmDyCXiQOg"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "-ljc7GJciQOh"
+      },
+      "outputs": [],
+      "source": [
+        "# Cell 21: save output files\n",
+        "work_df.to_csv(\"/content/news_data_scored_sentiment.csv\", index=False)\n",
+        "sentiment_distribution.to_csv(\"/content/sentiment_distribution.csv\", index=False)\n",
+        "ticker_summary.to_csv(\"/content/ticker_sentiment_summary.csv\")\n",
+        "daily_summary.to_csv(\"/content/daily_sentiment_summary.csv\", index=False)\n",
+        "\n",
+        "print(\"Saved:\")\n",
+        "print(\"/content/news_data_scored_sentiment.csv\")\n",
+        "print(\"/content/sentiment_distribution.csv\")\n",
+        "print(\"/content/ticker_sentiment_summary.csv\")\n",
+        "print(\"/content/daily_sentiment_summary.csv\")\n",
+        "\n",
+        "if labeled_path is not None and eval_df is not None and len(eval_df) > 0:\n",
+        "    eval_df.to_csv(\"/content/news_data_daily_evaluation.csv\", index=False)\n",
+        "    print(\"/content/news_data_daily_evaluation.csv\")\n",
+        "\n",
+        "    if evaluation_results is not None:\n",
+        "        evaluation_results.to_csv(\"/content/evaluation_results.csv\", index=False)\n",
+        "        print(\"/content/evaluation_results.csv\")\n",
+        "\n",
+        "    if \"misclassified\" in globals():\n",
+        "        misclassified.to_csv(\"/content/misclassified_daily_examples.csv\", index=False)\n",
+        "        print(\"/content/misclassified_daily_examples.csv\")"
+      ],
+      "id": "-ljc7GJciQOh"
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}