{ "cells": [ { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Logistic Classification\n", "=======================\n", "\n", "*Important:* Please read the [installation page](http://gpeyre.github.io/numerical-tours/installation_matlab/) for details about how to install the toolboxes.\n", "$\\newcommand{\\dotp}[2]{\\langle #1, #2 \\rangle}$\n", "$\\newcommand{\\enscond}[2]{\\lbrace #1, #2 \\rbrace}$\n", "$\\newcommand{\\pd}[2]{ \\frac{ \\partial #1}{\\partial #2} }$\n", "$\\newcommand{\\umin}[1]{\\underset{#1}{\\min}\\;}$\n", "$\\newcommand{\\umax}[1]{\\underset{#1}{\\max}\\;}$\n", "$\\newcommand{\\umin}[1]{\\underset{#1}{\\min}\\;}$\n", "$\\newcommand{\\uargmin}[1]{\\underset{#1}{argmin}\\;}$\n", "$\\newcommand{\\norm}[1]{\\|#1\\|}$\n", "$\\newcommand{\\abs}[1]{\\left|#1\\right|}$\n", "$\\newcommand{\\choice}[1]{ \\left\\{ \\begin{array}{l} #1 \\end{array} \\right. }$\n", "$\\newcommand{\\pa}[1]{\\left(#1\\right)}$\n", "$\\newcommand{\\diag}[1]{{diag}\\left( #1 \\right)}$\n", "$\\newcommand{\\qandq}{\\quad\\text{and}\\quad}$\n", "$\\newcommand{\\qwhereq}{\\quad\\text{where}\\quad}$\n", "$\\newcommand{\\qifq}{ \\quad \\text{if} \\quad }$\n", "$\\newcommand{\\qarrq}{ \\quad \\Longrightarrow \\quad }$\n", "$\\newcommand{\\ZZ}{\\mathbb{Z}}$\n", "$\\newcommand{\\CC}{\\mathbb{C}}$\n", "$\\newcommand{\\RR}{\\mathbb{R}}$\n", "$\\newcommand{\\EE}{\\mathbb{E}}$\n", "$\\newcommand{\\Zz}{\\mathcal{Z}}$\n", "$\\newcommand{\\Ww}{\\mathcal{W}}$\n", "$\\newcommand{\\Vv}{\\mathcal{V}}$\n", "$\\newcommand{\\Nn}{\\mathcal{N}}$\n", "$\\newcommand{\\NN}{\\mathcal{N}}$\n", "$\\newcommand{\\Hh}{\\mathcal{H}}$\n", "$\\newcommand{\\Bb}{\\mathcal{B}}$\n", "$\\newcommand{\\Ee}{\\mathcal{E}}$\n", "$\\newcommand{\\Cc}{\\mathcal{C}}$\n", "$\\newcommand{\\Gg}{\\mathcal{G}}$\n", "$\\newcommand{\\Ss}{\\mathcal{S}}$\n", "$\\newcommand{\\Pp}{\\mathcal{P}}$\n", "$\\newcommand{\\Ff}{\\mathcal{F}}$\n", "$\\newcommand{\\Xx}{\\mathcal{X}}$\n", "$\\newcommand{\\Mm}{\\mathcal{M}}$\n", "$\\newcommand{\\Ii}{\\mathcal{I}}$\n", "$\\newcommand{\\Dd}{\\mathcal{D}}$\n", "$\\newcommand{\\Ll}{\\mathcal{L}}$\n", "$\\newcommand{\\Tt}{\\mathcal{T}}$\n", "$\\newcommand{\\si}{\\sigma}$\n", "$\\newcommand{\\al}{\\alpha}$\n", "$\\newcommand{\\la}{\\lambda}$\n", "$\\newcommand{\\ga}{\\gamma}$\n", "$\\newcommand{\\Ga}{\\Gamma}$\n", "$\\newcommand{\\La}{\\Lambda}$\n", "$\\newcommand{\\si}{\\sigma}$\n", "$\\newcommand{\\Si}{\\Sigma}$\n", "$\\newcommand{\\be}{\\beta}$\n", "$\\newcommand{\\de}{\\delta}$\n", "$\\newcommand{\\De}{\\Delta}$\n", "$\\newcommand{\\phi}{\\varphi}$\n", "$\\newcommand{\\th}{\\theta}$\n", "$\\newcommand{\\om}{\\omega}$\n", "$\\newcommand{\\Om}{\\Omega}$\n", "$\\newcommand{\\eqdef}{\\equiv}$" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "This tour details the logistic classification method (for 2 classes and\n", "multi-classes).\n", "\n", "\n", "_Warning:_ Logisitic classification is actually called [\"logistic\n", "regression\"](https://en.wikipedia.org/wiki/Logistic_regression) in the literature, but it is in fact a classification method.\n", "\n", "\n", "We recommend that after doing this Numerical Tours, you apply it to your\n", "own data, for instance using a dataset from [LibSVM](https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/).\n", "\n", "_Disclaimer:_ these machine learning tours are intended to be\n", "overly-simplistic implementations and applications of baseline machine learning methods.\n", "For more advanced uses and implementations, we recommend\n", "to use a state-of-the-art library, the most well known being\n", "[Scikit-Learn](http://scikit-learn.org/)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [], "source": [ "using PyPlot\n", "using NtToolBox" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "We define a few helpers." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "#SetAR = @(ar)set(gca, 'PlotBoxAspectRatio', [1 ar 1], 'FontSize', 10);\n", "Xm = X -> X - repeat(mean(X,1), outer=(size(X,1), 1))\n", "Cov = X -> Xm(X)'*Xm(X)\n", "dotp = (u,v) ->sum(u[:].*v[:]);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Two Classes Logistic Classification\n", "-----------------------------------\n", "Logistic classification is, with [support vector machine (SVM)](https://en.wikipedia.org/wiki/Support_vector_machine), the baseline\n", "method to perform classification. Its main advantage over SVM is that is\n", "is a smooth minimization problem, and that it also output class\n", "probabity, offering a probabilistic interpretation of the classification.\n", "\n", "\n", "To understand the behavior of the method, we generate synthetic data\n", "distributed according to a mixture of Gaussian with an overlap governed by an offset $\\omega$.\n", " Here classes indexes are set to $y_i \\in\n", "\\{-1,1\\}$ to simplify the equations." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: div not defined", "output_type": "error", "traceback": [ "UndefVarError: div not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "n = 1000 # number of sample\n", "p = 2 # dimensionality\n", "omega = [1 .5]*5 # offset \n", "X = [randn(div(n,2),2); randn(div(n,2),2)+ones(div(n,2),1)*omega]\n", "y = [ones(div(n,2),1);-ones(div(n,2),1)];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Plot the classes." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: plot_multiclasses not defined", "output_type": "error", "traceback": [ "UndefVarError: plot_multiclasses not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "plot_multiclasses(X,y,disp_dim=2,ms=5);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Logistic classification minimize a logistic loss in place of the usual\n", "$\\ell^2$ loss for regression\n", " $$ \\umin{w} E(w) \\eqdef \\frac{1}{n} \\sum_{i=1}^n L(\\dotp{x_i}{w},y_i) $$\n", "where the logistic loss reads\n", " $$ L( s,y ) \\eqdef \\log( 1+\\exp(-sy) ) $$\n", "This corresponds to a smooth convex minimization. If $X$ is injective,\n", "this is also strictly convex, hence it has a single global minimum.\n", "\n", "\n", "Compare the binary (ideal) 0-1 loss, the logistic loss and the\n", "\n", "(the one used for SVM)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "t = linspace(-3,3,255);\n", "plot(t, log(1+exp(t)), c=\"red\",lw=2, label=\"Logistic\")\n", "plot(t, t.>0, c=\"orange\",lw=2, label=\"Hinge\")\n", "plot(t,max(t,0), c=\"blue\", label=\"Binary\")\n", "axis(\"tight\"); legend(loc=\"best\");" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "This can be interpreted as a when one\n", "models the probability of belonging to the two classes for sample $x_i$ as\n", " $$ h(x_i) \\eqdef (\\th(x_i),1-\\th(x_i)) \\qwhereq\n", " \\th(s) \\eqdef \\frac{e^{s}}{1+e^s} = (1+e^{-s})^{-1} $$\n", "\n", "\n", "Re-writting the energy to minimize\n", " $$ E(w) = \\Ll(X w,y) \\qwhereq \\Ll(s,y)= \\frac{1}{n} \\sum_i L(s_i,y_i), $$\n", "its gradient reads\n", " $$ \\nabla E(w) = X^\\top \\nabla \\Ll(X w,y)\n", " \\qwhereq\n", " \\nabla \\Ll(s,y) = \\frac{y}{n} \\odot \\th(-y \\odot s), $$\n", "where $\\odot$ is the pointwise multiplication operator, i.e. |.*| in\n", "Matlab.\n", "\n", "\n", "Define the energies." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "L = (s,y) -> 1/n * sum( log( 1 + exp(-s.*y) ) );\n", "E = (w,X,y) -> L(X*w,y);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Define their gradients." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "theta = v -> 1 ./ (1+exp(-v));\n", "nablaL = (s,r) -> - 1/n * y.* theta(-s.*y);\n", "nablaE = (w,X,y) -> X'*nablaL(X*w,y);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "_Important:_ in order to improve performance, it is important (especially\n", "in low dimension $p$) to add a constant bias term $w_{p+1} \\in \\RR$, and replace $\\dotp{x_i}{w}$\n", "by $ \\dotp{x_i}{w} + w_{p+1} $. This is equivalently achieved by\n", "adding an extra $(p+1)^{\\text{th}}$ dimension equal to 1 to each\n", "$x_i$, which we do using a convenient macro." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "AddBias = X -> [X ones(size(X,1),1)];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "With this added bias term, once $w_{\\ell=0} \\in \\RR^{p+1}$ initialized\n", "(for instance at $0_{p+1}$)," ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "w = zeros(p+1,1);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "one step of gradient descent reads\n", " $$ w_{\\ell+1} = w_\\ell - \\tau_\\ell \\nabla E(w_\\ell). $$" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: X not defined", "output_type": "error", "traceback": [ "UndefVarError: X not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "tau = .8; # here we are using a fixed tau\n", "w = w - tau * nablaE(w,AddBias(X),y);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 1__\n", "\n", "Implement a gradient descent\n", "$$ w_{\\ell+1} = w_\\ell - \\tau_\\ell \\nabla E(w_\\ell). $$\n", "Monitor the energy decay.\n", "Test different step size, and compare with the theory (in particular\n", "plot in log domain to illustrate the linear rate).\n", "etAR(1);\n", "etAR(1);" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "LoadError: UndefVarError: X not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo1.jl, in expression starting on line 4", "output_type": "error", "traceback": [ "LoadError: UndefVarError: X not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo1.jl, in expression starting on line 4", "", " in macro expansion; at /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo1.jl:5 [inlined]", " in anonymous at ./:?", " in include_from_node1(::String) at ./loading.jl:488", " in include_from_node1(::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "include(\"NtSolutions/ml_3_classification/exo1.jl\");" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Generate a 2D grid of points." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: X not defined", "output_type": "error", "traceback": [ "UndefVarError: X not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "q = 201; tx = linspace(minimum(X[:,1]),maximum(X[:,1]),q); ty = linspace(minimum(X[:,2]),maximum(X[:,2]),q)\n", "B,A = meshgrid( ty,tx )\n", "G = [A[:] B[:]];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Evaluate class probability associated to weight vectors on this grid." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: G not defined", "output_type": "error", "traceback": [ "UndefVarError: G not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "Theta = theta(AddBias(G)*w);\n", "Theta = reshape(Theta, q, q);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display the data overlaid on top of the\n", "classification probability, this highlight the\n", "separating hyperplane $ \\enscond{x}{\\dotp{w}{x}=0} $." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: tx not defined", "output_type": "error", "traceback": [ "UndefVarError: tx not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "imshow(Theta'[:,end:-1:1], extent=[minimum(tx), maximum(tx), minimum(ty), maximum(ty)]);\n", "plot_multiclasses(X,y);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 2__\n", "\n", "Test the influence of the separation offset $\\omega$ on the result." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "LoadError: UndefVarError: div not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo2.jl, in expression starting on line 9", "output_type": "error", "traceback": [ "LoadError: UndefVarError: div not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo2.jl, in expression starting on line 9", "", " in macro expansion; at /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo2.jl:12 [inlined]", " in anonymous at ./:?", " in include_from_node1(::String) at ./loading.jl:488", " in include_from_node1(::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "include(\"NtSolutions/ml_3_classification/exo2.jl\");" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 3__\n", "\n", "Test logistic classification on a real life dataset. You can look at the Numerical Tour on stochastic gradient descent\n", "for an example. Split the data in training and testing to evaluate the\n", "classification performance, and check the impact of regularization." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "include(\"NtSolutions/ml_3_classification/exo3.jl\");" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Kernelized Logistic Classification\n", "----------------------------------\n", "Logistic classification tries to separate the classes using\n", "a linear separating hyperplane $ \\enscond{x}{\\dotp{w}{x}=0}. $\n", "\n", "\n", "In order to generate a non-linear descision boundary, one can replace the\n", "parametric linear model by a non-linear [non-parametric](https://en.wikipedia.org/wiki/Nonparametric_statistics) model, thanks to\n", "kernelization. It is non-parametric in the sense that the number of\n", "parameter grows with the number $n$ of sample (while for the basic\n", "method, the number of parameter is $p$. This allows in particular to\n", "generate decision boundary of arbitrary complexity.\n", "\n", "\n", "The downside is that the numerical complexity of the method grows\n", "(at least) quadratically with $n$.\n", "\n", "\n", "The good news however is that thanks to the theory of\n", " [reproducing kernel Hilbert spaces](https://en.wikipedia.org/wiki/Reproducing_kernel_Hilbert_space)\n", "(RKHS), one can still compute this non-linear decision\n", "function using (almost) the same numerical algorithm.\n", "\n", "\n", "Given a kernel $ \\kappa(x,z) \\in \\RR $ defined for $(x,z) \\in \\RR^p$,\n", "the kernelized method replace the linear decision functional $f(x) =\n", "\\dotp{x}{w}$ by a sum of kernel centered on the samples\n", "$$ f_h(x) = \\sum_{i=1}^p h_i k(x_i,x) $$\n", "where $h \\in \\RR^n$ is the unknown vector of weight to find.\n", "\n", "\n", "When using the linear kernel $\\kappa(x,y)=\\dotp{x}{y}$, one retrieves\n", "the previously studied linear method.\n", "\n", "\n", "Macro to compute pairwise squared Euclidean distance matrix." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "distmat = (X,Z) -> broadcast(+,sum(X'.*X',1)',sum(Z'.*Z',1))-2*(X*Z');" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The gaussian kernel is the most well known and used kernel\n", "$$ \\kappa(x,y) \\eqdef e^{-\\frac{\\norm{x-y}^2}{2\\sigma^2}} . $$\n", "The bandwidth parameter $\\si>0$ is crucial and controls the locality of\n", "the model. It is typically tuned through cross validation." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "kappa = (X,Z,sigma) -> exp( -distmat(X,Z)/(2*sigma^2) );" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "We generate synthetic data in 2-D which are not separable by an\n", "hyperplane." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: div not defined", "output_type": "error", "traceback": [ "UndefVarError: div not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "n = 1000; p = 2\n", "t = 2*pi*rand(div(n,2),1)\n", "R = 2.5\n", "r = R*(1 + .2*rand(div(n,2),1)); # radius\n", "X1 = [cos(t).*r sin(t).*r]\n", "X = [randn(div(n,2),2); X1]\n", "y = [ones(div(n,2),1);-ones(div(n,2),1)];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display the classes." ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: plot_multiclasses not defined", "output_type": "error", "traceback": [ "UndefVarError: plot_multiclasses not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "plot_multiclasses(X,y,disp_dim=2;disp_legend=1);\n", "axis(\"off\");" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Once avaluated on grid points, the kernel define a matrix\n", "$$ K = (\\kappa(x_i,x_j))_{i,j=1}^n \\in \\RR^{n \\times n}. $$" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: X not defined", "output_type": "error", "traceback": [ "UndefVarError: X not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "sigma = 1\n", "K = kappa(X,X,sigma);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Valid kernels are those that gives rise to positive symmetric matrices\n", "$K$. The linear and Gaussian kernel are valid kernel functions. Other\n", "popular kernels include the polynomial kernel $ \\dotp{x}{y}^a $ for $a\n", "\\geq 1$ and the Laplacian kernel $ \\exp( -\\norm{x-y}^2/\\si ) $.\n", "\n", "\n", "The kernelized Logistic minimization reads\n", " $$ \\umin{h} F(h) \\eqdef \\Ll(K h,y). $$" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "F = (h,K,y) -> L(K*h,y);\n", "nablaF = (h,K,y) -> K'*nablaL(K*h,y);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "This minimization can be related to an infinite dimensional optimization\n", "problem where one minimizes directly over the function $f$. This\n", "is shown to be equivalent to the above finite-dimenisonal optimization problem\n", "thanks to the theory of RKHS." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 4__\n", "\n", "Implement a gradient descent to minimize $F(h)$.\n", "Monitor the energy decay.\n", "Test different step size, and compare with the theory." ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "LoadError: UndefVarError: K not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo4.jl, in expression starting on line 5", "output_type": "error", "traceback": [ "LoadError: UndefVarError: K not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo4.jl, in expression starting on line 5", "", " in macro expansion; at /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo4.jl:6 [inlined]", " in anonymous at ./:?", " in include_from_node1(::String) at ./loading.jl:488", " in include_from_node1(::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "include(\"NtSolutions/ml_3_classification/exo4.jl\");" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Once this optimal $h$ has been found, class probability at a point\n", "$x$ are obtained as\n", " $$ (\\th(f_h(x)), 1-\\th(f_h(x)) $$\n", "where $f_h$ has been defined above.\n", "\n", "\n", "We evaluate this classification probability on a grid." ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: X not defined", "output_type": "error", "traceback": [ "UndefVarError: X not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "q = 201\n", "tmax = 3.5\n", "t = linspace(-tmax,tmax,q)\n", "B,A = meshgrid( t,t )\n", "G = [A[:] B[:]]\n", "Theta = reshape( theta(kappa(G,X,sigma)*h) , q,q);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display the classification probability." ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: Theta not defined", "output_type": "error", "traceback": [ "UndefVarError: Theta not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "imshow(Theta'[:,end:-1:1], extent=[-tmax, tmax, -tmax, tmax], cmap = get_cmap(\"jet\"));\n", "plot_multiclasses(X,y,disp_legend = 0);\n", "clim(0,1)\n", "#caxis([0 1]);\n", "axis(\"off\");" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 5__\n", "\n", "Display evolution of the classification probability with $\\sigma$" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "LoadError: UndefVarError: X not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo5.jl, in expression starting on line 4", "output_type": "error", "traceback": [ "LoadError: UndefVarError: X not defined\nwhile loading /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo5.jl, in expression starting on line 4", "", " in macro expansion; at /Users/gpeyre/Dropbox/github/numerical-tours/julia/NtSolutions/ml_3_classification/exo5.jl:7 [inlined]", " in anonymous at ./:?", " in include_from_node1(::String) at ./loading.jl:488", " in include_from_node1(::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "include(\"NtSolutions/ml_3_classification/exo5.jl\");" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 6__\n", "\n", "Separate the dataset into a training set and a testing set. Evaluate the classification performance\n", "for varying $\\si$. Try to introduce regularization and minmize\n", "$$ \\umin{h} F(h) \\eqdef \\Ll(K h,y) + \\la R(h) $$\n", "where for instance $R=\\norm{\\cdot}_2^2$ or $R=\\norm{\\cdot}_1$." ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "include(\"NtSolutions/ml_3_classification/exo6.jl\");" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Multi-Classes Logistic Classification\n", "-------------------------------------\n", "The logistic classification method is extended to an arbitrary number\n", "$k$ of classes by considering a familly of weight vectors $ w_\\ell\n", "$_{\\ell=1}^k, which are conveniently stored as columns of matrix $W \\in \\RR^{p \\times k}$.\n", "\n", "\n", "This allows to model probabilitically the belonging of a point $x \\in \\RR^p $ to a\n", "the classes using an exponential model\n", " $$ h(x) = \\pa{ \\frac{ e^{-\\dotp{x}{w_\\ell}} }{ \\sum_m e^{-\\dotp{x}{w_m}} } }_\\ell $$\n", "This vector $h(x) \\in [0,1]^k $ describes the probability of $x$\n", "belonging to the different classes, and $ \\sum_\\ell h(x)_\\ell = 1 $.\n", "\n", "\n", "The computation of $w$ is obtained by solving a maximum likelihood\n", "estimator\n", " $$ \\umax{w \\in \\RR^k} \\frac{1}{n} \\sum_{i=1}^n \\log( h(x_i)_{y_i} ) $$\n", "where we recall that $y_i \\in \\{1,\\ldots,k\\}$ is the class index of\n", "point $x_i$.\n", "\n", "\n", "This is conveniently rewritten as\n", " $$ \\umin{w} \\sum_i \\text{LSE}( XW )_i - \\dotp{XW}{D} $$\n", "where $D \\in \\{0,1\\}^{n \\times k}$ is the binary class index matrices\n", " $$ D_{i,\\ell} = \\choice{\n", " 1 \\qifq y_i=\\ell, \\\\\n", " 0 \\quad \\text{otherwise}.\n", " }\n", " $$\n", "and LSE is the log-sum-exp operator\n", " $$ \\text{LSE}(S) = \\log\\pa{ \\sum_\\ell \\exp(S_{i,\\ell}) } \\in \\RR^n. $$" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "LSE = S -> log( sum(exp(S), 2) );" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The computation of LSE is\n", "unstable for large value of $S_{i,\\ell}$ (numerical overflow, producing NaN), but this can be\n", "fixed by substracting the largest element in each row,\n", "since $ \\text{LSE}(S+a)=\\text{LSE}(S)+a $ if $a$ is constant along rows. This is\n", "the [celebrated LSE trick](https://en.wikipedia.org/wiki/LogSumExp)." ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "max2 = S -> repeat(mapslices(maximum, S,2), outer=(1, size(S,2)))\n", "LSE_stab = S -> LSE( S-max2(S) ) + mapslices(maximum, S,2);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The gradient of the LSE operator is the\n", "\n", "$$ \\nabla \\text{LSE}(S) = \\text{SM}(S) \\eqdef\n", " \\pa{\n", " \\frac{\n", " e^{S_{i,\\ell}}\n", " }{\n", " \\sum_m e^{S_{i,m}}\n", " } } $$" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "SM = S -> exp(S) ./ repeat( sum(exp(S),2), outer=(1, size(S,2)));" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Similarely to the LSE, it needs to be stabilized." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "SM_stab = S -> SM(S-max2(S));" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "We load a dataset of $n$ images of size $p = 8 \\times 8$, representing digits from 0\n", "to 9 (so there are $k=10$ classes).\n", "\n", "\n", "Load the dataset and randomly permute it.\n", "Separate the features $X$ from the data $y$ to predict information." ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "A = readdlm(\"NtToolBox/src/data/digits.csv\", ',')\n", "A = A[randperm(size(A,1)),:]\n", "X = A[:,1:end-1]; y = A[:,end];" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "$n$ is the number of samples, $p$ is the dimensionality of the features, $k$\n", "the number of classes." ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "n,p = size(X);\n", "CL = unique(y); # list of classes.\n", "k = length(CL);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display a few samples digits" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "q = 5\n", "for i=1:k\n", " I = find(y.==CL[i]);\n", " for j=1:q\n", " f = reshape(X[I[j],:], Int(sqrt(p)), Int(sqrt(p)))';\n", " subplot(q,k, (j-1)*k+i );\n", " imshow(-f, extent=[0,1,0,1], cmap=get_cmap(\"gray\")); axis(\"image\"); axis(\"off\")\n", " end\n", "end\n" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display in 2D." ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: plot_multiclasses not defined", "output_type": "error", "traceback": [ "UndefVarError: plot_multiclasses not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "plot_multiclasses(X,y,disp_dim = 2, ms = 5, disp_legend = 1);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display in 3D." ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: plot_multiclasses not defined", "output_type": "error", "traceback": [ "UndefVarError: plot_multiclasses not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "plot_multiclasses(X,y,disp_dim=3);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Compute the $D$ matrix." ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "D = Int.(repeat(CL[:]', outer=(n,1)) .== repeat(y, outer=(1,k))); #double" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Define the energy $E(W)$." ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "E = W -> 1/n*( sum(LSE(X*W)) - dotp(X*W,D) );" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Define its gradients\n", " $$ \\nabla E(W) = \\frac{1}{n} X^\\top ( \\text{SM}(X W) - D ). $$" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "nablaE = W -> 1/n * X'* ( SM_stab(X*W) - D );" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 7__\n", "\n", "Implement a gradient descent\n", "$$ W_{\\ell+1} = W_\\ell - \\tau_\\ell \\nabla E(W_\\ell). $$\n", "Monitor the energy decay." ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "include(\"NtSolutions/ml_3_classification/exo7.jl\");" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "W = zeros(p,k)\n", "Elist = []\n", "tau = .01\n", "niter = 500\n", "for i=1:niter\n", " W = W - tau * nablaE(W)\n", " append!(Elist, E(W))\n", "end\n", "plot(1:niter, Elist, lw=2)\n", "axis(\"tight\");" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Generate a 2D grid of points over PCA space and map it to feature space." ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "U,D,V = svd(Xm(X),thin=true)\n", "Z = Xm(X) * V\n", "M = maximum(abs(Z[:]))\n", "q = 201\n", "t = linspace(-M,M,q)\n", "B,A = meshgrid(t,t)\n", "G = zeros(q*q,p)\n", "G[:,1:2] = [A[:]; B[:]]\n", "G = G*V' + repeat(mean(X,1), outer=(q*q, 1));" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Evaluate class probability associated to weight vectors on this grid." ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "Theta = SM(G*W)\n", "Theta = reshape(Theta, q, q, k);" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display each probablity map." ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "PyPlot.Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for i=1:k\n", " subplot(3,4,i)\n", " imshow(Theta[:,:,i]'[:,end:-1:1], extent = [0,1,0,1], cmap=get_cmap(\"jet\"));\n", " title(string(\"Class \", i))\n", " axis(\"image\"); axis(\"off\")\n", "end\n", "tight_layout()" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Build a single color image of this map." ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "col = [ [1 0 0]; [0 1 0]; [0 0 1]; [0 0 0]; [0 1 1]; [1 0 1]; [1 1 0];\n", " [1 .5 .5]; [.5 1 .5]; [.5 .5 1] ]'\n", "R = zeros(q,q,3)\n", "for i=1:k\n", " for a=1:3\n", " R[:,:,a] = R[:,:,a] + Theta[:,:,i] .* col[a,i]\n", " end\n", "end" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Display." ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false, "deletable": true, "editable": true }, "outputs": [ { "ename": "LoadError", "evalue": "UndefVarError: plot_multiclasses3 not defined", "output_type": "error", "traceback": [ "UndefVarError: plot_multiclasses3 not defined", "", " in include_string(::String, ::String) at ./loading.jl:441", " in include_string(::String, ::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?" ] } ], "source": [ "imshow(permutedims(R, [2, 1, 3]), extent = [-tmax, tmax, -tmax, tmax]); \n", "plot_multiclasses3(X,y,disp_dim=2,ms=3,disp_legend=1);\n", "axis(\"off\");" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__Exercise 8__\n", "\n", "Separate the dataset into a training set and a testing set. Evaluate the classification performance\n", "and display the confusion matrix. You can try the impact of kernlization and regularization." ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "include(\"NtSolutions/ml_3_classification/exo8.jl\");" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": true, "deletable": true, "editable": true }, "outputs": [], "source": [ "# Insert your code here." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "" ] } ], "metadata": { "kernelspec": { "display_name": "Julia 0.5.0", "language": "julia", "name": "julia-0.5" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "0.5.0" } }, "nbformat": 4, "nbformat_minor": 1 }