{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [], "collapsed_sections": [], "authorship_tag": "ABX9TyPerCc9BOHuu325tr+FyFx3", "include_colab_link": true }, "kernelspec": { "name": "python3", "display_name": "Python 3" } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "S9l0lyqLvkW7" }, "source": [ "# Tutorial 1\n", "\n", "**Linear Algebra IV: Matrix Decomposition & Dimensionality Reduction**\n", "\n", "**[insert your name]**\n", "\n", "**Important reminders**: Before starting, click \"File -> Save a copy in Drive\". Produce a pdf for submission by \"File -> Print\" and then choose \"Save to PDF\".\n", "\n", "To complete this tutorial, you should have watched Videos 4.1, 4.2, 4.3, and 4.4.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "l7on9Hsec0Y9" }, "source": [ "**Credits**: Video 4.3 is the Week 1 Day 5 Intro Video from NMA (Neuromatch Academy) (https://github.com/NeuromatchAcademy/course-content). Exercise 2/3 in this tutorial are modified from content in NMA W1D5 tutorials.\n", "\n", "We are again using code for visualizing linear transformations from https://openedx.seas.gwu.edu/courses/course-v1:GW+EngComp4+2019/about. In particular, we are using their `plot_linear_transformation` and `plot_linear_transformations` functions.\n", "\n", "The interactive demo in Exercise 2A is based on matlab code from: https://stats.stackexchange.com/questions/2691/making-sense-of-principal-component-analysis-eigenvectors-eigenvalues" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Imports\n" ] }, { "cell_type": "code", "metadata": { "id": "cv9HSBNPyLV9", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Imports\n", "\n", "# Imports\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import ipywidgets as widgets # interactive display\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Plotting functions\n" ] }, { "cell_type": "code", "metadata": { "id": "ZIdPVYl9TzmK", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Plotting functions\n", "import numpy\n", "from numpy.linalg import inv, eig\n", "from math import ceil\n", "from matplotlib import pyplot, ticker, get_backend, rc\n", "from mpl_toolkits.mplot3d import Axes3D\n", "from itertools import cycle\n", "\n", "\n", "%config InlineBackend.figure_format = 'retina'\n", "plt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle\")\n", "\n", "classic = 'k'\n", "\n", "_int_backends = ['GTK3Agg', 'GTK3Cairo', 'MacOSX', 'nbAgg',\n", " 'Qt4Agg', 'Qt4Cairo', 'Qt5Agg', 'Qt5Cairo',\n", " 'TkAgg', 'TkCairo', 'WebAgg', 'WX', 'WXAgg', 'WXCairo']\n", "_backend = get_backend() # get current backend name\n", "\n", "# shrink figsize and fontsize when using %matplotlib notebook\n", "if _backend in _int_backends:\n", " fontsize = 4\n", " fig_scale = 0.75\n", "else:\n", " fontsize = 5\n", " fig_scale = 1\n", "\n", "grey = '#808080'\n", "gold = '#cab18c' # x-axis grid\n", "lightblue = '#0096d6' # y-axis grid\n", "green = '#008367' # x-axis basis vector\n", "red = '#E31937' # y-axis basis vector\n", "darkblue = '#004065'\n", "\n", "pink, yellow, orange, purple, brown = '#ef7b9d', '#fbd349', '#ffa500', '#a35cff', '#731d1d'\n", "\n", "quiver_params = {'angles': 'xy',\n", " 'scale_units': 'xy',\n", " 'scale': 1,\n", " 'width': 0.012}\n", "\n", "grid_params = {'linewidth': 0.5,\n", " 'alpha': 0.8}\n", "def plot_sample_images(X):\n", " \"\"\"\n", " Plots 9 images from the data.\n", "\n", " Args:\n", " X (numpy array of floats) : Data matrix each column corresponds to a\n", " different random variable\n", "\n", " Returns:\n", " Nothing.\n", "\n", " \"\"\"\n", " im_size = int(np.sqrt(X.shape[1]))\n", " fig, ax = plt.subplots()\n", " k = 0\n", " for k1 in range(3):\n", " for k2 in range(3):\n", " k = k + 1\n", " plt.imshow(np.reshape(X[k, :], (im_size, im_size)),\n", " extent=[(k1 + 1) * im_size, k1 * im_size, (k2+1) * im_size, k2 * im_size],\n", " vmin=0, vmax=255, cmap='gray')\n", " plt.xlim((3 * im_size, 0))\n", " plt.ylim((3 * im_size, 0))\n", " plt.tick_params(axis='both', which='both', bottom=False, top=False,\n", " labelbottom=False)\n", " plt.clim([0, 250])\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", " plt.show()\n", "\n", "\n", "def plot_variance_explained(variance_explained):\n", " \"\"\"\n", " Plots eigenvalues.\n", "\n", " Args:\n", " variance_explained (numpy array of floats) : Vector of variance explained\n", " for each PC\n", "\n", " Returns:\n", " Nothing.\n", "\n", " \"\"\"\n", "\n", " plt.figure()\n", " plt.plot(np.arange(1, len(variance_explained) + 1), variance_explained,\n", " '--k')\n", " plt.xlabel('Number of components')\n", " plt.ylabel('Variance explained')\n", " plt.show()\n", "\n", "def plot_reconstructions(X, X_reconstructed):\n", " \"\"\"\n", " Plots 9 images in the dataset side-by-side with the reconstructed\n", " images.\n", "\n", " Args:\n", " X (numpy array of floats) : Data matrix each column\n", " corresponds to a different\n", " random variable\n", " X_reconstructed (numpy array of floats) : Data matrix each column\n", " corresponds to a different\n", " random variable\n", "\n", " Returns:\n", " Nothing.\n", " \"\"\"\n", "\n", " im_size = int(np.sqrt(X.shape[1]))\n", "\n", " plt.figure()\n", " ax = plt.subplot(121)\n", " k = 0\n", " for k1 in range(3):\n", " for k2 in range(3):\n", " k = k + 1\n", " plt.imshow(np.reshape(X[k, :], (im_size, im_size)),\n", " extent=[(k1 + 1) * im_size, k1 * im_size, (k2 + 1) * im_size, k2 * im_size],\n", " vmin=0, vmax=255, cmap='gray')\n", " plt.xlim((3 * im_size, 0))\n", " plt.ylim((3 * im_size, 0))\n", " plt.tick_params(axis='both', which='both', bottom=False, top=False,\n", " labelbottom=False)\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", " plt.title('Data')\n", " plt.clim([0, 250])\n", " ax = plt.subplot(122)\n", " k = 0\n", " for k1 in range(3):\n", " for k2 in range(3):\n", " k = k + 1\n", " plt.imshow(np.reshape(np.real(X_reconstructed[k, :]), (im_size, im_size)),\n", " extent=[(k1 + 1) * im_size, k1 * im_size, (k2 + 1) * im_size, k2 * im_size],\n", " vmin=0, vmax=255, cmap='gray')\n", " plt.xlim((3 * im_size, 0))\n", " plt.ylim((3 * im_size, 0))\n", " plt.tick_params(axis='both', which='both', bottom=False, top=False,\n", " labelbottom=False)\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", " plt.clim([0, 250])\n", " plt.title('Reconstructed')\n", " plt.tight_layout()\n", "\n", "def plot_principal_components(weights):\n", " \"\"\"\n", " Visualize PCA basis vector weights. Red = positive weights,\n", " blue = negative weights, white = zero weight.\n", "\n", " Args:\n", " weights (numpy array of floats) : PCA basis vector\n", "\n", " Returns:\n", " Nothing.\n", " \"\"\"\n", " im_size = int(np.sqrt(X.shape[1]))\n", "\n", " fig, ax = plt.subplots()\n", " cmap = plt.cm.get_cmap('seismic')\n", " plt.imshow(np.real(np.reshape(weights, (im_size, im_size))), cmap=cmap)\n", " plt.tick_params(axis='both', which='both', bottom=False, top=False,\n", " labelbottom=False)\n", " plt.clim(-.15, .15)\n", " plt.colorbar(ticks=[-.15, -.1, -.05, 0, .05, .1, .15])\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", " plt.show()\n", "\n", "\n", "def plot_pca_transformation(data, transformed_data):\n", "\n", "\n", " fig, axes = plt.subplots(1, 2)\n", " axes[0].scatter(data[:,0], data[:, 1], s=1, c='#63BA79');\n", " for j in range(2):\n", " axes[j].spines['right'].set_visible(False)\n", " axes[j].spines['top'].set_visible(False)\n", "\n", " orig_correlation = round(np.corrcoef(data[:, 0], data[:, 1])[0, 1], 2)\n", " axes[0].set(title='Data in original coordinates \\n Correlation = ' + str(orig_correlation), xlabel='Neuron 1 activity', ylabel='Neuron 2 activity', xlim=[-5, 15], ylim=[-5, 15]);\n", "\n", " axes[1].scatter(transformed_data[:,0], transformed_data[:, 1], s=1, c='#63BA79');\n", " pca_correlation = round(np.corrcoef(transformed_data[:, 0], transformed_data[:, 1])[0, 1], 2)\n", " axes[1].set(title='Data in PC coordinates \\n Correlation = ' + str(pca_correlation), xlabel='PC 1', ylabel='PC 2');\n", "\n", " plt.tight_layout()\n", "\n", "def plot_data_and_PCs(X, W):\n", " \"\"\"\n", " Plots bivariate data as well as new basis vectors.\n", "\n", " Args:\n", " X (numpy array of floats) : Data matrix each column corresponds to a\n", " different random variable\n", " W (numpy array of floats) : Square matrix representing new orthonormal\n", " basis each column represents a basis vector\n", "\n", " Returns:\n", " Nothing.\n", " \"\"\"\n", "\n", " plt.figure()\n", " plt.scatter(X[:, 0], X[:, 1], s=1, color='#63BA79')\n", " plt.axis('equal')\n", " plt.xlabel('Neuron 1 activity')\n", " plt.ylabel('Neuron 2 activity')\n", " colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", " plt.plot([0, W[0, 0]], [0, W[1, 0]], color=colors[4], linewidth=1,\n", " label='Component 1')\n", " plt.plot([0, W[0, 1]], [0, W[1, 1]], color=colors[3], linewidth=1,\n", " label='Component 2')\n", " plt.legend()\n", " plt.show()\n", "\n", "\n", "def plot_vector(vectors, tails=None):\n", " ''' Draw 2d vectors based on the values of the vectors and the position of their tails.\n", " \n", " Parameters\n", " ----------\n", " vectors : list.\n", " List of 2-element array-like structures, each represents a 2d vector.\n", " \n", " tails : list, optional.\n", " List of 2-element array-like structures, each represents the coordinates of the tail\n", " of the corresponding vector in vectors. If None (default), all tails are set at the\n", " origin (0,0). If len(tails) is 1, all tails are set at the same position. Otherwise,\n", " vectors and tails must have the same length.\n", " \n", " Examples\n", " --------\n", " >>> v = [(1, 3), (3, 3), (4, 6)]\n", " >>> plot_vector(v) # draw 3 vectors with their tails at origin\n", " >>> t = [numpy.array((2, 2))]\n", " >>> plot_vector(v, t) # draw 3 vectors with their tails at (2,2)\n", " >>> t = [[3, 2], [-1, -2], [3, 5]]\n", " >>> plot_vector(v, t) # draw 3 vectors with 3 different tails\n", "\n", " ''' \n", " vectors = numpy.array(vectors)\n", " assert vectors.shape[1] == 2, \"Each vector should have 2 elements.\" \n", " if tails is not None:\n", " tails = numpy.array(tails)\n", " assert tails.shape[1] == 2, \"Each tail should have 2 elements.\"\n", " else:\n", " tails = numpy.zeros_like(vectors)\n", " \n", " # tile vectors or tails array if needed\n", " nvectors = vectors.shape[0]\n", " ntails = tails.shape[0]\n", " if nvectors == 1 and ntails > 1:\n", " vectors = numpy.tile(vectors, (ntails, 1))\n", " elif ntails == 1 and nvectors > 1:\n", " tails = numpy.tile(tails, (nvectors, 1))\n", " else:\n", " assert tails.shape == vectors.shape, \"vectors and tail must have a same shape\"\n", "\n", " # calculate xlimit & ylimit\n", " heads = tails + vectors\n", " limit = numpy.max(numpy.abs(numpy.hstack((tails, heads))))\n", " limit = numpy.ceil(limit * 1.2) # add some margins\n", " \n", " figsize = numpy.array([2,2]) * fig_scale\n", " figure, axis = pyplot.subplots(figsize=figsize)\n", " axis.quiver(tails[:,0], tails[:,1], vectors[:,0], vectors[:,1], color=darkblue, \n", " angles='xy', scale_units='xy', scale=1)\n", " axis.set_xlim([-limit, limit])\n", " axis.set_ylim([-limit, limit])\n", " axis.set_aspect('equal')\n", "\n", " # if xticks and yticks of grid do not match, choose the finer one\n", " xticks = axis.get_xticks()\n", " yticks = axis.get_yticks()\n", " dx = xticks[1] - xticks[0]\n", " dy = yticks[1] - yticks[0]\n", " base = max(int(min(dx, dy)), 1) # grid interval is always an integer\n", " loc = ticker.MultipleLocator(base=base)\n", " axis.xaxis.set_major_locator(loc)\n", " axis.yaxis.set_major_locator(loc)\n", " axis.grid(True, **grid_params)\n", " \n", " # show x-y axis in the center, hide frames\n", " axis.spines['left'].set_position('center')\n", " axis.spines['bottom'].set_position('center')\n", " axis.spines['right'].set_color('none')\n", " axis.spines['top'].set_color('none')\n", "\n", "def plot_transformation_helper(axis, matrix, *vectors, unit_vector=True, unit_circle=False, title=None):\n", " \"\"\" A helper function to plot the linear transformation defined by a 2x2 matrix.\n", " \n", " Parameters\n", " ----------\n", " axis : class matplotlib.axes.Axes.\n", " The axes to plot on.\n", "\n", " matrix : class numpy.ndarray.\n", " The 2x2 matrix to visualize.\n", "\n", " *vectors : class numpy.ndarray.\n", " The vector(s) to plot along with the linear transformation. Each array denotes a vector's\n", " coordinates before the transformation and must have a shape of (2,). Accept any number of vectors. \n", " \n", " unit_vector : bool, optional.\n", " Whether to plot unit vectors of the standard basis, default to True.\n", " \n", " unit_circle: bool, optional.\n", " Whether to plot unit circle, default to False.\n", " \n", " title: str, optional.\n", " Title of the plot.\n", "\n", " \"\"\"\n", " assert matrix.shape == (2,2), \"the input matrix must have a shape of (2,2)\"\n", " grid_range = 20\n", " x = numpy.arange(-grid_range, grid_range+1)\n", " X_, Y_ = numpy.meshgrid(x,x)\n", " I = matrix[:,0]\n", " J = matrix[:,1]\n", " X = I[0]*X_ + J[0]*Y_\n", " Y = I[1]*X_ + J[1]*Y_\n", " origin = numpy.zeros(1)\n", " \n", " # draw grid lines\n", " for i in range(x.size):\n", " axis.plot(X[i,:], Y[i,:], c=gold, **grid_params)\n", " axis.plot(X[:,i], Y[:,i], c=lightblue, **grid_params)\n", " \n", " # draw (transformed) unit vectors\n", " if unit_vector:\n", " axis.quiver(origin, origin, [I[0]], [I[1]], color=green, **quiver_params)\n", " axis.quiver(origin, origin, [J[0]], [J[1]], color=red, **quiver_params)\n", "\n", " # draw optional vectors\n", " color_cycle = cycle([pink, darkblue, orange, purple, brown])\n", " if vectors:\n", " for vector in vectors:\n", " color = next(color_cycle)\n", " vector_ = matrix @ vector.reshape(-1,1)\n", " axis.quiver(origin, origin, [vector_[0]], [vector_[1]], color=color, **quiver_params)\n", "\n", " # draw optional unit circle\n", " if unit_circle:\n", " alpha = numpy.linspace(0, 2*numpy.pi, 41)\n", " circle = numpy.vstack((numpy.cos(alpha), numpy.sin(alpha)))\n", " circle_trans = matrix @ circle\n", " axis.plot(circle_trans[0], circle_trans[1], color=red, lw=0.8)\n", "\n", " # hide frames, set xlimit & ylimit, set title\n", " limit = 4\n", " axis.spines['left'].set_position('center')\n", " axis.spines['bottom'].set_position('center')\n", " axis.spines['left'].set_linewidth(0.3)\n", " axis.spines['bottom'].set_linewidth(0.3)\n", " axis.spines['right'].set_color('none')\n", " axis.spines['top'].set_color('none')\n", " axis.set_xlim([-limit, limit])\n", " axis.set_ylim([-limit, limit])\n", " if title is not None:\n", " axis.set_title(title)\n", "\n", "def plot_linear_transformation(matrix, *vectors, unit_vector=True, unit_circle=False):\n", " \"\"\" Plot the linear transformation defined by a 2x2 matrix using the helper\n", " function plot_transformation_helper(). It will create 2 subplots to visualize some\n", " vectors before and after the transformation.\n", " \n", " Parameters\n", " ----------\n", " matrix : class numpy.ndarray.\n", " The 2x2 matrix to visualize.\n", "\n", " *vectors : class numpy.ndarray.\n", " The vector(s) to plot along with the linear transformation. Each array denotes a vector's\n", " coordinates before the transformation and must have a shape of (2,). Accept any number of vectors.\n", " \n", " unit_vector : bool, optional.\n", " Whether to plot unit vectors of the standard basis, default to True.\n", " \n", " unit_circle: bool, optional.\n", " Whether to plot unit circle, default to False.\n", " \n", " \"\"\"\n", " with plt.rc_context({\"figure.dpi\": 200, 'font.family':'serif', 'axes.axisbelow':True, 'font.size':fontsize, \"axes.titlesize\":5, \"lines.linewidth\":1}):\n", " figsize = numpy.array([4,2]) * fig_scale\n", " figure, (axis1, axis2) = pyplot.subplots(1, 2, figsize=figsize)\n", " plot_transformation_helper(axis1, numpy.identity(2), *vectors, unit_vector=unit_vector, unit_circle=unit_circle, title='Before transformation')\n", " plot_transformation_helper(axis2, matrix, *vectors, unit_vector=unit_vector, unit_circle=unit_circle, title='After transformation')\n", "\n", "def plot_linear_transformations(*matrices, unit_vector=True, unit_circle=False):\n", " \"\"\" Plot the linear transformation defined by a sequence of n 2x2 matrices using the helper\n", " function plot_transformation_helper(). It will create n+1 subplots to visualize some\n", " vectors before and after each transformation.\n", "\n", " Parameters\n", " ----------\n", " *matrices : class numpy.ndarray.\n", " The 2x2 matrices to visualize. Accept any number of matrices.\n", " \n", " unit_vector : bool, optional.\n", " Whether to plot unit vectors of the standard basis, default to True.\n", " \n", " unit_circle: bool, optional.\n", " Whether to plot unit circle, default to False.\n", " \n", " \"\"\"\n", " nplots = len(matrices) + 1\n", " nx = 2\n", " ny = ceil(nplots/nx)\n", " with plt.rc_context({\"figure.dpi\": 200, 'font.family':'serif', 'axes.axisbelow':True, 'font.size':fontsize, \"axes.titlesize\":5, \"lines.linewidth\":1}):\n", " figsize = numpy.array([2*nx, 2*ny]) * fig_scale\n", " figure, axes = pyplot.subplots(nx, ny, figsize=figsize)\n", "\n", " for i in range(nplots): # fig_idx \n", " if i == 0:\n", " matrix_trans = numpy.identity(2)\n", " title = 'Before transformation'\n", " else:\n", " matrix_trans = matrices[i-1] @ matrix_trans\n", " if i == 1:\n", " title = 'After {} transformation'.format(i)\n", " else:\n", " title = 'After {} transformations'.format(i)\n", " plot_transformation_helper(axes[i//nx, i%nx], matrix_trans, unit_vector=unit_vector, unit_circle=unit_circle, title=title)\n", " # hide axes of the extra subplot (only when nplots is an odd number)\n", " if nx*ny > nplots:\n", " axes[-1,-1].axis('off')" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Helper functions\n" ] }, { "cell_type": "code", "metadata": { "id": "TQ4WLMMb4Rb_", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Helper functions\n", "def sort_evals_descending(evals, evectors):\n", " \"\"\"\n", " Sorts eigenvalues and eigenvectors in decreasing order. Also aligns first two\n", " eigenvectors to be in first two quadrants (if 2D).\n", "\n", " Args:\n", " evals (numpy array of floats) : Vector of eigenvalues\n", " evectors (numpy array of floats) : Corresponding matrix of eigenvectors\n", " each column corresponds to a different\n", " eigenvalue\n", "\n", " Returns:\n", " (numpy array of floats) : Vector of eigenvalues after sorting\n", " (numpy array of floats) : Matrix of eigenvectors after sorting\n", " \"\"\"\n", "\n", " index = np.flip(np.argsort(evals))\n", " evals = evals[index]\n", " evectors = evectors[:, index]\n", " if evals.shape[0] == 2:\n", " if np.arccos(np.matmul(evectors[:, 0],\n", " 1 / np.sqrt(2) * np.array([1, 1]))) > np.pi / 2:\n", " evectors[:, 0] = -evectors[:, 0]\n", " if np.arccos(np.matmul(evectors[:, 1],\n", " 1 / np.sqrt(2) * np.array([-1, 1]))) > np.pi / 2:\n", " evectors[:, 1] = -evectors[:, 1]\n", " return evals, evectors\n", "\n", "def calculate_cov_matrix(var_1, var_2, corr_coef):\n", " \"\"\"\n", " Calculates the covariance matrix based on the variances and\n", " correlation coefficient.\n", "\n", " Args:\n", " var_1 (scalar) : variance of the first random variable\n", " var_2 (scalar) : variance of the second random variable\n", " corr_coef (scalar) : correlation coefficient\n", "\n", " Returns:\n", " (numpy array of floats) : covariance matrix\n", " \"\"\"\n", " cov = corr_coef * np.sqrt(var_1 * var_2)\n", " cov_matrix = np.array([[var_1, cov], [cov, var_2]])\n", " return cov_matrix\n", "\n", "def get_variance_explained(evals):\n", " \"\"\"\n", " Plots eigenvalues.\n", "\n", " Args:\n", " (numpy array of floats) : Vector of eigenvalues\n", "\n", " Returns:\n", " Nothing.\n", "\n", " \"\"\"\n", "\n", " # cumulatively sum the eigenvalues\n", " csum = np.cumsum(evals)\n", " # normalize by the sum of eigenvalues\n", " variance_explained = csum / np.sum(evals)\n", "\n", " return variance_explained\n", "\n", "def add_noise(X, frac_noisy_pixels):\n", " \"\"\"\n", " Randomly corrupts a fraction of the pixels by setting them to random values.\n", "\n", " Args:\n", " X (numpy array of floats) : Data matrix\n", " frac_noisy_pixels (scalar) : Fraction of noisy pixels\n", "\n", " Returns:\n", " (numpy array of floats) : Data matrix + noise\n", "\n", " \"\"\"\n", "\n", " X_noisy = np.reshape(X, (X.shape[0] * X.shape[1]))\n", " N_noise_ixs = int(X_noisy.shape[0] * frac_noisy_pixels)\n", " noise_ixs = np.random.choice(X_noisy.shape[0], size=N_noise_ixs,\n", " replace=False)\n", " X_noisy[noise_ixs] = np.random.uniform(0, 255, noise_ixs.shape)\n", " X_noisy = np.reshape(X_noisy, (X.shape[0], X.shape[1]))\n", "\n", " return X_noisy\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "FtUJK2gYommf" }, "source": [ "# Key concept review & coding tips\n", "\n", "## Special matrices\n", "\n", "### Diagonal matrices\n", "* Have only nonzero entries on the diagonal \n", "* Can be rectangular\n", "* Scales space\n", "* Inverse is diagonal matrix with inverse entries\n", "\n", "### Orthogonal matrices\n", "* Square matrix where every column is a unit vector and every pair of columns is orthogonal\n", "* Rotates space\n", "* Its inverse is its transpose\n", "\n", "### Symmetric matrices\n", "* Square matrix where $a_{ij} = a_{ji}$\n", "* Equals its own transpose\n", "* Eigenvalues are always real (not complex)\n", "* Eigenvectors associated with different eigenvalues are orthogonal\n", "\n", "## Matrix decomposition\n", "\n", "* Factorization of a matrix into a product of matrices \n", "* Product matrices might be more compact/ordered, could make computations easier, could shed light on matrix structure\n", "\n", "### Eigendecomposition\n", "* $A = VDV^{-1}$ where V has eigenvectors as columns and D is diagonal matrix with eigenvalues on the diagonal\n", "* Can only do this if A is square and if eigenvectors of A form a basis for space\n", "* $A^n = VD^nV^{-1}$\n", "* $A^{-1} = VD^{-1}V^{-1}$\n", "\n", "### Singular value decomposition\n", "* `np.linalg.svd`\n", "* $A = USV^T$ where U/V are orthogonal matrices and S is diagonal\n", "* Can decompose any matrix this way\n", "* Diagonal entries of S are singular values, columns of U are left singular values, columns of V are right singular values\n", "* Decomposes transformation that matrix enacts into a rotation, then a scaling, then a rotation\n", "* Columns of V associated with zero or non-existant singular values form an orthogonal basis for the nullspace of A\n", "* Columns of U associated with non-zero singular values form an orthogonal basis for the column space of A\n", "* rank(A) = number of non-zero singular values\n", "* SVD factorizes A into sum of outer products with decreasing influence, can use first K sums to form rank K approximation of A\n", "\n", "## Dimensionality Reduction\n", "* Transform data from high D to low D while keeping as much information as possible about the data (finding new representation for the data)\n", "* Can help with data visualization, noise reduction, data preprocessing for further analyses, and scientific findings, among other things\n", "\n", "### Principal components analysis\n", "* `sklearn.decomposition.pca` for PCA, see info at the end of this tutorial\n", "* Find axes in space that maximize the variance of the data (and minimize the residuals) while being orthongal to each other. Project data onto these axes and keep first K components\n", "* Can think of PCA as a change of basis where the new basis vectors are the principal components\n", "* $U = XV$ where U is the transformed data (# data points x reduced dim), X is the data matrix (# data points x orig dim), and V is the components matrix (orig dim x reduced dim)\n", "* Always center your data first!\n", "* Can find principal components as the eigenvectors of the covariance matrix ($\\frac{1}{n}X^TX$), eigenvalues tell you the variance explained by that component (plot these to make a scree plot) \n", "* Could also use SVD to find PCA - the columns of V are the eigenvectors of the covariance matrix and the squared singular values over N are the eigenvalues" ] }, { "cell_type": "markdown", "metadata": { "id": "31yvHJrIX97I" }, "source": [ "# Exercise 1: Delving into SVD\n", "\n", "We'll explore SVD by hand in this problem to help solidify our understanding of how the matrices interact with each other. Let $$A = \\begin{bmatrix}\n", "2 & -4 \\\\\n", "3 & 1 \\\\\n", "\\end{bmatrix}, \\bar{v} = \\begin{bmatrix}\n", "2 \\\\\n", "1 \\\\\n", "\\end{bmatrix}$$\n", "\n", "In the following plot, we'll see the transformation that this matrix enacts.\n" ] }, { "cell_type": "code", "metadata": { "id": "9qpt1J626izD", "outputId": "f5dff7b8-6142-496e-d670-ba753634d919", "colab": { "base_uri": "https://localhost:8080/", "height": 373 } }, "source": [ "A = np.array([[2, -4], [3, 1]])\n", "plot_linear_transformation(A)" ], "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "image/png": { "width": 749, "height": 356 }, "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "qZRBWdvEdT9C" }, "source": [ "## A) Computing the SVD\n", "\n", "Use `np.linalg.svd` to get the SVD of the matrix A. Note that the outputs are not quite the U, S, V we've been discussing. This function outputs $V^T$ directly. Get S/V from the outputs.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "8ialA_16dqJM", "outputId": "1696409b-2ca8-4639-f34a-e2867eb9609c", "colab": { "base_uri": "https://localhost:8080/", "height": 205 } }, "source": [ "U, s, VT = ...\n", "S = ...\n", "V = ..." ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "TypeError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mU\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mVT\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m...\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mS\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m...\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mV\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m...\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: cannot unpack non-iterable ellipsis object" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "yDKYQdd0mFPK" }, "source": [ "## B) SVD step by step transformations\n", "\n", "Multiply out the operations of $V^T$, S, and U with vector $\\bar{v}$ one at a time. In other words, get $V^T\\bar{v}$, then $SV^T\\bar{v}$, then $USV^t\\bar{v}$. You do not need to do this by hand - use code - but make sure you understand the matrix vector multiplication! \n", "\n", "Make sure $USV^t\\bar{v}$ = $A\\bar{v}$.\n", "\n", "Execute the following cell to visualize the vectors." ] }, { "cell_type": "code", "metadata": { "id": "KmEmxqSNmoB8" }, "source": [ "v = ...\n", "VTv = ...\n", "SVTv = ...\n", "USVTv = ...\n", "Av = ...\n", "print(USVTv)\n", "print(Av)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute to visualize vector transforms\n" ] }, { "cell_type": "code", "metadata": { "id": "X7qX2EbFyCCU", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @title\n", "# @markdown Execute to visualize vector transforms\n", "vec_names = [r'$\\bar{v}$', r'$SV^T\\bar{v}$', r'$V^T\\bar{v}$', r'A$\\bar{v}$']\n", "vecs = np.array([v, \n", " SVTv,\n", " VTv,\n", " USVTv])\n", "\n", "fig, axes = plt.subplots(1, 1)\n", "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", "\n", "axes.set(xlim=[-8, 8], ylim=[-8, 8])\n", "axes.axis('Off')\n", "\n", "for i_vec, vec in enumerate(vecs): \n", " axes.arrow(0, 0, vec[0], vec[1], head_width=.2, facecolor=colors[i_vec], edgecolor=colors[i_vec], length_includes_head=True);\n", " axes.annotate(vec_names[i_vec], xy=(vec[0]+np.sign(vec[0])*.15, vec[1]+np.sign(vec[1])*.15), color=colors[i_vec]);\n", "\n", "axes.plot([0, 0], [-8, 8], classic, alpha=.4);\n", "axes.plot([-8, 8], [0, 0], classic, alpha=.4);\n", "\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "zlhGZPgryRQ6" }, "source": [ "What transformation is happening to $\\bar{v}$ at each step?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "W9bd8B87ySbP" }, "source": [ "**Your text answer**" ] }, { "cell_type": "markdown", "metadata": { "id": "wCxubbvrOiL9" }, "source": [ "## (Optional) C) Low rank approximation \n", "\n", "We'll explore successful low rank approximations of receptive fields in Tutorial 2 and this will make the concept much more intuitive - the goal of this problem is just to understand the computation involved and what a rank 1 approximation means.\n", "\n", "Calculate a rank 1 approximation of A by hand. Specifically, compute:\n", "\n", "$$\\text{Rank 1 approx } = B = s_1\\bar{u}_1\\bar{v}_1^T $$\n", "\n", "where $s_1$ is the first (highest) singular value and $\\bar{u}_1$ and $\\bar{v}_1$ are the corresponding columns of U and V. \n", "\n", "Show your work for the computation! You should round to 2 places after the decimal." ] }, { "cell_type": "markdown", "metadata": { "id": "GSm4PsBtRs9a" }, "source": [ "**Your math answer** show your work!" ] }, { "cell_type": "markdown", "metadata": { "id": "dU3Cn7orR--b" }, "source": [ "Compare B to the original matrix A. What does a rank 1 approximation mean? What is the computation \"trying to do\"? What is happening with the columns/rows of B? " ] }, { "cell_type": "markdown", "metadata": { "id": "_IUl6mHYSGQK" }, "source": [ "**Your text answer here**" ] }, { "cell_type": "markdown", "metadata": { "id": "xVJdlGKwSIXy" }, "source": [ "Note that the rank 1 approximation here is not great because our matrix is not anywhere close to rank 1! We would fully recover our matrix with a rank 2 approximation - $ A = s_1\\bar{u}_1\\bar{v}_1^T + s_2\\bar{u}_2\\bar{v}_2^T$ - since A is 2 x 2 and has maximum rank of 2.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "9XOGsCNtyahv" }, "source": [ "## (Optional) Extra info: Orthogonal matrices can also reflect\n", "\n", "Execute the next cell to visualize the transformation at each step of SVD (by $V^T$, then $S$, then $U$). You will notice that it isn't simply rotation, then scaling, then a rotation. Both $V^T$ and $U$ enact a reflection in addition to a rotation. Orthogonal matrices can reflect in addition to rotating space. \n", "\n", "We could get an SVD without reflection if we hadn't ordered our columns by the size of the singular values. If we switched the columns in U, S, and V, we would see just a rotation, then scaling, then another rotation (show below)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute this cell to visualize transformations\n" ] }, { "cell_type": "code", "metadata": { "id": "SVfwxAKppUK7", "cellView": "form", "outputId": "024200f0-680d-4c34-80f5-7c7f191269aa", "colab": { "base_uri": "https://localhost:8080/", "height": 205 }, "tags": [ "hide-input" ] }, "source": [ "# @markdown Execute this cell to visualize transformations\n", "\n", "plot_linear_transformations(VT, S, U, unit_vector=True, unit_circle=False)\n" ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "NameError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# @markdown Execute this cell to visualize transformations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplot_linear_transformations\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mVT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mU\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munit_vector\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munit_circle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'VT' is not defined" ] } ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute this cell to visualize transformations with permuted columns\n" ] }, { "cell_type": "code", "metadata": { "id": "P97m4A8ht2Cs", "cellView": "form", "outputId": "3800edc4-57c0-4a6c-dd63-f487fc771621", "colab": { "base_uri": "https://localhost:8080/", "height": 205 }, "tags": [ "hide-input" ] }, "source": [ "# @markdown Execute this cell to visualize transformations with permuted columns\n", "\n", "plot_linear_transformations(V[:, [1, 0]].T, np.diag(s[::-1]), U[:, [1, 0]], unit_vector=True, unit_circle=False)\n" ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "NameError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# @markdown Execute this cell to visualize transformations with permuted columns\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplot_linear_transformations\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mV\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mU\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munit_vector\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munit_circle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'V' is not defined" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "bfgPXNMizbkN" }, "source": [ "# Exercise 2: PCA implementation and correlation exploration\n", "\n", "### Modified from NMA W1D5 T2\n", "\n", "In this exercise, you will implement PCA, apply it to 2 dimensional data, and examine the effects of correlations between dimensions." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute this cell to generate some data (X)\n" ] }, { "cell_type": "code", "metadata": { "id": "8BQ3zOJeEBHR", "cellView": "form", "outputId": "23989b07-8d98-4459-de9e-f596f0bddbd9", "colab": { "base_uri": "https://localhost:8080/", "height": 430 }, "tags": [ "hide-input" ] }, "source": [ "# @markdown Execute this cell to generate some data (X)\n", "np.random.seed(123)\n", "variance_1 = 1\n", "variance_2 = 1\n", "corr_coef = 0.8\n", "cov_matrix = calculate_cov_matrix(variance_1, variance_2, corr_coef)\n", "X = np.random.multivariate_normal([5, 10], cov_matrix, size=1000)\n", "\n", "fig, ax = plt.subplots()\n", "ax.scatter(X[:,0], X[:, 1], s=1, color='#63BA79');\n", "ax.spines['right'].set_visible(False)\n", "ax.spines['top'].set_visible(False)\n", "\n", "ax.set(xlabel='Neuron 1 activity', ylabel='Neuron 2 activity', xlim=[-5, 15], ylim=[-5, 15]);" ], "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "image/png": { "width": 557, "height": 413 }, "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "0lbntNzCONT7" }, "source": [ "## A) Interactive Demo: Identifying first principal component\n", "\n", "Let's take a subset of our data as shown below and mean subtract it. Play with the interactive demo. About which value of theta represents the first principal component? Why?\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Make sure you execute this cell to enable the widget!\n" ] }, { "cell_type": "code", "metadata": { "id": "kx5hhzZHU18K", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Make sure you execute this cell to enable the widget!\n", "\n", "def plot_potential_component(theta=180):\n", " n_points = 30\n", "\n", " mean_subtracted_X = X - np.mean(X, 0)\n", "\n", " fig, ax = plt.subplots()\n", " ax.spines['right'].set_visible(False)\n", " ax.spines['top'].set_visible(False)\n", "\n", " ax.set(xlabel='Neuron 1 activity', ylabel='Neuron 2 activity', xlim=[-5, 5], ylim=[-5, 5]);\n", "\n", " w = np.asarray([np.cos(theta*np.pi/180), np.sin(theta*np.pi/180)])[None, :];\n", " z = mean_subtracted_X[:n_points, :] @ w.T @ w;\n", " for i in range(n_points):\n", " ax.plot([mean_subtracted_X[i,0], z[i,0]], [mean_subtracted_X[i,1], z[i,1]], 'r')\n", "\n", " ax.plot(w[0, 0]*5*np.array([-1, 1]), w[0, 1]*5*np.array([-1, 1]), 'k')\n", " ax.scatter(z[:,0], z[:, 1], color='r')\n", " ax.scatter(mean_subtracted_X[:n_points,0], mean_subtracted_X[:n_points, 1], color='#63BA79');\n", "\n", "\n", "_ = widgets.interact(plot_potential_component, theta = (0, 180, 1), fontsize=60)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "Gr3lYuXhU0hM" }, "source": [ "**Your text answer**" ] }, { "cell_type": "markdown", "metadata": { "id": "AbG3UzoAz8PG" }, "source": [ "## B) Implement PCA \n", "\n", "Let's first implement PCA! We will build a function that takes in data and returns the transformed data, the principal components, and the variance explained by each component.\n", "\n", "We will use an implementation involving the eigenvectors/eigenvalues of the covariance matrix (as opposed to using SVD).\n" ] }, { "cell_type": "code", "metadata": { "id": "f7CDch1fvIqY" }, "source": [ "def pca(X):\n", " \"\"\"\n", " Sorts eigenvalues and eigenvectors in decreasing order.\n", "\n", " Args:\n", " X (numpy array of floats): Data matrix each column corresponds to a\n", " different random variable \n", "\n", " Returns:\n", " (numpy array of floats) : Data projected onto the new basis\n", " (numpy array of floats) : Vector of eigenvalues\n", " (numpy array of floats) : Corresponding matrix of eigenvectors\n", "\n", " \"\"\"\n", "\n", " # Subtract the mean of X\n", " X = ...\n", "\n", " # Calculate the sample covariance matrix\n", " cov_matrix = ... # hint: covariance matrix = (1/n)X^TX\n", "\n", " # Calculate the eigenvalues and eigenvectors\n", " evals, evectors = ... # hint: use np.linalg.eig\n", "\n", " # Sort the eigenvalues in descending order using a helper function\n", " evals, evectors = sort_evals_descending(evals, evectors)\n", "\n", " # Project the data onto the new eigenvector basis\n", " transformed_data = ... # hint: remember U = XV\n", " \n", " return transformed_data, evectors, evals\n", "\n", "# Uncomment below once you have filled in the above function\n", "\n", "# Perform PCA on the data matrix X\n", "#X_pca, evectors, evals = pca(X)\n", "\n", "# Plot the data projected into the new basis\n", "#plot_pca_transformation(X, X_pca)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "Ca3ClyTb6F1h" }, "source": [ "Note that the correlation between dimensions goes to 0 after the transformation to the principal components basis! This is a property of PCA: it decorrelates the data." ] }, { "cell_type": "markdown", "metadata": { "id": "pEassDaK6_Ii" }, "source": [ "## C) Visualize variance explained\n", "\n", "We want to create a plot telling us the percent of variance explained by each principal component (here we have just two). Determine what information you need for this (the inputs) and complete the function below." ] }, { "cell_type": "code", "metadata": { "id": "TzACc3Z8JXqj" }, "source": [ "def plot_variances(...):\n", "\n", " percent_explained_variance = ...\n", "\n", " fig, ax = plt.subplots() \n", " colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", " ax.plot(percent_explained_variance, '-o', color=colors[4])\n", " ax.set(ylim=[0, 1], ylabel='% Explained Variance', xlabel='Component number', xticks=np.arange(len(percent_explained_variance)))\n", " \n", "plot_variances(...)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "jOlAMstb7PEJ" }, "source": [ "## D) Interactive Demo: Exploration of the correlation coefficient\n", "\n", "Run the following cell and use the slider to change the correlation coefficient of the data. This will update a plot of the data with the principal components overlaid and a plot of percentage of explained variance.\n", "\n", "**Questions:**\n", "* Can you find a correlation coefficient value for which the components have equal explained variance?\n", "* Can you find a value for which only only one component explains any variance?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Make sure you execute this cell to enable the widget!\n" ] }, { "cell_type": "code", "metadata": { "id": "ZJw30vF6Jizw", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Make sure you execute this cell to enable the widget!\n", "\n", "def refresh(corr_coef=.8):\n", " cov_matrix = calculate_cov_matrix(variance_1, variance_2, corr_coef)\n", " X = X = np.random.multivariate_normal([0, 0], cov_matrix, size=1000)\n", " score, evectors, evals = pca(X)\n", " plot_data_and_PCs(X, evectors)\n", " plot_variances(evals)\n", "\n", "_ = widgets.interact(refresh, corr_coef=(-1, 1, .1), fontsize=60)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "I8dhaIewLT_-" }, "source": [ "**Your text answer**" ] }, { "cell_type": "markdown", "metadata": { "id": "BVl9D6vv-qPX" }, "source": [ "## Optional advanced challenge: PCA implementation with SVD\n", "\n", "Take the PCA function from part A and implement with SVD instead of with the eigenvectors of the covariance matrix.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "3XN7xqpZ4OWX" }, "source": [ "def pca_with_SVD(X):\n", "\n", " ..." ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "5SSIoA4M7V7n" }, "source": [ "# Exercise 3: PCA of images \n", "## Modified from NMA W1D5 T3\n", "\n", "In this exercise, we will look at the PCA of images. We will use images from the MNIST dataset, which is a dataset of handdrawn numbers (0-9). We're using this data instead of more neuroscience related data because it's a small dataset that's easy to interpret. Everything we will learn here could be applied to, for example, the frames of a video of a mouse performing a task. \n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "2l7sQ0ZGdoxP" }, "source": [ "The MNIST dataset consists of a 70,000 images of individual handwritten digits. Each image is a 28x28 pixel grayscale image. For convenience, each 28x28 pixel image is often unravelled into a single 784 (=28*28) element vector (a process called flattening the images), so that the whole dataset is represented as a 70,000 x 784 matrix. Each row represents a different image, and each column represents a different pixel.\n", " \n", "Execute the following cell to load the MNIST dataset and plot the first nine images." ] }, { "cell_type": "code", "metadata": { "id": "OSMEbdlx7cdK", "colab": { "base_uri": "https://localhost:8080/", "height": 430 }, "outputId": "58400753-b6e7-4009-ed12-b9e00dfcfb64" }, "source": [ "from sklearn.datasets import fetch_openml\n", "mnist = fetch_openml(name='mnist_784')\n", "X = np.array(mnist.data)\n", "plot_sample_images(X)" ], "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0UAAAM7CAYAAACFrzsEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dbZAV5Hk38HNwEUEDClLAMYoGU18RQesbA05D1BCqNBbRgApplZGpRmc02kiMERMTtbZEC6lVNFRm0JHwYkerJgJqotaX2qlRovGFYBAxRoQggrrn+fB0fLRPkvuCPWfP7l6/35d8+e91XwO7y/73NnNXa7VaBQAAIKtuzV4AAACgmZQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASK2hpaharc6vVqvzG3kGAABAW1RrtVrjhlerT1UqleENOwAAAOBjarVadVs/xn8+BwAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApNbS7AUAAKCRRowYEcr97d/+bTFz5plnhmbNmzevmLnhhhtCs55++ulQju3npggAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABIrVqr1Ro3vFp9qlKpDG/YAdTFZz/72WKme/fuoVmjRo0qZmbPnh2a1draGsp1VEuWLClmTjvttNCsrVu3tnUdAOhyhg0bFso9+OCDoVzv3r3bss42e+edd0K5fv36NXiTrqVWq1W39WPcFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACk5vHWTuqggw4qZqZMmRKaNWHChGKmW7dYf95jjz2KmWo19p5WIz83O4p58+aFchdccEExs2HDhrauAwAdxp/92Z8VMwsXLgzNivx8UqnEfvbYuHFjaFbk4fXoo6wjR44sZp5++unQrAwPwnu8FQAAYBspRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpVSMv92738Gr1qUqlMrxhByS2dOnSYmbs2LHtsMm2q1Zjjww38nOzsxk9enQx89Of/rQdNoE/7sgjjwzlJk+eXMxEPu8rlUrloIMOCuUiLrroolBuzZo1xUzkBfpKpVK5/fbbi5nHH388NAuarVevXsXM8OGxHw0jXxt77rlnaFY9f/Z4+umnQ7OuueaaYmbBggWhWZH9Z8yYEZp19dVXh3KdWa1Wi/2Ff4ybIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUWpq9ANvngQceKGbq+XjrunXrQrlbbrmlmOnWLdbFW1tbQ7mIY445JpSLPhYJGU2cOLGYmTVrVmjW7rvvXsxEH1tcvnx5KNe/f/9i5tprrw3NiojuH9nrtNNOa+s60C7++Z//uZg5/fTT22GTxok+PrvLLrsUMytWrAjNOu6444qZoUOHhmbx+7kpAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJrafYCbJ85c+YUM4sXL67bee+//34ot3bt2rqdWU+9e/cO5Z599tliZo899mjrOh+J/h09+eSTdTuTXFpayt/mDz/88NCsf/mXfylmevXqFZr10EMPFTMzZ84MzXrkkUdCuR49ehQzd955Z2jW8ccfH8pF+PqmMxgxYkQo98UvfrGYqVarbV3nIytWrAjl7r777lDuuuuuK2bWrFkTmvWf//mfxczbb78dmvXnf/7nxUw9/1wzclMEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJrHWzupDz74oJhZvXp1O2zSOZxwwgmh3G677dbgTT7ptddeC+W2bNnS4E3oqiZPnlzM3HzzzXU774EHHgjlJk6cWMxs2LChrets85n1fJQ1+vX9wx/+sG5nwvYYNmxYMRP92o48ll6r1UKz7r333mLm9NNPD80aPXp0KDdjxoxiJvo988033yxm/uu//is0q7W1tZiJPJxbqVQqw4cPL2aefvrp0KyuxE0RAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkFo1+qrwdg2vVp+qVCrlZ3OhDU477bRi5uyzzw7Nir54XS99+/YN5TZs2NDgTehsZs6cGcp9/etfL2ai/w7Mnj27mIm8Bl+pNOdz+vnnny9m9ttvv7qdd8opp4RyS5YsqduZ8HGf/exnQ7lvfvObxUzk39pKpVL5zW9+U8y8/vrroVlXXXVVMXPXXXeFZnV2H374YTET/V5+xx13FDOTJk0KzeqoarVadVs/xk0RAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGotzV6AfKIPgl166aWh3JAhQ4qZ7t27h2bV0zPPPFPMvP/+++2wCZ3N5ZdfXsxEHmWtVCqVrVu3FjP33XdfaNYll1xSzGzevDk0K2KnnXYK5Y4//vhQbq+99ipmqtXYe3+RRyU9ykoj9ejRo5i57rrrQrPGjh1bzGzcuDE068wzzyxmnnzyydCsnj17hnJsm8j3wozcFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACptTR7AbbP4MGDi5kzzjgjNGvMmDFt3GbbjBw5MpSr1WoN3uT/t2HDhmLm0ksvDc265557ipnNmzeHZtE17LrrrqHc9OnTi5no18d9991XzIwfPz40q56GDBlSzMyfPz80a8SIEW1d5yN33XVXKHfNNdfU7UzYHocddlgxM3bs2Lqdd/LJJ4dyK1asqNuZ0J7cFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACk5vHWDubggw8O5ZYuXVrM7LXXXm1dJ52HH364mLnpppvaYRO6oh133DGU23333et25vnnn1/M/Mmf/Elo1tSpU4uZk046KTQr8r1ul112Cc2KPmQbyd1+++2hWZs2bQrloFGuv/76YqZarYZmRR5c9Shrc3XrVr7HaG1tbYdNui43RQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqLc1egO0TeaU6+pJ1e4u8ylypNOdl5nHjxhUzX/jCF0Kz7r333rauQxezdevWUO7NN98sZvr37x+a9corrxQztVotNKue1qxZU8xs2LAhNGvQoEGh3G9+85ti5u677w7NgkaJ/DtUqVQqw4YNK2aiX9tLly4N5WieyM9E0b/vZ555pq3rdEluigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUWpq9AJ/07LPPhnLHHXdcMTN58uTQrPvuu6+Yee+990KzmuGv//qvi5nzzjuvHTaBP279+vWh3Pjx44uZf/u3fwvN6tu3bzHz0ksvhWYtWbKkmLnttttCs377298WMwsWLAjNGjRoUCgXnQfN1LNnz1Buxx13LGbWrVsXmnXHHXeEcmybHj16FDNXXHFF3c578MEHQ7m/+7u/q9uZXYmbIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUPN7aSa1ataqY+fa3v90OmzRf5OEzj7fSmTz++OPFTP/+/dthk8YZNWpUMTN69OjQrNbW1lDu5ZdfDuWgq9iyZUso9/rrrzd4k64l8ihrpVKpzJgxo5i5+OKLQ7Nee+21Yubv//7vQ7N+97vfhXLZuCkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUmtp9gLQVieccEKzVwC2Uc+ePYuZ1tbW0KxarRbKLViwIJSDrmLp0qXNXqHTGTZsWDFz8cUXh2ZNnDixmFmyZElo1imnnBLKsf3cFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACk5vHWOujevXsod/zxxxczDz74YGjW5s2bQ7nObOrUqaHcrFmzGrwJUG/33Xdfs1eADqlardYtN378+NCsr371q6FcZ3bhhReGct/4xjeKmT59+oRmzZ8/v5g588wzQ7NoPDdFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGotzV6goxs5cmQxc9lll4Vmff7zny9m9tlnn9Cs1atXh3LtrW/fvsXM2LFjQ7Ouv/76UK5Xr16hXMTmzZuLmffee69u50FWJ5xwQrNXgA6pVqvVLTdw4MDQrO9///vFzNy5c0Oz3nrrrWLmqKOOCs0644wziplDDz00NGvPPfcM5X71q18VM/fdd19o1uzZs0M5OgY3RQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpeby14MYbbyxmDj744Lqd97WvfS2U27hxY93OrKfIA7XDhw8PzYo+YBexfPnyUG7OnDnFzLJly9q4DbDvvvs2ewXo8nbYYYdQbvr06cXMKaecEpq1YcOGYma//fYLzaqnn/3sZ6Fc5N/4yy+/vK3r0AG5KQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSa2n2AnzSueee2+wVOox169aFcnfffXcx89WvfjU067333gvlgLZ5+OGHi5lu3WK/t2ttbW3rOtBhPProo6HcE088UcwcccQRbV3nIwMHDgzlBgwYULcz33rrrWJmwYIFoVnRnwPIy00RAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGrVWq3WuOHV6lOVSmV4ww5oB8OGDStmzjvvvNCss846q63rNM1LL70Uyr377rvFTOTRxkqlUrnppptCuWeffTaUAzqXF154IZTbd999Q7mRI0cWM4899lhoFjTboEGDiplp06aFZs2YMaOYqVaroVmRnytnzZoVmjVnzpxi5pe//GVoFrnUarXYJ+zHuCkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUqtGXh7e7uHV6lOVSmV4ww7oIHr06BHKTZkypZi56qqrQrN22223Ymbx4sWhWQ888EAxs2TJktCstWvXhnIAJZHvmZVKpXLzzTeHcitWrChmzjvvvNCs5557LpQDoP3VarXqtn6MmyIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1DzeCkCH1Lt371DuzjvvDOXGjBlTzPzoRz8KzZo6dWoxs2nTptAsAOrL460AAADbSCkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASK1aq9UaN7xafapSqQxv2AEApNe7d+9Q7tvf/nYxc+6554ZmDR06tJh57rnnQrMAqK9arVbd1o9xUwQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmsdbAQCALsPjrQAAANtIKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgtZZmL0Dn0L1791DumGOOKWa+853vhGYde+yxoRyQ26c+9alQbpdddilmvvjFL4Zm9e/fv5i5/vrrQ7O2bNkSygF5fe5znytm5s+fH5o1evToYuYXv/hFaFZX4qYIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWPtxLSp0+fUG7ZsmXFzNq1a0OzBg4cGMpF5wEdx+DBg4uZSy65JDTr6KOPDuUOPvjgUK5eBg0aFMqdf/75Dd6ERhs1alQo169fv2Jm0aJFbV2HLuiII44oZp544ol22KTrclMEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApNbS7AXIZ+DAgXXNrV27ti3rAEH7779/MXPBBReEZk2aNKmY6dmzZ2hWtVoN5VavXl3MbNy4MTTrgAMOKGZOPfXU0KzZs2cXMytXrgzNojmOO+64UG6//fYrZhYtWtTGbehMunWL3U/ss88+xczee+8dmhX9npmNmyIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1DzeSrvzaBi0nz59+hQz3/ve90KzJk6cWMx86lOfCs2qpxdffDGUO+GEE4qZ7t27h2ZFHlPdfffdQ7OiOTquM888M5R79NFHG7wJnc2gQYNCubPPPruYuf3220OzPAb9+7kpAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJrafYC5FOr1UK5nXbaqcGbQNf3l3/5l8XM3/zN37TDJtvupZdeCuU+//nPh3KrV68uZoYMGRKaBR/XrZvfMbN9br755rrNevHFF+s2KyNfxQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpebyVDuvwww8P5R577LEGbwKd14QJE9r1vFdffTWUe+KJJ4qZSy65JDQr8ihr1AEHHFC3WXQNQ4cOLWYGDBjQDpvQFfXp06dusx544IG6zcrITREAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQWkuzF6Bz+OCDD0K5d955p5iJvt78mc98JpQD/rCzzz67mDnnnHNCs+6///5i5pe//GVo1rp160K59jZgwIBmr0AHM3bs2GKmZ8+e7bAJnU3k+8k+++xTt/N+/etf121WRm6KAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFLzeCsh69evD+UefvjhYmbcuHFtXQcIWrNmTTFzxRVXNH6RTuLoo49u9gp0MH/6p39at1k///nP6zaLju+6664rZqIPRr/wwgvFzMaNG0Oz+P3cFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACptTR7AQDyOf/884uZnXfeuR02+aRDDjmkbrN+9rOfhXKPPvpo3c6kY3viiSeavUJavXv3DuVOPPHEYmby5MmhWccff3woFzFz5sxiZv369XU7LyM3RQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpebyVDqtfv37NXgFS6NWrVyh34IEHFjPf/OY3Q7PGjh0bykV06xb7/V5ra2vdzlyzZk0xM3Xq1NCsDz/8sK3r0En07du32Sv8XoceemgxU61WQ7PGjBlTzOy5556hWTvuuGMxM2nSpNCs6PeJzZs3FzOPP/54aNaWLVuKmZaW2I/iTz31VCjH9nNTBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKQWe0YXmuCkk05q9grQYXXv3j2UO+yww4qZhQsXhmYNGjSomIm8Bl+pVCpr1qwpZh599NHQrBNPPDGU69WrVygXEXmF/ktf+lJo1qxZs4qZrVu3hmZRf5HP6VqtFpr1gx/8oJj5+te/HppVT0OHDi1mqtVqaNYHH3xQzLz77ruhWc8991wxM3fu3NCsJ598MpRbsWJFMfPGG2+EZr322mvFTM+ePUOzVq5cGcqx/dwUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKmVn+SGbbBs2bJiZty4ce2wCXReO+64YzFz4oknhmb96Ec/aus6H/nWt75VzDz44IOhWT/96U+Lmb59+4ZmRc88+OCDQ7mI/v37FzNXX311aNavfvWrYmbx4sWhWVu2bAnliJs+fXoxs2rVqtCsY445pq3rNEQ9Pweff/75Yuaxxx4LzeqozjnnnFAu8n3i5Zdfbus61ImbIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUPN5KXUUegIvq3r17KLf33nsXM9GH9aCRop/TkUdSL7744rau85F77703lLvhhhuKmfXr14dmRR41vOeee0KzDjnkkFBu69atxcw111wTmhV5CPbkk08OzZo/f34x8+Mf/zg063vf+14x8/bbb4dmRTzzzDN1m9WZRf7c6To+97nP1W3WwoUL6zaLtnFTBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKTW0uwF6Fo++OCDus2qVquhXI8ePep2JmyvHXbYoZiZOXNmaNZFF11UzGzatCk069JLLy1mFixYEJq1fv36Yubwww8PzbrxxhuLmcMOOyw068UXXwzlzj333GJm2bJloVm9e/cuZo455pjQrEmTJhUzJ510UmjWAw88EMpFrF69upjZZ5996nYeZLRo0aJmr8D/cFMEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJrHW6mrJUuWFDMrV64Mzdp///1DuQsuuKCYmT59emgWbK9zzjmnmIk8ylqpVCrvvvtuMTNt2rTQrPvvv7+YOeqoo0Kzpk6dWsx84QtfCM3q2bNnMXPllVeGZt16662hXOQx0qgNGzYUM//+7/8emhXJnX766aFZX/7yl0O5iAsvvLBuswA6OjdFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGrVWq3WuOHV6lOVSmV4ww6gU/rHf/zHUG7q1Kmh3IABA4qZ9957LzQLttfrr79ezPTv3z80a8uWLcXMypUrQ7N23nnnYmbIkCGhWfV0xRVXFDNXX311aNaHH37Yxm0A4u64445Q7tRTTy1mzjrrrNCsefPmhXL8X7VarbqtH+OmCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACC1lmYvAH9I9GHhrVu3NngTKFu7dm0xE328tUePHsXMoYceGpoVcc8994RyDz30UDGzePHi0KxXX321mPEoK9CZRX6O6dbN/URH4W8CAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASK2l2QvAH9K7d+9Q7uSTTy5mFi1a1NZ14I8aNWpUMTN+/PjQrOHDhxcz69atC82aO3duMfP222+HZm3dujWUAyDm6KOPDuVuu+22xi6CmyIAACA3pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1DzeSrs79dRTQ7ktW7aEcs8//3xb1oG62LhxYzHzr//6r6FZ0RwAHVe1Wm32CmwDN0UAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAai3NXoB8HnrooVDugAMOCOU2b97clnUAAMLuvffeUG7ChAkN3oR6clMEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkFq1Vqs1bni1+lSlUhnesAMAAAA+plarVbf1Y9wUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqLc1eAChbsWJFMVOtVkOzRo0a1dZ14A+aNWtWKHf++ecXM88++2xo1rhx40K5VatWhXIA5OOmCAAASE0pAgAAUlOKAIPjUqgAAAvvSURBVACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEitpdkLQGbf//73Q7ljjz22mLntttvauA38cYMHDy5mJk+eHJrV2tpazBxwwAGhWfvvv38ot2rVqlAOoB5mzJhRzHzrW98KzerWrXyPcdxxx4VmrVixIpTLxk0RAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGoeb4UGufbaa4uZ6dOnh2a9//77xcyPf/zj0CzYXm+++WYx89BDD4VmnXTSSW1dB6AppkyZEspdcsklxUzkIeuoWq1Wt1kZuSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUmtp9gLQVR111FHFzA477BCa9fDDDxczCxYsCM2C7bVp06ZiZtWqVe2wCUDz7L333qHcTjvt1OBNqCc3RQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpebyVkNGjR4dyl19+eTEzYcKE0Kzf/va3oVx7mzRpUig3dOjQYuaVV14JzbrwwgtDOWikXXfdtZg59NBD22ETgMYYM2ZMMXPeeefV7byVK1eGcuPGjStm3njjjbauk5qbIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACC1lmYvQOcwd+7cUG7fffctZg488MDQrEceeSSUa2+XX355KNe7d+9iZsqUKaFZzzzzTCgHjdSrV69iZq+99mqHTT7piCOOCOUiL8evWrWqresAHdDIkSNDuVtvvbWY6dOnT1vX+ci1114byvne1HhuigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABS83grIZs2barbrJ49e9ZtVr0NGzasmKnn45SRxzCho1izZk0xc9ttt4VmXXHFFW1bZjtmrV+/vpi58cYb27gN0BGdddZZodwee+xRtzOXL19ezMybN69u59E2booAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1FqavQDN953vfKeYOeSQQ0KzXnjhhWLmmWeeCc2qp5133jmUu+yyy4qZnXbaKTTrP/7jP4qZO++8MzQLOouZM2eGcldccUVjFwFS2H333UO5r3zlK6Fca2trMbN+/frQrKuuuiqUo2NwUwQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmsdbu7BPf/rTody0adOKmQ8//LBus958883QrHqaNWtWKPdXf/VXxczatWtDs4488shQDjLq1q38O7nII4pA1zV48OBiZuHChY1f5H+54YYbQrlly5Y1eBPqyU0RAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkFpLsxdg+wwdOrSYWbp0aWhW3759i5no683Lly8P5erpa1/7WjHzla98pW7nXXnllXWbBVm1trYWM7VarR02ATqqE088sZiJ/Dy0LX7yk58UM7NmzarrmXQMbooAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUvN4aztqaSn/cZ9xxhmhWXPnzm3rOtvkmGOOCeVmzJhRzFx77bWhWZFHZSuVSmXixInFTLVaDc2aN29eMTNnzpzQLADg/zd+/PhQ7rvf/W7dznzkkUdCubPOOquYeeedd9q6Dh2QmyIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgtZZmL5DJl7/85WJm7ty57bDJJ73yyivFzIgRI0KzIrnoS9Z77rlnKDdgwIBi5q233grNirxkDQD8foMHDy5mFi5c2PhF/peXX345lHvjjTcavAkdlZsiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAILWWZi/QFZx++umh3A9/+MNi5sMPPwzNWr9+fTEzYcKE0Ky33367mJk1a1Zo1qhRo4qZESNGhGbVU79+/UK5tWvXFjPHHntsaNZLL70UykFG3bqVfyfX2tpa1zMj359uvPHGup4J2VxyySXFTL2/tiO++93vtvuZdC5uigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABS83hrHZx77rmh3OrVq4uZK6+8MjTr5ptvDuXqZfr06aHcLbfcUswceeSRbV2nYX7yk58UMx5lhbaLPN5Yq9XqeuaXvvSlYubAAw8MzXruuefaug50KsOGDQvljj/++AZv8klLliwJ5X7xi180eBM6OzdFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGotzV6gK1i0aFEod9dddxUzq1evbus6DbH77ruHcgcddFDdzjz99NNDuf/+7/+u25kd9c8fupof/OAHxcy0adPaYZNPOuecc0K5Cy64oMGbQMdy//33h3K77bZb3c587LHHipkpU6bU7Txyc1MEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJrHW+vgH/7hH5q9Qpv06dOnmDnttNNCs3bZZZdi5tVXXw3NWrBgQSgHdD4rV65s9grANujXr18o19raWrczZ8+eXcz87ne/q9t55OamCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEitWqvVGje8Wn2qUqkMb9gB1MVll11WzFx11VWhWW+99VYxM2zYsNCs1157LZQDuqYXXnghlPvMZz5TtzO7dYv9rnDIkCHFzEsvvdTWdaBd3HrrrcXMlClTQrNaW1vbuM3/s++++xYzq1atqtt5dB21Wq26rR/jpggAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1JQiAAAgtZZmL0Dj7L333qHctGnT6nbmnDlzihmPsgIRP//5z0O5yAOPUfV8eBKaLfpY+pgxY4qZ6NfG1q1bi5l/+qd/Cs164403QjmoBzdFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGotzV6Axlm+fHko9+lPf7qYuf3220OzvvGNb4RyACU33XRTKPcXf/EXDd4EOqddd901lBs4cGDdzvz1r39dzFx00UV1Ow/qxU0RAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGoeb+3CbrnlllBu5syZxczixYvbug7ANnnuuedCueeffz6UO+CAA9qyDgBdmJsiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAILVqrVZr3PBq9alKpTK8YQcAAPB7DRw4MJS74447ipmRI0eGZr3yyivFzJAhQ0KzYHvVarXqtn6MmyIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAIDWlCAAASE0pAgAAUlOKAACA1DzeCgAAdBkebwUAANhGShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKSmFAEAAKkpRQAAQGpKEQAAkJpSBAAApKYUAQAAqSlFAABAakoRAACQmlIEAACkphQBAACpKUUAAEBqShEAAJCaUgQAAKTW6FI0uMHzAQAAPlKtVudv68e0NGKRj9nwP//7aoPPAQAA2C7VWq3W7B0AAACaxv+nCAAASE0pAgAAUlOKAACA1JQiAAAgNaUIAABITSkCAABSU4oAAIDUlCIAACA1pQgAAEhNKQIAAFJTigAAgNSUIgAAILX/A4PitWuf9AFfAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "image/png": { "width": 418, "height": 413 } } } ] }, { "cell_type": "markdown", "metadata": { "id": "04DQStqmeRpe" }, "source": [ "## A) Explained variances\n", "\n", "We will first perform PCA and plot the cumulative percentage explained variance over components. Note that this is related to our earlier plots but now we are plotting the percentage of explained variance **cumulatively**. Execute the next cell to do this. \n", "\n", "- How many principal components are required to explain 90% of the variance?\n", "- How does the intrinsic dimensionality of this dataset compare to its extrinsic dimensionality? \n" ] }, { "cell_type": "code", "metadata": { "id": "JTF-oiCveGsv", "colab": { "base_uri": "https://localhost:8080/", "height": 198 }, "outputId": "261b18c2-bac8-4eec-ed77-0b1b6e87777e" }, "source": [ "transformed_data, evectors, evals = pca(X)\n", "variance_explained = get_variance_explained(evals)\n", "plot_variance_explained(variance_explained)" ], "execution_count": null, "outputs": [ { "output_type": "error", "ename": "NameError", "evalue": "ignored", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtransformed_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevectors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpca\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mvariance_explained\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_variance_explained\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mplot_variance_explained\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvariance_explained\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'pca' is not defined" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "OlnK9dsYeni5" }, "source": [ "**Your text answer**" ] }, { "cell_type": "markdown", "metadata": { "id": "lC0vE4ITflA4" }, "source": [ "## B) PCA Reconstruction\n", "\n", "Let's try projecting down onto our reduced dimensionality PCA space and then **reconstructing** our images from the low-D space.\n", "\n", "To see this, recall that to perform PCA we projected the data $\\bf X$ onto the eigenvectors of the covariance matrix:\n", "\\begin{equation}\n", "\\bf U = X V\n", "\\end{equation}\n", "where $U$ is the transformed data, $X$ is the data matrix, and $V$ is the components matrix.\n", "\n", "Since $\\bf V$ is an orthogonal matrix, ${\\bf V}^{-1} = {\\bf V}^T$. We can reconstruct by:\n", " \n", "\\begin{equation}\n", "\\bf X = U V^T\n", "\\end{equation}\n", "\n", "To reconstruct the data from a low-dimensional approximation, we just have to truncate these matrices. Let's call ${\\bf U}_{1:K}$ and ${\\bf V}_{1:K}$ as keeping only the first $K$ columns of this matrix. Then our reconstruction is:\n", "\\begin{equation}\n", "{\\bf \\hat X = U}_{1:K} ({\\bf V}_{1:K})^T.\n", "\\end{equation}\n", "\n", "Complete the following function to reconstruct the images from the top K components." ] }, { "cell_type": "code", "metadata": { "id": "42Yta-O8eoba" }, "source": [ "def reconstruct_data(transformed_data, evectors, X_mean, K):\n", " \"\"\"\n", " Reconstruct the data based on the top K components.\n", "\n", " Args:\n", " transformed_data (numpy array of floats) : data projected onto PCA basis\n", " evectors (numpy array of floats) : Matrix of eigenvectors\n", " X_mean (numpy array of floats) : Vector corresponding to data mean\n", " K (scalar) : Number of components to include\n", "\n", " Returns:\n", " (numpy array of floats) : Matrix of reconstructed data\n", "\n", " \"\"\"\n", "\n", " #################################################\n", " ## TO DO for students: Reconstruct the original data in X_reconstructed\n", " # Comment once you've filled in the function\n", " raise NotImplementedError(\"Student exercise: reconstructing data function!\")\n", " #################################################\n", "\n", " # Reconstruct the data from the score and eigenvectors\n", " # Don't forget to add the mean!!\n", " X_reconstructed = ...\n", "\n", " return X_reconstructed\n", "\n", "\n", "K = 100\n", "\n", "# Fill in below then uncomment the last line\n", "\n", "# Reconstruct the data based on all components\n", "X_mean = ...\n", "X_reconstructed = reconstruct_data()\n", "\n", "# Plot the data and reconstruction\n", "# plot_reconstructions(X, X_reconstructed)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "uzQ_pWJMis55" }, "source": [ "## C) Interactive Demo: Reconstruct the data matrix using different numbers of PCs\n", "\n", "Now run the code below and experiment with the slider to reconstruct the data matrix using different numbers of principal components.\n", "\n", "\n", "- How many principal components are necessary to reconstruct the numbers (by eye)? How does this relate to the intrinsic dimensionality of the data?\n", "- Do you see any information in the data with only a single principal component?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Make sure you execute this cell to enable the widget!\n" ] }, { "cell_type": "code", "metadata": { "id": "haWPdnj3ixWF", "tags": [ "hide-input" ] }, "source": [ "# @markdown Make sure you execute this cell to enable the widget!\n", "\n", "\n", "def refresh(K=100):\n", " X_reconstructed = reconstruct_data(transformed_data, evectors, X_mean, K)\n", " plot_reconstructions(X, X_reconstructed)\n", " plt.title('Reconstructed, K={}'.format(K))\n", "\n", "\n", "_ = widgets.interact(refresh, K=(1, 784, 10))" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "MkG78Dn2i7qN" }, "source": [ "**Your text answer**" ] }, { "cell_type": "markdown", "metadata": { "id": "a3qjQEQGjI0I" }, "source": [ "## D) Visualization of the principal components\n", "\n", "We can visualize the principal components as images by reversing the flattening. Here we plot using a differenet colormap than black & white as it highlights more structure.\n", "\n", "* What structure do you see in the first principal component? What kinds of images would this basis vector differentiate?\n", "* Try visualizing the second and third basis vectors. Do you see any structure? What about the 100th basis vector? 500th? 700th?" ] }, { "cell_type": "code", "metadata": { "id": "UWx9GWIrjuBI" }, "source": [ " plot_principal_components(evectors[:, 0])" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "nGh5PexVkeb2" }, "source": [ "**Your text answer**" ] }, { "cell_type": "markdown", "metadata": { "id": "Tt6HzB3UjLse" }, "source": [ "## (Read only) E) Denoising with PCA\n", "\n", "We will add some noise to our images to see how PCA reconstructions can be helpful for reducing noise. In this case, we will set 20% of the pixels to random values. We will then visualize some of the noisy images and the resulting cumulative variance explained plot.\n", "\n", "In the next cell, we will project the images onto the original PCA space (from the clean, not noisy, data) and then reconstruct from the top 50 components. Observe that this removes the noise quite effectively!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute this cell to visualize noisy data\n" ] }, { "cell_type": "code", "metadata": { "id": "HJZuksdGkux6", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Execute this cell to visualize noisy data\n", "np.random.seed(2020) # set random seed\n", "X_noisy = add_noise(X, .2)\n", "score_noisy, evectors_noisy, evals_noisy = pca(X_noisy)\n", "variance_explained_noisy = get_variance_explained(evals_noisy)\n", "\n", "\n", "plot_sample_images(X_noisy)\n", "plot_variance_explained(variance_explained_noisy)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute to visualize denoised reconstructions\n" ] }, { "cell_type": "code", "metadata": { "id": "Cx08LiVElRzx", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Execute to visualize denoised reconstructions\n", "X_noisy_mean = np.mean(X_noisy, 0)\n", "projX_noisy = np.matmul(X_noisy - X_noisy_mean, evectors)\n", "X_reconstructed = reconstruct_data(projX_noisy, evectors, X_noisy_mean, 50)\n", "\n", "plot_reconstructions(X_noisy, X_reconstructed)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "LpZixEh3f6XL" }, "source": [ "# Extra info: PCA & Sklearn\n", "\n", "In this tutorial, we created our own functions to compute PCA and reconstruct images so we could better understand the algorithms. Usually though, you would use `sklearn.decomposition.pca` to perform PCA. Sklearn is a class based package - I have a video explaining the basics of class based programming (object oriented programming) and a video on sklearn as part of my Pandemic Python for Neuroscientists course so check that out if interested. \n", "I'll demonstrate the basics here using some data with 3 features (X). \n", "\n", "See docs here: https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Execute to generate some data X\n" ] }, { "cell_type": "code", "metadata": { "id": "HKJq25k-y4dC", "cellView": "form", "tags": [ "hide-input" ] }, "source": [ "# @markdown Execute to generate some data X\n", "np.random.seed(123)\n", "variance_1 = 1\n", "variance_2 = 1\n", "corr_coef = 0.8\n", "cov_matrix = np.array([[1, .2, .3], [.2, 1, .3], [.3, .3, 1]])\n", "X = np.random.multivariate_normal([5, 10, 2], cov_matrix, size=1000)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "HbmbY_cJzSKd" }, "source": [ "# Import PCA class\n", "from sklearn.decomposition import PCA\n", "\n", "# Set up model, tell it the number of components you'll want to keep (if not set, all components will be kept)\n", "pca = PCA(n_components=2)\n", "\n", "# Fit the model to your data, aka find the principal components\n", "pca.fit(X)\n", "\n", "# Now you can access the principal components\n", "print(pca.components_)\n", "\n", "# And the % of explained variance for each component\n", "print(pca.explained_variance_ratio_)\n", "\n", "# You can transform your data now\n", "transformed_data = pca.transform(X)\n", "\n", "# You could have fit and transformed at the same time if you had wanted\n", "transformed_data = pca.fit_transform(X)\n", "\n", "# You can also reconstruct into the original space\n", "reconstruction = pca.inverse_transform(transformed_data)" ], "execution_count": null, "outputs": [] } ] }