7bitlyrus/alt_detection.ipynb

## alt_detection.ipynb
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "alt_detection.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPw1OEeDWIU1bSvb3vfyboO",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/7bitlyrus/9d427d87bed0f0889d8187085465e6d5/alt_detection.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7w_AYCz8Qsvf"
      },
      "source": [
        "Code for this workbook adapted from [jabraunlin/reddit-user-id](https://github.com/jabraunlin/reddit-user-id/blob/master/delta_model.py).\n",
        "\n",
        "Make sure to add new `*.json` files to the runtime in formatted as: `[{'author': '...', 'content': '...'}, ...]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qVBOo_bDQDSy",
        "outputId": "647b778e-7950-44a5-8b67-f995dcfdba54"
      },
      "source": [
        "!pip install pyspark\n",
        "!wget https://raw.githubusercontent.com/jabraunlin/reddit-user-id/master/skip_grams.csv"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pyspark in /usr/local/lib/python3.7/dist-packages (3.2.0)\n",
            "Requirement already satisfied: py4j==0.10.9.2 in /usr/local/lib/python3.7/dist-packages (from pyspark) (0.10.9.2)\n",
            "--2021-11-29 18:47:16--  https://raw.githubusercontent.com/jabraunlin/reddit-user-id/master/skip_grams.csv\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.109.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 1526 (1.5K) [text/plain]\n",
            "Saving to: ‘skip_grams.csv.3’\n",
            "\n",
            "skip_grams.csv.3    100%[===================>]   1.49K  --.-KB/s    in 0s      \n",
            "\n",
            "2021-11-29 18:47:16 (36.0 MB/s) - ‘skip_grams.csv.3’ saved [1526/1526]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dSlvJyRTQZym"
      },
      "source": [
        "import pyspark as ps\n",
        "from pyspark.sql import functions as F\n",
        "from pyspark.sql.functions import udf, col\n",
        "from pyspark.sql.types import StringType, FloatType, IntegerType, ArrayType\n",
        "from pyspark.ml import Pipeline\n",
        "from pyspark.ml.classification import LogisticRegression\n",
        "from pyspark.ml.feature import CountVectorizer, Tokenizer, HashingTF, StandardScaler, Normalizer\n",
        "from pyspark.ml.feature import StopWordsRemover\n",
        "import re\n",
        "import matplotlib.pyplot as plt\n",
        "import nltk\n",
        "import numpy as np\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.tokenize import TweetTokenizer\n",
        "import pandas as pd\n",
        "from nltk.util import skipgrams\n",
        "from itertools import chain\n",
        "from scipy.cluster import hierarchy\n",
        "import csv\n",
        "from scipy.stats import norm"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JakHWiBmSknj",
        "outputId": "0a5d4c18-b4bf-4b57-90ea-495fa9d01c3a"
      },
      "source": [
        "nltk.download('stopwords')\n",
        "nltk.download('averaged_perceptron_tagger')"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n",
            "[nltk_data] Downloading package averaged_perceptron_tagger to\n",
            "[nltk_data]     /root/nltk_data...\n",
            "[nltk_data]   Package averaged_perceptron_tagger is already up-to-\n",
            "[nltk_data]       date!\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j3IrK90ORFT1"
      },
      "source": [
        "spark = (\n",
        "    ps.sql.SparkSession.builder\n",
        "    .master(\"local[4]\")\n",
        "    .appName(\"project1\")\n",
        "    .getOrCreate()\n",
        ")\n",
        "\n",
        "sc = spark.sparkContext"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KdhwD8aZUHHq"
      },
      "source": [
        "# Read sharded json files\n",
        "df = spark.read.json(\"*.json\")"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lZnqHryoRLiS"
      },
      "source": [
        "# Find authors that have more than 400 comments so that splitting them leaves us with at least 200 comments\n",
        "new_df = df.groupby('author').agg(F.count('content'))\n",
        "authors = new_df.filter(new_df['count(content)'] > 400).select('author')"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LACO-GbZRmKW"
      },
      "source": [
        "# Filter the original data with authors that have more than 400 comments\n",
        "filtered_df = authors.join(df, ['author'], 'left')"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oSxVJiSgRnlI"
      },
      "source": [
        "# Split users into users and pseudo-users to compare them\n",
        "df1, df2 = filtered_df.randomSplit([0.5, 0.5])"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XCAGwo9oRot4"
      },
      "source": [
        "# Concatenate comments into corpora of each user's entire comment history\n",
        "join_comments_udf = udf(lambda x: ' '.join(x), StringType())\n",
        "\n",
        "comments1 = df1.groupBy(\"author\").agg(F.collect_list(\"content\"))\n",
        "df1_join_comments = comments1.withColumn('corpus', join_comments_udf(comments1['collect_list(content)']))\n",
        "\n",
        "comments2 = df2.groupBy(\"author\").agg(F.collect_list(\"content\"))\n",
        "df2_join_comments = comments2.withColumn('corpus', join_comments_udf(comments2['collect_list(content)']))"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s0vAW9sBRToB"
      },
      "source": [
        "# Data Cleaning - Count Links\n",
        "def count_links(s):\n",
        "    try:\n",
        "        num_links = len(re.findall(r'\\(http.+\\)', s)[0].split(')('))\n",
        "        return num_links\n",
        "    except:\n",
        "        return 0\n",
        "\n",
        "count_links_udf = udf(count_links, IntegerType())\n",
        "\n",
        "df_count_links1 = df1_join_comments.withColumn('link_count', count_links_udf(df1_join_comments['corpus']))\n",
        "df_count_links2 = df2_join_comments.withColumn('link_count', count_links_udf(df2_join_comments['corpus']))"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C0z4z0bOThuS"
      },
      "source": [
        "# Drop Links\n",
        "def drop_links(s):\n",
        "    return re.sub(r'\\(http.+\\)', '', s)\n",
        "\n",
        "drop_links_udf = udf(drop_links, StringType())\n",
        "\n",
        "df_drop_links1 = df_count_links1.withColumn('corpus', drop_links_udf(df_count_links1['corpus']))\n",
        "df_drop_links2 = df_count_links2.withColumn('corpus', drop_links_udf(df_count_links2['corpus']))"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YsEILx07RVNm"
      },
      "source": [
        "# Tokenize words\n",
        "def tokenize(s):\n",
        "    s = s.lower()\n",
        "    token = TweetTokenizer()\n",
        "    return token.tokenize(s)\n",
        "\n",
        "tokenize_udf = udf(tokenize, ArrayType(StringType()))\n",
        "\n",
        "df_tokens1 = df_drop_links1.withColumn('tokens', tokenize_udf(df_drop_links1['corpus']))\n",
        "df_tokens2 = df_drop_links2.withColumn('tokens', tokenize_udf(df_drop_links2['corpus']))"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uSjT8O1GRXZ7"
      },
      "source": [
        "# Tag parts of speech for each word\n",
        "def pos_tagger(s):\n",
        "    return [i[1] for i in nltk.pos_tag(s)]\n",
        "\n",
        "pos_tagger_udf = udf(pos_tagger, ArrayType(StringType()))\n",
        "df_pos_tagger1 = df_tokens1.withColumn('POS', pos_tagger_udf(df_tokens1['tokens']))\n",
        "\n",
        "pos_tagger_udf = udf(pos_tagger, ArrayType(StringType()))\n",
        "df_pos_tagger2 = df_tokens2.withColumn('POS', pos_tagger_udf(df_tokens2['tokens']))"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0iAH5oN2RZWR"
      },
      "source": [
        "# Find POS tagging tendencies to determine sentence structure patterns\n",
        "def skip_grams(s):\n",
        "    grams = []\n",
        "    for i in skipgrams(s, 2, 2):\n",
        "        grams.append(str(i))\n",
        "    return grams\n",
        "\n",
        "skip_grams_udf = udf(skip_grams, ArrayType(StringType()))\n",
        "\n",
        "df_skip_grams1 = df_pos_tagger1.withColumn('skip_grams', skip_grams_udf(df_pos_tagger1['POS']))\n",
        "df_skip_grams2 = df_pos_tagger2.withColumn('skip_grams', skip_grams_udf(df_pos_tagger2['POS']))"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FfFLMr3mRbl3"
      },
      "source": [
        "# Open file containing the most common skip grams made previously\n",
        "with open('skip_grams.csv', 'r') as f:\n",
        "    reader = csv.reader(f)\n",
        "    com_skips = list(reader)\n",
        "\n",
        "skips = com_skips[0]"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eF0Z1uyDRegW"
      },
      "source": [
        "# Filter through each user's POS skip-grams and keep them if they are in the most commonly found skip-grams\n",
        "def skip_grams_filter(s):\n",
        "    return [i for i in s if i in skips]\n",
        "\n",
        "com_skips_udf = udf(skip_grams_filter, ArrayType(StringType()))\n",
        "\n",
        "df_com_skips1 = df_skip_grams1.withColumn('com_skips', com_skips_udf(df_skip_grams1['skip_grams']))\n",
        "df_com_skips2 = df_skip_grams2.withColumn('com_skips', com_skips_udf(df_skip_grams2['skip_grams']))"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KmeSZOOkRgIw"
      },
      "source": [
        "# Create stop words feature list and add extra features\n",
        "stops = stopwords.words('english')\n",
        "x = [i.split(\"'\")for i in stops]\n",
        "stops = [i[0] for i in x]\n",
        "stops = list(set(stops))\n",
        "slang_stops = ['gonna', 'coulda', 'shoulda',\n",
        "               'lotta', 'lots', 'oughta', 'gotta', 'ain', 'sorta', 'kinda', 'yeah', 'whatever', 'cuz', 'ya', 'haha', 'lol', 'eh']\n",
        "puncts = ['!', ':', '...', '.', '%', '$', \"'\", '\"', ';']\n",
        "formattings = ['##', '__', '_', '    ', '*', '**']\n",
        "\n",
        "stops.extend(slang_stops)\n",
        "stops.extend(puncts)\n",
        "stops.extend(formattings)\n",
        "stops.extend(skips)"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vrWlRzn6RkWY"
      },
      "source": [
        "# Filter words with the list of stop words\n",
        "def stop_words_filter(s):\n",
        "    return [i for i in s if i in stops]\n",
        "\n",
        "stop_words_udf = udf(stop_words_filter, ArrayType(StringType()))\n",
        "\n",
        "df_stop_words1 = df_com_skips1.withColumn('stop_words', stop_words_udf(df_com_skips1['tokens']))\n",
        "df_stop_words2 = df_com_skips2.withColumn('stop_words', stop_words_udf(df_com_skips2['tokens']))"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xbh3FAezRr4Q"
      },
      "source": [
        "# Concatenate each user's list of function words and skip grams to a single array\n",
        "def concat(type):\n",
        "    def concat_(*args):\n",
        "        return list(chain.from_iterable((arg if arg else [] for arg in args)))\n",
        "    return udf(concat_, ArrayType(type))\n",
        "\n",
        "concat_arrays_udf = concat(StringType())\n",
        "\n",
        "df_all_words1 = df_stop_words1.select(\"author\", concat_arrays_udf(\"stop_words\", \"com_skips\"))\n",
        "df_all_words2 = df_stop_words2.select(\"author\", concat_arrays_udf(\"stop_words\", \"com_skips\"))"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H2FdHd4fRtMt"
      },
      "source": [
        "# Count Vectorize the combined function word and skip gram array\n",
        "hashingTF = HashingTF(numFeatures=285, inputCol='concat_(stop_words, com_skips)', outputCol='features')\n",
        "\n",
        "tf1 = hashingTF.transform(df_all_words1)\n",
        "tf2 = hashingTF.transform(df_all_words2)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZdFQO52tRurE"
      },
      "source": [
        "# Normalize the counts so that they are a percentage of total counts of the features\n",
        "tf_norm1 = Normalizer(inputCol=\"features\", outputCol=\"features_norm\", p=1).transform(tf1)\n",
        "tf_norm2 = Normalizer(inputCol=\"features\", outputCol=\"features_norm\", p=1).transform(tf2)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4N1jGUvdRv-Q"
      },
      "source": [
        "# Standardize the vector based on average use of each feature among all users\n",
        "stdscaler = StandardScaler(inputCol='features_norm', outputCol='scaled', withMean=True)\n",
        "scale_fit1 = stdscaler.fit(tf_norm1)\n",
        "\n",
        "scaled1 = scale_fit1.transform(tf_norm1)\n",
        "scaled2 = scale_fit1.transform(tf_norm2)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYnE6BV_RzPm"
      },
      "source": [
        "# Calculate the cosine similarity for each author in subset 1 against every author in subset 2\n",
        "sims1 = scaled1.select('author', 'scaled')\n",
        "sims2 = scaled2.select('author', 'scaled')\n",
        "similarities = {}\n",
        "for i in sims1.rdd.collect():\n",
        "    similarity = {}\n",
        "    auth1, vec1 = i[0], i[1]\n",
        "    for j in sims2.rdd.collect():\n",
        "        auth2, vec2 = j[0], j[1]\n",
        "        cos = vec1.dot(vec2) / (vec2.norm(2)*vec1.norm(2))\n",
        "        similarity[auth2] = cos\n",
        "    similarities[auth1] = similarity"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ZJkiJOlR2Es"
      },
      "source": [
        "pdf = pd.DataFrame(similarities)"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bGuTq_7LR5BJ"
      },
      "source": [
        "# split the cosines of authors who match with the authors who don't match\n",
        "cols = pdf.columns\n",
        "mask = []\n",
        "for i in pdf:\n",
        "    mask.append(i == pdf.index)\n",
        "mask = np.array(mask)\n",
        "mask = mask.T\n",
        "\n",
        "matches = pdf.values[mask]\n",
        "non_matches = pdf.values[~mask]"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2F1tdVIcR5ad",
        "outputId": "7aa2b955-38cc-4ea4-ae90-dafd835cc154"
      },
      "source": [
        "# Calculate accuracy of the model\n",
        "non_mas = non_matches.reshape(len(matches), -1)\n",
        "non_mas_max = np.max(non_mas, axis=1)\n",
        "np.sum(matches > non_mas_max) / len(matches)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jzTOm3uGR7Bu"
      },
      "source": [
        "match_list = matches\n",
        "nonma_list = non_matches"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3CiBzf_TR-Cc",
        "outputId": "5f052e5b-0ff0-40c7-f828-1a20046e7ec9"
      },
      "source": [
        "# Calculate cosine threshold and power for a given alpha level\n",
        "n = norm.ppf(0.9999) * np.std(nonma_list) - np.mean(nonma_list)\n",
        "\n",
        "1 - norm.cdf(n, np.mean(match_list), np.std(match_list))"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9544371747821463"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F1uzcnjNR_qE"
      },
      "source": [
        "# Plotting - Dendogram\n",
        "sparkdf = scaled1.select('author', 'scaled')\n",
        "pandaDF = sparkdf.toPandas()"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 347
        },
        "id": "V_nmSDuFAuNo",
        "outputId": "25038908-93d6-4483-d377-2d98372e44a3"
      },
      "source": [
        "series = pandaDF['scaled'].apply(lambda x: np.array(x.toArray())).values.reshape(-1, 1)\n",
        "features = np.apply_along_axis(lambda x: x[0], 1, series)\n",
        "df = pd.DataFrame(features, index=pandaDF['author'])\n",
        "\n",
        "threshold = 0.405\n",
        "Z = hierarchy.linkage(df, 'single', metric=\"cosine\")\n",
        "hierarchy.set_link_color_palette(None)\n",
        "\n",
        "fig, axes = plt.subplots(1, 1, figsize=(len(df.index)*1.25, 7))\n",
        "hierarchy.dendrogram(Z, ax=axes, color_threshold=threshold, labels=df.index)\n",
        "axes.axhline(y=0.405, color='r', linestyle='-', label='threshold')\n",
        "axes.set_ylabel('1 - Cosine')\n",
        "axes.set_title('Hierarchical Clustering')\n",
        "plt.tight_layout()\n",
        "plt.legend()\n",
        "plt.savefig('dendogram.png')"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 2250x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "NE3csDuWSAFN",
        "outputId": "42a5bbc1-85da-4325-e2cb-7fe4d7c9052f"
      },
      "source": [
        "# Matches and non-matches hist\n",
        "plt.hist(matches, label='matches')\n",
        "plt.hist(non_matches, label='non-matches')\n",
        "plt.xlabel('Cosine Similarity')\n",
        "plt.legend()\n",
        "plt.savefig('match_distro.png')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}