Bhargav_solanki_assignment_08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please fill in your name and that of your teammate.\n",
    "\n",
    "You: Bhargav Solanki\n",
    "\n",
    "Teammate: Carmen Sangro Prieto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the eighth lab. Today we have _way too many_ topics to cover to do everything by hand as usual, so I selected different depths to each topic to make sure you gain full insight and applicable experience.\n",
    "\n",
    "As you go through the exercise and you apply algorithm after algorithm, method after method, I want you to think about the actual **competence** you are accumulating over the months, both theoretical and applied. Think about it, and be confident: covering so many, so different algorithms in a single lab may sound like a challenge to the version of Past You from barely two months ago, but I believe Today's You is capable of taking on this whale of a lab and have space for more.\n",
    "\n",
    "Working with many algorithms gives me another chance to shake you out of your confidence zone with respect to _data processing_ . Basically each algorithm requires different formats, so you cannot just define the data on top and keep reusing it: you will need to re-load the dataset for each exercise, applying a different processing each time.\n",
    "Be flexible, and don't forget your train-test splits (and their correct usage) -- I should not need to mention it anymore, right? :)\n",
    "\n",
    "Good luck, have fun!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to pass the lab?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below you find the exercise questions. Each question awarding points is numbered and states the number of points like this: **[0pt]**. To answer a question, fill the cell below with your answer (markdown for text, code for implementation). Incorrect or incomplete answers are in principle worth 0 points: to assign partial reward is only up to teacher discretion. Over-complete answers do not award extra points (though they are appreciated and will be kept under consideration). Save your work frequently! (`ctrl+s`)\n",
    "\n",
    "**You need at least 16 points (out of 24 available) to pass** (66%)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Fundamentals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1 **[1pt]** Write an example (in English) of a Machine Learning application for which the Supervised Learning paradigm is not (directly) applicable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For self driving cars, when they try to detect items on the road, we initially do not know if its a car, or person, i.e not all objects can be identified that it sees on the road. So it has first cluster it and check if it belongs to a cluster of obstacle or not. Then it will be labelled as obsctacle. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 **[1pt]** Write an example (in English) of a Machine Learning application for which the Unsupervised Learning paradigm is an ideal choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The netflix recommendation system, clusters movies and shows together, based on my past viewing history. There is no label, and yet, I see good recommendations. This uses clustering."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Clustering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 **[2pt]** Explain the $k$-means algorithm using a few words of your own. Particularly, state any requirements, and what the user needs to define."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To use \"your own words\", a trick is to read the slide, decide which things you need to mention, then close the slide and imagine a friend with only basic technical background in front of you (aka \"rubberducking\", Google it!). Now tell this person the things that you decided to mention.\n",
    "- No need to go crazy. This is a type of (vague!) question that you will need to answer over and over, typically to convince your boss to let you use a particular method, or to guide someone with less knowledge in the field. It's not a right/wrong question: you need to show that you have competence, list the key points, be brief and to the point.\n",
    "- And of course, copy+paste+change words from the slide will score you 0 points :) while a sincere, fair try that is not wrong will pass, so no worries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. K is the hyper parameter that we set to decide how many clusters do we need.\n",
    "2. we start the process by randomly selecting some points as centroid of the k clusters. Here centroid is centre of a cluster. ( Birds of same feather, flock together)\n",
    "3. we then calculate the distance ( norm) of each point with the cluster and then assign each point to a cluster which is closest to the point.\n",
    "4. Now we calculate the new centroid based on the points assigned to the clusters.\n",
    "5. We discard the points in the clusters and keep track of the centroids,\n",
    "6. We repeat the process from step 3 a few times to ensure we get the best centroids.\n",
    "7. We then try different values of K from 1,2,3... n and pick the best k, such the points that are similar are in the same cluster, while the centroids of the cluster are far apart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the next question, we need to understand how to evaluate a clustering algorithm. The main difference between clustering and classification is that, well, it's UL not SL: the labels are not involved in the training, and they should not be involved in the testing. So how do you test the performance of a clustering algorithm?\n",
    "\n",
    "Each mean/cluster gets a numerical identifier, the only problem is that the number does not correspond to our labels because it's assigned randomly based on initialization. The most naïve way then is to brute-force all mappings between the labels and the cluster numbers: the one that makes the most sense is the one that should be used for evaluation. Since this is orthogonal to the lecture and may take a long time to debug, here is a snippet of code that does that.\n",
    "\n",
    "Read it, understand it, play with it, and possibly improve it. Bruteforcing is rarely optimal, which is the very reason why ML exists :)  \n",
    "(note: it may be easier to understand it if you first go ahead with answering the next question first, then come back to this)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "sns.set(rc={'figure.figsize':(8,6)}, style=\"whitegrid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Goal: convert the labels to the cluster numbers generated by k-means\n",
    "import itertools\n",
    "from sklearn.model_selection import train_test_split\n",
    "species_names = sns.load_dataset('iris').species.unique()\n",
    "possible_codes = itertools.permutations(range(len(species_names)))\n",
    "converters = [dict(zip(species_names, perm)) for perm in possible_codes]\n",
    "#print(converters)\n",
    "# try printing each of these variables and understand what they do\n",
    "\n",
    "def my_misclass_fn(conv_y_test, results):\n",
    "    new_results = np.array(results)\n",
    "    temp = new_results == conv_y_test\n",
    "    #print(temp.shape[0]-temp.sum())\n",
    "    #print(conv_y_test)\n",
    "    #print(results)\n",
    "    return temp.shape[0]-temp.sum()\n",
    "\n",
    "# I modified this method. No need to calculate the result of model every time we call the method,\n",
    "# rather I call it once outside and pass it as a param, Makes it faster\n",
    "def cluster_to_class(fn_that_counts_misclassified, y_test, results):\n",
    "    min_score = np.Infinity # we saw how to write a minimizer already right?\n",
    "    right_conversion = None\n",
    "    for converter in converters:\n",
    "        conv_y_test = y_test.replace(converter) # conveniently works with `dict`s\n",
    "        misclassified = fn_that_counts_misclassified(conv_y_test, results)\n",
    "        if misclassified < min_score:\n",
    "            min_score = misclassified\n",
    "            right_conversion = converter\n",
    "    return right_conversion\n",
    "\n",
    "df = sns.load_dataset('iris')\n",
    "train, test = train_test_split(df, test_size=0.2)\n",
    "x_train = train[train.columns[:-1]]\n",
    "y_train = train[train.columns[-1]]\n",
    "x_test = test[test.columns[:-1]]\n",
    "y_test = test[test.columns[-1]]\n",
    "#print(x_train)\n",
    "\n",
    "## to use this function, you will need something like this\n",
    "# right_conversion = cluster_to_class(k_means_model, my_misclass_fn, x_test, y_test)\n",
    "# conv_y_test = y_test.replace(right_conversion)\n",
    "# k_means_misclassified = my_misclass_fn(k_means_model, x_test, conv_y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 **[3pt]** Apply the scikit-learn implementation of the $k$-means algorithm to the Iris dataset (4 features, but drop the labels for training), and print a performance score of your choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Of course you want to pass $k=3$.\n",
    "- Passing the trained `KMeans` object to `print()` shows several useful parameters and their default values.\n",
    "- After you get it to work though, why don't you try $k=2$ or $k=4$ and see what happens when you have to _guess_ $k$ (which is the normal case in real applications).\n",
    "- For the performance score, remember this is [clustering, not classification](https://stackoverflow.com/a/48617825/6392246), which means `score()` will ignore the labels and print \"strange numbers\". No worries, you know how to make your own scoring from the past labs, right?\n",
    "- Notice how $k$-means is _very_ sensitive to initialization. To get a consistently better result you may want to explore options `max_iter`, `n_jobs` and of course `init`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 86.67%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "df = sns.load_dataset('iris')\n",
    "x = df[df.columns[:-1]]\n",
    "labels = df[df.columns[:-1]]\n",
    "kmeans = KMeans(n_clusters=3, random_state=0, n_init=30, init='k-means++', max_iter=400)\n",
    "kmeans.fit(x_train)\n",
    "#print(kmeans)\n",
    "#print(kmeans.score(x_test))\n",
    "centroids = kmeans.cluster_centers_\n",
    "results = kmeans.predict(x_test)\n",
    "results\n",
    "right_conversion = cluster_to_class(my_misclass_fn, y_test, results)\n",
    "#print(right_conversion)\n",
    "#print(y_test)\n",
    "#print(results)\n",
    "missclassified = my_misclass_fn(y_test.replace(right_conversion), results)\n",
    "accuracy = round( ((len(results)-missclassified)/len(results))*100, 2)\n",
    "print(\"Accuracy is \" + str(accuracy) + \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 **[1pt]** Plot the centroids learned with $k$-means on top of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To get the centroids coordinates, access attribute `cluster_centers_` of the KMeans object. Here are some options I passed to `scatterplot` for visibility (remember you can use the [double-splat](https://stackoverflow.com/questions/36901/what-does-double-star-asterisk-and-star-asterisk-do-for-parameters) to transform the dict into keyword parameters):\n",
    "```python\n",
    "kwargs = {'marker':'X', 'color':'r', 's':200, 'label':'centroids'}\n",
    "```\n",
    "- The question does not specify the details of what to plot, so it's up to you to provide a correct and useful interpretation. You learned how to make useful plots, just be confident.\n",
    "- The simplest is of course to reproduce what we saw so far: one plot, `petal_width` vs. `petal_length`. As they are the last two features, make sure to pick the corresponding coordinates from the centroids. Remember your ranges and your `transpose()` ;) \n",
    "- Even fancier: why not converting it to a DataFrame? Remember to drop the `species` column when constructing the `df`, as the centroids (learned with UL) have no species information (and thus one less column than iris): `columns=iris.columns.drop('species')`\n",
    "- After answering correctly, if you want to learn something useful and fancy, try plotting a [[PairGrid]](https://seaborn.pydata.org/generated/seaborn.PairGrid.html) that mimics a PairPlot but with added clusters off-diagonal. If you want the usual distributions on the diagonal, it is time to learn it is done with _Density Estimation_ (which is what you learned to do for Gaussians in NB), automated in Seaborn with `kdeplot()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5.854      2.702      4.346      1.41      ]\n",
      " [5.01315789 3.42631579 1.47105263 0.25263158]\n",
      " [6.9        3.05       5.7375     2.028125  ]] [[4.346      1.41      ]\n",
      " [1.47105263 0.25263158]\n",
      " [5.7375     2.028125  ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='petal_length', ylabel='petal_width'>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "new_x_train = x_train[[ 'petal_length', 'petal_width']]\n",
    "new_x_test = x_test[[ 'petal_length', 'petal_width']]\n",
    "new_centroids = centroids[:, 2:]\n",
    "sns.scatterplot(x=new_x_test['petal_length'], y=new_x_test['petal_width'],\n",
    "      hue=y_test, # let's use different colors for the three classes\n",
    "      palette=sns.color_palette(['green', 'darkblue','red']),\n",
    "      s=100)\n",
    "print(centroids, new_centroids)\n",
    "sns.scatterplot(x=new_centroids[:,0], y = new_centroids[:,1], palette=sns.color_palette(['yellow']), s=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: this is a very basic application: while a decent knowledge of $k$-means can typically be useful in itself, the focus here is to cements your understanding of clustering, centroid, expectation maximization, and the difference between clustering and classification. For further reading, I strongly suggest you have a look at [[this very complete tutorial]](https://towardsdatascience.com/k-means-clustering-algorithm-applications-evaluation-methods-and-drawbacks-aa03e644b48a)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 **[2pt]** Train a scikit-learn OneClassSVM on the _versicolor_ class of the Iris dataset, and print the number of missed outliers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Careful with the input: you need to train this SVM only on the subset of the train data where the species is `versicolor`. That's \"one-class\". The training should not have access to data from the other two species.\n",
    "- Also remember to drop the species column (as always) after selecting the lines with `versicolor`.\n",
    "- The test inputs should work as expected, but the test labels should be converted so that `versicolor` is `1` and the others are `-1` (because those are the model outputs for \"normal\" and \"outlier\").\n",
    "- Again, to compute the missed outliers, you cannot use `score()` or `plot_confusion_matrix()` because technically it's not a classifier. But you already made a function of the scoring code for the previous question right?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -1  1 -1  1  1  1  1 -1  1]\n",
      "96    1\n",
      "50    1\n",
      "54    1\n",
      "60    1\n",
      "66    1\n",
      "53    1\n",
      "74    1\n",
      "78    1\n",
      "77    1\n",
      "71    1\n",
      "Name: species, dtype: object\n",
      "Accuracy is 70.0%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import OneClassSVM\n",
    "#df.loc[df['species'] == 'versicolor', 'species'] = -1\n",
    "versis = df.loc[df['species'] == 'versicolor']\n",
    "versis.loc[versis['species'] == 'versicolor', 'species'] = 1\n",
    "\n",
    "v_train, v_test = train_test_split(versis, test_size=0.2)\n",
    "x_v_train = v_train[v_train.columns[:-1]]\n",
    "\n",
    "y_v_train = v_train[v_train.columns[-1]]\n",
    "x_v_test = v_test[v_test.columns[:-1]]\n",
    "y_v_test = v_test[v_test.columns[-1]]\n",
    "oneSvm = OneClassSVM(gamma='auto')\n",
    "oneSvm.fit(x_v_train)\n",
    "res = oneSvm.predict(x_v_test)\n",
    "print(res)\n",
    "#print(oneSvm.predict(x_v_test))\n",
    "print(y_v_test)\n",
    "miss = my_misclass_fn(np.array(y_v_test),res )\n",
    "#df.loc[df['species'] == 'versicolor', 'species'] = -1\n",
    "accuracy = round( ((len(y_v_test)-miss)/len(y_v_test))*100, 2)\n",
    "print(\"Accuracy is \" + str(accuracy) + \"%\")\n",
    "#converted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Compression and encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are too many topics to cover for this lab. Having to choose one to cut off from practice, I had to objectively decide to remove my favorite one: compression and encoding. The reason is that in most jobs experience in the others will be more useful, while you will still see plenty of encoding techniques over the course. And the concept of dictionary building is related to $k$-means and feature extraction anyway.\n",
    "\n",
    "On the other hand, understanding dictionaries as features, and encodings as mappings, allows for a much deeper competence and broader flexibility in the field than being stuck to only the \"big guns\" of Deep Learning for this task.\n",
    "\n",
    "So my gift to you is one of my favorite papers so far: \"The Importance of Encoding Versus Training with Sparse Coding and Vector Quantization\", from A. Coates and A. Ng [[link]](http://ai.stanford.edu/~acoates/papers/coatesng_icml_2011.pdf).\n",
    "\n",
    "If you want to learn the state of the art, in any scientific field, you need to learn to read papers. A good suggestion not to be overwhelmed, especially at the beginning while building knowledge and glossary, is to read it this way\n",
    "\n",
    "- First the abstract\n",
    "- Then think about it and read the abstract again\n",
    "- Now read the introduction, but don't fret about terms you don't understand, it's normal\n",
    "- Next read the conclusion, and make sure their claims make sense with what you read so far\n",
    "- The \"discussion\" explains how they interpreted their results and built the conclusion, which could be invaluable to understand their claims\n",
    "- If you want more detail on the \"how\", check out the \"method\" section (here called \"learning framework\")\n",
    "- The \"related work\" (sometimes \"literature review\") gives you pointers to extend your study on the field and applications\n",
    "- Do not overlook \"experimental results\", as it will give you the means to reproduce their results. And yes, chances are your thesis (especially if Master) will begin by asking you to reproduce a paper's result. Repeatability and verification (the hypothesis needs to be falsifiable) are at the very core of the scientific process.\n",
    "\n",
    "So: go at least through abstract, introduction and conclusions, and then answer the following question:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 **[4pt]** In the conclusion of the paper \"The Importance of Encoding Versus Training with Sparse Coding and Vector Quantization\", which part do the authors find more effective, the encoding (i.e. decision-making) or the dictionary training (i.e. feature extraction)? Reflect on the consequences on modeling, and express your opinion on Feature Extraction and Decision Mappings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution will contain no \"right\" answer, just **my** answer. It actually constitutes one the foundations of my research. Full points will be awarded to anyone (i) asserting their opinion, and (ii) justifying it with findings from the paper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As per me, the authors results suggest that encoding gives competetive, if not better, results than sparse coding with vector quantization. The choice of dictionary doesnt matter, as long as there is even a simple encoding.  They are basically suggesting that encoding in general makes performance better, on top of that sparse codding is efficient also because of  non-linear encoding scheme.\n",
    "I think so because, thats what the stated in the  section.\n",
    "```javascript\n",
    "We discover two surprising results:\n",
    "1. When using sparse coding as the encoder, virtually any training algorithm can be used to create\n",
    "a suitable dictionary. We can use VQ, or even\n",
    "randomly chosen exemplars to achieve very high\n",
    "performance.\n",
    "2. Regardless of the choice of dictionary, a very simple encoder (a soft thresholding function) can often be competitive with sparse coding.\n",
    "```\n",
    "Reflection on modelling:\n",
    "If we encode the data , that is we perform some manipulation on the data, we get much better results, \n",
    "Mapping allows for projection of data.  Once we have a encoder, we can use that to extract features, which will give good performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 4. Matrix decomposition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1 **[1pt]** For this data imputation exercise, use the entire Iris dataset (no split in train/test, but do drop `species`). Select the value in row index 110 column index 1, and store it in an outside variable. Then delete it from the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To delete a value from a dataset, simply assign the `not a number` value `np.nan` to the corresponding element.\n",
    "- Have you tried using `drop()` to remove a column? Remember that the default axis is the rows, so you need to pass `axis=1` or `axis='columns'` to drop a column by name.\n",
    "- You can print a few rows around your target to verify everything is going as you expect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sepal_length    6.5\n",
      "sepal_width     NaN\n",
      "petal_length    5.1\n",
      "petal_width     2.0\n",
      "Name: 110, dtype: float64\n",
      "3.6\n",
      "2.7\n"
     ]
    }
   ],
   "source": [
    "matrix = df[df.columns[:-1]]\n",
    "temp = matrix.iloc[110][1] \n",
    "matrix.iloc[110][1]  = np.nan\n",
    "print(matrix.iloc[110])\n",
    "print(matrix.iloc[109][1])\n",
    "print(matrix.iloc[111][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2 **[4pt]** Reconstruct (impute) the missing value using SVD and dimensionality reduction-based denoising. Do not use scikit-learn. Use the SVD method from `np.linalg`. Print the (absolute) difference between the original and reconstructed values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ok, relax, this is not your first complex question. As usual, deconstruct the process in smaller, achievable goals, then work through them step by step.\n",
    "- The first thing you need to do is to get rid of is the \"hole\" in the data, because SVD will not work with `nan` values. Simply patch it with an average of the values above and below in the same feature. We know this is not ideal, but no worries. BTW congratulations with this you just learned the foundation of the **$k$-nearest-neighbors algorithm (KNN)**.\n",
    "- Now decompose the entire dataframe('s data matrix) using the SVD implementation in numpy's `linalg` module. Read carefully the documentation: it does not return `u`, $\\Sigma$ and `v` as expected from the lecture! Instead you get `v` as expected $n \\times n$; `s` a vector of size $n$ containing the $\\sigma$ eigenvalues (the diagonal of $\\Sigma$, remember?); and `vh` $m \\times m$ is the transposition of `v` -- saves a transpose, but remember you will need to zero a _row_ not a _column_.\n",
    "- Next you want to drop the least contributing eigenvector. Find the smallest non-zero eigenvalue, and set to zero the corresponding column in `u` and row in `vh`. The relative size also tells you how much precision will you be losing with this reduction.\n",
    "- Now you can already reconstruct the data. Remember the order of the dot products matters. Also, you need to build your $\\Sigma$. There's an example in the documentation of SVD. Importantly: $\\Sigma$ is rectangular, the eigenvalues go in the diagonal of the first \"square\" of this matrix, the rest is zeros. You can set a range of rows and columns of a numpy rectangular matrix to (the values of) a diagonal matrix created with `np.diag()`, just match the sizes.\n",
    "- Fetch the value in the target element's position in the reconstruction matrix. Has it changed w.r.t. its initial estimate? Print the difference with the original and technically you're done.\n",
    "- If you are unsatisfied with the result though, you can run the cycle a few times. Place the code written so far in a function, so you can iterate multiple calls. Remember that you need to insert the new value in the _original matrix_ , and then loop all your calls to the denoising function on this matrix. Looping on the reconstruction is a common error which may cost you a lot! With every denoising you are losing a bit of information; copying only the value you are denoising reintegrates the information in the rest of the matrix, allowing for a much more accurate result.\n",
    "- I converge (i.e. no more significant changes) to within 0.07 of the correct value in 50 iterations. I also simply save the errors (abs diff) at every iteration, then do the usual `lineplot`. Nothing new, but these sanity checks are priceless when working with ML.\n",
    "- Alternatively: what happens if you drop two columns instead of one?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1500000000000004\n",
      "4\n",
      "3\n",
      "0.0063153606659280825\n",
      "Value is 3.193684639334072\n"
     ]
    }
   ],
   "source": [
    "# making it the mean\n",
    "#print(matrix)\n",
    "matrix.iloc[110][1] = (matrix.iloc[111][1] + matrix.iloc[109][1])  /2\n",
    "print(matrix.iloc[110][1])\n",
    "u, sigmas,v= np.linalg.svd(matrix)\n",
    "print(v.shape[0])\n",
    "#print(type(sigmas))\n",
    "minIndex = np.where(sigmas == np.amin(sigmas))[0][0]\n",
    "print(minIndex)\n",
    "u[minIndex] = 0\n",
    "v[minIndex] = 0\n",
    "sigmaMat = np.zeros((u.shape[0], v.shape[0]))\n",
    "sigmaMat[:v.shape[0], :v.shape[0]] = np.diag(sigmas)\n",
    "resultMatrix  = np.dot(u, np.dot(sigmaMat, v))\n",
    "#print(v)\n",
    "difference = abs(temp - resultMatrix[110][1])\n",
    "print(difference)\n",
    "print('Value is ' + str(resultMatrix[110][1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3 **[3pt]** Plot the entire Iris dataset (no split, keep the classes) projected into 2 dimensions using PCA. Use scikit-learn to compute the principal components."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Yes, you need to reproduce the same picture as in the slides :)\n",
    "- You need a fresh copy of the Iris dataset, then `sklearn` requires the labels to be numeric. Do you remember the `astype('category').cat.codes` trick?\n",
    "- Check the documentation of PCA. You need to set the `n_components` parameter.\n",
    "- Projecting data on the principal components is much, much easier by using the `transform()` function.\n",
    "- For a neat one-line plot with Seaborn, convert the projected data back to a DataFrame and name the columns! Then add back the `species` column so you can use `hue` ;) and use a nice palette!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.36138659 -0.08452251  0.85667061  0.3582892 ]\n",
      " [ 0.65658877  0.73016143 -0.17337266 -0.07548102]]\n",
      "<class 'list'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca_df = sns.load_dataset('iris')\n",
    "pca_df.loc[pca_df['species'] == 'setosa', 'species'] = 1\n",
    "pca_df.loc[pca_df['species'] == 'versicolor', 'species'] = 2\n",
    "pca_df.loc[pca_df['species'] == 'virginica', 'species'] = 3\n",
    "#pca_df['species'] = pd.to_numeric(pca_df['species'])\n",
    "\n",
    "pca_x = pca_df.iloc[:,:-1]\n",
    "#print(pca_x)\n",
    "pca = PCA(n_components=2).fit(pca_x)\n",
    "components = pca.components_\n",
    "print(components)\n",
    "def helper(point, components):\n",
    "    #print(point)\n",
    "    #print(components)\n",
    "    x = np.dot(point, components[0])\n",
    "    y = np.dot(point, components[1])\n",
    "    return [x, y]\n",
    "pca_res = pca_x.apply(lambda x : helper(x, components), axis = 1).to_frame().iloc[:,0].tolist()\n",
    "print(type(pca_res))\n",
    "species = sns.load_dataset('iris')\n",
    "labels = species.iloc[:,-1].tolist()\n",
    "#print(labels)\n",
    "x,y = [], []\n",
    "for val in pca_res:\n",
    "    x.append(val[0])\n",
    "    y.append(val[1])\n",
    "\n",
    "sns.scatterplot(x=x, y=y, hue=labels,\n",
    "               palette=sns.color_palette(['blue', 'orange', 'green']),s=90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.4 **[2pt]** Explain (in English) the relationship between (classic) recommender systems and denoising. Then go one step further: to understand the current state of the art (not covered in the lecture), explain a recommender system in term of _mapping_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Modern recommender systems rarely use matrix decomposition approaches. Better results have been obtained modeling the mapping directly with flexible, generic function approximators with high generalization capabilities such as neural networks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classic reccomendation systems create a matrix. users on rows and areas of interest ( for eg, movies, tv shows, products etc) on columns. The entire data is one matrix and treated as a single entity. It accounds for noise. Denoising, ignores the lowest contributing eigenvectors and reconstructs the data. \n",
    "\n",
    "Part 2:\n",
    "I read this paper, https://link.springer.com/article/10.1007/s40747-020-00200-0 and I found that data can be mapped in several ways to ensure we get correct centroids. Which use different Meta-heuristic methods to find centroids like cuckoo search method https://en.wikipedia.org/wiki/Cuckoo_search#:~:text=Cuckoo%20search%20(CS)%20uses%20the,each%20nest%20has%20one%20egg. \n",
    "or map map reduce https://en.wikipedia.org/wiki/MapReduce.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# At the end of the exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bonus question with no points! Answering this will have no influence on your scoring, not at the assignment and not towards the exam score -- really feel free to ignore it with no consequence. But solving it will reward you with skills that will make the next lectures easier, give you real applications, and will be good practice towards the exam.\n",
    "\n",
    "The solution for this questions will not be included in the regular lab solutions pdf, but you are welcome to open a discussion on the Moodle: we will support your addressing it, and you may meet other students that choose to solve this, and find a teammate for the next assignment that is willing to do things for fun and not only for score :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BONUS **[ZERO pt]** Clustering is the core of UL. Master $k$-means with this [[tutorial]](https://towardsdatascience.com/k-means-clustering-algorithm-applications-evaluation-methods-and-drawbacks-aa03e644b48a)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BONUS **[ZERO pt]** Curious about implementing SVD in Python? It's not hard, here's a good tutorial: [[link]](https://machinelearningmastery.com/singular-value-decomposition-for-machine-learning/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BONUS **[ZERO pt]** Over the years, I found that whipping out a quick PCA often makes visual analysis of complex data much clearer and with minimal investment. Follow [this tutorial](http://bebi103.caltech.edu.s3-website-us-east-1.amazonaws.com/2015/tutorials/r5_pca.html) to get some experience at it. Challenge: no copy+paste allowed, type everything: muscle memory is much more effective at retaining experience than passive study. Particularly useful is the discussion at the end: learn that Dimensionality Reduction _hides_ information!! It is extremely dangerous to found your decisions on a PCA plot on a subset of axis (e.g. 2), people have lost entire careers on that! As always, each tools has its own utility and drawbacks, and you need to learn the consequences BEFORE you blindly call a library someone else wrote and bet your whole career on its output. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BONUS **[ZERO pt]** Dictionary-based learning has tons of applications. This scikit-learn page contains a good explanation, reference to a library algorithm, an example, and even a link to the paper which published the algorithm [[link]](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.DictionaryLearning.html). I definitely suggest you have a good look at it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BONUS **[ZERO pt]** Once you have a dictionary, you can learn about Sparse Coding here: [[link]](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.SparseCoder.html). If you want to see a cool application, Google for \"super resolution\": although some recent results use Neural Networks, early Sparse Coding results were used to detect congenital heart problems in newborns, where their hearts are too small for defects to be visible on normal MRI scans. *Enhance! (cit.)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final considerations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Supervised Learning implies the presence of a _supervisor_ in the data preparation, an expert *oracle* that provides the *correct* labels. This is typically either a human (which means limited data, human errors, time constraints, etc.), or (lately more common) another algorithm that is trusted to be exact (but have you ever heard of bug-free code?). In Deep Reinforcement Learning we will see that the reward function is learned through SL; in Self-Supervised Learning and in Embeddings applications it is typically an Unsupervised Learning algorithm to provide the oracle.\n",
    "- All applications of UL stem from two concepts:\n",
    "    - **Similarity**: similar things are put together, different things are separated.\n",
    "    - **Information**: data contains redundancy and noise which can be mitigated by studying/extracting global patterns and references. What interests us is the underlying *information*, the true behavior of the underlying generating function.\n",
    "- Unsupervised Learning is almost always present one way or another in complex applications, yet rarely recognized or credited for what it is -- it's always called something like \"embedding\", \"pre-processing\", \"cleaning\", \"aggregation\" etc. Plain \"UL\" is so old school that nobody wants to say they are doing it, basing their whole fancy Deep Learning models on its output. Learn to recognize when UL is applied, and the competence you gained today will find more applications than you imagine."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}