EECS445-PythonTutorialExercises.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#---------------------------------------------------#\n",
    "# PYTHON EXERCISES\n",
    "# September 12, 2016 #\n",
    "# EECS 445: Machine Learning #\n",
    "# Author: Valliappa Chockalingam (valli@umich.edu) \n",
    "# --------------------------------------------------#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 1: Numbers and Data Structures\n",
    "\n",
    "* Example: If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.\n",
    "\n",
    "* ***Question: Find the sum of all the multiples of 3 or 5 below 1000 in 3 ways.***\n",
    "\n",
    "- *Hint 1: * Loop through all the possible numbers, i.e., $x \\in \\mathbb{N} \\wedge x < 1000$ and simply add up the multiples as you go through them. Use two loops first and then try making your code more concise.\n",
    "\n",
    "- *Bonus: * Use the inclusion-exclusion principle. Write a function that calculates the sum of the first $n$ numbers in an arithmetic series. Hint: $S_n = \\frac{n}{2}(u_1 + u_n) = \\frac{n}{2}(2u_1 + (n - 1) \\cdot d)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Open Ended, No Skeleton Code for this question."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 2: Strings and Data Structures\n",
    "\n",
    "Note: *You are free to use any functions and libraries that come with Python.* The aim is not to necessarily implement\n",
    "code from scratch, but to get familiar with Python (specifically the syntax and data structures) and, to some extent, write concise readable working code.\n",
    "\n",
    "* *** (a): Given a non-empty string like \"Code\" return a string like \"CCoCodCode\". ***\n",
    "\n",
    "\n",
    "\n",
    "* *** (b): Given strings a, b and c, write a function that will replace all occurences of a in b with c. ***\n",
    "\n",
    "\n",
    "\n",
    "* *** (c): Given a string s that has been Caeser enciphered with a numeric shift n. Return the deciphered string.*** \n",
    "For example, s = \"vjku ku c eqfg\" and n = -2, returns \"this is a code\" Note: You can assume the string is all in lowercase without any special characters.\n",
    "\n",
    "\n",
    "\n",
    "* *** (d): Given a string s, return whether s is a palindrome, i.e, it is spelt the same when read from either direction. *** Note: Ignore case, special characters and spacing.\n",
    "\n",
    "\n",
    "\n",
    "* *** (e): Using the higher order function filter(), define a function filter_long_words() that takes a list of words and an integer n and returns the list of words that are longer than n (in the same order). ***\n",
    "\n",
    "\n",
    "\n",
    "* *** (f): Given a string s and a number n, return a list of size n consisting of tuples with two elements, the first being the correct string in the look-and-say-sequence and the second being a dictionary of character: count pairs. *** For example, if s = \"1\" and n = 5, the look-and-say-sequence is as follows:\n",
    "\n",
    "    ```\n",
    "    1 (\"1\", {\"1\" : 1})\n",
    "    11 (\"11\", {\"1\" : 2})\n",
    "    21 (\"21\", {\"1\" : 1, \"2\" : 1})\n",
    "    1211 (\"1211\", {\"1\" : 3, \"2\" : 1})\n",
    "    111221 (\"111221\", {\"1\" : 4, \"2\" : 2})\n",
    "    correct output: [(\"1\", {\"1\" : 1}), (\"11\", {\"1\" : 2}), (\"21\", {\"1\" : 1, \"2\" : 1}), \n",
    "    (\"1211\", {\"1\" : 3, \"2\" : 1}), (\"111221\", {\"1\" : 4, \"2\" : 2})]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Implement part (a) below\n",
    "def string_repeater(s):\n",
    "    pass\n",
    "\n",
    "# Implement part (b) below\n",
    "def string_occurence_remover(a, b, c):\n",
    "    pass\n",
    "\n",
    "# Implement part (c) below\n",
    "def caeser_decipher(s, n):\n",
    "    pass\n",
    "\n",
    "def is_palindrome(s):\n",
    "    pass\n",
    "\n",
    "def filter_long_words(l):\n",
    "    pass\n",
    "\n",
    "def look_and_say(s):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Simple Tests for part (a)\n",
    "assert(string_repeater(\"Code\") == \"CCoCodCode\")\n",
    "assert(string_repeater(\"EECS445\") == \"EEEEECEECSEECS4EECS44EECS445\")\n",
    "\n",
    "\n",
    "# Simple Tests for part (b)\n",
    "assert(string_occurence_remover(\"Boring\", \"PythonIsBoring\", \"Fun\") == \"PythonIsFun\")\n",
    "assert(string_occurence_remover(\"12\", \"Today is September 12 and 12 is my favorite number.\", \"9\") == \\\n",
    "       \"Today is September 9 and 9 is my favorite number.\")\n",
    "\n",
    "# Simple Tests for part (c)\n",
    "assert(caeser_decipher(\"vjku ku eqfg\", -2) == \"this is code\")\n",
    "assert(caeser_decipher(\"h khjd bnlotdqr\", 1) == \"i like computers\")\n",
    "\n",
    "# Simple Tests for part (d)\n",
    "assert(is_palindrome(\"Rats live on no evil star.\"))\n",
    "assert(is_palindrome(\"On a clover, if alive, erupts a vast pure evil; a fire volcano\"))\n",
    "assert(not is_palindrome(\"Hello, this is Jupyter Notebook speaking.\"))\n",
    "assert(not is_palindrome(\"I am currently in a hands-on lecture.\"))\n",
    "\n",
    "# Simple Tests for part (e)\n",
    "assert(filter_long_words(['a', '', '0', 'a0', 'a0b02030', 'ee', 'cs', 'eecs', 'eeccss'], 2) == ['a0b02030', 'eecs', 'eeccss'])\n",
    "assert(filter_long_words(['1', '2'], 2) == ['1', '2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3: Classes and Interactive I/O\n",
    "\n",
    "*** (a) Define a class which has at least two methods, getString: to get a string from console input and printString: to print the string in upper case. Also write a simple test to check the functionality class methods. ***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** (b) Write a program able to play the \"Guess the number\"-game, where the number to be guessed is randomly chosen between 1 and 20.***\n",
    "\n",
    "(Source: http://inventwithpython.com) This is how it should work when run in a terminal:\n",
    "\n",
    "```\n",
    "Hello! What is your name?\n",
    "Valli\n",
    "Well, Valli, I am thinking of a number between 1 and 20.\n",
    "Take a guess.\n",
    "10\n",
    "Your guess is too low.\n",
    "Take a guess.\n",
    "15\n",
    "Your guess is too low.\n",
    "Take a guess.\n",
    "18\n",
    "Good job, Valli! You guessed my number in 3 guesses!\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random\n",
    "class GuessTheNumber():\n",
    "    # Create a constructor here (__init__ function) that takes two numbers, a minimum and a maximum for \n",
    "    # the range that guesses can take. Save these in variable min_guess and max_guess. Create and \n",
    "    # initialize a Boolean called incorrect to be true. (Note: Python booleans use capitalization, >T<rue or >F<alse)\n",
    "        \n",
    "    def play():\n",
    "        print(\"Hello! What is your name?\")\n",
    "        # Write code to get input from the user and save it into a string variable name.\n",
    "        print(\"Well, \" + name + \", I am thinking of a number between 1 and 20.\")\n",
    "        answer = random.randrange(self.min_guess, self.max_guess + 1)\n",
    "        # Write the main loop to collect guesses and check whether it's write. Also remember to save the count!\n",
    "        # Additionally, if the guess is out of range or input is unexpected (like type mismatch or non-numeric input), \n",
    "        # simply print an error message and break from the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Test out your game!\n",
    "g = GuessTheNumber(1, 20)\n",
    "g.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 4: Pandas and Data Exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Generate some Data for analysis\n",
    "from sklearn.datasets import make_classification\n",
    "X, y = make_classification(1000, n_features=5, n_informative=2, \n",
    "                           n_redundant=2, n_classes=2, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (a) Get a glimpse of the data by making a Pandas DataFrame from the data and then printing the first few and last\n",
    "# few rows.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (b) Plot a boxplot of each column to visualize the distribution of the data column values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (c) Try using the description() function of the DataFrame.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (d) Install Seaborn if it is not already installed and import it below. Then, perform a pairwise plot using the data. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (e) Now try Seaborn's correlation plot (Heatmap).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (Optional) Using the first 70% of the data as a training set and the last 30% as a test set, construct a classifier\n",
    "# and see how well it performs. You will be certainly able to do this at the end of the course!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 6: Numpy Exercises "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (a) Write a function that takes in a tuple and a string that can either \n",
    "# be 'zero', 'one' or 'gaussian' and correspondingly return a NumPy array that contains those elements. For 'gaussian', \n",
    "# assume sampling with mean = 0, std = 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (b) Write a function that returns a n x n identity matrix with n as a parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (c) Write a function that normalizes a matrix to [0, 1] and returns the normalized matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (d) Write code that creates a NumPy array and makes it immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (e) Write a function that finds the closest value to a given scalar s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (f) Write a function that subtracts the mean of each row from a matrix and returns it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (g) Write a function that sorts an array by the nth column and returns the sorted array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 7: Numpy + First ML algorithm!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (a) Write a function that implements Ordinary Least Squares given an input matrix X and a vector of targets y. \n",
    "# We will go over the method in the forthcoming lecture, but the equation is given in \n",
    "# https://en.wikipedia.org/wiki/Linear_regression#Estimation_methods \n",
    "# Note: Use NumPy here, but do NOT make use of library functions that do this for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_regression\n",
    "X, y = make_regression(1000, n_features=1, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (b) Run your function on the above data and plot the data as well as the decision boundary (trendline) \n",
    "# generated by your classifer using matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [py3k]",
   "language": "python",
   "name": "Python [py3k]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}