Machine Learning/NumPy_Intro.ipynb

{
 "metadata": {
  "gist_id": "3a13c1e21be788efa5dc",
  "name": "",
  "signature": "sha256:aa41a4c4eb33bbac597ed2ddccf8ef540f1d7977e377e26b359d7a01ca62240e"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Getting Warmed Up:"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This is a series of notebooks (in progress) to document my learning, and hopefully to help others learn machine learning. I would love suggestions / corrections / feedback for these notebooks.\n",
      "\n",
      "<a target=\"_parent\"href=\"http://rmdk.ca\">Visit my webpage for more</a>. \n",
      "\n",
      "Email me: <a target=\"_parent\" href=\"http://rmdk.ca/contact/\">ryan@rmdk.ca</a>\n",
      "\n",
      "\n",
      "I'd love if you shared this post"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "social()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "\n",
        "    <a style='float:left; margin-right:5px;' href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-text=\"Check this out\" data-via=\"Ryanmdk\">Tweet</a>\n",
        "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>\n",
        "    <a style='float:left; margin-right:5px;' href=\"https://twitter.com/Ryanmdk\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @Ryanmdk</a>\n",
        "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>\n",
        "    <a style='float:left; margin-right:5px;'target='_parent' href=\"http://www.reddit.com/submit\" onclick=\"window.location = 'http://www.reddit.com/submit?url=' + encodeURIComponent(window.location); return false\"> <img src=\"http://www.reddit.com/static/spreddit7.gif\" alt=\"submit to reddit\" border=\"0\" /> </a>\n",
        "<script src=\"//platform.linkedin.com/in.js\" type=\"text/javascript\">\n",
        "  lang: en_US\n",
        "</script>\n",
        "<script type=\"IN/Share\"></script>\n"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "<IPython.core.display.HTML at 0x105c7e2d0>"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Learning NumPy Basics"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "numpy.version.full_version"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 66,
       "text": [
        "'1.8.0'"
       ]
      }
     ],
     "prompt_number": 66
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([0,1,2,3,4, 5])\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 48,
       "text": [
        "array([0, 1, 2, 3, 4, 5])"
       ]
      }
     ],
     "prompt_number": 48
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Get a look at the dimensions and shape of the data"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print a.ndim\n",
      "print a.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "(6,)\n"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Transform array into 2D matrix."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = a.reshape((3,2)) # rows, columns\n",
      "b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 50,
       "text": [
        "array([[0, 1],\n",
        "       [2, 3],\n",
        "       [4, 5]])"
       ]
      }
     ],
     "prompt_number": 50
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However, since we set a = b, any changes in either will be reflected in both to avoid copying."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b[0][0] = 100\n",
      "b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 51,
       "text": [
        "array([[100,   1],\n",
        "       [  2,   3],\n",
        "       [  4,   5]])"
       ]
      }
     ],
     "prompt_number": 51
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 52,
       "text": [
        "array([100,   1,   2,   3,   4,   5])"
       ]
      }
     ],
     "prompt_number": 52
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Whenever you need a true copy, use **.copy( ) **"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c = a.reshape((3,2)).copy()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 53
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Another feature of NumPy array's is that the operations are propagated to the individual elements. Which is in contrast to normal python lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print a * 2\n",
      "print [1,2,3,4] * 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[6 2 4 6 6 6]\n",
        "[1, 2, 3, 4, 1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 84
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Indexing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Arrays can be accessed in several ways.\n",
      "\n",
      "- In addtion to normal list indexing, we can use arrays themselves as indices."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Index a with a vector 2,3,4\n",
      "a[np.array([2,3,4])]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 55,
       "text": [
        "array([2, 3, 4])"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Since conditions are propagated to the individual elements, we can access out data in interesting ways."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Return boolean mask\n",
      "print a > 4\n",
      "mask = a > 4\n",
      "\n",
      "print a[a>4] == a[mask]\n",
      "\n",
      "# Return the masked data or everything but the mask\n",
      "print a[mask]\n",
      "print a[-mask]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ True False False False False  True]\n",
        "[ True  True]\n",
        "[100   5]\n",
        "[1 2 3 4]\n"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You could also do things like trim outliers."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a[a>3] = 3\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 57,
       "text": [
        "array([3, 1, 2, 3, 3, 3])"
       ]
      }
     ],
     "prompt_number": 57
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It turns out that this is pretty popular, so there is a predefined function for it.\n",
      "\n",
      "**.clip( )** will take two arguments are clip the values at both ends of the interval."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.clip(1,3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 58,
       "text": [
        "array([3, 1, 2, 3, 3, 3])"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Dealing with missing values"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One of the most common things we run into as data scientists is missing data. How we deal with that missing data is integral to the outcome and robustness of the analysis. NumPy can use one of several special NAN characters to denote missing values"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Pretend to be read from text file\n",
      "c = np.array([1,2, np.NAN, 3, 5]) \n",
      "print c\n",
      "print np.isnan(c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[  1.   2.  nan   3.   5.]\n",
        "[False False  True False False]\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c[-np.isnan(c)] # Non-missing data"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 32,
       "text": [
        "array([ 1.,  2.,  3.,  5.])"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This becomes a required tool even for the first stages of exploratory analysis"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print np.mean(c)\n",
      "print np.mean(c[-np.isnan(c)])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "nan\n",
        "2.75\n"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Lets compare runtime between NumPy and regular python lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We are using NumPy for a reason right? Here we will simply calculate the sum of squares for all numbers from 1 - 2 000 and report how long it takes over 10 000 iterations."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from timeit import timeit\n",
      "\n",
      "normal_python = timeit('sum(x*x for x in xrange(1000))',\n",
      "                       number = 10000)\n",
      "\n",
      "#compute dot product of vectors which is equivilent to the product\n",
      "Numpy_python = timeit('x.dot(x)', setup='import numpy as np;\\\n",
      "                      x=np.arange(1000)' ,number=10000)\n",
      "\n",
      "print(\"Normal Python: {} seconds\").format(normal_python)\n",
      "print (\"Numpy: {} seconds\").format(Numpy_python)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Normal Python: 0.676285982132 seconds\n",
        "Numpy: 0.0202009677887 seconds\n"
       ]
      }
     ],
     "prompt_number": 74
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However, we have to be careful, because simply using NumPy does not gaurentee efficiency."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If we dont take advantage of the optimized Numpy code, we are not going to get anywhere. We should always look for the optimized, or vectorized versions, which allow us to operate on the entire matrix or array at once, rather than looping."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dumb_numpy = timeit ('sum(x*x)', setup='import numpy as np;\\\n",
      "                    x=np.arange(1000)', number=10000)\n",
      "print(\"Dumb numpy: {} seconds\").format(dumb_numpy)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Dumb numpy: 3.61384701729 seconds\n"
       ]
      }
     ],
     "prompt_number": 76
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "At the mercy of speed, we sacrifice some of the flexibility of python lists. In Numpy we can only store a single datatype in an array, where as a list can hold pretty much anything.\n",
      "\n",
      "Keep in mind that sometimes a list could be better suited to your problem rather than a NumPy array"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.dtype"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 77,
       "text": [
        "dtype('int64')"
       ]
      }
     ],
     "prompt_number": 77
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When we try to use different data types in the same array, Numpy will try to coerce them into a common format. For example, if we combine strings and integers, NumPy will convert the numeric values into strings."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.array([1,'string'])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 78,
       "text": [
        "array(['1', 'string'], \n",
        "      dtype='|S6')"
       ]
      }
     ],
     "prompt_number": 78
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.core.display import HTML\n",
      "\n",
      "\n",
      "def css_styling():\n",
      "    styles = open(\"/users/ryankelly/desktop/custom_notebook.css\", \"r\").read()\n",
      "    return HTML(styles)\n",
      "css_styling()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "\n",
        "<style>\n",
        "body {\n",
        "    font-family: Century Gothic, sans;\n",
        "\n",
        "}\n",
        "\n",
        "\n",
        "div.text_cell_render h1 { /* Main titles bigger, centered */\n",
        "font-size: 2.2em;\n",
        "line-height:1.4em;\n",
        "text-align:center;\n",
        "}\n",
        "\n",
        "/*Input and output cells formatting*/\n",
        "div.prompt.input_prompt, div.prompt.output_prompt {\n",
        "    visibility: hidden;\n",
        "    /*font-family: Consolas;*/\n",
        "    color: #575748;\n",
        "    /*background-color: #CCCCCC;*/\n",
        "    border: 0px;\n",
        "    width: 6.5em;\n",
        "    float:left;\n",
        "}\n",
        "\n",
        "\n",
        "div.output_subarea.output_text.output_stream.output_stdout,div.output_subarea.output_text {\n",
        "    margin-left: 1.5em;\n",
        "    padding-top: 1em;\n",
        "    padding-bottom: 0.5em;\n",
        "    margin-top: 8px; /*This is for getting the box-shadow property of the parent to display properly;*/\n",
        "}\n",
        "\n",
        "div.cell { /* Tunes the space between cells */\n",
        "margin-top:1em;\n",
        "margin-bottom:1em;\n",
        "width:100%;\n",
        "margin-right:auto;\n",
        "overflow-x:hidden;\n",
        "}\n",
        "\n",
        "div.text_cell_render{\n",
        "    overflow-x:hidden;\n",
        "      \n",
        "}\n",
        "\n",
        "\n",
        "div.input{\n",
        "margin-right:1%;\n",
        "}\n",
        "\n",
        "</style>\n",
        " \n",
        "\n",
        "\n",
        "\n"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 2,
       "text": [
        "<IPython.core.display.HTML at 0x105c7e850>"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def social():\n",
      "    code = \"\"\"\n",
      "    <a style='float:left; margin-right:5px;' href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-text=\"Check this out\" data-via=\"Ryanmdk\">Tweet</a>\n",
      "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>\n",
      "    <a style='float:left; margin-right:5px;' href=\"https://twitter.com/Ryanmdk\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @Ryanmdk</a>\n",
      "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>\n",
      "    <a style='float:left; margin-right:5px;'target='_parent' href=\"http://www.reddit.com/submit\" onclick=\"window.location = 'http://www.reddit.com/submit?url=' + encodeURIComponent(window.location); return false\"> <img src=\"http://www.reddit.com/static/spreddit7.gif\" alt=\"submit to reddit\" border=\"0\" /> </a>\n",
      "<script src=\"//platform.linkedin.com/in.js\" type=\"text/javascript\">\n",
      "  lang: en_US\n",
      "</script>\n",
      "<script type=\"IN/Share\"></script>\n",
      "\"\"\"\n",
      "    return HTML(code)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}