Lab3_Association_analysis_for_MatFörAlla.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 3 - Association Analysis for *MatFörAlla*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "In this lab, we will look at transaction data from a supermarket.\n",
    "\n",
    "The grocery store *MatFörAlla* has trouble displaying its products optimally in the store. What the store wants to do is to increase sales to customers. For this, *MatFörAlla* has given you a dataset containing transaction data on what customers bought during every visit to the store."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Load the data into a matrix\n",
    "\n",
    "We will use a package called `mlxtend` for this lab. If you wish, can read more about the details of `mlxtend` [here](https://rasbt.github.io/mlxtend/) but it is not necessary for completing this lab exercise.\n",
    "\n",
    "First, let's load the relevant modules we will use in this lab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import pandas as pd\n",
    "from mlxtend.preprocessing import TransactionEncoder\n",
    "from mlxtend.frequent_patterns import apriori\n",
    "from mlxtend.frequent_patterns import association_rules\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "from client.api.notebook import Notebook\n",
    "ok = Notebook('lab3.ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "The dataset we want to use is available in a local `.csv` file and to load this we need to use the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"groceries.csv\") as groceries_file:\n",
    "    dataset = list(csv.reader(groceries_file))\n",
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "If you are unsure what this `.csv` file looks like in its raw format, you check the contents of it in a regular text editor, or by going to the Jupyter dashboard and opening it, just to get a hint of what data we will handle.\n",
    "\n",
    "Now we will use `mlxtend` to read all the items into a sparse matrix.\n",
    "\n",
    "Every product item that exists throughout the set of data will have its own column - in other words, if there are 1000 unique items in the dataset then there will be 1000 columns in the matrix. Each row represents a shopping cart with an ID used as the index. The content of each cell in each row represents the number of each product item purchased in a shopping cart.\n",
    "\n",
    "Below is displayed an explanatory example of how a sparse matrix can look with 3 items and 3\n",
    "customers. Do you see the difference between the `.csv` file and this matrix?\n",
    "\n",
    "\n",
    "| &nbsp; | Produkt 1 | Produkt 2 | Produkt 3 |\n",
    "|:------:|:---------:|:---------:|:---------:|\n",
    "| Kund 1 |     0     |     0     |     1     |\n",
    "| Kund 2 |     1     |     1     |     0     |\n",
    "| Kund 3 |     0     |     1     |     0     |\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Explain in short what the difference is by typing it directly into the cell below.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sparse matrix is more memory-efficient than keeping each shopping cart record in its full format.\n",
    "\n",
    "If we had saved it in a full `DataFrame` then we would have had to keep the entire data in the memory, repeating the names of elements that appear more than once. The downside is that we get a matrix with many cells containing just zero.\n",
    "\n",
    "The `mlxtend` package lets us create the sparse matrix by fitting the input data records using a `TransactionEncoder()` class. We can load it as a Pandas `DataFrame` to inspect more easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "te = TransactionEncoder()\n",
    "te_ary = te.fit(dataset).transform(dataset)\n",
    "groceries = pd.DataFrame(te_ary, columns=te.columns_)\n",
    "groceries.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Summarize and inspect the transactions\n",
    "\n",
    "Now you have loaded the dataset that *MatFörAlla* has provided, we need to familiarize ourselves with transactions before generating the association rules.\n",
    "\n",
    "Use the functions you learned from Lab 1 to describe the groceries dataset by replacing the ellipsis `...` in the next code cell with your own code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Hint: Run the following cell to get the number of `True` and `False` values in the sparse matrix. This will help you calculate the density.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries.stack().value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it may be desirable to see specific transactions. To do so, use Pandas indexing with `[ ... ]` if you do this on the entire dataset then you will get all the transactions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries[groceries.sum(axis=1) == 1].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries[groceries.sum(axis=1) == 1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries.sum(axis=1).max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries[groceries.sum(axis=1) == groceries.sum(axis=1).max()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "groceries[5:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Note that the index shows that you got transactions 5-9, but actually you got transactions 6-10 (`DataFrame`s are indexed starting with row 0).\n",
    "\n",
    "It is important, however, to understand that the numbers in the output does not show the transaction number, but is an auto-generated ID given by Pandas that simply reflects the row number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also count the numbers of instances of `True`for different items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries.sum().sort_values(ascending=False)[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries[\"soda\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "groceries[groceries.sum(axis=1) == 1].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Your task now is to compile what we just got from the output of the code above. The following questions you should try to figure out and make sure to run each cell that contains your answer, and validate them by running the `ok.grade()` cell after Q3.7. Make sure you really try to figure out the answers first before you check if they are correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.1.** How many product items are in the dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_product_items_in_dataset = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.2.** How many transactions are there in the dataset?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_transactions_in_dataset = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.3.** What is the density of the dataset? Provide your answer to 5 decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_density = ...\n",
    "dataset_density"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.4.** What are the most common items in the dataset? Provide your answer as a list of string, for example `[\"potato\", \"köttbullar\"]` etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "most_common_5_items = [ ... ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.5.** How many of the transactions contain soda?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_transactions_containing_soda = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.6.** How many transactions contain only 1 item?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_transactions_containing_1_item = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3.7.** How many items are in the transaction with the most items?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_num_product_items_in_a_transcation = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell to check questions 1 to 7. Make sure to run the code cells that contain your answers\n",
    "_ = ok.grade('q31to37')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Frequency of items\n",
    "\n",
    "If you want to see how many transactions of a particular item relative to the total number of transactions (expressed as a percentage) we can define a function `item_frequency()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def item_frequency(dataset):\n",
    "    return dataset.sum() / len(dataset) * 100\n",
    "\n",
    "item_frequency(groceries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also filter by specific column names on the input `DataFrame` by providing the column name within square brackets `[ ... ]`, for example just `meat spreads` we would write: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "item_frequency(groceries['meat spreads'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also filter by specific row numbers on the input `DataFrame`by providing the row range within the square brackets as normal, for example just rows 0 to 3 we would write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "item_frequency(groceries[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "If you want to look at a specific set of products to compare their frequency, you can provide an array of column names to the `groceries` indexer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "item_frequency(groceries[[\"whole milk\", \"butter\", \"rice\"]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "This may be interesting, but it may be more interesting to see such goods occurring over a certain frequency. For this you can further filter out frequencies above a certain degree of support. We can define a new function that we can specify the minimum support:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def item_frequency_plot(dataset, support):\n",
    "    frequencies = dataset.sum() / len(dataset)\n",
    "    freq = frequencies[frequencies > support]\n",
    "    return freq * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "We can additionally now visualize the results in a bar chart. Fill in the missing parameters to the new function with the input dataset and a minimum support of 0.125:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = item_frequency_plot(groceries, 0.125).plot.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Q3.8.** What does your graph look like? What is the most frequently purchased item according to the transaction data?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Extracting Association Rules\n",
    "\n",
    "*MatFörAlla* is now getting impatient and say that you have only produced things that they already knew and could easily look up in their databases. You promised that you will contribute new knowledge about their customers.\n",
    "\n",
    "Because you do not want to tempt more on their patience you do not want to end up in to bring out unnecessary rules again. There are three different types of rules - *trivial*, *unexplained* and *actionable*.\n",
    "\n",
    "*Trivial* are ones that you can easily predict, for example, that you often buy milk and cereal together.\n",
    "\n",
    "*Unexplainable*. For example, when you buy diapers you might often buy hammer. There is no explanation for why that would be so.\n",
    "\n",
    "*Actionable* ones are the rules that lead to insight into something and that we can act on. Examples of what we can do are:\n",
    "\n",
    "1. Have one item at low cost while the other is a little more expensive,\n",
    "1. Make sure that customers have to go past the goods that are relevant,\n",
    "1. Alternative ways to market the goods\n",
    "1. Put the goods closer together.\n",
    "\n",
    "In order to make it easier for us to talk about rules, we hereby develop one common way to talk about these.\n",
    "\n",
    "We will now write $Antecedent \\rightarrow Consequent$.\n",
    "\n",
    "Example:\n",
    "\n",
    "$Toys, wrapping paper \\rightarrow Batteries$\n",
    "\n",
    "It is read out that if you buy toys and wrapping paper you are also likely to buy batteries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Measuring Association Rules\n",
    "\n",
    "There are three different ways to measure association rules. This is to we can evaluate how much weight we should attach to a specific rule.\n",
    "\n",
    "#### Support\n",
    "\n",
    "Support is about the number of transactions that contain a certain set of items. The more often items occur together in the input dataset, the greater the support weight.\n",
    "\n",
    "```\n",
    "t1: Beef, Carrot, Milk\n",
    "t2: Steak, Cheese\n",
    "t3: Cheese, Flingor\n",
    "t4: Steak, Carrot, Cheese\n",
    "t5: Steak, Carrot, Butter, Cheese, Milk\n",
    "t6: Carrot, Butter, Milk\n",
    "t7: Carrot, Milk, Butter\n",
    "```\n",
    "\n",
    "For example,\n",
    "\n",
    "$$Support(Carrot, Butter, Milk) = \\frac{3}{7} = 0.43$$\n",
    "\n",
    "because the combination of these three items appears 3 times in the input of 7 transactions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "#### Confidence\n",
    "\n",
    "Confidence is that if there is a rule $Beef, Chicken \\rightarrow Apple$ and has a confidence of 33%, we mean that if there is beef and chicken bought together, there is 33% chance that there are also apples in the shopping cart.\n",
    "\n",
    "Confidence is calculated for example that one has the rule:\n",
    "\n",
    "$$Butter \\rightarrow Milk, Chicken = \\frac{Support (Butter \\land Milk \\land Chicken)}{Support (Butter)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "#### Lift\n",
    "\n",
    "Lift gives us a metric about how good a rule is, only based on the right side of the rule. For example, if items on the right side are already common the rule will not tell us anything valuable.\n",
    "\n",
    "If the lift is $>1$ then the rule is better than guessing. If the lift is $\\leq1$ the rule is pretty much as good as guessing.\n",
    "\n",
    "For example:\n",
    "\n",
    "$$Chicken \\rightarrow Milk = \\frac{Support (Chicken \\land Milk)}{Support(Chicken) \\times Support (Milk)} = \\frac{(4 / 7)}{(5 / 7) \\times (4 / 7)} = 1.4$$\n",
    "\n",
    "This implies that $Chicken \\rightarrow Milk$ might be a good rule as $1.4 > 1$. However if we increase the support for milk to $6 \\div 7$ to show that it is bought more often in more cases:\n",
    "\n",
    "$$Chicken \\rightarrow Milk = \\frac{Support (Chicken \\land Milk)}{Support(Chicken) \\times Support (Milk)} = \\frac{(4 / 7)}{(5 / 7) \\times (6 / 7)} = 0.933$$\n",
    "\n",
    "This now implies $Chicken \\rightarrow Milk$ might be a bad rule as $0.933 < 1$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Explain the different symbols in the matemathical expressions? (${\\land , \\times }$). Write your answer in the cell below.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Perform association analysis with Python\n",
    "\n",
    "Now let's find associations between items in the dataset using default values on support and confidence.\n",
    "\n",
    "First we create a frequent item sets dataset using the `apriori()` function that calculates the support (item frequency) in a similar method as we did at the beginning of this lab. The function also adds combinations of items into the calculation, and additionally allows us to filter on the minimum support. In this case we set the minimum support to 0.5%:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frequent_itemsets = apriori(groceries, min_support=0.005, use_colnames=True)\n",
    "frequent_itemsets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "As you can see, this does not generate rules so we now need to generate them. If you want to decide what values you want to consider, `frequent_itemsets` is a `DataFrame` so you can filter on it before you provide it to the `association_rules()` function.\n",
    "\n",
    "Note that you can explore the rules generated filtered on different metrics (`support`, `confidence` and `lift`) by specifying the metric and minimum threshold to the function, for example as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grocery_rules = association_rules(frequent_itemsets, metric=\"confidence\", min_threshold=0.1)\n",
    "grocery_rules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add columns to calculate the size (number of items contained) of the antecendants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grocery_rules[\"num_antecedents\"] = grocery_rules[\"antecedents\"].apply(lambda x: len(x))\n",
    "grocery_rules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Use the `describe()` function on your grocery rules dataset to get a summary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grocery_rules.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can filter out the rules by filtering on the `num_antecedents` column we created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grocery_rules_3_items = grocery_rules[grocery_rules.num_antecedents >= 3]\n",
    "grocery_rules_3_items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Q3.9.** How many rules have three items?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_rules_with_three_items = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = ok.grade('q39')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's filter further on various rule measures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grocery_rules[(grocery_rules.num_antecedents >= 3) \n",
    "              & (grocery_rules.confidence > 0.6)\n",
    "              & (grocery_rules.support > 0.0005)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Q3.10.** What makes a rule interesting? Is there an interesting rule found in our rules with three antecedents that is worth investigating further?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Sometimes it may be desirable to want to know the rules that contain a certain product. For example, *MatFörAlla* has had trouble knowing what to put next to citrus fruits. First, we filter out the rules that contain citrus fruit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "citrus_rules = grocery_rules[grocery_rules.antecedents.apply(str).str.contains(\"citrus fruit\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Now you can explore the association rules for just citrus fruit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "citrus_rules[(citrus_rules.num_antecedents == 1) \n",
    "              & (citrus_rules.confidence > 0.1)\n",
    "              & (citrus_rules.support > 0.01)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Q3.11.** What products do you recommend *MatFörAlla* to put next to citrus fruit? Explain your answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "*MatFörAlla* thank you for your help and are grateful that you arranged so that they now sells much better.\n",
    "\n",
    "Because you did such a good job, you have also learned that there is some further aspects that *MatFörAlla* wants to know:\n",
    "\n",
    "**Q3.12.** *MatFörAlla* can now see which customers have made which transactions. What further possibilities can such data provide?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Q3.13.** A customer makes a purchase where he buys a candle together with 20 cans of beer and *MatFörAlla* then wonder how this will affect the analysis. You can say with confidence that it will not affect the analysis. Why can you say that?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "*Edit this cell to type your answer here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "*When you are finished*, save your work in this notebook to upload to Studium.\n",
    "\n",
    "Choose **Save and Checkpoint** from the **File** menu, then choose **Download as HTML** from the **File** menu and save it to your computer (the filename saved should be `Lab3_Association_analysis_for_MatFörAlla.html`).\n",
    "\n",
    "Then on the course page in *Studium* choose **Labb 3** and upload the HTML file and send the submission."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  },
  "nbTranslate": {
   "displayLangs": [],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "sv",
   "targetLang": "en",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}