Assignment1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from os import getcwd\n",
    "TRAIN = os.path.join(getcwd(), 'MinHash/data/articles_1000.train')\n",
    "TRUTH = os.path.join(getcwd(), 'MinHash/data/articles_1000.truth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_data(filename):\n",
    "    if not filename:\n",
    "        raise ValueError(\"filename is empty.\")\n",
    "    \n",
    "    with open(filename) as f:\n",
    "        content = f.readlines()  # read lines from filename\n",
    "        content = [x.strip() for x in content]\n",
    "        exclude = set(string.punctuation)\n",
    "        tuples = list()\n",
    "        \n",
    "    for line in content:\n",
    "        id, article = line.split(\" \", 1)\n",
    "        article = ''.join(ch for ch in article if ch not in exclude).replace(' ', '').lower()\n",
    "        tuples.append((id, article))  # construct tuple of id and text\n",
    "        \n",
    "    return tuples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shingle_document(string, k):\n",
    "    if not string:\n",
    "        raise ValueError(\"String is empty.\")\n",
    "    if not k:\n",
    "        raise ValueError(\"k is empty.\")\n",
    "    \n",
    "    import binascii\n",
    "    \n",
    "    unique_hash = set() # initialize set data structure\n",
    "    for i in range(0, len(string) - k + 1):\n",
    "        unique_hash.add(binascii.crc32(string[i:i+k].encode(\"utf-8\"))) # has substring into 32-bit integer\n",
    "        \n",
    "    return unique_hash"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jaccard(a, b):\n",
    "    if not a:\n",
    "        raise ValueError(\"a is empty.\")\n",
    "    if not b:\n",
    "        raise ValueError(\"b is empty.\")\n",
    "        \n",
    "    a = set(a)\n",
    "    b = set(b)\n",
    "\n",
    "    return len(a.intersection(b))/len(a.union(b)) # return raio of union and intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def similarity(filename, k):\n",
    "    if not filename:\n",
    "        raise ValueError(\"filename is empty.\")\n",
    "    if not k:\n",
    "        raise ValueError(\"k is empty.\")\n",
    "        \n",
    "    tuples = parse_data(filename)  # parse a file with data\n",
    "    tuples_js = list()\n",
    "\n",
    "    n = len(tuples)\n",
    "\n",
    "    for i in range(0, n - 1):\n",
    "        id_i, article_i = tuples[i]\n",
    "        \n",
    "        if k > len(article_i):\n",
    "            raise ValueError(\"k is out of bound.\")\n",
    "\n",
    "        for j in range(i + 1, n):\n",
    "            id_j, article_j = tuples[j]\n",
    "            \n",
    "            if k > len(article_j):\n",
    "                raise ValueError(\"k is out of bound.\")\n",
    "\n",
    "            s = jaccard(shingle_document(article_i, k), shingle_document(article_j, k))\n",
    "            tuples_js.append((id_i, id_j, s))\n",
    "            \n",
    "    return tuples_js # return a list of tuples, each tuple contains: (id1, id2, s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mean_table(train, truth, n):\n",
    "    \n",
    "    if not train:\n",
    "        raise ValueError(\"train data is empty.\")\n",
    "    if not truth:\n",
    "        raise ValueError(\"truth data is empty.\")\n",
    "    if not n:\n",
    "        raise ValueError(\"n is empty.\")\n",
    "    \n",
    "    mytruth = parse_data(truth) # parse_data(), my truth is a pair of document ids   \n",
    "    tuples  = list()\n",
    "    \n",
    "    for k in range(1, n + 1):\n",
    "        \n",
    "        js = similarity(train, k) # similarity\n",
    "        abbr_dict = {tuple(item[0:2]): item[2] for item in js} # (id1, id2) is key, js is content.\n",
    "        sum_train, sum_truth = 0, 0\n",
    "        \n",
    "        for j in range(0, len(mytruth)-1):\n",
    "            sum_truth = abbr_dict[(mytruth[j])] + sum_truth # from dictionary we get js of key of (id1, id2)\n",
    "            \n",
    "        mean_truth = sum_truth/len(mytruth)\n",
    "        \n",
    "        for i in range(0, len(js)-1): \n",
    "            sum_train = js[i][2] + sum_train\n",
    "            \n",
    "        mean_train = (sum_train - sum_truth) / (len(js) - len(mytruth)) # (sum of train js - sum of truth js)/# of js\n",
    "        tuples.append((k, mean_train, mean_truth))\n",
    "        \n",
    "    return tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mean_table(filename1, filename2, n):\n",
    "    if not filename1:\n",
    "        raise ValueError(\"filename1 is empty.\")\n",
    "    if not filename2:\n",
    "        raise ValueError(\"filename2 is empty.\")\n",
    "    if not n:\n",
    "        raise ValueError(\"n is empty.\")\n",
    "    \n",
    "    import matplotlib.pyplot as plt\n",
    "    import pandas as pd\n",
    "    \n",
    "    mean_table = get_mean_table(filename1, filename2, n)\n",
    "    df         = pd.DataFrame(mean_table)\n",
    "    df.columns = [\"k\", \"non-plagiarism instances\", \"plagiarism instances\"]\n",
    "    \n",
    "    plt.plot('k', 'non-plagiarism instances', data = df, color = 'green')\n",
    "    plt.plot('k', 'plagiarism instances',     data = df, color = 'red')\n",
    "    \n",
    "    plt.xlabel('k value')\n",
    "    plt.ylabel('average Jaccard similarity')\n",
    "    \n",
    "    plt.title('Plagiarism and Non-Plagiarism Articles\\'\\nJaccard Similarity Comparison\\n')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    \n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_mean_table(TRAIN, TRUTH, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What is the effect of sharding length k on the Jaccard similarity of plagiarism instances versus instances that are not plagiarized?\n",
    "\n",
    "### My thoughts:\n",
    "#### 1. The effect of sharding length k on the Jaccard similarity of plagiarism instantces is far less stronger than that on the Jaccard similarity of non-plagiarism instance. ######\n",
    "\n",
    "#### 2. Jaccard similarity of non-plagiarism instances increases dramatically when the length k is sharded from a small value to a smaller one, while that of plagiarism instances doesn't change much within the scope of length k."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}