BigData_project.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RiccardoRobb/BigData_project/blob/main/BigData_project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ydnT0-krmCTZ"
      },
      "source": [
        "# **Twitter sentiment analysis**\n",
        "### BigData 2023 project\n",
        "\n",
        "[@Author](https://github.com/RiccardoRobb): Riccardo Ruberto 1860609"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TaC0pFVy5ha-"
      },
      "source": [
        "---\n",
        "## **Inital configuration**\n",
        "### PySpark installation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P9pfBiCD4wMp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5fe81ca0-69e2-4261-ed89-6ced0d42a041"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pyspark\n",
            "  Downloading pyspark-3.4.1.tar.gz (310.8 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m310.8/310.8 MB\u001b[0m \u001b[31m4.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.10/dist-packages (from pyspark) (0.10.9.7)\n",
            "Building wheels for collected packages: pyspark\n",
            "  Building wheel for pyspark (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pyspark: filename=pyspark-3.4.1-py2.py3-none-any.whl size=311285387 sha256=893498fe9ca3c9958cca167ef12c2dcc8c0af779f87ba5ac421dbcf8e2e10b5e\n",
            "  Stored in directory: /root/.cache/pip/wheels/0d/77/a3/ff2f74cc9ab41f8f594dabf0579c2a7c6de920d584206e0834\n",
            "Successfully built pyspark\n",
            "Installing collected packages: pyspark\n",
            "Successfully installed pyspark-3.4.1\n"
          ]
        }
      ],
      "source": [
        "! pip install pyspark"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r5rRWp3R5xKn"
      },
      "source": [
        "### Useful imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DZyT2VD7ZMb6"
      },
      "outputs": [],
      "source": [
        "import pyspark\n",
        "from pyspark.sql import *\n",
        "from pyspark.sql.types import *\n",
        "from pyspark.sql.functions import *\n",
        "from pyspark import SparkContext, SparkConf\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sn\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sMZu4CcD51-e"
      },
      "source": [
        "### Spark configuration"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zc_wOE8Fl7aN"
      },
      "outputs": [],
      "source": [
        "# create the session\n",
        "conf = SparkConf().\\\n",
        "                set('spark.ui.port', \"8000\").\\\n",
        "                set('spark.executor.memory', '4G').\\\n",
        "                set('spark.driver.memory', '45G').\\\n",
        "                set('spark.driver.maxResultSize', '10G').\\\n",
        "                setAppName(\"Twitter sentiment analysis\").\\\n",
        "                setMaster(\"local[*]\")\n",
        "\n",
        "# create the context\n",
        "sc = pyspark.SparkContext(conf=conf)\n",
        "spark = SparkSession.builder.getOrCreate()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VJSs9ejr58TM"
      },
      "source": [
        "### Check spark configurations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-rHsaeM75DvA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 219
        },
        "outputId": "4d2107fc-d4d2-4093-de64-63f917c43426"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<pyspark.sql.session.SparkSession at 0x7e68c08033d0>"
            ],
            "text/html": [
              "\n",
              "            <div>\n",
              "                <p><b>SparkSession - in-memory</b></p>\n",
              "                \n",
              "        <div>\n",
              "            <p><b>SparkContext</b></p>\n",
              "\n",
              "            <p><a href=\"http://54690ec488f9:8000\">Spark UI</a></p>\n",
              "\n",
              "            <dl>\n",
              "              <dt>Version</dt>\n",
              "                <dd><code>v3.4.1</code></dd>\n",
              "              <dt>Master</dt>\n",
              "                <dd><code>local[*]</code></dd>\n",
              "              <dt>AppName</dt>\n",
              "                <dd><code>Twitter sentiment analysis</code></dd>\n",
              "            </dl>\n",
              "        </div>\n",
              "        \n",
              "            </div>\n",
              "        "
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "spark"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hTx8THde5L9T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1014625-41d3-45a9-fae9-6ad945acae7f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('spark.driver.memory', '45G'),\n",
              " ('spark.driver.port', '45893'),\n",
              " ('spark.executor.id', 'driver'),\n",
              " ('spark.sql.warehouse.dir', 'file:/content/spark-warehouse'),\n",
              " ('spark.ui.port', '8000'),\n",
              " ('spark.driver.maxResultSize', '10G'),\n",
              " ('spark.app.startTime', '1693653260323'),\n",
              " ('spark.driver.extraJavaOptions',\n",
              "  '-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false'),\n",
              " ('spark.app.name', 'Twitter sentiment analysis'),\n",
              " ('spark.app.submitTime', '1693653259976'),\n",
              " ('spark.driver.host', '54690ec488f9'),\n",
              " ('spark.rdd.compress', 'True'),\n",
              " ('spark.serializer.objectStreamReset', '100'),\n",
              " ('spark.master', 'local[*]'),\n",
              " ('spark.submit.pyFiles', ''),\n",
              " ('spark.submit.deployMode', 'client'),\n",
              " ('spark.app.id', 'local-1693653264024'),\n",
              " ('spark.executor.memory', '4G'),\n",
              " ('spark.ui.showConsoleProgress', 'true'),\n",
              " ('spark.executor.extraJavaOptions',\n",
              "  '-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false')]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "sc._conf.getAll()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrHRiI0C-jDI"
      },
      "source": [
        "---\n",
        "## Load dataset [***Sentiment140***]\n",
        "### Download dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zayTBDQL98iG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fda0af33-2dc5-4af6-ba57-227d48b0f354"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-09-02 11:14:29--  https://raw.githubusercontent.com/RiccardoRobb/BigData_project/main/Sentiment140.zip\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.111.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 84855679 (81M) [application/zip]\n",
            "Saving to: ‘Sentiment140.zip’\n",
            "\n",
            "Sentiment140.zip    100%[===================>]  80.92M   124MB/s    in 0.7s    \n",
            "\n",
            "2023-09-02 11:14:30 (124 MB/s) - ‘Sentiment140.zip’ saved [84855679/84855679]\n",
            "\n",
            "Archive:  ./Sentiment140.zip\n",
            "  inflating: training.1600000.processed.noemoticon.csv  \n"
          ]
        }
      ],
      "source": [
        "! wget https://raw.githubusercontent.com/RiccardoRobb/BigData_project/main/Sentiment140.zip\n",
        "\n",
        "! unzip \"./*.zip\" && rm *.zip\n",
        "! mv training.1600000.processed.noemoticon.csv train140.csv"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hAbLzmUGXNu_"
      },
      "source": [
        "### Create data frame [***Sentiment140***]\n",
        "1600000 tweets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e7UAiEc-_GEv"
      },
      "outputs": [],
      "source": [
        "schema = StructType([ \\\n",
        "    StructField(\"target\",IntegerType(),True), \\\n",
        "    StructField(\"id\",LongType(),True), \\\n",
        "    StructField(\"full_date\",StringType(),True), \\\n",
        "    StructField(\"flag\", StringType(), True), \\\n",
        "    StructField(\"user\", StringType(), True), \\\n",
        "    StructField(\"text\", StringType(), True) \\\n",
        "  ])\n",
        "\n",
        "df = spark.read.csv('./train140.csv', schema=schema, header=\"false\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NUGsEwMyXR9d"
      },
      "source": [
        "---\n",
        "## **Inital cleaning**\n",
        "### Removal of unnecessary columns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jfTVRLBRXTDx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa78694d-0d30-475f-853e-647722509d94"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ],
      "source": [
        "# sentiment of the tweet is not affected by the \"user\"\n",
        "df = df.drop(\"user\")\n",
        "\n",
        "# verify \"flag\" utility\n",
        "print(df.select(countDistinct(\"flag\")).collect()[0][0])\n",
        "\n",
        "# \"flag\" has only one value == NO_QUERY, so I delete it\n",
        "df = df.drop(\"flag\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efsWAcIVXjxt"
      },
      "source": [
        "### From ***date*** to ***day_name***; ***hour***; ***date***"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CnXFsS1rXsjI"
      },
      "outputs": [],
      "source": [
        "months_map = {\"Jan\": \"01\", \"Feb\": \"02\", \"Mar\": \"03\", \"Apr\": \"04\", \"May\": \"05\", \"Jun\": \"06\", \"Jul\": \"07\", \"Aug\": \"08\", \"Sep\": \"09\", \"Oct\": \"10\", \"Nov\": \"11\", \"Dec\": \"12\"}\n",
        "\n",
        "convert_date_udf = udf(lambda month_name : months_map[month_name], StringType())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kUg1WK_Ml0Au"
      },
      "source": [
        "### From **hour:min:mill** to int **hour**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QrCqebf9l9uP"
      },
      "outputs": [],
      "source": [
        "convert_hour_udf = udf(lambda time: int(time[:2]), IntegerType())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FcXyz4aKg_ul"
      },
      "outputs": [],
      "source": [
        "split_col = pyspark.sql.functions.split(df['full_date'], ' ')\n",
        "\n",
        "df = df.withColumn(\"day_name\", split_col.getItem(0)) \\\n",
        "      .withColumn(\"hour\", convert_hour_udf(split_col.getItem(3))) \\\n",
        "      .withColumn(\"date\", to_date( concat_ws(\"-\", split_col.getItem(2), convert_date_udf(split_col.getItem(1)), split_col.getItem(5)), \"dd-MM-yyyy\"))\n",
        "\n",
        "df = df.drop(\"full_date\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6CyYJJi59XKs"
      },
      "source": [
        "---\n",
        "## **Data analysis**\n",
        "### ***target*** values analisys"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b1JWoNnM9k4k"
      },
      "outputs": [],
      "source": [
        "#df.select(\"target\").distinct().show()\n",
        "# \"target\" value is or 0 or 4\n",
        "\n",
        "df = df.withColumn(\"target\", when(df[\"target\"] == 4.0, 1).otherwise(0))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ehZD6TQNAH6H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1c840187-c8ee-4ea6-fb9a-a5dd6776489e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sad tweets =  800000\n",
            "Happy tweets =  800000\n"
          ]
        }
      ],
      "source": [
        "sad_tweets = df.filter(col(\"target\") == 0)\n",
        "happy_tweets = df.filter(col(\"target\") == 1)\n",
        "\n",
        "print(\"Sad tweets = \", sad_tweets.count())\n",
        "print(\"Happy tweets = \", happy_tweets.count())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_n13xetpApkt"
      },
      "source": [
        "Sad tweets and happy tweets are balanced."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zW2CBtpkBIGM"
      },
      "source": [
        "### Time frame of interest"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fNQmo6WsBQDD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc32fc8b-42af-43ae-828b-6fdab7ccb759"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Min date =  2009-04-06\n",
            "Max date =  2009-06-25\n"
          ]
        }
      ],
      "source": [
        "print(\"Min date = \", df.select(min(df.date)).collect()[0][0])\n",
        "print(\"Max date = \", df.select(max(df.date)).collect()[0][0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5PXQSmfOCezG"
      },
      "source": [
        "The time frame used is too small, datas were collected in 2 months. \\\\\n",
        "*Using data column will be useful only if we try to predict tweets written during the [2009-04-06, 2009-06-25] period.*\n",
        "\n",
        "### Better to delete the ***date*** column"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gwpxRRdnDZrI"
      },
      "outputs": [],
      "source": [
        "df = df.drop(\"date\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DAE60S3iFRpF"
      },
      "source": [
        "---\n",
        "## **Data processing**\n",
        "### Case normalization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qSNd63XFTdlK"
      },
      "outputs": [],
      "source": [
        "# used for all columns to see if null values are present\n",
        "# df.filter(col(\"text\").isNull()).show()\n",
        "\n",
        "df = df.withColumn(\"text\", lower(col(\"text\")))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qJSbjy6kTQEV"
      },
      "source": [
        "### Username and links removal"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gSkQ5dCkGDJX"
      },
      "outputs": [],
      "source": [
        "import re\n",
        "\n",
        "# twitter ids can contain alphanumeric and '_' characters\n",
        "username_regex = r\"@[A-Za-z0-9_]+\"\n",
        "\n",
        "# http:// / https:// links\n",
        "link_regex1 = r\"https?://[^ ]+\"\n",
        "\n",
        "# www. links\n",
        "link_regex2 = r\"www.[^ ]+\"\n",
        "\n",
        "\n",
        "master_regex = r\"|\".join((username_regex, link_regex1, link_regex2))\n",
        "\n",
        "df = df.withColumn(\"text\", regexp_replace(df.text, master_regex, \"\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQNB7bpRaxIG"
      },
      "source": [
        "### Filter out punctual symbols"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6ILeqT4Ha22N"
      },
      "outputs": [],
      "source": [
        "df = df.withColumn(\"text\", regexp_replace(df.text, \"[^a-zA-Z\\s]\", \"\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bwH-VfJXU71D"
      },
      "source": [
        "### Trimming"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NSeeMi1QU-nN"
      },
      "outputs": [],
      "source": [
        "df = df.withColumn(\"text\", trim(col(\"text\")))\n",
        "\n",
        "# extra whitespaces\n",
        "df = df.withColumn(\"text\", trim(regexp_replace(df.text, \" +\", \" \")))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "We8YznuapL3U"
      },
      "source": [
        "### Tokenization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0p6KKbDhpOAF"
      },
      "outputs": [],
      "source": [
        "from pyspark.ml.feature import Tokenizer\n",
        "\n",
        "tokenizer = Tokenizer(inputCol = \"text\", outputCol = \"tokens\")\n",
        "tokens_df = tokenizer.transform(df)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOQCWCA3qo0h"
      },
      "source": [
        "### Stopwords removal"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rnulIkVIqrtl"
      },
      "outputs": [],
      "source": [
        "from pyspark.ml.feature import StopWordsRemover\n",
        "\n",
        "stopwords_remover = StopWordsRemover(inputCol = \"tokens\", outputCol = \"terms\")\n",
        "terms_df = stopwords_remover.transform(tokens_df)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7fcc-7xrMB1"
      },
      "source": [
        "### Stemming"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VOGvpgdirOOs"
      },
      "outputs": [],
      "source": [
        "from nltk.stem.snowball import SnowballStemmer\n",
        "\n",
        "stemmer = SnowballStemmer(language = \"english\")\n",
        "stemmer_udf = udf(lambda tokens: [stemmer.stem(token) for token in tokens], ArrayType(StringType()))\n",
        "\n",
        "\n",
        "tweets_df = terms_df.withColumn(\"terms_stemmed\", stemmer_udf(\"terms\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vLK2YpWdsiaH"
      },
      "source": [
        "### Removal of unnecessary columns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RUk2wyD9soOX"
      },
      "outputs": [],
      "source": [
        "tweets_df = tweets_df.drop(\"id\", \"text\", \"tokens\", \"terms\")\n",
        "\n",
        "#tweets_df.show(7, truncate = False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5L6ju2yHRESq"
      },
      "source": [
        "---\n",
        "## **Additional cleaning**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HJJpggTkRT05",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5f6f70d1-7388-47b6-f40d-994fee7c6ae1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sad tweets =  774763\n",
            "Happy tweets =  767489\n"
          ]
        }
      ],
      "source": [
        "tweets_df.cache()\n",
        "\n",
        "tweets_df = tweets_df.filter(size(tweets_df.terms_stemmed) > 1)\n",
        "\n",
        "sad_tweets = tweets_df.filter(tweets_df.target == 0)\n",
        "happy_tweets = tweets_df.filter(tweets_df.target == 1)\n",
        "\n",
        "sad_tweets_count = sad_tweets.count()\n",
        "happy_tweets_count = happy_tweets.count()\n",
        "\n",
        "print(\"Sad tweets = \", sad_tweets_count)\n",
        "print(\"Happy tweets = \", happy_tweets_count)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P5zA3f9HRXH0"
      },
      "source": [
        "### After the cleaning Sad and Happy tweets are ***unbalanced***"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IYTHKIqCRgLK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "outputId": "c5f6ca68-776e-47f7-aa98-4eef6d36338b"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "(figure_, axes_) = plt.subplots()\n",
        "\n",
        "y = [sad_tweets_count, happy_tweets_count]\n",
        "axes_.set_ylabel(\"Number of tweets\")\n",
        "\n",
        "x = [\"Sad tweets\", \"Happy tweets\"]\n",
        "\n",
        "axes_.bar(x, y, color = [\"red\", \"green\"])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uBY026hPgd3h"
      },
      "source": [
        "### Balancing dataframes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xJygEfWNgmxU"
      },
      "outputs": [],
      "source": [
        "sad_tweets = sad_tweets.select(\"*\").orderBy(rand())\n",
        "sad_tweets = sad_tweets.limit(happy_tweets_count)\n",
        "\n",
        "tweets_df = sad_tweets.union(happy_tweets)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uY_VvQBrKisT"
      },
      "source": [
        "---\n",
        "## **Word Vector representation**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5x_pMftKtt2"
      },
      "source": [
        "### Load **GloVe** embeddings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NnmMF2HMNcTc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d96c561d-2074-42a4-f6b5-586edf6e4483"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[=================================================-] 98.4% 381.0/387.1MB downloaded\n"
          ]
        }
      ],
      "source": [
        "import gensim.downloader as api\n",
        "\n",
        "embeddings = 100\n",
        "word2vector = None\n",
        "\n",
        "if word2vector == None:\n",
        "  word2vector = api.load(\"glove-twitter-\" + str(embeddings))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T3epcP4Vc48E"
      },
      "source": [
        "### Mapping tokens - embeddings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QssWZt9MSB2C"
      },
      "outputs": [],
      "source": [
        "extractor_udf = udf(lambda tokens: [[float(x) for x in word2vector[token]] if token in word2vector else [float(0.0)]*word2vector[\"tweet\"].shape[0] for token in tokens], ArrayType((ArrayType(FloatType()))))\n",
        "\n",
        "avg_embedding_udf = udf(lambda x :[float(y) for y in np.mean(x, axis = 0)])\n",
        "\n",
        "tweets_embedded = tweets_df.withColumn(\"tweet_embeddings\", extractor_udf(\"terms_stemmed\"))\n",
        "tweets_embedded = tweets_embedded.withColumn(\"tweet_embeddings\", avg_embedding_udf(\"tweet_embeddings\"))\n",
        "\n",
        "#tweets_embedded.printSchema()\n",
        "#tweets_embedded.show(7, truncate = False)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KbTIOB_ref7U"
      },
      "source": [
        "### Conversion from `ArrayType( ArrayType( Float() ) )` to `VectorUDT()`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2t-3-JrtfCtC"
      },
      "outputs": [],
      "source": [
        "from pyspark.ml.linalg import Vectors, VectorUDT\n",
        "\n",
        "to_vector_udf = udf(lambda embedded: Vectors.dense(embedded), VectorUDT())\n",
        "\n",
        "tweets_embedded = tweets_embedded.withColumn(\"tweet_embeddings\", to_vector_udf(tweets_embedded.tweet_embeddings))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hdjs_CoYOWBu"
      },
      "source": [
        "---\n",
        "## **Train and Test setup**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FxAMJ3ziO3g1"
      },
      "outputs": [],
      "source": [
        "#tweets_embedded.cache()\n",
        "\n",
        "(train_df, test_df) = tweets_embedded.randomSplit([0.8, 0.2], seed=1234)\n",
        "\n",
        "train_df_count = train_df.count()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0mbRp_58Bdp"
      },
      "source": [
        "### **Assign weights** to unbalanced columns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "thWzMiDn8Enr"
      },
      "outputs": [],
      "source": [
        "# calculate the weights for the train set\n",
        "class_weights_train = train_df.groupBy('target').count().withColumn('class_weight_train', 1 / col('count'))\n",
        "hour_weights_train = train_df.groupBy('hour').count().withColumn('hour_weight_train', col('count') / train_df_count)\n",
        "day_weights_train = train_df.groupBy('day_name').count().withColumn('day_weight_train', col('count') / train_df_count)\n",
        "\n",
        "# join the weights\n",
        "train_df_weighted = train_df.join(class_weights_train, 'target', 'left').join(hour_weights_train, 'hour', 'left').join(day_weights_train, 'day_name', 'left')\n",
        "\n",
        "# fill null values in case of missing values\n",
        "train_df_weighted = train_df_weighted.fillna(0.0, subset=['class_weight_train', 'hour_weight_train', 'day_weight_train'])\n",
        "\n",
        "train_df_weighted = train_df_weighted.withColumn('terms_stemmed', col('terms_stemmed'))\n",
        "train_df_weighted = train_df_weighted.withColumn('tweet_embeddings', col('tweet_embeddings'))\n",
        "\n",
        "# delete \"count\" columns\n",
        "#  cannot delete columns with the same name, so I rename them\n",
        "df_cols = train_df_weighted.columns\n",
        "\n",
        "duplicate_col_index = [idx for idx, val in enumerate(df_cols) if val in df_cols[:idx]]\n",
        "\n",
        "cols_to_remove = list()\n",
        "\n",
        "for i in duplicate_col_index:\n",
        "    df_cols[i] = 'count_'+ str(i)\n",
        "    cols_to_remove.append(col(df_cols[i]))\n",
        "\n",
        "train_df_weighted = train_df_weighted.toDF(*df_cols)\n",
        "\n",
        "cols_to_remove.append(col(\"count\"))\n",
        "train_df_weighted = train_df_weighted.drop(*cols_to_remove)\n",
        "\n",
        "#train_df_weighted.show(5)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YY6nxAOOcoeZ"
      },
      "source": [
        "### Combine weighted columns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a41p_MOVcl7_"
      },
      "outputs": [],
      "source": [
        "from pyspark.ml.feature import VectorAssembler, CountVectorizer\n",
        "\n",
        "train_df_weighted = train_df_weighted.withColumn(\"combined_weight\", train_df_weighted[\"class_weight_train\"] * train_df_weighted[\"hour_weight_train\"] * train_df_weighted[\"day_weight_train\"])\n",
        "test_df = test_df.withColumn(\"combined_weight\", lit(1.0))\n",
        "\n",
        "assembler = VectorAssembler(inputCols = [\"hour\", \"day_name\", \"tweet_embeddings\"], outputCol = \"features\")\n",
        "\n",
        "# before the VectorAssembler I need to handle the string data \"day_name\"\n",
        "days_map = {\"Mon\": 1, \"Tue\": 2, \"Wed\": 3, \"Thu\": 4, \"Fri\": 5, \"Sat\": 6, \"Sun\": 7}\n",
        "\n",
        "convert_day_name_udf = udf(lambda day_name : days_map[day_name], IntegerType())\n",
        "\n",
        "train_df_weighted = train_df_weighted.withColumn(\"day_name\", convert_day_name_udf(train_df_weighted.day_name))\n",
        "test_df = test_df.withColumn(\"day_name\", convert_day_name_udf(test_df.day_name))\n",
        "\n",
        "# apply the VectorAssembler\n",
        "train_df_weighted = assembler.transform(train_df_weighted).select(\"features\", \"target\", \"combined_weight\")\n",
        "test_df = assembler.transform(test_df).select(\"features\", \"target\", \"combined_weight\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wk7aFwiBtK0p"
      },
      "outputs": [],
      "source": [
        "#train_df_weighted.show(2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I85VDce0YJnh"
      },
      "source": [
        "---\n",
        "## **Load ready-to-use dataset**\n",
        "Load train and test cleaned and preprocessed datasetes `.parquet`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZFJ_Hw4yYPlP"
      },
      "outputs": [],
      "source": [
        "from google.colab import files\n",
        "\n",
        "#train_dataset_parquet = files.upload()\n",
        "#test_dataset_parquet = files.upload()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#test_df = spark.read.parquet(\"/content/part-00000-2ca64f1f-1881-4e69-9494-40e8764fe08e-c000.snappy.parquet\")\n",
        "#test_df.show(10)"
      ],
      "metadata": {
        "id": "OWWFu1jU9pnM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mv3hLOsbqpw8"
      },
      "source": [
        "---\n",
        "## **Logistic Regression**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3Ddp3HKNqst5"
      },
      "outputs": [],
      "source": [
        "from pyspark.ml.classification import LogisticRegression\n",
        "\n",
        "lr = LogisticRegression(featuresCol='features', labelCol='target', weightCol='combined_weight')\n",
        "lr_model = lr.fit(train_df_weighted)\n",
        "\n",
        "predictions = lr_model.transform(test_df)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FN2-tY1RpHuX"
      },
      "source": [
        "### Save model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I5WWQ728fQfI"
      },
      "outputs": [],
      "source": [
        "lr_model.save(\"LogisticRegressionModel\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9BMY67NFrmBX"
      },
      "source": [
        "---\n",
        "## **Support Vector Classifier**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z_NeZcNvr1AW"
      },
      "outputs": [],
      "source": [
        "from pyspark.ml.classification import LinearSVC\n",
        "\n",
        "svc = LinearSVC(featuresCol='features', labelCol='target')\n",
        "svc_model = svc.fit(train_df_weighted)\n",
        "\n",
        "predictions = svc_model.transform(test_df)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Save model"
      ],
      "metadata": {
        "id": "Ii8zetPV8f-Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "svc_model.save(\"SupportVectorModel\")"
      ],
      "metadata": {
        "id": "q3Eox54_8pIQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Decision Tree Classifier**"
      ],
      "metadata": {
        "id": "af_6MKVwHdP0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.ml.classification import DecisionTreeClassifier\n",
        "\n",
        "dt =  DecisionTreeClassifier(featuresCol='features', labelCol='target')\n",
        "dt_model = dt.fit(train_df_weighted)\n",
        "\n",
        "predictions = dt_model.transform(test_df)"
      ],
      "metadata": {
        "id": "uYJ6Qll0Hhdn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Save model"
      ],
      "metadata": {
        "id": "5Iv0Ng99H3oa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dt_model.save(\"DecisionTreeModel\")"
      ],
      "metadata": {
        "id": "J1Q-0SruH5Rn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Random Forest Classifier**\n"
      ],
      "metadata": {
        "id": "OLrhtRBGSNIh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.ml.classification import RandomForestClassifier\n",
        "\n",
        "rf = RandomForestClassifier(featuresCol='features', labelCol='target')\n",
        "rf_model = rf.fit(train_df_weighted)\n",
        "\n",
        "predictions = rf_model.transform(test_df)"
      ],
      "metadata": {
        "id": "qS9C30j9SS0X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Save model"
      ],
      "metadata": {
        "id": "Nl3JjcXUcZ-a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rf_model.save(\"RandomForestModel\")"
      ],
      "metadata": {
        "id": "RaWkWCU8cbvp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## **Load models**"
      ],
      "metadata": {
        "id": "4no4UGNEhyJ3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "! sudo apt install subversion"
      ],
      "metadata": {
        "id": "SJzo9RTzh3rL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d33e3fb2-9835-4a48-a1f7-74fb5c49bbb8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "The following additional packages will be installed:\n",
            "  libapr1 libaprutil1 libserf-1-1 libsvn1 libutf8proc2\n",
            "Suggested packages:\n",
            "  db5.3-util libapache2-mod-svn subversion-tools\n",
            "The following NEW packages will be installed:\n",
            "  libapr1 libaprutil1 libserf-1-1 libsvn1 libutf8proc2 subversion\n",
            "0 upgraded, 6 newly installed, 0 to remove and 16 not upgraded.\n",
            "Need to get 2,672 kB of archives.\n",
            "After this operation, 10.5 MB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libapr1 amd64 1.7.0-8ubuntu0.22.04.1 [108 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libaprutil1 amd64 1.6.1-5ubuntu4.22.04.1 [92.6 kB]\n",
            "Get:3 http://archive.ubuntu.com/ubuntu jammy/universe amd64 libserf-1-1 amd64 1.3.9-10ubuntu2 [50.0 kB]\n",
            "Get:4 http://archive.ubuntu.com/ubuntu jammy/universe amd64 libutf8proc2 amd64 2.7.0-3 [73.9 kB]\n",
            "Get:5 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 libsvn1 amd64 1.14.1-3ubuntu0.22.04.1 [1,387 kB]\n",
            "Get:6 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 subversion amd64 1.14.1-3ubuntu0.22.04.1 [960 kB]\n",
            "Fetched 2,672 kB in 1s (2,568 kB/s)\n",
            "debconf: unable to initialize frontend: Dialog\n",
            "debconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78, <> line 6.)\n",
            "debconf: falling back to frontend: Readline\n",
            "debconf: unable to initialize frontend: Readline\n",
            "debconf: (This frontend requires a controlling tty.)\n",
            "debconf: falling back to frontend: Teletype\n",
            "dpkg-preconfigure: unable to re-open stdin: \n",
            "Selecting previously unselected package libapr1:amd64.\n",
            "(Reading database ... 120893 files and directories currently installed.)\n",
            "Preparing to unpack .../0-libapr1_1.7.0-8ubuntu0.22.04.1_amd64.deb ...\n",
            "Unpacking libapr1:amd64 (1.7.0-8ubuntu0.22.04.1) ...\n",
            "Selecting previously unselected package libaprutil1:amd64.\n",
            "Preparing to unpack .../1-libaprutil1_1.6.1-5ubuntu4.22.04.1_amd64.deb ...\n",
            "Unpacking libaprutil1:amd64 (1.6.1-5ubuntu4.22.04.1) ...\n",
            "Selecting previously unselected package libserf-1-1:amd64.\n",
            "Preparing to unpack .../2-libserf-1-1_1.3.9-10ubuntu2_amd64.deb ...\n",
            "Unpacking libserf-1-1:amd64 (1.3.9-10ubuntu2) ...\n",
            "Selecting previously unselected package libutf8proc2:amd64.\n",
            "Preparing to unpack .../3-libutf8proc2_2.7.0-3_amd64.deb ...\n",
            "Unpacking libutf8proc2:amd64 (2.7.0-3) ...\n",
            "Selecting previously unselected package libsvn1:amd64.\n",
            "Preparing to unpack .../4-libsvn1_1.14.1-3ubuntu0.22.04.1_amd64.deb ...\n",
            "Unpacking libsvn1:amd64 (1.14.1-3ubuntu0.22.04.1) ...\n",
            "Selecting previously unselected package subversion.\n",
            "Preparing to unpack .../5-subversion_1.14.1-3ubuntu0.22.04.1_amd64.deb ...\n",
            "Unpacking subversion (1.14.1-3ubuntu0.22.04.1) ...\n",
            "Setting up libutf8proc2:amd64 (2.7.0-3) ...\n",
            "Setting up libapr1:amd64 (1.7.0-8ubuntu0.22.04.1) ...\n",
            "Setting up libaprutil1:amd64 (1.6.1-5ubuntu4.22.04.1) ...\n",
            "Setting up libserf-1-1:amd64 (1.3.9-10ubuntu2) ...\n",
            "Setting up libsvn1:amd64 (1.14.1-3ubuntu0.22.04.1) ...\n",
            "Setting up subversion (1.14.1-3ubuntu0.22.04.1) ...\n",
            "Processing triggers for libc-bin (2.35-0ubuntu3.1) ...\n",
            "/sbin/ldconfig.real: /usr/local/lib/libtbbmalloc.so.2 is not a symbolic link\n",
            "\n",
            "/sbin/ldconfig.real: /usr/local/lib/libtbbmalloc_proxy.so.2 is not a symbolic link\n",
            "\n",
            "/sbin/ldconfig.real: /usr/local/lib/libtbb.so.12 is not a symbolic link\n",
            "\n",
            "/sbin/ldconfig.real: /usr/local/lib/libtbbbind_2_5.so.3 is not a symbolic link\n",
            "\n",
            "/sbin/ldconfig.real: /usr/local/lib/libtbbbind.so.3 is not a symbolic link\n",
            "\n",
            "/sbin/ldconfig.real: /usr/local/lib/libtbbbind_2_0.so.3 is not a symbolic link\n",
            "\n",
            "Processing triggers for man-db (2.10.2-1) ...\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! svn export https://github.com/RiccardoRobb/BigData_project/trunk/Models"
      ],
      "metadata": {
        "id": "h1z3YhzEyvP2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "29d136f0-6e56-4482-dc40-866d444f7a04"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A    Models\n",
            "A    Models/DecisionTreeModel\n",
            "A    Models/DecisionTreeModel/data\n",
            "A    Models/DecisionTreeModel/data/_SUCCESS\n",
            "A    Models/DecisionTreeModel/data/part-00000-df68955c-05bc-4d4c-bdca-8b7adbf12532-c000.snappy.parquet\n",
            "A    Models/DecisionTreeModel/metadata\n",
            "A    Models/DecisionTreeModel/metadata/_SUCCESS\n",
            "A    Models/DecisionTreeModel/metadata/part-00000\n",
            "A    Models/LogisticRegressionModel\n",
            "A    Models/LogisticRegressionModel/data\n",
            "A    Models/LogisticRegressionModel/data/_SUCCESS\n",
            "A    Models/LogisticRegressionModel/data/part-00000-8441a849-9c40-48cc-8f51-2b2ee2917b24-c000.snappy.parquet\n",
            "A    Models/LogisticRegressionModel/metadata\n",
            "A    Models/LogisticRegressionModel/metadata/_SUCCESS\n",
            "A    Models/LogisticRegressionModel/metadata/part-00000\n",
            "A    Models/RandomForestModel\n",
            "A    Models/RandomForestModel/data\n",
            "A    Models/RandomForestModel/data/_SUCCESS\n",
            "A    Models/RandomForestModel/data/part-00000-a0f46889-5887-44ac-b7bf-cc7e8c31779d-c000.snappy.parquet\n",
            "A    Models/RandomForestModel/metadata\n",
            "A    Models/RandomForestModel/metadata/_SUCCESS\n",
            "A    Models/RandomForestModel/metadata/part-00000\n",
            "A    Models/RandomForestModel/treesMetadata\n",
            "A    Models/RandomForestModel/treesMetadata/_SUCCESS\n",
            "A    Models/RandomForestModel/treesMetadata/part-00000-f8917d23-d843-4304-a9f5-186c8efcbcad-c000.snappy.parquet\n",
            "A    Models/SupportVectorModel\n",
            "A    Models/SupportVectorModel/data\n",
            "A    Models/SupportVectorModel/data/_SUCCESS\n",
            "A    Models/SupportVectorModel/data/part-00000-782d46cc-8c20-42dd-84a1-37e09a2c254f-c000.snappy.parquet\n",
            "A    Models/SupportVectorModel/metadata\n",
            "A    Models/SupportVectorModel/metadata/_SUCCESS\n",
            "A    Models/SupportVectorModel/metadata/part-00000\n",
            "Exported revision 45.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Evaluate Models**"
      ],
      "metadata": {
        "id": "0vyYT3vX0H5C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "def evaluate_manually(predictions):\n",
        "  # True positive, True negative, False positive and False negative\n",
        "  tp = predictions.filter((predictions.target > 0) & (predictions.prediction > 0)).count()\n",
        "  tn = predictions.filter((predictions.target == 0) & (predictions.prediction == 0)).count()\n",
        "  fp = predictions.filter((predictions.target == 0) & (predictions.prediction > 0)).count()\n",
        "  fn = predictions.filter((predictions.target > 0) & (predictions.prediction == 0)).count()\n",
        "\n",
        "  # Calculate evaluation metrics\n",
        "  accuracy = (tp + tn) / (tp + tn + fp + fn)\n",
        "  precision = tp / (tp + fp)\n",
        "  recall = tp / (tp + fn)\n",
        "  f1_score = 2 * (precision * recall) / (precision + recall)\n",
        "\n",
        "  # Print the evaluation metrics\n",
        "  print(\"Accuracy:\", accuracy)\n",
        "  print(\"Precision:\", precision)\n",
        "  print(\"Recall:\", recall)\n",
        "  print(\"F1-Score:\", f1_score)\n",
        "\n",
        "def draw_confusion_matrix(model, predictions):\n",
        "  pred_pd = predictions.toPandas()\n",
        "\n",
        "  plt.figure(figsize=(8, 6))\n",
        "  class_labels = [\"Sad\", \"Happy\"]\n",
        "\n",
        "  confusion_matrix = pd.crosstab(pred_pd[\"target\"], pred_pd[\"prediction\"], rownames=['Target'], colnames=['Predicted'])\n",
        "  sn.heatmap(confusion_matrix, fmt=\"d\", cmap=\"Greens\", cbar=False, annot=True, xticklabels=class_labels, yticklabels=class_labels)\n",
        "\n",
        "  plt.title(f'{model} confusion matrix')\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "gnS1k_HB-3Ma"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Logistic Regression"
      ],
      "metadata": {
        "id": "6rypB0UsP2eD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.ml.classification import LogisticRegressionModel\n",
        "\n",
        "loaded_lr_model = LogisticRegressionModel.load(\"/content/Models/LogisticRegressionModel\")\n",
        "\n",
        "predictions = loaded_lr_model.transform(test_df)\n",
        "predictions.printSchema()\n",
        "test_df.printSchema()\n",
        "\n",
        "evaluate_manually(predictions)"
      ],
      "metadata": {
        "id": "rhh6PajQ0LwO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "626900b3-5a71-47d5-cdb6-be224e5da9f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            " |-- rawPrediction: vector (nullable = true)\n",
            " |-- probability: vector (nullable = true)\n",
            " |-- prediction: double (nullable = false)\n",
            "\n",
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            "\n",
            "Accuracy: 0.7141949649474864\n",
            "Precision: 0.69628380184236\n",
            "Recall: 0.7621010206071638\n",
            "F1-Score: 0.7277072386491663\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "draw_confusion_matrix(\"Logistic regression\", predictions)"
      ],
      "metadata": {
        "id": "kGfewzsIWx8R",
        "outputId": "9b2f9c32-912a-4537-9f52-47f08deb736d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Support Vector Classifier"
      ],
      "metadata": {
        "id": "OQUIHviWP7Ph"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.ml.classification import LinearSVCModel\n",
        "\n",
        "loaded_svc_model = LinearSVCModel.load(\"/content/Models/SupportVectorModel\")\n",
        "\n",
        "predictions = loaded_svc_model.transform(test_df)\n",
        "predictions.printSchema()\n",
        "test_df.printSchema()\n",
        "\n",
        "evaluate_manually(predictions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9FS1LMmNQBWH",
        "outputId": "83ec5770-5db4-43b5-ee9a-9bc33f6170c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            " |-- rawPrediction: vector (nullable = true)\n",
            " |-- prediction: double (nullable = false)\n",
            "\n",
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            "\n",
            "Accuracy: 0.7173027807458758\n",
            "Precision: 0.7150269701692611\n",
            "Recall: 0.7247090944549177\n",
            "F1-Score: 0.7198354765079437\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "draw_confusion_matrix(\"Support vector\", predictions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "L0geEsj-y0pu",
        "outputId": "fc245eae-4331-4fb6-84e1-b2531ec1da2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Decision Tree"
      ],
      "metadata": {
        "id": "hGprf73Yk2ee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.ml.classification import DecisionTreeClassificationModel\n",
        "\n",
        "loaded_dt_model = DecisionTreeClassificationModel.load(\"/content/Models/DecisionTreeModel\")\n",
        "\n",
        "predictions = loaded_dt_model.transform(test_df)\n",
        "predictions.printSchema()\n",
        "test_df.printSchema()\n",
        "\n",
        "evaluate_manually(predictions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IMGhV-wJk5xI",
        "outputId": "0005bd45-5e8a-47eb-f70d-26e041137409"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            " |-- rawPrediction: vector (nullable = true)\n",
            " |-- probability: vector (nullable = true)\n",
            " |-- prediction: double (nullable = false)\n",
            "\n",
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            "\n",
            "Accuracy: 0.6239347423835709\n",
            "Precision: 0.655765641483405\n",
            "Recall: 0.5253201586166547\n",
            "F1-Score: 0.5833393488774994\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "draw_confusion_matrix(\"Decision tree\", predictions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "aDx1dvDI-f3K",
        "outputId": "29eef02a-69a9-4f80-81c1-fd6a470fdb6e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Random Forest"
      ],
      "metadata": {
        "id": "H2NZkueAxTEE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyspark.ml.classification import RandomForestClassificationModel\n",
        "\n",
        "loaded_rf_model = RandomForestClassificationModel.load(\"/content/Models/RandomForestModel\")\n",
        "\n",
        "predictions = loaded_rf_model.transform(test_df)\n",
        "predictions.printSchema()\n",
        "test_df.printSchema()\n",
        "\n",
        "evaluate_manually(predictions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2SRlfuLrxU1b",
        "outputId": "d8131903-228b-4f08-aa8e-019b91019d0a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            " |-- rawPrediction: vector (nullable = true)\n",
            " |-- probability: vector (nullable = true)\n",
            " |-- prediction: double (nullable = false)\n",
            "\n",
            "root\n",
            " |-- features: vector (nullable = true)\n",
            " |-- target: integer (nullable = false)\n",
            " |-- combined_weight: double (nullable = false)\n",
            "\n",
            "Accuracy: 0.6571369002632196\n",
            "Precision: 0.6662378012893335\n",
            "Recall: 0.6328544497172203\n",
            "F1-Score: 0.6491171920840667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "draw_confusion_matrix(\"Random forest\", predictions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "priC4iyKMgTw",
        "outputId": "6632f5b5-a22f-4a63-8c74-ea8925bbcd59"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DGRnV9GJAslh"
      },
      "source": [
        "---\n",
        "## Verify data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lEO6FUTeAwF9"
      },
      "outputs": [],
      "source": [
        "#tweets_embedded.printSchema()\n",
        "#tweets_embedded.show(10)\n",
        "\n",
        "#print(\"tot = \", tweets_embedded.count())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tAb77yZ9fzMG"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pafL7Li0jyXW"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "machine_shape": "hm",
      "provenance": [],
      "collapsed_sections": [
        "4no4UGNEhyJ3"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}