Web_Mining_CSE3024/Apriori_Lab_11/Apriori.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0bzLFcopHq-o"
   },
   "source": [
    "\n",
    "# Apriori Algorithm for Associated Rule Mining\n",
    "\n",
    "**Question** : Find the frequent news itemsets using apriori algorithm and generate strong rules with \n",
    "* Support = 50%\n",
    "* Confidence = 50%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iBga6JvZ1wIV"
   },
   "outputs": [],
   "source": [
    "# Set the conditions given\n",
    "\n",
    "minSupport = 0.5\n",
    "minConfidence = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0AoUh7ehHq-s"
   },
   "source": [
    "## 1. Using Apyriori Library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U_wJFdaXHq-s"
   },
   "source": [
    "### 1.1 Import Libraries and dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4a0wK4EWHq-t",
    "outputId": "8c1c1351-caec-4fe9-8119-eaef22144b8e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting apyori\n",
      "  Downloading https://files.pythonhosted.org/packages/5e/62/5ffde5c473ea4b033490617ec5caa80d59804875ad3c3c57c0976533a21a/apyori-1.1.2.tar.gz\n",
      "Building wheels for collected packages: apyori\n",
      "  Building wheel for apyori (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "  Created wheel for apyori: filename=apyori-1.1.2-cp37-none-any.whl size=5975 sha256=6d56c2bf7814b2efecdd1aed130a65e3a4c128171ff4de91887263683eb29173\n",
      "  Stored in directory: /root/.cache/pip/wheels/5d/92/bb/474bbadbc8c0062b9eb168f69982a0443263f8ab1711a8cad0\n",
      "Successfully built apyori\n",
      "Installing collected packages: apyori\n",
      "Successfully installed apyori-1.1.2\n"
     ]
    }
   ],
   "source": [
    "# Install this library first\n",
    "\n",
    "!pip install apyori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XeiL9BbhHq-u"
   },
   "outputs": [],
   "source": [
    "# Import the necessary libraries\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from apyori import apriori, load_transactions\n",
    "import csv\n",
    "\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "c6V2dMa4Hq-u",
    "outputId": "3a6c95d8-f934-4578-b7af-50c49d9780f8"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>11</th>\n",
       "      <th>12</th>\n",
       "      <th>13</th>\n",
       "      <th>14</th>\n",
       "      <th>15</th>\n",
       "      <th>16</th>\n",
       "      <th>17</th>\n",
       "      <th>18</th>\n",
       "      <th>19</th>\n",
       "      <th>20</th>\n",
       "      <th>21</th>\n",
       "      <th>22</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>13</td>\n",
       "      <td>23</td>\n",
       "      <td>25</td>\n",
       "      <td>34</td>\n",
       "      <td>36</td>\n",
       "      <td>38</td>\n",
       "      <td>40</td>\n",
       "      <td>52</td>\n",
       "      <td>54</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>67</td>\n",
       "      <td>76</td>\n",
       "      <td>85</td>\n",
       "      <td>86</td>\n",
       "      <td>90</td>\n",
       "      <td>93</td>\n",
       "      <td>98</td>\n",
       "      <td>107</td>\n",
       "      <td>113</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>14</td>\n",
       "      <td>23</td>\n",
       "      <td>26</td>\n",
       "      <td>34</td>\n",
       "      <td>36</td>\n",
       "      <td>39</td>\n",
       "      <td>40</td>\n",
       "      <td>52</td>\n",
       "      <td>55</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>67</td>\n",
       "      <td>76</td>\n",
       "      <td>85</td>\n",
       "      <td>86</td>\n",
       "      <td>90</td>\n",
       "      <td>93</td>\n",
       "      <td>99</td>\n",
       "      <td>108</td>\n",
       "      <td>114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>9</td>\n",
       "      <td>15</td>\n",
       "      <td>23</td>\n",
       "      <td>27</td>\n",
       "      <td>34</td>\n",
       "      <td>36</td>\n",
       "      <td>39</td>\n",
       "      <td>41</td>\n",
       "      <td>52</td>\n",
       "      <td>55</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>67</td>\n",
       "      <td>76</td>\n",
       "      <td>85</td>\n",
       "      <td>86</td>\n",
       "      <td>90</td>\n",
       "      <td>93</td>\n",
       "      <td>99</td>\n",
       "      <td>108</td>\n",
       "      <td>115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "      <td>15</td>\n",
       "      <td>23</td>\n",
       "      <td>25</td>\n",
       "      <td>34</td>\n",
       "      <td>36</td>\n",
       "      <td>38</td>\n",
       "      <td>41</td>\n",
       "      <td>52</td>\n",
       "      <td>54</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>67</td>\n",
       "      <td>76</td>\n",
       "      <td>85</td>\n",
       "      <td>86</td>\n",
       "      <td>90</td>\n",
       "      <td>93</td>\n",
       "      <td>98</td>\n",
       "      <td>107</td>\n",
       "      <td>113</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "      <td>24</td>\n",
       "      <td>28</td>\n",
       "      <td>34</td>\n",
       "      <td>37</td>\n",
       "      <td>39</td>\n",
       "      <td>40</td>\n",
       "      <td>53</td>\n",
       "      <td>54</td>\n",
       "      <td>59</td>\n",
       "      <td>63</td>\n",
       "      <td>67</td>\n",
       "      <td>76</td>\n",
       "      <td>85</td>\n",
       "      <td>86</td>\n",
       "      <td>90</td>\n",
       "      <td>94</td>\n",
       "      <td>99</td>\n",
       "      <td>109</td>\n",
       "      <td>114</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0   1   2   3   4   5   6   7   8   ...  14  15  16  17  18  19  20   21   22\n",
       "0   1   3   9  13  23  25  34  36  38  ...  67  76  85  86  90  93  98  107  113\n",
       "1   2   3   9  14  23  26  34  36  39  ...  67  76  85  86  90  93  99  108  114\n",
       "2   2   4   9  15  23  27  34  36  39  ...  67  76  85  86  90  93  99  108  115\n",
       "3   1   3  10  15  23  25  34  36  38  ...  67  76  85  86  90  93  98  107  113\n",
       "4   2   3   9  16  24  28  34  37  39  ...  67  76  85  86  90  94  99  109  114\n",
       "\n",
       "[5 rows x 23 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import the dataset\n",
    "\n",
    "df = pd.read_csv(\"HungarianNewsItems_indexedforARM.csv\", header=None)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "G6FlZIobJuyE",
    "outputId": "6d0154a2-0994-456b-b209-c05e8a92dd59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 413 entries, 0 to 412\n",
      "Data columns (total 23 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   0       413 non-null    int64 \n",
      " 1   1       413 non-null    int64 \n",
      " 2   2       413 non-null    int64 \n",
      " 3   3       413 non-null    int64 \n",
      " 4   4       413 non-null    int64 \n",
      " 5   5       413 non-null    int64 \n",
      " 6   6       413 non-null    int64 \n",
      " 7   7       413 non-null    int64 \n",
      " 8   8       413 non-null    int64 \n",
      " 9   9       413 non-null    int64 \n",
      " 10  10      413 non-null    int64 \n",
      " 11  11      413 non-null    int64 \n",
      " 12  12      413 non-null    int64 \n",
      " 13  13      413 non-null    int64 \n",
      " 14  14      413 non-null    int64 \n",
      " 15  15      413 non-null    int64 \n",
      " 16  16      413 non-null    int64 \n",
      " 17  17      413 non-null    int64 \n",
      " 18  18      413 non-null    int64 \n",
      " 19  19      413 non-null    int64 \n",
      " 20  20      413 non-null    int64 \n",
      " 21  21      413 non-null    object\n",
      " 22  22      413 non-null    object\n",
      "dtypes: int64(21), object(2)\n",
      "memory usage: 74.3+ KB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Uozox4dQLMlI"
   },
   "source": [
    "### 1.2 Pre-processing the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tlG19J1oJ09M"
   },
   "outputs": [],
   "source": [
    "# Convert these outliers into integers\n",
    "\n",
    "df[21] = df[21].replace('0 11', 110)\n",
    "df[22] = df[22].replace('0 116', 110)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ua36kk_cLuHE"
   },
   "outputs": [],
   "source": [
    "# FOrce all the data types to be integers\n",
    "\n",
    "df = df.astype(\"int64\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "anQ_1YCrMEqY",
    "outputId": "f94d1fcc-caad-4687-f18d-947dda01b1a7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 413 entries, 0 to 412\n",
      "Data columns (total 23 columns):\n",
      " #   Column  Non-Null Count  Dtype\n",
      "---  ------  --------------  -----\n",
      " 0   0       413 non-null    int64\n",
      " 1   1       413 non-null    int64\n",
      " 2   2       413 non-null    int64\n",
      " 3   3       413 non-null    int64\n",
      " 4   4       413 non-null    int64\n",
      " 5   5       413 non-null    int64\n",
      " 6   6       413 non-null    int64\n",
      " 7   7       413 non-null    int64\n",
      " 8   8       413 non-null    int64\n",
      " 9   9       413 non-null    int64\n",
      " 10  10      413 non-null    int64\n",
      " 11  11      413 non-null    int64\n",
      " 12  12      413 non-null    int64\n",
      " 13  13      413 non-null    int64\n",
      " 14  14      413 non-null    int64\n",
      " 15  15      413 non-null    int64\n",
      " 16  16      413 non-null    int64\n",
      " 17  17      413 non-null    int64\n",
      " 18  18      413 non-null    int64\n",
      " 19  19      413 non-null    int64\n",
      " 20  20      413 non-null    int64\n",
      " 21  21      413 non-null    int64\n",
      " 22  22      413 non-null    int64\n",
      "dtypes: int64(23)\n",
      "memory usage: 74.3 KB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ldXxtq8J1D7C"
   },
   "outputs": [],
   "source": [
    "# Save the pre-processed dataset\n",
    "df.to_csv(\"HungarianNewsItems_preprocessed.csv\", header=False, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Mm6roUMcHq-w"
   },
   "source": [
    "### 1.2 Find Most Frequent News Items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q6IzOzmOHq-v"
   },
   "outputs": [],
   "source": [
    "# Extract the data from the dataframe and save them as numpy arrays\n",
    "\n",
    "data = df.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4WKdNybCHq-x"
   },
   "outputs": [],
   "source": [
    "# Sort the news items by their frequency of occurance\n",
    "\n",
    "# Find the unique news items and their corresponding frequencies of occurance\n",
    "news_items, news_frequencies = np.unique(data.flatten(), return_counts=True)\n",
    "# Convert them into lists for them to be zipped together\n",
    "news_items = list(news_items)\n",
    "news_frequencies = list(news_frequencies)\n",
    "# Zip the news items and their counts into a single list\n",
    "news_items_zip = [i for i in zip(news_items, news_frequencies)]\n",
    "\n",
    "# Sort them by the frequency counts in the decreasing order of frequency\n",
    "news_items_zip.sort(key = lambda i : i[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "E0xxNat-Pnfj",
    "outputId": "2759d722-83b3-4067-fdb9-e357a1082b63"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The most Frequent News Items are : \n",
      "34 occuring 413 times\n",
      "85 occuring 413 times\n",
      "86 occuring 413 times\n",
      "90 occuring 413 times\n",
      "76 occuring 412 times\n",
      "67 occuring 410 times\n",
      "59 occuring 399 times\n",
      "93 occuring 378 times\n",
      "2 occuring 370 times\n",
      "36 occuring 345 times\n"
     ]
    }
   ],
   "source": [
    "# Print the most frequent news items\n",
    "\n",
    "print(\"The most Frequent News Items are : \")\n",
    "for (news_temp, freq_temp) in news_items_zip[:10] :\n",
    "    print(f\"{news_temp} occuring {freq_temp} times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y6Aq4jLNHq-y"
   },
   "source": [
    "### 1.3 Find the Rules with the given support and Confidence Thresholds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ngH_PA33Hq-y"
   },
   "outputs": [],
   "source": [
    "# Find the rules based on the given support and confidence thresholds\n",
    "\n",
    "rules = apriori(data, min_support = minSupport, min_confidence = minConfidence)\n",
    "association_results = list(rules)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RW5-Ig9BAYjv",
    "outputId": "ef5f7bcb-b223-48f7-b72f-187c75df5760"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have a total of 12159 sets, which are the different combinations which have the above said support of 50.0 %.\n"
     ]
    }
   ],
   "source": [
    "print(f\"We have a total of {len(association_results)} sets, which are the different combinations which have the above said support of {minSupport * 100} %.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c0ZSxVYUCF1U"
   },
   "source": [
    "This is the format of eery record of the `association_results`.\n",
    "\n",
    "```python\n",
    "RelationRecord(items=frozenset({'beer', 'nuts'}),\n",
    "               support=0.5,\n",
    "               ordered_statistics=[OrderedStatistic(items_base=frozenset({'beer'}),\n",
    "                                                    items_add=frozenset({'nuts'}),\n",
    "                                                    confidence=0.5,\n",
    "                                                    lift=1.0),\n",
    "                                   OrderedStatistic(items_base=frozenset({'nuts'}),\n",
    "                                                    items_add=frozenset({'beer'}),\n",
    "                                                    confidence=1.0,\n",
    "                                                    lift=1.0)])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cy00wEZaBQGK",
    "outputId": "792395df-57b8-41a6-e041-3ff513978cd0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rule : (2 , 34 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (67 , 36),   support=0.6319612590799032, confidence=1.0, lift=1.2076023391812867\n",
      "Rule : (2 , 34 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 93)   =>   (59 , 36),   support=0.6319612590799032, confidence=1.0, lift=1.1971014492753624\n",
      "Rule : (2 , 34 , 67 , 39 , 76 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (36 , 52),   support=0.6319612590799032, confidence=1.0, lift=1.2076023391812867\n",
      "Rule : (2 , 34 , 67 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (36 , 39),   support=0.6319612590799032, confidence=1.0, lift=1.5643939393939394\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59)   =>   (34 , 93),   support=0.6319612590799032, confidence=1.0, lift=1.0925925925925926\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 59 , 93)   =>   (34 , 90),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 85 , 23 , 90 , 59 , 93)   =>   (34 , 86),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 86 , 23 , 90 , 59 , 93)   =>   (34 , 85),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 67 , 36 , 39 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (34 , 76),   support=0.6319612590799032, confidence=1.0, lift=1.0024271844660195\n",
      "Rule : (2 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (34 , 67),   support=0.6319612590799032, confidence=1.0, lift=1.0073170731707317\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 93)   =>   (34 , 59),   support=0.6319612590799032, confidence=1.0, lift=1.0350877192982457\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (34 , 52),   support=0.6319612590799032, confidence=1.0, lift=1.2076023391812867\n",
      "Rule : (2 , 67 , 36 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (34 , 39),   support=0.6319612590799032, confidence=1.0, lift=1.3812709030100334\n",
      "Rule : (2 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (34 , 36),   support=0.6319612590799032, confidence=1.0, lift=1.1971014492753624\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 90 , 59)   =>   (93 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 59 , 93)   =>   (90 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 90 , 59 , 93)   =>   (86 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 86 , 90 , 59 , 93)   =>   (85 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (76 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.2182890855457227\n",
      "Rule : (2 , 34 , 36 , 39 , 76 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (67 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.225519287833828\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 90 , 93)   =>   (59 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 85 , 86 , 90 , 59 , 93)   =>   (52 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.3585526315789473\n",
      "Rule : (2 , 34 , 36 , 67 , 76 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (23 , 39),   support=0.6319612590799032, confidence=0.8729096989966556, lift=1.365574642748556\n",
      "Rule : (2 , 34 , 67 , 39 , 76 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (36 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.3452768729641693\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (34 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59)   =>   (2 , 93),   support=0.6319612590799032, confidence=1.0, lift=1.2328358208955223\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 59 , 93)   =>   (2 , 90),   support=0.6319612590799032, confidence=1.0, lift=1.1162162162162161\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 85 , 23 , 90 , 59 , 93)   =>   (2 , 86),   support=0.6319612590799032, confidence=1.0, lift=1.1162162162162161\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 85),   support=0.6319612590799032, confidence=1.0, lift=1.1162162162162161\n",
      "Rule : (34 , 67 , 36 , 39 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 76),   support=0.6319612590799032, confidence=1.0, lift=1.119241192411924\n",
      "Rule : (34 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 67),   support=0.6319612590799032, confidence=1.0, lift=1.125340599455041\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 93)   =>   (2 , 59),   support=0.6319612590799032, confidence=1.0, lift=1.1601123595505618\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 52),   support=0.6319612590799032, confidence=1.0, lift=1.3812709030100334\n",
      "Rule : (34 , 67 , 36 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 39),   support=0.6319612590799032, confidence=0.8585526315789475, lift=1.1858937687026934\n",
      "Rule : (34 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 36),   support=0.6319612590799032, confidence=1.0, lift=1.3675496688741722\n",
      "Rule : (67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2 , 34),   support=0.6319612590799032, confidence=1.0, lift=1.1162162162162161\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (2 , 23),   support=0.6319612590799032, confidence=1.0, lift=1.3905723905723906\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59)   =>   (93),   support=0.6319612590799032, confidence=1.0, lift=1.0925925925925926\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 59 , 93)   =>   (90),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 23 , 90 , 59 , 93)   =>   (86),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 86 , 23 , 90 , 59 , 93)   =>   (85),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (76),   support=0.6319612590799032, confidence=1.0, lift=1.0024271844660195\n",
      "Rule : (2 , 34 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (67),   support=0.6319612590799032, confidence=1.0, lift=1.0073170731707317\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 93)   =>   (59),   support=0.6319612590799032, confidence=1.0, lift=1.0350877192982457\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (52),   support=0.6319612590799032, confidence=1.0, lift=1.2076023391812867\n",
      "Rule : (2 , 34 , 36 , 67 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (39),   support=0.6319612590799032, confidence=1.0, lift=1.3812709030100334\n",
      "Rule : (2 , 34 , 67 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (36),   support=0.6319612590799032, confidence=1.0, lift=1.1971014492753624\n",
      "Rule : (2 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (34),   support=0.6319612590799032, confidence=1.0, lift=1.0\n",
      "Rule : (2 , 34 , 36 , 67 , 39 , 76 , 52 , 85 , 86 , 90 , 59 , 93)   =>   (23),   support=0.6319612590799032, confidence=1.0, lift=1.214705882352941\n",
      "Rule : (34 , 67 , 36 , 39 , 76 , 52 , 85 , 86 , 23 , 90 , 59 , 93)   =>   (2),   support=0.6319612590799032, confidence=1.0, lift=1.1162162162162161\n"
     ]
    }
   ],
   "source": [
    "# Print a few rules\n",
    "\n",
    "for relationRecord in association_results[-1:] :    # We print the rules for only the last rule set\n",
    "    cur_support = relationRecord[1]\n",
    "    for orderedStatistic in relationRecord[2][-50:] :   # We print only the last 50 rules\n",
    "        cur_base_items = \" , \".join([str(i) for i in list(orderedStatistic[0])])\n",
    "        cur_add_items = \" , \".join([str(i) for i in list(orderedStatistic[1])])\n",
    "        cur_confidence = orderedStatistic[2]\n",
    "        cur_lift = orderedStatistic[3]\n",
    "\n",
    "        print(f\"Rule : ({cur_base_items})   =>   ({cur_add_items}),   support={cur_support}, confidence={cur_confidence}, lift={cur_lift}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nLg5M3hMLRVj"
   },
   "outputs": [],
   "source": [
    "# Count the total number of rules\n",
    "\n",
    "total_rule_count = 0\n",
    "for relationRecord in association_results :\n",
    "    for orderedStatistic in relationRecord[2] :\n",
    "        total_rule_count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bPIx_WUnBQCz",
    "outputId": "e448e945-ffcd-49d6-989d-300d005dfd6f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have a total of 2268881 strong rules whose support and confidence matches our threshold conditions.\n"
     ]
    }
   ],
   "source": [
    "print(f\"We have a total of {total_rule_count} strong rules whose support and confidence matches our threshold conditions.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qgBxoxZph6ld"
   },
   "source": [
    "## 2. Apriori Algorithm\n",
    "\n",
    "In this section, we write our own version of the Apriori algorithm without making use of any libraries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dBCL5tpvMbro"
   },
   "source": [
    "### 2.1 Import necessary Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ote9gY_OMfjH"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "from itertools import chain, combinations\n",
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AMnn5fVYMitL"
   },
   "source": [
    "### 2.2 Utility Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VclyswYmMqKA"
   },
   "outputs": [],
   "source": [
    "# To find the non-empty subsets\n",
    "\n",
    "def subsets(arr):\n",
    "    \"\"\" Returns non empty subsets of arr\"\"\"\n",
    "    return chain(*[combinations(arr, i + 1) for i, a in enumerate(arr)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "M8ult52ZNqO0"
   },
   "outputs": [],
   "source": [
    "# Find and return item sets which satisfies the given support threshold conditions\n",
    "\n",
    "def returnItemsWithMinSupport(itemSet, transactionList, minSupport, freqSet):\n",
    "    \"\"\"calculates the support for items in the itemSet and returns a subset\n",
    "    of the itemSet each of whose elements satisfies the minimum support\"\"\"\n",
    "    _itemSet = set()\n",
    "    localSet = defaultdict(int)\n",
    "\n",
    "    for item in itemSet:\n",
    "        for transaction in transactionList:\n",
    "            if item.issubset(transaction):\n",
    "                freqSet[item] += 1\n",
    "                localSet[item] += 1\n",
    "\n",
    "    for item, count in localSet.items():\n",
    "        support = float(count) / len(transactionList)\n",
    "\n",
    "        if support >= minSupport:\n",
    "            _itemSet.add(item)\n",
    "\n",
    "    return _itemSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kCEyJVHkN1ZD"
   },
   "outputs": [],
   "source": [
    "def joinSet(itemSet, length):\n",
    "    \"\"\"Join a set with itself and returns the n-element itemsets\"\"\"\n",
    "    return set(\n",
    "        [i.union(j) for i in itemSet for j in itemSet if len(i.union(j)) == length]\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i-zSrsBON7AK"
   },
   "outputs": [],
   "source": [
    "# Get the item sets from a given transaction list\n",
    "\n",
    "def getItemSetTransactionList(data_iterator):\n",
    "    transactionList = list()\n",
    "    itemSet = set()\n",
    "    for record in data_iterator:\n",
    "        transaction = frozenset(record)\n",
    "        transactionList.append(transaction)\n",
    "        for item in transaction:\n",
    "            itemSet.add(frozenset([item]))  # Generate 1-itemSets\n",
    "    return itemSet, transactionList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0Ma840xQOGlS"
   },
   "outputs": [],
   "source": [
    "# The main runner function\n",
    "\n",
    "def runApriori(data_iter, minSupport, minConfidence):\n",
    "    \"\"\"\n",
    "    run the apriori algorithm. data_iter is a record iterator\n",
    "    Return both:\n",
    "     - items (tuple, support)\n",
    "     - rules ((pretuple, posttuple), confidence)\n",
    "    \"\"\"\n",
    "    itemSet, transactionList = getItemSetTransactionList(data_iter)\n",
    "\n",
    "    freqSet = defaultdict(int)\n",
    "    largeSet = dict()\n",
    "    # Global dictionary which stores (key=n-itemSets,value=support)\n",
    "    # which satisfy minSupport\n",
    "\n",
    "    assocRules = dict()\n",
    "    # Dictionary which stores Association Rules\n",
    "\n",
    "    oneCSet = returnItemsWithMinSupport(itemSet, transactionList, minSupport, freqSet)\n",
    "\n",
    "    currentLSet = oneCSet\n",
    "    k = 2\n",
    "    while currentLSet != set([]):\n",
    "        largeSet[k - 1] = currentLSet\n",
    "        currentLSet = joinSet(currentLSet, k)\n",
    "        currentCSet = returnItemsWithMinSupport(\n",
    "            currentLSet, transactionList, minSupport, freqSet\n",
    "        )\n",
    "        currentLSet = currentCSet\n",
    "        k = k + 1\n",
    "\n",
    "    def getSupport(item):\n",
    "        \"\"\"local function which Returns the support of an item\"\"\"\n",
    "        return float(freqSet[item]) / len(transactionList)\n",
    "\n",
    "    toRetItems = []\n",
    "    for key, value in largeSet.items():\n",
    "        toRetItems.extend([(tuple(item), getSupport(item)) for item in value])\n",
    "\n",
    "    toRetRules = []\n",
    "    for key, value in list(largeSet.items())[1:]:\n",
    "        for item in value:\n",
    "            _subsets = map(frozenset, [x for x in subsets(item)])\n",
    "            for element in _subsets:\n",
    "                remain = item.difference(element)\n",
    "                if len(remain) > 0:\n",
    "                    confidence = getSupport(item) / getSupport(element)\n",
    "                    if confidence >= minConfidence:\n",
    "                        toRetRules.append(((tuple(element), tuple(remain)), confidence))\n",
    "    return toRetItems, toRetRules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "b1QewkOwOMSO"
   },
   "outputs": [],
   "source": [
    "# Print the rules\n",
    "\n",
    "def printResults(items, rules):\n",
    "    \"\"\"prints the generated itemsets sorted by support and the confidence rules sorted by confidence\"\"\"\n",
    "    print(\"\\n------------------------ Top Item Sets ------------------------\")\n",
    "    for item, support in sorted(items, key=lambda x: x[1])[:10]:      # added[:10] after sorted() to reduce the output\n",
    "        print(\"item: %s , %.3f\" % (str(item), support))\n",
    "    print(\"\\n------------------------ Top RULES ------------------------\")\n",
    "    for rule, confidence in sorted(rules, key=lambda x: x[1])[:10]:   # added[:10] after sorted() to reduce the output\n",
    "        pre, post = rule\n",
    "        print(\"Rule: %s ==> %s , %.3f\" % (str(pre), str(post), confidence))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9E5jMq48h9wF"
   },
   "outputs": [],
   "source": [
    "# Reads data from a file\n",
    "\n",
    "def dataFromFile(fname):\n",
    "    \"\"\"Function which reads from the file and yields a generator\"\"\"\n",
    "    with open(fname, \"r\") as file_iter:\n",
    "        for line in file_iter:\n",
    "            line = line.strip().rstrip(\",\")  # Remove trailing comma\n",
    "            record = frozenset(line.split(\",\"))\n",
    "            yield record"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Sy4LllT2SIIv"
   },
   "source": [
    "### 2.3 Implementing the Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JCErRehTihFV"
   },
   "outputs": [],
   "source": [
    "# Load the data from file\n",
    "\n",
    "inFile = dataFromFile(\"HungarianNewsItems_indexedforARM.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nrQftEouieYe"
   },
   "outputs": [],
   "source": [
    "# Find the top item sets and rules\n",
    "\n",
    "items, rules = runApriori(inFile, minSupport, minConfidence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OYPPjcFPRXf8",
    "outputId": "0981d06d-3015-462b-b18a-ae198d885d76"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "------------------------ Top Item Sets ------------------------\n",
      "item: ('59', '67', '3') , 0.501\n",
      "item: ('59', '67', '3', '34') , 0.501\n",
      "item: ('59', '67', '85', '3') , 0.501\n",
      "item: ('59', '67', '3', '86') , 0.501\n",
      "item: ('59', '67', '3', '90') , 0.501\n",
      "item: ('59', '76', '67', '3') , 0.501\n",
      "item: ('59', '85', '3', '67', '90') , 0.501\n",
      "item: ('59', '85', '3', '34', '67') , 0.501\n",
      "item: ('59', '76', '85', '3', '67') , 0.501\n",
      "item: ('59', '3', '34', '67', '90') , 0.501\n",
      "\n",
      "------------------------ Top RULES ------------------------\n",
      "Rule: ('34',) ==> ('59', '67', '3') , 0.501\n",
      "Rule: ('85',) ==> ('59', '67', '3') , 0.501\n",
      "Rule: ('86',) ==> ('59', '67', '3') , 0.501\n",
      "Rule: ('90',) ==> ('59', '67', '3') , 0.501\n",
      "Rule: ('85',) ==> ('59', '67', '90', '3') , 0.501\n",
      "Rule: ('90',) ==> ('59', '67', '85', '3') , 0.501\n",
      "Rule: ('90', '85') ==> ('59', '67', '3') , 0.501\n",
      "Rule: ('85',) ==> ('59', '67', '3', '34') , 0.501\n",
      "Rule: ('34',) ==> ('59', '67', '85', '3') , 0.501\n",
      "Rule: ('85', '34') ==> ('59', '67', '3') , 0.501\n"
     ]
    }
   ],
   "source": [
    "# Print the rules\n",
    "\n",
    "printResults(items, rules)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JSEw-lF0jziX",
    "outputId": "b09f4eb1-bea7-44f1-c2ac-f34e74876e6b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have a total of 2256722 strong rules whose support and confidence matches our threshold conditions.\n"
     ]
    }
   ],
   "source": [
    "print(f\"We have a total of {len(rules)} strong rules whose support and confidence matches our threshold conditions.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aKQ9A2GzIpU2"
   },
   "source": [
    "## 3. References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lERd80v7ItVJ"
   },
   "source": [
    "I have referred to the following blogs and codes while implementing the above code.\n",
    "\n",
    "* https://pypi.org/project/apyori/\n",
    "* https://zaxrosenberg.com/unofficial-apyori-documentation/\n",
    "* https://github.com/asaini/Apriori\n",
    "* Agrawal, Rakesh, and Ramakrishnan Srikant. \"Fast algorithms for mining association rules.\" Proc. 20th int. conf. very large data bases, VLDB. Vol. 1215. 1994."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IYtWMzOvLQ3s"
   },
   "source": [
    "## Prevent random disconnects\n",
    "\n",
    "This cell runs JS code to automatic reconnect to runtime.\n",
    "\n",
    "**This is to be used when this notebook is being run in a Google Colab Environment**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "jtClEMAMLVHw",
    "outputId": "1337d4f5-29a8-4fee-ac90-ca72152ff3ba"
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       " function ClickConnect(){\n",
       "   btn = document.querySelector(\"colab-connect-button\")\n",
       "   if (btn != null){\n",
       "     console.log(\"Click colab-connect-button\"); \n",
       "     btn.click() \n",
       "     }\n",
       "   \n",
       "   btn = document.getElementById('ok')\n",
       "   if (btn != null){\n",
       "     console.log(\"Click reconnect\"); \n",
       "     btn.click() \n",
       "     }\n",
       "  }\n",
       "  \n",
       "setInterval(ClickConnect,60000)\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done.\n"
     ]
    }
   ],
   "source": [
    "import IPython\n",
    "from google.colab import output\n",
    "\n",
    "display(IPython.display.Javascript('''\n",
    " function ClickConnect(){\n",
    "   btn = document.querySelector(\"colab-connect-button\")\n",
    "   if (btn != null){\n",
    "     console.log(\"Click colab-connect-button\"); \n",
    "     btn.click() \n",
    "     }\n",
    "   \n",
    "   btn = document.getElementById('ok')\n",
    "   if (btn != null){\n",
    "     console.log(\"Click reconnect\"); \n",
    "     btn.click() \n",
    "     }\n",
    "  }\n",
    "  \n",
    "setInterval(ClickConnect,60000)\n",
    "'''))\n",
    "\n",
    "print(\"Done.\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "0AoUh7ehHq-s",
    "U_wJFdaXHq-s",
    "Uozox4dQLMlI",
    "Mm6roUMcHq-w",
    "y6Aq4jLNHq-y",
    "qgBxoxZph6ld",
    "dBCL5tpvMbro",
    "AMnn5fVYMitL",
    "Sy4LllT2SIIv",
    "aKQ9A2GzIpU2",
    "IYtWMzOvLQ3s"
   ],
   "name": "Q1.ipynb",
   "provenance": []
  },
  "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.8.3"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}