notebooks/7-algos-and-data-structures.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "7-algos-and-data-structures.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jonkrohn/ML-foundations/blob/master/notebooks/7-algos-and-data-structures.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aTOLgsbN69-P"
      },
      "source": [
        "# Algorithms & Data Structures"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yqUB9FTRAxd-"
      },
      "source": [
        "This class, *Algorithms & Data Structures*, introduces the most important computer science topics for machine learning, enabling you to design and deploy computationally efficient data models. \n",
        "\n",
        "Through the measured exposition of theory paired with interactive examples, you’ll develop a working understanding of all of the essential data structures across the list, dictionary, tree, and graph families. You’ll also learn the key algorithms for working with these structures, including those for searching, sorting, hashing, and traversing data. \n",
        "\n",
        "The content covered in this class is itself foundational for the *Optimization* class of the *Machine Learning Foundations* series."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d4tBvI88BheF"
      },
      "source": [
        "Over the course of studying this topic, you'll: \n",
        "\n",
        "* Use “Big O” notation to characterize the time efficiency and space efficiency of a given algorithm, enabling you to select or devise the most sensible approach for tackling a particular machine learning problem with the hardware resources available to you.\n",
        "* Get acquainted with the entire range of the most widely-used Python data structures, including list-, dictionary-, tree-, and graph-based structures. \n",
        "* Develop an understanding of all of the essential algorithms for working with data, including those for searching, sorting, hashing, and traversing. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z68nQ0ekCYhF"
      },
      "source": [
        "**Note that this Jupyter notebook is not intended to stand alone. It is the companion code to a lecture or to videos from Jon Krohn's [Machine Learning Foundations](https://github.com/jonkrohn/ML-foundations) series, which offer detail on the following:**\n",
        "\n",
        "*Segment 1: Introduction to Data Structures and Algorithms*\n",
        "* A Brief History of Data\n",
        "* A Brief History of Algorithms\n",
        "* “Big O” Notation for Time and Space Complexity \n",
        " \n",
        "*Segment 2: Lists and Dictionaries*\n",
        "* List-Based Data Structures: Arrays, Linked Lists, Stacks, Queues, and Deques \n",
        "* Searching and Sorting: Binary, Bubble, Merge, and Quick\n",
        "* Set-Based Data Structures: Maps and Dictionaries\n",
        "* Hashing: Hash Tables, Load Factors, and Hash Maps\n",
        "\n",
        "*Segment 3: Trees and Graphs*\n",
        "* Trees: Decision Trees, Random Forests, and Gradient-Boosting (XGBoost)\n",
        "* Graphs: Terminology, Directed Acyclic Graphs (DAGs)\n",
        "* Resources for Further Study of Data Structures & Algorithms\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "US_XIfDtbQ97"
      },
      "source": [
        "# Segment 1: Intro to Data Structures & Algorithms"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ovp27r5XbQ98"
      },
      "source": [
        "### \"Big O\" Notation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H9P5M6chbQ98"
      },
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import torch\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import time # for timing processes\n",
        "import random # for generating random values"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rG1p0sPTbQ9_"
      },
      "source": [
        "#### Constant Time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vjkFiJxCbQ-A"
      },
      "source": [
        "def take_first(my_list):\n",
        "    return my_list[0]"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgiIJRe0bQ-C"
      },
      "source": [
        "short_list = [13, 25, 42]"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GV9YDEMSbQ-F"
      },
      "source": [
        "tic = time.process_time() # if using a version of Python older than 3.3, you can use time.clock() here\n",
        "first = take_first(short_list)\n",
        "toc = time.process_time()"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rK1UsYwgbQ-H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e950a974-9600-449c-bcea-149434ab923d"
      },
      "source": [
        "first"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q4Ek1NZXbQ-L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7327777c-2257-49a9-d3aa-182d284ecc5f"
      },
      "source": [
        "toc-tic"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7.340600000027564e-05"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7gOQ5YsDbQ-N"
      },
      "source": [
        "long_list = [42] * 10**8 # one hundred million items"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mvlDw_QubQ-Q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89760d23-af3b-459c-896b-30ac04df9589"
      },
      "source": [
        "len(long_list)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "100000000"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "atHBBvjUbQ-S"
      },
      "source": [
        "tic = time.process_time()\n",
        "first = take_first(long_list)\n",
        "toc = time.process_time()"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c5-RorglbQ-V",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f77b409-8b0d-47f2-b488-180c2ba7f386"
      },
      "source": [
        "toc-tic"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9.509300000054566e-05"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VOzWLc7hbQ-Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "da7a5f80-2a7c-49a9-9f33-ba178dc5149a"
      },
      "source": [
        "list_lengths = [10**l for l in range(1, 8)]\n",
        "list_lengths"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 100, 1000, 10000, 100000, 1000000, 10000000]"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P_cblOS1bQ-b"
      },
      "source": [
        "constant_times = []\n",
        "\n",
        "for l in list_lengths:\n",
        "    lst = [42]*l\n",
        "  \n",
        "    tic = time.process_time()\n",
        "    x = take_first(lst)\n",
        "    toc = time.process_time()\n",
        "  \n",
        "    constant_times.append(toc-tic)"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "75ZhYcELbQ-f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "outputId": "2841ae00-0fee-48c1-cbae-06c6e999929e"
      },
      "source": [
        "constant_df = pd.DataFrame(list(zip(list_lengths, constant_times)), columns=['n', 'time'])\n",
        "constant_df"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>n</th>\n",
              "      <th>time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>0.000006</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>100</td>\n",
              "      <td>0.000001</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1000</td>\n",
              "      <td>0.000001</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>10000</td>\n",
              "      <td>0.000001</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>100000</td>\n",
              "      <td>0.000006</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>1000000</td>\n",
              "      <td>0.000008</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>10000000</td>\n",
              "      <td>0.000010</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "          n      time\n",
              "0        10  0.000006\n",
              "1       100  0.000001\n",
              "2      1000  0.000001\n",
              "3     10000  0.000001\n",
              "4    100000  0.000006\n",
              "5   1000000  0.000008\n",
              "6  10000000  0.000010"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OuN_BT2cbQ-h"
      },
      "source": [
        "#### Linear Time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FZL22BUebQ-i"
      },
      "source": [
        "def find_max(my_list):\n",
        "    max_value = my_list[0]\n",
        "    for i in range(len(my_list)):\n",
        "        if my_list[i] > max_value:\n",
        "            max_value = my_list[i]\n",
        "    return max_value"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcN1QkRMbQ-l"
      },
      "source": [
        "tic = time.process_time()\n",
        "largest = find_max(short_list)\n",
        "toc = time.process_time()"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8lMMH3ckbQ-o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea16ccd5-e6c9-45b0-ca07-9544dde8c802"
      },
      "source": [
        "toc-tic"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.935200000057762e-05"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z6wEKdTVbQ-q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07baf17b-e383-4960-93c5-eda378437459"
      },
      "source": [
        "largest"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aWCO7ykabQ-s"
      },
      "source": [
        "tic = time.process_time()\n",
        "largest = find_max(long_list)\n",
        "toc = time.process_time()"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ml1ymMSdbQ-u",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36c5559f-54e1-4204-b28c-913f693c0abd"
      },
      "source": [
        "toc-tic"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7.366269512000001"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tNNuyd8vbQ-w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a0d36154-864c-4d5c-82ee-b5837eda271e"
      },
      "source": [
        "largest"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M8CH9iVqbQ-y"
      },
      "source": [
        "linear_times = []\n",
        "\n",
        "for l in list_lengths:\n",
        "    lst = [42]*l\n",
        "  \n",
        "    tic = time.process_time()\n",
        "    x = find_max(lst)\n",
        "    toc = time.process_time()\n",
        "  \n",
        "    linear_times.append(toc-tic)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WdH0rse1bQ-0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "92dd86a4-5af9-47ff-e8e8-01948cc278c5"
      },
      "source": [
        "linear_df = pd.DataFrame(list(zip(list_lengths, linear_times)), columns=['n', 'time'])\n",
        "linear_df"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>n</th>\n",
              "      <th>time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>0.000010</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>100</td>\n",
              "      <td>0.000011</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1000</td>\n",
              "      <td>0.000111</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>10000</td>\n",
              "      <td>0.001233</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>100000</td>\n",
              "      <td>0.007534</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>1000000</td>\n",
              "      <td>0.070181</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>10000000</td>\n",
              "      <td>0.736056</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "          n      time\n",
              "0        10  0.000010\n",
              "1       100  0.000011\n",
              "2      1000  0.000111\n",
              "3     10000  0.001233\n",
              "4    100000  0.007534\n",
              "5   1000000  0.070181\n",
              "6  10000000  0.736056"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NcAT8vylbQ-2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "a0ff98fc-4198-46ce-d39b-7cfb47891ae4"
      },
      "source": [
        "_ = sns.lmplot(x='n', y='time', data=linear_df, ci=None) # linear model (regression) plot"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yDkSjD7QbQ-4"
      },
      "source": [
        "#### Polynomial Time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GDU07KttbQ-5"
      },
      "source": [
        "def element_multiplier(my_list): \n",
        "    for i in range(len(my_list)):\n",
        "        for j in range(len(my_list)):\n",
        "            x = my_list[i] * my_list[j]"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gKJhMq94bQ-7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f2971b1-ed2c-4a2b-9e98-c8b14737b63a"
      },
      "source": [
        "list_lengths"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 100, 1000, 10000, 100000, 1000000, 10000000]"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8POGVlk_bQ-9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d94f939f-c510-4870-b3e4-cc531779da3e"
      },
      "source": [
        "list_lengths[:4] # compute time gets annoyingly long from list_lengths[5] onward"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 100, 1000, 10000]"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HSTNVTA1bQ_A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f061a461-da34-4147-c455-9987f9801800"
      },
      "source": [
        "granular_list_lengths = list_lengths[:4] + [50, 500, 5000]\n",
        "granular_list_lengths.sort()\n",
        "granular_list_lengths"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 50, 100, 500, 1000, 5000, 10000]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "luWZPfGkbQ_B"
      },
      "source": [
        "poly_times = []\n",
        "\n",
        "for l in granular_list_lengths:\n",
        "    lst = [42]*l\n",
        "\n",
        "    tic = time.process_time()\n",
        "    x = element_multiplier(lst)\n",
        "    toc = time.process_time()\n",
        "\n",
        "    poly_times.append(toc-tic)"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LuIgiv79bQ_E",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "b14d381a-6059-4766-cf0e-8029e39be823"
      },
      "source": [
        "poly_df = pd.DataFrame(list(zip(granular_list_lengths, poly_times)), columns=['n', 'time'])\n",
        "poly_df"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>n</th>\n",
              "      <th>time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>0.000029</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>50</td>\n",
              "      <td>0.000472</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>100</td>\n",
              "      <td>0.001740</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>500</td>\n",
              "      <td>0.041035</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1000</td>\n",
              "      <td>0.114318</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>5000</td>\n",
              "      <td>2.859176</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>10000</td>\n",
              "      <td>11.243735</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       n       time\n",
              "0     10   0.000029\n",
              "1     50   0.000472\n",
              "2    100   0.001740\n",
              "3    500   0.041035\n",
              "4   1000   0.114318\n",
              "5   5000   2.859176\n",
              "6  10000  11.243735"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YRPtWuObbQ_G",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "d8f8d38b-5455-4558-8929-fdd36fddbf0b"
      },
      "source": [
        "_ = sns.lmplot(x='n', y='time', data=poly_df, ci=None, order=2)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBOSI7RgbQ_I"
      },
      "source": [
        "**In Big O notation**:\n",
        "\n",
        "* Constant: O(1)\n",
        "* Linear: O($n$)\n",
        "* Polynomial: O($n^2$)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S-Iu9v9pbQ_I"
      },
      "source": [
        "**Other common runtimes**:\n",
        "\n",
        "* Logarithmic: O(log $n$)\n",
        "* Exponential: O($2^n$)\n",
        "* O($n$ log $n$)\n",
        "* O($n!$)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yEmvHfjDbQ_I"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uwkFwWfGbQ_J"
      },
      "source": [
        "## Segment 2: Lists and Dictionaries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "75kQx0StbQ_J"
      },
      "source": [
        "### List-Based Data Structures"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LMZUkiBzbQ_K"
      },
      "source": [
        "#### Lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bYjn-LUvbQ_K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "850019d8-192b-4df2-daca-ca88f7622cf5"
      },
      "source": [
        "t = [25, 2, 5]\n",
        "t"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[25, 2, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_9ue0FJzbQ_M"
      },
      "source": [
        "Lists in Python are **extensible** by default: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BxLoVg9LbQ_N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d73ba5f8-5534-4b06-e819-68bdc8c979b5"
      },
      "source": [
        "t.append(26)\n",
        "t"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[25, 2, 5, 26]"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nn0mjz8IbQ_P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19a88d02-1800-4238-d497-c30528982309"
      },
      "source": [
        "t[2]"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pNCGZLPibQ_Q"
      },
      "source": [
        "Cannot apply mathematical operators, e.g., try uncommenting: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UYOXE7t3bQ_R"
      },
      "source": [
        "# t/2"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3bqqZduEbQ_T"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IO1j-BB3bQ_T"
      },
      "source": [
        "#### Arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T9Wufa8ZbQ_U",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b242ac42-82dd-4302-e050-1f96ebe10132"
      },
      "source": [
        "x = np.array([25, 2, 5])\n",
        "x"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([25,  2,  5])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ILAFgARTbQ_W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d0f10fa-4bc9-4bd8-fef6-eea3a9c9de48"
      },
      "source": [
        "x[2]"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eaQZXwGYbQ_Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca12bbef-1548-4cd7-cdfa-d50cdb684efe"
      },
      "source": [
        "x/2."
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([12.5,  1. ,  2.5])"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O2njtLKPbQ_b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8aec13a-34c7-4deb-ec7c-3e09bae33cfe"
      },
      "source": [
        "y = torch.tensor([[25, 2, 5], [26, 1, 4]])\n",
        "y"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[25,  2,  5],\n",
              "        [26,  1,  4]])"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lO4Fp87RbQ_d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e3e1893a-5574-4b02-d659-67a84bce1fb7"
      },
      "source": [
        "y[0, 2]"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(5)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WVmPPyNybQ_g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1ebec2e-a5ac-4e5c-92da-573963e1ba4c"
      },
      "source": [
        "y/2."
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[12.5000,  1.0000,  2.5000],\n",
              "        [13.0000,  0.5000,  2.0000]])"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XLGc3ZLNbQ_i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11c6f84f-9c88-4d90-942e-a27c2d9a1f99"
      },
      "source": [
        "z = tf.Variable([[[0, 1], [2, 3]], [[25, 26], [7, 9]]], dtype=tf.float16)\n",
        "z"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(2, 2, 2) dtype=float16, numpy=\n",
              "array([[[ 0.,  1.],\n",
              "        [ 2.,  3.]],\n",
              "\n",
              "       [[25., 26.],\n",
              "        [ 7.,  9.]]], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b-mBUUXSbQ_l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddfc98b2-1e66-44ec-f493-9c765a3470a9"
      },
      "source": [
        "z[1, 0, 0]"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=25.0>"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vF_Vx6kUbQ_n",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25bbe601-7747-4234-99c4-de1f1a931b1c"
      },
      "source": [
        "z/2."
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 2), dtype=float16, numpy=\n",
              "array([[[ 0. ,  0.5],\n",
              "        [ 1. ,  1.5]],\n",
              "\n",
              "       [[12.5, 13. ],\n",
              "        [ 3.5,  4.5]]], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grLMKTA9bQ_p"
      },
      "source": [
        "Arrays in Python are also typically extensible by default.\n",
        "\n",
        "Note that it's very efficient (O(1)) to append items to end of list..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yw0vxB1wbQ_p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "58f4e60b-29c9-48eb-edbe-ec48ee5e0ec8"
      },
      "source": [
        "np.append(x, 26)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([25,  2,  5, 26])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3VVvEmDcbQ_r"
      },
      "source": [
        "...but time inefficient to add at start or middle of long list as later items will need to be shifted to later in list. Worst case is insert at beginning of list, which has O($n$) complexity. \n",
        "\n",
        "Note that as well as appending, accessing an array element by index or finding the array's length are O(1)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eAMI_JhobQ_s"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ux7X2TtObQ_t"
      },
      "source": [
        "#### Stacks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mfUpv9mmbQ_t"
      },
      "source": [
        "Can be implemented in Python with lists: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ox6jmYt1bQ_t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "684af062-3554-4703-f27e-aafa1406149e"
      },
      "source": [
        "s = []\n",
        "s"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aO62dJ7mbQ_v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "62e94c41-d0be-4acb-91a1-516d9c40dd94"
      },
      "source": [
        "s.append('five_of_diamonds') # push\n",
        "s"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['five_of_diamonds']"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6xL9EVlEbQ_x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b553c5d-0d1c-41c2-b801-a432779f39b2"
      },
      "source": [
        "s.append('queen_of_hearts')\n",
        "s"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['five_of_diamonds', 'queen_of_hearts']"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mp3FWjIAbQ_1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "164493ba-0293-47c9-c4db-9762f02711cd"
      },
      "source": [
        "s.append('ace_of_spades')\n",
        "s"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['five_of_diamonds', 'queen_of_hearts', 'ace_of_spades']"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yj7R5DypbQ_3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "07a7f104-df74-4643-cf85-15132a495ed7"
      },
      "source": [
        "s.pop()"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'ace_of_spades'"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PRJMSEi6bQ_6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a2de7e1-77c6-4ac4-e98b-1b1e0fc8345c"
      },
      "source": [
        "s"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['five_of_diamonds', 'queen_of_hearts']"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1h5Jn3sNbQ_8"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sW1P2RYgbQ_8"
      },
      "source": [
        "### Searching and Sorting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MOGhRGE7bQ_-"
      },
      "source": [
        "Topics in this section: \n",
        "* Binary search\n",
        "* Bubble sort\n",
        "* Merge sort\n",
        "* Quick sort"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "926iDawVbQ__"
      },
      "source": [
        "#### Binary Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vh4b6rjibQ__"
      },
      "source": [
        "Let's say we have an array, `b`: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AqihwZaBbRAA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "effb9865-1ba1-4273-c6d0-c1a05a710f0c"
      },
      "source": [
        "b = np.array([25, 2, 5, 14, 22, 11, 96, 1, 101])\n",
        "b"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 25,   2,   5,  14,  22,  11,  96,   1, 101])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ILRfUWW8bRAB"
      },
      "source": [
        "Under normal circumstances, the only way to search for a value (e.g., `25`) is to search element by element. In the worse-case, this has O($n$) time complexity (e.g., if we were to search `b` for `25` from its end).\n",
        "\n",
        "If `b` already happens to be sorted, however..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H3kijg5DbRAB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2cb14a06-79ab-420d-df9e-c3395e32d8b0"
      },
      "source": [
        "b.sort() # FYI: uses quick sort\n",
        "b"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([  1,   2,   5,  11,  14,  22,  25,  96, 101])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jUNwtC9VbRAD"
      },
      "source": [
        "...we can use the **binary search** algorithm, which has O(log $n$) time complexity: \n",
        "\n",
        "* Start at the midpoint (`b` is nine elements long, so midpoint is 5th: `14`).\n",
        "* Since `25` is larger than `14`, we need only search the top half of `b`...\n",
        "* So we find the midpoint between the 5th element and the 9th, which is the 7th, and which happens to be `25`. \n",
        "* Done! And in only two steps instead of seven (if we were to search elementwise from first onward).\n",
        "* If we were searching for `22`, then our next search would be halfway between 5th and 7th elements, which is 6th element and voilà!\n",
        "* With our nine-element array, worst case is four steps (for `1` or `101`) to find any value (or determine value *isn't* in array).\n",
        "\n",
        "(Note: called *binary* because at each step we either search upward or downward.)\n",
        "\n",
        "Doubling $n$ results in only one extra step in worst case: \n",
        "* One step with array of length 1($= 2^0$)\n",
        "* Two steps with length 2($= 2^1$) up to length 3\n",
        "* Three steps with $n = 4 (= 2^2$) up to $n = 7$\n",
        "* Four steps with $n = 8 (= 2^3$) up to $n = 15$\n",
        "* Five steps with $n = 16 (= 2^4$) up to $n = 31$\n",
        "\n",
        "Hence O(log $n$) where, as is typical in CS, we use $\\text{log}_2$ (because of binary bits and frequently doubling/halving quantities). E.g.: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aMCXLkATbRAD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "182af65b-8462-46e3-e5d7-a9c2ea7576d2"
      },
      "source": [
        "np.log2(4) + 1"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GkKU00_jbRAF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "79ca9906-5395-4f0d-ae40-f2067ec90c23"
      },
      "source": [
        "np.log2(8) + 1"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4.0"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lem_1CFEbRAH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "28a6e0bb-8779-433a-be22-b99f692572fe"
      },
      "source": [
        "np.log2(16) + 1"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qw_uflkYbRAJ"
      },
      "source": [
        "Recall that we retain only the dominant term, so O(log $n$ + 1) becomes O(log $n$)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uKR2g6w-bRAK"
      },
      "source": [
        "Here's an implementation of binary search, for your reference, that *iterates* over binary search steps with a `while` loop: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eSnow5fBbRAK"
      },
      "source": [
        "def binary_search(array, value):\n",
        "    \n",
        "    low = 0\n",
        "    high = len(array)-1\n",
        "    \n",
        "    while low <= high:\n",
        "        midpoint = (low + high) // 2 # rounds down to nearest integer after division\n",
        "        if value < array[midpoint]:\n",
        "            high = midpoint-1\n",
        "        elif value > array[midpoint]:\n",
        "            low = midpoint+1\n",
        "        else:\n",
        "            return midpoint\n",
        "    return -1"
      ],
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KVLvfQyMbRAL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e18deeeb-9f73-4475-e55f-49afc76de86d"
      },
      "source": [
        "binary_search(b, 25)"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vlIy86McbRAO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb4ce70f-ab36-4667-b903-a695087c706d"
      },
      "source": [
        "binary_search(b, 255)"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QgWnRKYMbRAP"
      },
      "source": [
        "Alternatively, you could implement binary search with *recursion* instead of iteration: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CGW08COgbRAQ"
      },
      "source": [
        "def recursive_binary_search(array, value, low, high):\n",
        "    \n",
        "    if low <= high:\n",
        "        \n",
        "        midpoint = (low + high) // 2\n",
        "        \n",
        "        if array[midpoint] == value:\n",
        "            return midpoint\n",
        "        elif array[midpoint] > value:\n",
        "            return recursive_binary_search(array, value, low, midpoint-1)\n",
        "        else:\n",
        "            return recursive_binary_search(array, value, midpoint+1, high)\n",
        "    else:\n",
        "        return -1"
      ],
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KCybEoSTbRAR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "538c9d8c-04e9-482c-8695-cfe7391912f2"
      },
      "source": [
        "recursive_binary_search(b, 25, 0, len(b)-1)"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rHNqJWZFbRAS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1d62bce-2237-4708-9ea1-81dbe13e3afe"
      },
      "source": [
        "recursive_binary_search(b, 255, 0, len(b)-1)"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-4qFVG7wbRAV"
      },
      "source": [
        "#### Bubble Sort"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xXl97ruDbRAV"
      },
      "source": [
        "Binary search required a sorted list. To sort a list (e.g., from smallest to largest value), the most naïve (and computationally complex) approach would be to compare every given element with all other elements.\n",
        "\n",
        "A common naïve implementation is the **bubble sort**, which allows the largest values to gradually \"bubble up\" toward the \"top\" (typically the end) of the array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Si7_TCUBbRAW"
      },
      "source": [
        "def bubble_sort(array):\n",
        "    \n",
        "    n = len(array)\n",
        "    \n",
        "    for i in range(n-1):\n",
        "        for j in range(0, n-1): # could be n-i-1 as, e.g., top value is guaranteed to have bubbled up in 1st iteration\n",
        "            if array[j] > array[j+1]:\n",
        "                array[j], array[j+1] = array[j+1], array[j]\n",
        "                \n",
        "    return array"
      ],
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bHJXYGoWbRAX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2aa0c755-6675-4939-d996-0b6eed1b3331"
      },
      "source": [
        "b = np.array([25, 2, 5, 14, 22, 11, 96, 1, 101])\n",
        "b"
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 25,   2,   5,  14,  22,  11,  96,   1, 101])"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dRG0hcs8bRAa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1e4ff96e-1ef3-4010-97f2-73e2a294c6e0"
      },
      "source": [
        "bubble_sort(b)"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([  1,   2,   5,  11,  14,  22,  25,  96, 101])"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SeEwGoyhbRAb"
      },
      "source": [
        "* During each iteration, we make $n-1$ comparisons \n",
        "* A total of $n-1$ iterations need to be made\n",
        "\n",
        "$$ (n-1)(n-1) = n^2 -2n + 1 $$\n",
        "\n",
        "Since we drop all terms but the dominant one, this leaves us with polynomial O($n^2$) time complexity for the worst case and the average case. (For more clever implementations, best case is O($n$) because array would already be sorted.)\n",
        "\n",
        "In contrast, as is typical in algos, there is a time- vs memory-complexity trade-off: Memory complexity is constant, O(1)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XaVyDNNEbRAb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7acc4605-31dc-46eb-8e08-017d1eea0d9f"
      },
      "source": [
        "granular_list_lengths"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 50, 100, 500, 1000, 5000, 10000]"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5VCZfbt5bRAd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "01797a85-a668-4f12-e4fd-0c750de92a06"
      },
      "source": [
        "max(granular_list_lengths)"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10000"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KF3yROSObRAf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cbb60788-ef17-492e-a7bd-7c84cac07c44"
      },
      "source": [
        "random.sample(range(0, max(granular_list_lengths)), 5) # samples 5 integers w/o replacement from uniform distribution"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4100, 6070, 6320, 1403, 1156]"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BH-e63O-bRAg"
      },
      "source": [
        "bubble_times = []\n",
        "\n",
        "for l in granular_list_lengths[0:7]:\n",
        "    lst = random.sample(range(0, max(granular_list_lengths)), l)\n",
        "    \n",
        "    tic = time.process_time()\n",
        "    x = bubble_sort(lst)\n",
        "    toc = time.process_time()\n",
        "    \n",
        "    bubble_times.append(toc-tic)"
      ],
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sc7PYo7rbRAi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "b4b45c40-feb5-43b0-c1cf-c7f80aae00a1"
      },
      "source": [
        "bubble_df = pd.DataFrame(list(zip(granular_list_lengths, bubble_times)), columns=['n', 'time'])\n",
        "bubble_df"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>n</th>\n",
              "      <th>time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>0.000034</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>50</td>\n",
              "      <td>0.000650</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>100</td>\n",
              "      <td>0.002506</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>500</td>\n",
              "      <td>0.069574</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1000</td>\n",
              "      <td>0.192991</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>5000</td>\n",
              "      <td>4.496831</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>10000</td>\n",
              "      <td>17.602106</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       n       time\n",
              "0     10   0.000034\n",
              "1     50   0.000650\n",
              "2    100   0.002506\n",
              "3    500   0.069574\n",
              "4   1000   0.192991\n",
              "5   5000   4.496831\n",
              "6  10000  17.602106"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ylF8L9ZRbRAk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "4977f132-0ae9-4762-f874-2ea3db903f8d"
      },
      "source": [
        "_ = sns.lmplot(x='n', y='time', data=bubble_df, ci=None, order=2)"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BaIYCE7CbRAl"
      },
      "source": [
        "#### Merge Sort"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ebEOGvNbRAm"
      },
      "source": [
        "* General idea is to \"divide and conquer\"; specifically:\n",
        "    1. Halve the array into smaller arrays\n",
        "    2. Sort the smaller arrays\n",
        "    3. Merge them back into full array\n",
        "* The above steps are carried out recursively so ultimately sort arrays of max length 2, then merge back up to full length."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rwJEeUdTbRAm"
      },
      "source": [
        "def merge_sort(my_list): # using list instead of array so we can .pop() (np arrays don't pop with built-in method)\n",
        "    \n",
        "    if len(my_list) > 1: # if length is 1, no need to sort (at deepest recursion, some will have len 1, others len 2)\n",
        "        \n",
        "        # 1. Halve: \n",
        "        midpoint = len(my_list) // 2 # Note: This is ~O(log n) behavior\n",
        "        left_half = my_list[:midpoint]\n",
        "        right_half = my_list[midpoint:]\n",
        "        \n",
        "        # 2. Sort (recursively):\n",
        "        left_half = merge_sort(left_half)\n",
        "        right_half = merge_sort(right_half)\n",
        "        \n",
        "        my_list = []\n",
        "        \n",
        "        # 3. Merge: \n",
        "        while len(left_half)>0 and len(right_half)>0: # Note: This inner loop exhibits ~O(n) behavior\n",
        "            \n",
        "            if left_half[0] < right_half[0]:\n",
        "                my_list.append(left_half.pop(0)) # pop first element\n",
        "            \n",
        "            else: # 1st element of right half < 1st element of left\n",
        "                my_list.append(right_half.pop(0))\n",
        "                \n",
        "        # If any elements remain from either half, they must be the largest value:\n",
        "        for i in left_half:\n",
        "            my_list.append(i)\n",
        "        for i in right_half:\n",
        "            my_list.append(i)\n",
        "    \n",
        "    return my_list"
      ],
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yu0POqD4bRAo"
      },
      "source": [
        "m = [25, 2, 5, 14, 22, 11, 96, 1, 101]"
      ],
      "execution_count": 72,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yb5kYBRNbRAq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a94f85c7-34a2-4c3a-f3cc-c08d75e88962"
      },
      "source": [
        "merge_sort(m)"
      ],
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 5, 11, 14, 22, 25, 96, 101]"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wft09yAQbRAr"
      },
      "source": [
        "Because of the O($n$) loop performing comparisons inside of the function halving list sizes (which we'll need to call O(log $n$) times), merge sort time complexity is the product, i.e., O($n$ log $n$)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UsiZJrrobRAs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "90b26620-3bc8-4fd4-ca91-4984f32be093"
      },
      "source": [
        "granular_list_lengths"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 50, 100, 500, 1000, 5000, 10000]"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O2bhlTkgbRAw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c80a331-ade7-4130-8ec2-7791293df063"
      },
      "source": [
        "ext_granular_lengths = granular_list_lengths + [50000, 100000] # extended\n",
        "ext_granular_lengths"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000]"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y174TTjwbRAx"
      },
      "source": [
        "merge_times = []\n",
        "\n",
        "for l in ext_granular_lengths:\n",
        "    lst = random.sample(range(0, max(ext_granular_lengths)), l)\n",
        "    \n",
        "    tic = time.process_time()\n",
        "    x = merge_sort(lst)\n",
        "    toc = time.process_time()\n",
        "    \n",
        "    merge_times.append(toc-tic)"
      ],
      "execution_count": 76,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pNQfPAy7bRAz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "601fd2b8-b22f-4af4-8a46-7a6b2ab31d9e"
      },
      "source": [
        "merge_df = pd.DataFrame(list(zip(ext_granular_lengths, merge_times)), columns=['n', 'time'])\n",
        "merge_df"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>n</th>\n",
              "      <th>time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>0.000052</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>50</td>\n",
              "      <td>0.000306</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>100</td>\n",
              "      <td>0.000540</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>500</td>\n",
              "      <td>0.003802</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1000</td>\n",
              "      <td>0.008672</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>5000</td>\n",
              "      <td>0.039585</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>10000</td>\n",
              "      <td>0.071275</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>50000</td>\n",
              "      <td>0.610348</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>100000</td>\n",
              "      <td>1.692389</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        n      time\n",
              "0      10  0.000052\n",
              "1      50  0.000306\n",
              "2     100  0.000540\n",
              "3     500  0.003802\n",
              "4    1000  0.008672\n",
              "5    5000  0.039585\n",
              "6   10000  0.071275\n",
              "7   50000  0.610348\n",
              "8  100000  1.692389"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TxbDpaXUbRA1"
      },
      "source": [
        "On local laptop, $n=10000$ took ~0.05s with merge sort compared to ~10.5s with bubble sort: a ~200x speedup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_vNv29-3bRA1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "1b66074c-b3b3-471f-ac21-f52685aa384b"
      },
      "source": [
        "_ = sns.lmplot(x='n', y='time', data=merge_df, ci=None, order=2)"
      ],
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j09sAT9ubRA3"
      },
      "source": [
        "In contrast, while memory complexity for bubble sort was O(1) because we were sorting \"in place\" (not storing any values in memory), memory complexity is O($n$) for merge sort. \n",
        "\n",
        "(We need at least two array copies (2$n$) for the most space-efficient merge sort implementations, but we drop constants so this becomes O($n$). Our recursive merge sort implementation would require more as it stores several copies in memory; one more copy of size $n$ would be used for every time the array length doubles (log $n$) resulting in O($n$ log $n$) memory complexity.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QgsX2oJNbRA3"
      },
      "source": [
        "#### Quick Sort"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "liGs0XOabRA3"
      },
      "source": [
        "Under many common conditions, the aptly-named **quick sort** is at least as time-efficient as merge sort while also being more space-efficient.\n",
        "\n",
        "Like merge sort, quick sort uses the \"divide and conquer\" principle:\n",
        "1. Pick a *pivot* point (often the final element, though it could be any element, e.g., first, random, median)\n",
        "2. Move pivot within array such that all elements above pivot are larger (though randomly ordered) and all elements below pivot are smaller (though likewise randomly ordered)\n",
        "    * Movement occurs element-by-element (and \"in place\", thus retaining O(1) memory complexity)\n",
        "3. Recursively, perform quick sort both below and above pivot"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k0oYCHi0bRA3"
      },
      "source": [
        "def quick_sort(array):\n",
        "    _quick_sort(array, 0, len(array)-1) # to start, low is index of first element in array; high is penultimate\n",
        "    return array"
      ],
      "execution_count": 79,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VW6wpvafbRA4"
      },
      "source": [
        "def _quick_sort(array, low, high): \n",
        "    \n",
        "    if low < high: # when low reaches high, we know all elements in array must be in order\n",
        "        \n",
        "        # Result of 2.: Element at \"partitioning index\" has been pivoted to its correct position\n",
        "        p_index = partition(array, low, high) \n",
        "        \n",
        "        # 3. Recursively sort the elements below the partitioning index...\n",
        "        _quick_sort(array, low, p_index-1)\n",
        "        # ...and, separately, above the partitioning index: \n",
        "        _quick_sort(array, p_index+1, high)\n",
        "        \n",
        "    return array"
      ],
      "execution_count": 80,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c4vF29ylbRA6"
      },
      "source": [
        "def partition(array, low, high):\n",
        "    \n",
        "    # 1. Use the final element as the pivot:\n",
        "    pivot = array[high]\n",
        "    \n",
        "    i = (low-1) # index of element on small side\n",
        "    for j in range(low, high): # like a bubble swap, we compare pivot to all elements between low and high\n",
        "        if array[j] < pivot: # if value < pivot, it's correctly on left so increment the smaller element's index...\n",
        "            i = i+1\n",
        "            array[i], array[j] = array[j], array[i] \n",
        "    array[i+1], array[high] = array[high], array[i+1] # ...otherwise, swap greater value to right of pivot (now what we want)\n",
        "    return(i+1) # return index of correctly positioned pivot"
      ],
      "execution_count": 81,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TGbYfXozbRA7"
      },
      "source": [
        "b = np.array([25, 2, 5, 14, 22, 11, 96, 1, 101])"
      ],
      "execution_count": 82,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eUwabel3bRA9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff275b9c-4b90-40e1-c36a-45339472736d"
      },
      "source": [
        "quick_sort(b)"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([  1,   2,   5,  11,  14,  22,  25,  96, 101])"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgrhXuTSbRA-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c6e6e5d3-ede1-4d5e-e390-0b2a56189d96"
      },
      "source": [
        "list_lengths"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 100, 1000, 10000, 100000, 1000000, 10000000]"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Zw2sLRDbRBA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5a0b6fb-e1c4-4ce1-dbbf-f62d8e65f4c1"
      },
      "source": [
        "list_lengths[:6]"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 100, 1000, 10000, 100000, 1000000]"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WMkykWEjbRBB"
      },
      "source": [
        "quick_times = []\n",
        "\n",
        "for l in list_lengths[:6]:\n",
        "    lst = random.sample(range(0, max(list_lengths[:6])), l)\n",
        "    \n",
        "    tic = time.process_time()\n",
        "    x = quick_sort(lst)\n",
        "    toc = time.process_time()\n",
        "    \n",
        "    quick_times.append(toc-tic)"
      ],
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aA3pD0GEbRBC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "de0616b8-67bc-44d2-861c-c1030d95965d"
      },
      "source": [
        "quick_df = pd.DataFrame(list(zip(list_lengths[:6], quick_times)), columns=['n', 'time'])\n",
        "quick_df"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>n</th>\n",
              "      <th>time</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>0.000028</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>100</td>\n",
              "      <td>0.000281</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1000</td>\n",
              "      <td>0.005268</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>10000</td>\n",
              "      <td>0.037872</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>100000</td>\n",
              "      <td>0.484105</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>1000000</td>\n",
              "      <td>5.806947</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "         n      time\n",
              "0       10  0.000028\n",
              "1      100  0.000281\n",
              "2     1000  0.005268\n",
              "3    10000  0.037872\n",
              "4   100000  0.484105\n",
              "5  1000000  5.806947"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WEWln2HPbRBF"
      },
      "source": [
        "At $n=$ 10k, about a 2x speed-up relative to merge sort (so ~400 relative to bubble sort).\n",
        "\n",
        "At $n=$ 100k, about a 5x speed-up relative to merge sort."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yMG5f6hwbRBG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "9d4f2122-dd7b-4b60-be51-f554b7a385c9"
      },
      "source": [
        "_ = sns.lmplot(x='n', y='time', data=quick_df, ci=None, order=2)"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "svDy0tGRbRBH"
      },
      "source": [
        "**Average-case time**: The efficiency of quick sort comes from moving lower-valued pivots toward the front (ideally to the midpoint) of the array then \"dividing and conquering\" on either side of the pivot. In which case (the average case), quick sort behaves like a merge sort (thereby it has O($n$ log $n$) time complexity), but in a manner that requires only a single copy of the array in memory.\n",
        "\n",
        "**Worst-case time**: With the pivot starting at the final element, if the array is already sorted, this is the worst case. There will be as many calls to `quick_sort()` as there are elements in the array (i.e., $n$ calls) and quick sort will perform a full round of bubble sorting (as per the `for j in range` loop) during each of those (i.e., $n-1$ comparisons); the product of these resulting in O($n^2$) time complexity. So, don't use quick sort if the array is nearly in order! \n",
        "\n",
        "**Best-case time**: If all values in the array are equal, quick sort will scan over them all once to confirm this, in which case it has O($n$) time complexity. The more values that are equal in the array, the closer to O($n$) performance will be."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wGql4D1WbRBH"
      },
      "source": [
        "Those are the most frequently covered sorting algos. They're relatively straightforward to implement and illustrate time/space complexity trade-offs clearly. There are, however, many more ways to sort, with pros and cons related to time/space complexity as well as implementation difficulty. See the [Big O Cheat Sheet here](https://www.bigocheatsheet.com)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ceTsWVKgbRBH"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LQOPQyUxbRBI"
      },
      "source": [
        "### Set-Based Data Structures: Maps/Dictionaries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-iUBoFZEbRBI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de1d66c3-a4b7-4992-d9ea-42ff686d0ede"
      },
      "source": [
        "inventory = {}\n",
        "inventory"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{}"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k9ThSSP7bRBK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e78e4dc5-871e-4ade-a741-ae3c19c62bca"
      },
      "source": [
        "inventory['hammer'] = [17]\n",
        "inventory"
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'hammer': [17]}"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CHAlpCLgbRBL"
      },
      "source": [
        "inventory['nail'] = [2552]\n",
        "inventory['unicorn'] = [2]\n",
        "inventory['dolphin'] = ['none']"
      ],
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GJvRhipdbRBM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15331c23-9602-4e4e-e5ab-6b0fadce777b"
      },
      "source": [
        "inventory"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'dolphin': ['none'], 'hammer': [17], 'nail': [2552], 'unicorn': [2]}"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iJElGR-VbRBO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebc4948b-de98-4e63-866b-d5d70e9b93f0"
      },
      "source": [
        "inventory['dolphin'] = [0]\n",
        "inventory"
      ],
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'dolphin': [0], 'hammer': [17], 'nail': [2552], 'unicorn': [2]}"
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kl1avvQAbRBP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b6fced4c-aa2b-4459-a702-1f423fdaaa1f"
      },
      "source": [
        "inventory['unicorn'].append(3)\n",
        "inventory"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'dolphin': [0], 'hammer': [17], 'nail': [2552], 'unicorn': [2, 3]}"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8EQa-WNwbRBQ"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QeJeTpTUbRBR"
      },
      "source": [
        "### Hashing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EZuRS1k8bRBR"
      },
      "source": [
        "Let's say we have some value: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qaEqWADrbRBR"
      },
      "source": [
        "value = 5551234567 # a phone number from any American '90s sitcom"
      ],
      "execution_count": 95,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SYNQv_GgbRBS"
      },
      "source": [
        "A common hash function approach is to use the modulo operator on the last few digits of the value..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NdQHebyabRBT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd464a6f-46f5-41e1-b9d1-30ec08f7d991"
      },
      "source": [
        "split_value = [digit for digit in str(value)]\n",
        "split_value"
      ],
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['5', '5', '5', '1', '2', '3', '4', '5', '6', '7']"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ElRrr1obRBU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e20becc0-bb6c-4f18-a4dd-1ece48758683"
      },
      "source": [
        "final_digits = int(''.join(split_value[-2:])) # final digits typically used b/c they tend to vary more than first ones\n",
        "final_digits"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "67"
            ]
          },
          "metadata": {},
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z8Z9NUsTbRBV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "175d2187-e141-4001-a1e6-b1407b9e7ff5"
      },
      "source": [
        "hash_value = final_digits % 10 # 10 is arbitrary, but would be used consistently across values to be hashed\n",
        "hash_value"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XEBGAP0FbRBW"
      },
      "source": [
        "def simple_hash(v):\n",
        "    split_v = [digit for digit in str(v)]\n",
        "    final_2 = int(''.join(split_v[-2:]))\n",
        "    return final_2 % 10"
      ],
      "execution_count": 99,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FTtuf6sJbRBZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c1c648e-6ff7-438b-8c76-138c8a37d5db"
      },
      "source": [
        "simple_hash(value)"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sNdnyNMkbRBb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d009c44-ca3c-437f-d213-a40cc41ac7bd"
      },
      "source": [
        "simple_hash(5557654321)"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bPfLF9b4bRBd"
      },
      "source": [
        "These hash values (`7` and `1`) could be used in a sequential, small-integer index, i.e., a *hash table*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pmpE8IHfbRBe"
      },
      "source": [
        "#### Collisions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lus6EYZhbRBe"
      },
      "source": [
        "Major problem with the `simple_hash()` function:\n",
        "* The hash table has at most ten indices \n",
        "* Ergo, many input values will result in **collisions**, e.g.:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ylVWx8jbRBe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca2d53e6-24cc-48c2-ee55-2c58fe61c9e0"
      },
      "source": [
        "simple_hash(555)"
      ],
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rSIkIOMtbRBf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20399069-0e07-4aee-db4c-9edd8339528b"
      },
      "source": [
        "simple_hash(125)"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jeVzqmMsbRBg"
      },
      "source": [
        "Three common ways to resolve collisions:\n",
        "1. Change the modulus denominator (e.g., `10` --> `11`); this adds procedural (and thus time) complexity to hash algo\n",
        "2. Change the hash function entirely; ditto w.r.t. procedural complexity\n",
        "3. Store a list (or similar) at the index, e.g.:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZxBjBwmcbRBg"
      },
      "source": [
        "hash_table = {}"
      ],
      "execution_count": 104,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vNyDE65wbRBh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d899c0db-ba7d-443d-b16b-c44372734713"
      },
      "source": [
        "hash_table[simple_hash(555)] = [555]\n",
        "hash_table"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{5: [555]}"
            ]
          },
          "metadata": {},
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x4ztIzo4bRBi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "74da3558-7f5e-473a-82b5-b59946d691d9"
      },
      "source": [
        "hash_table[simple_hash(125)].append(125)\n",
        "hash_table"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{5: [555, 125]}"
            ]
          },
          "metadata": {},
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nE4V0Qq4bRBk"
      },
      "source": [
        "Such a list is called a **bucket**. \n",
        "\n",
        "Worst case:\n",
        "* All of the values hash to the same hash value (e.g., `5`)\n",
        "* Thus, all of the values are stored in a single bucket\n",
        "* Searching through the bucket has linear O($n$) time complexity\n",
        "\n",
        "Alternatively, we can increase memory complexity instead of time complexity: \n",
        "* Use very large modulus denominator\n",
        "* Reduces probability of collisions\n",
        "* If use denominator of `1e9`, we have a hash table with a billion buckets\n",
        "\n",
        "Could also have a second hash function *inside* of the bucket (e.g., if we know we'll have a few very large buckets).\n",
        "\n",
        "There is no \"perfect hash\". It depends on the values you're working with. There are many options to consider with various trade-offs."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "98fmN7hBbRBk"
      },
      "source": [
        "**Load Factor**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GOG4oYkAbRBk"
      },
      "source": [
        "Metric that guides hashing decisions:\n",
        "$$ \\text{load factor} = \\frac{n_\\text{values}}{n_\\text{buckets}} $$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HfnftH3VbRBk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea44e70b-6d06-493d-8221-0b9dc21e94c7"
      },
      "source": [
        "10/1e9"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1e-08"
            ]
          },
          "metadata": {},
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PXphCIwvbRBl"
      },
      "source": [
        "If we have ten values to store, but a billion buckets...\n",
        "$$ \\text{load factor} = \\frac{10}{10^9} = 10^{-8}$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YtgP2bP2bRBl"
      },
      "source": [
        "...we are probably using much more memory than we need to. This is the case whenever load factor $\\approx 0$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xD6_09uwbRBm"
      },
      "source": [
        "On the other hand, if the load factor is approaching one, $n_\\text{values} \\approx n_\\text{buckets}$ and we may want to consider a larger hash table.\n",
        "\n",
        "If load factor $>1$, then collisions are guaranteed and the case for a larger hash table is even stronger."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f6CRWlNrbRBm"
      },
      "source": [
        "#### Hash Maps"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rfdnZtvZbRBm"
      },
      "source": [
        "In all of the above examples, we were hashing \"values\", but these \"values\" could in fact be the *keys* of a key-value pair, allowing us to have a **hash map**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DrsTrapabRBm"
      },
      "source": [
        "Let's say `Jane Dough` has receipt number `5551234567`, where we're using the receipt numbers as keys to look up customers. \n",
        "\n",
        "We can add this as an entry in a hash table for quick lookup later (once we have many more receipts...):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJWypGfybRBm"
      },
      "source": [
        "hash_map = {}"
      ],
      "execution_count": 108,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-WE0_Lu3bRBn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "60b42484-e1ed-40e7-e8c3-18ea522a491c"
      },
      "source": [
        "hash_map[simple_hash(5551234567)] = (5551234567, 'Jane Dough')\n",
        "hash_map"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{7: (5551234567, 'Jane Dough')}"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J6uw0CTbbRBo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bc19b8a-a87c-4c37-cc04-f58ea04d7f12"
      },
      "source": [
        "hash_map[simple_hash(5551234568)] = (5551234568, 'Johnny Dochevski')\n",
        "hash_map"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{7: (5551234567, 'Jane Dough'), 8: (5551234568, 'Johnny Dochevski')}"
            ]
          },
          "metadata": {},
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D2EcE46ubRBq"
      },
      "source": [
        "**FYI**: In Python, dictionaries are hash maps."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "31sAGRifbRBq"
      },
      "source": [
        "#### String Keys"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h7jhtFxvbRBr"
      },
      "source": [
        "If our keys are character strings, we can still make use of hashing by converting the character string into an integer.\n",
        "\n",
        "For example, we could use the [ASCII table](http://www.asciitable.com) to convert `Jon` to `112157156`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L4WA71uvKYm8"
      },
      "source": [
        "**Exercises**\n",
        "\n",
        "1. Use the `simple_hash()` function to add a customer named Jean d'Eau, who has receipt number `5551234569`, to `hash_map`.\n",
        "\n",
        "1. You have a hash table with a million buckets and two million values to store in the table. What is your load factor? Are collisions likely? If so, how can the probability of collisions be reduced? \n",
        "\n",
        "1. Use the octal standard of the ASCII table to convert the string `Llama` into an integer representation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zZMONjCZbRBr"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CP9-bZ3XbRBr"
      },
      "source": [
        "## Segment 3: Trees and Graphs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4I1ClWo7bRBr"
      },
      "source": [
        "### Decision Trees"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_AQ6Eo8qbRBr"
      },
      "source": [
        "titanic = sns.load_dataset('titanic')"
      ],
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4r5mwCPWbRBs",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "outputId": "b4d1c1cc-e5f6-4fca-f6ce-e2da68baccf1"
      },
      "source": [
        "titanic"
      ],
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>survived</th>\n",
              "      <th>pclass</th>\n",
              "      <th>sex</th>\n",
              "      <th>age</th>\n",
              "      <th>sibsp</th>\n",
              "      <th>parch</th>\n",
              "      <th>fare</th>\n",
              "      <th>embarked</th>\n",
              "      <th>class</th>\n",
              "      <th>who</th>\n",
              "      <th>adult_male</th>\n",
              "      <th>deck</th>\n",
              "      <th>embark_town</th>\n",
              "      <th>alive</th>\n",
              "      <th>alone</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>male</td>\n",
              "      <td>22.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>7.2500</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>female</td>\n",
              "      <td>38.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>71.2833</td>\n",
              "      <td>C</td>\n",
              "      <td>First</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>C</td>\n",
              "      <td>Cherbourg</td>\n",
              "      <td>yes</td>\n",
              "      <td>False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>3</td>\n",
              "      <td>female</td>\n",
              "      <td>26.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>7.9250</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>yes</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>female</td>\n",
              "      <td>35.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>53.1000</td>\n",
              "      <td>S</td>\n",
              "      <td>First</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>C</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>yes</td>\n",
              "      <td>False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>male</td>\n",
              "      <td>35.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>8.0500</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>886</th>\n",
              "      <td>0</td>\n",
              "      <td>2</td>\n",
              "      <td>male</td>\n",
              "      <td>27.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>13.0000</td>\n",
              "      <td>S</td>\n",
              "      <td>Second</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>887</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>female</td>\n",
              "      <td>19.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>30.0000</td>\n",
              "      <td>S</td>\n",
              "      <td>First</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>B</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>yes</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>888</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>female</td>\n",
              "      <td>NaN</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>23.4500</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>889</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>male</td>\n",
              "      <td>26.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>30.0000</td>\n",
              "      <td>C</td>\n",
              "      <td>First</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>C</td>\n",
              "      <td>Cherbourg</td>\n",
              "      <td>yes</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>890</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>male</td>\n",
              "      <td>32.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>7.7500</td>\n",
              "      <td>Q</td>\n",
              "      <td>Third</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Queenstown</td>\n",
              "      <td>no</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>891 rows × 15 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     survived  pclass     sex   age  ...  deck  embark_town  alive  alone\n",
              "0           0       3    male  22.0  ...   NaN  Southampton     no  False\n",
              "1           1       1  female  38.0  ...     C    Cherbourg    yes  False\n",
              "2           1       3  female  26.0  ...   NaN  Southampton    yes   True\n",
              "3           1       1  female  35.0  ...     C  Southampton    yes  False\n",
              "4           0       3    male  35.0  ...   NaN  Southampton     no   True\n",
              "..        ...     ...     ...   ...  ...   ...          ...    ...    ...\n",
              "886         0       2    male  27.0  ...   NaN  Southampton     no   True\n",
              "887         1       1  female  19.0  ...     B  Southampton    yes   True\n",
              "888         0       3  female   NaN  ...   NaN  Southampton     no  False\n",
              "889         1       1    male  26.0  ...     C    Cherbourg    yes   True\n",
              "890         0       3    male  32.0  ...   NaN   Queenstown     no   True\n",
              "\n",
              "[891 rows x 15 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ybcAVekXbRBt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0cafae45-ef2f-46d1-fc23-0518bcd7123e"
      },
      "source": [
        "np.unique(titanic['survived'], return_counts=True)"
      ],
      "execution_count": 113,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([0, 1]), array([549, 342]))"
            ]
          },
          "metadata": {},
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iRMcgJsMbRBu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b627959b-aaef-464e-c2d1-04dd66a81583"
      },
      "source": [
        "np.unique(titanic['sex'], return_counts=True)"
      ],
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array(['female', 'male'], dtype=object), array([314, 577]))"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ypbFKoWYbRBw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1e62deab-175e-43de-9584-a02e293f71b3"
      },
      "source": [
        "np.unique(titanic['class'], return_counts=True)"
      ],
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array(['First', 'Second', 'Third'], dtype=object), array([216, 184, 491]))"
            ]
          },
          "metadata": {},
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c7fhfdfjbRBx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "outputId": "ec705dca-742d-4deb-f8df-919f742edf1f"
      },
      "source": [
        "gender = pd.get_dummies(titanic['sex'])\n",
        "gender"
      ],
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>female</th>\n",
              "      <th>male</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>886</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>887</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>888</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>889</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>890</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>891 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     female  male\n",
              "0         0     1\n",
              "1         1     0\n",
              "2         1     0\n",
              "3         1     0\n",
              "4         0     1\n",
              "..      ...   ...\n",
              "886       0     1\n",
              "887       1     0\n",
              "888       1     0\n",
              "889       0     1\n",
              "890       0     1\n",
              "\n",
              "[891 rows x 2 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5ZrmCPalbRBy",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "outputId": "974a0f20-fde1-4ee6-d01c-9535dfa3f767"
      },
      "source": [
        "clas = pd.get_dummies(titanic['class'])\n",
        "clas"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>First</th>\n",
              "      <th>Second</th>\n",
              "      <th>Third</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>886</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>887</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>888</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>889</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>890</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>891 rows × 3 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     First  Second  Third\n",
              "0        0       0      1\n",
              "1        1       0      0\n",
              "2        0       0      1\n",
              "3        1       0      0\n",
              "4        0       0      1\n",
              "..     ...     ...    ...\n",
              "886      0       1      0\n",
              "887      1       0      0\n",
              "888      0       0      1\n",
              "889      1       0      0\n",
              "890      0       0      1\n",
              "\n",
              "[891 rows x 3 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iyu7ditFbRBz"
      },
      "source": [
        "y = titanic.survived"
      ],
      "execution_count": 118,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxhDwnjFbRB2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "outputId": "91fc0719-ccb7-40a5-a1f5-7933d70980e5"
      },
      "source": [
        "X = pd.concat([clas.First, clas.Second, gender.female], axis=1)\n",
        "X"
      ],
      "execution_count": 119,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>First</th>\n",
              "      <th>Second</th>\n",
              "      <th>female</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>886</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>887</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>888</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>889</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>890</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>891 rows × 3 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     First  Second  female\n",
              "0        0       0       0\n",
              "1        1       0       1\n",
              "2        0       0       1\n",
              "3        1       0       1\n",
              "4        0       0       0\n",
              "..     ...     ...     ...\n",
              "886      0       1       0\n",
              "887      1       0       1\n",
              "888      0       0       1\n",
              "889      1       0       0\n",
              "890      0       0       0\n",
              "\n",
              "[891 rows x 3 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 119
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zsJ5YtrdbRB3"
      },
      "source": [
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": 120,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WuqGw1-ZbRB5"
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)"
      ],
      "execution_count": 121,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U-NyY2qTbRB6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "72a86d20-49ca-4970-840e-c3997496cd66"
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(596, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9YOgdtp3bRB7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5d639c7-d7bc-4a1f-ed90-8fe374d475b2"
      },
      "source": [
        "y_train.shape"
      ],
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(596,)"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jjc8dNehbRB9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1bc24809-529b-49be-e655-99ace11b4f14"
      },
      "source": [
        "X_test.shape"
      ],
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(295, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AQn0vfiLbRCA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3e2189c7-6f6b-48dd-857b-e0e85c87b320"
      },
      "source": [
        "y_test.shape"
      ],
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(295,)"
            ]
          },
          "metadata": {},
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_qqzwlHWbRCB"
      },
      "source": [
        "from sklearn.tree import DecisionTreeClassifier, plot_tree"
      ],
      "execution_count": 126,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6rQcNwcgbRCC"
      },
      "source": [
        "dt_model = DecisionTreeClassifier()"
      ],
      "execution_count": 127,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5qy2a1RKbRCE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36e2158f-1b08-49ac-f61e-77c338ed0e58"
      },
      "source": [
        "dt_model.fit(X_train, y_train)"
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "DecisionTreeClassifier()"
            ]
          },
          "metadata": {},
          "execution_count": 128
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rwU0_o7tbRCG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 439
        },
        "outputId": "8117e568-8895-4445-8626-1d3b9b614f15"
      },
      "source": [
        "plot_tree(dt_model) # can read about Gini here: en.wikipedia.org/wiki/Decision_tree_learning#Gini_impurity"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Text(186.0, 190.26, 'X[2] <= 0.5\\ngini = 0.467\\nsamples = 596\\nvalue = [374, 222]'),\n",
              " Text(111.60000000000001, 135.9, 'X[0] <= 0.5\\ngini = 0.304\\nsamples = 390\\nvalue = [317, 73]'),\n",
              " Text(74.4, 81.53999999999999, 'X[1] <= 0.5\\ngini = 0.263\\nsamples = 314\\nvalue = [265, 49]'),\n",
              " Text(37.2, 27.180000000000007, 'gini = 0.252\\nsamples = 237\\nvalue = [202, 35]'),\n",
              " Text(111.60000000000001, 27.180000000000007, 'gini = 0.298\\nsamples = 77\\nvalue = [63, 14]'),\n",
              " Text(148.8, 81.53999999999999, 'gini = 0.432\\nsamples = 76\\nvalue = [52, 24]'),\n",
              " Text(260.40000000000003, 135.9, 'X[0] <= 0.5\\ngini = 0.4\\nsamples = 206\\nvalue = [57, 149]'),\n",
              " Text(223.20000000000002, 81.53999999999999, 'X[1] <= 0.5\\ngini = 0.465\\nsamples = 147\\nvalue = [54, 93]'),\n",
              " Text(186.0, 27.180000000000007, 'gini = 0.498\\nsamples = 99\\nvalue = [53, 46]'),\n",
              " Text(260.40000000000003, 27.180000000000007, 'gini = 0.041\\nsamples = 48\\nvalue = [1, 47]'),\n",
              " Text(297.6, 81.53999999999999, 'gini = 0.097\\nsamples = 59\\nvalue = [3, 56]')]"
            ]
          },
          "metadata": {},
          "execution_count": 129
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h11i69csbRCH"
      },
      "source": [
        "rose = np.array([[1, 0, 1]]) # must be matrix format\n",
        "jack = np.array([[0, 0, 0]])"
      ],
      "execution_count": 130,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ij3pgICEbRCI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f39e540-a2bd-433f-9842-2ae7605513b5"
      },
      "source": [
        "dt_model.predict(rose)"
      ],
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/base.py:446: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n",
            "  \"X does not have valid feature names, but\"\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1])"
            ]
          },
          "metadata": {},
          "execution_count": 131
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XShTUGbPu1Pl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4664e28-e6e0-4106-88b5-168e8ca1ccc1"
      },
      "source": [
        "dt_model.predict_proba(rose)"
      ],
      "execution_count": 132,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/base.py:446: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n",
            "  \"X does not have valid feature names, but\"\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.05084746, 0.94915254]])"
            ]
          },
          "metadata": {},
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VO3j3_T8bRCJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee1d1127-c767-41ce-8ee0-f0e19855d5ca"
      },
      "source": [
        "dt_model.predict(jack)"
      ],
      "execution_count": 133,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/base.py:446: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n",
            "  \"X does not have valid feature names, but\"\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0])"
            ]
          },
          "metadata": {},
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mnjuDxEou-1e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6888af25-de6f-44a3-8193-3256f4cd8fa5"
      },
      "source": [
        "dt_model.predict_proba(jack)"
      ],
      "execution_count": 134,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/base.py:446: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n",
            "  \"X does not have valid feature names, but\"\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.85232068, 0.14767932]])"
            ]
          },
          "metadata": {},
          "execution_count": 134
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P3OSLifkbRCK"
      },
      "source": [
        "dt_yhat = dt_model.predict(X_test) # decision trees are prone to overfitting training data"
      ],
      "execution_count": 135,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmSFtkv6tgr1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c0f7684c-ed81-4b73-94b5-ea72b8bc0435"
      },
      "source": [
        "dt_yhat[0:6]"
      ],
      "execution_count": 136,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 0, 0, 1, 0, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "45DfyRL9bRCM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11616a89-6917-43b2-b6a4-dba74889299b"
      },
      "source": [
        "y_test[0:6]"
      ],
      "execution_count": 137,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "709    1\n",
              "439    0\n",
              "840    0\n",
              "720    1\n",
              "39     1\n",
              "290    1\n",
              "Name: survived, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 137
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rkjgiymJbRCN"
      },
      "source": [
        "from sklearn.metrics import accuracy_score, roc_auc_score"
      ],
      "execution_count": 138,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MsahEJR2bRCP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09bbf949-36cb-45b1-8c4d-42b3d3c91e52"
      },
      "source": [
        "accuracy_score(y_test, dt_yhat)"
      ],
      "execution_count": 139,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7728813559322034"
            ]
          },
          "metadata": {},
          "execution_count": 139
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "beXofak0bRCQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b9b23f23-ffe1-4ed6-ea15-d778414b7ffe"
      },
      "source": [
        "roc_auc_score(y_test, dt_yhat)"
      ],
      "execution_count": 140,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7273809523809524"
            ]
          },
          "metadata": {},
          "execution_count": 140
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DvjgUHJxbRCT"
      },
      "source": [
        "**Exercises**:\n",
        "\n",
        "1. Create more features ([here are some ideas for creating them](https://towardsdatascience.com/predicting-the-survival-of-titanic-passengers-30870ccc7e8)) with an eye to improving model fit on the test data. \n",
        "\n",
        "2. Re-train the decision tree on the training data and evaluate its accuracy and ROC AUC on the test data. How does the tree compare with an ordinary-least-squares regression model (from [*Intro to Stats*](https://github.com/jonkrohn/ML-foundations/blob/master/notebooks/6-statistics.ipynb)) trained on the same data?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7qiPS5IjbRCT"
      },
      "source": [
        "**Return to slides here.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EGl67nVMbRCT"
      },
      "source": [
        "### Random Forests"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y--kKV7DbRCT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 423
        },
        "outputId": "4c95682a-a667-418e-b373-1d085161b971"
      },
      "source": [
        "iris = sns.load_dataset('iris')\n",
        "iris"
      ],
      "execution_count": 141,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>sepal_length</th>\n",
              "      <th>sepal_width</th>\n",
              "      <th>petal_length</th>\n",
              "      <th>petal_width</th>\n",
              "      <th>species</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>5.1</td>\n",
              "      <td>3.5</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>setosa</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>4.9</td>\n",
              "      <td>3.0</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>setosa</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>4.7</td>\n",
              "      <td>3.2</td>\n",
              "      <td>1.3</td>\n",
              "      <td>0.2</td>\n",
              "      <td>setosa</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4.6</td>\n",
              "      <td>3.1</td>\n",
              "      <td>1.5</td>\n",
              "      <td>0.2</td>\n",
              "      <td>setosa</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5.0</td>\n",
              "      <td>3.6</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>setosa</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>145</th>\n",
              "      <td>6.7</td>\n",
              "      <td>3.0</td>\n",
              "      <td>5.2</td>\n",
              "      <td>2.3</td>\n",
              "      <td>virginica</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>146</th>\n",
              "      <td>6.3</td>\n",
              "      <td>2.5</td>\n",
              "      <td>5.0</td>\n",
              "      <td>1.9</td>\n",
              "      <td>virginica</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>147</th>\n",
              "      <td>6.5</td>\n",
              "      <td>3.0</td>\n",
              "      <td>5.2</td>\n",
              "      <td>2.0</td>\n",
              "      <td>virginica</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>148</th>\n",
              "      <td>6.2</td>\n",
              "      <td>3.4</td>\n",
              "      <td>5.4</td>\n",
              "      <td>2.3</td>\n",
              "      <td>virginica</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>149</th>\n",
              "      <td>5.9</td>\n",
              "      <td>3.0</td>\n",
              "      <td>5.1</td>\n",
              "      <td>1.8</td>\n",
              "      <td>virginica</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>150 rows × 5 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     sepal_length  sepal_width  petal_length  petal_width    species\n",
              "0             5.1          3.5           1.4          0.2     setosa\n",
              "1             4.9          3.0           1.4          0.2     setosa\n",
              "2             4.7          3.2           1.3          0.2     setosa\n",
              "3             4.6          3.1           1.5          0.2     setosa\n",
              "4             5.0          3.6           1.4          0.2     setosa\n",
              "..            ...          ...           ...          ...        ...\n",
              "145           6.7          3.0           5.2          2.3  virginica\n",
              "146           6.3          2.5           5.0          1.9  virginica\n",
              "147           6.5          3.0           5.2          2.0  virginica\n",
              "148           6.2          3.4           5.4          2.3  virginica\n",
              "149           5.9          3.0           5.1          1.8  virginica\n",
              "\n",
              "[150 rows x 5 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 141
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mvehRZ4vbRCU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 280
        },
        "outputId": "0cd73f5a-ec59-4ecc-c45d-d6bee87ac8e5"
      },
      "source": [
        "_ = sns.scatterplot(x='sepal_width', y='petal_length', hue='species', data=iris)"
      ],
      "execution_count": 142,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b2r2B8f6bRCV"
      },
      "source": [
        "X = iris[['sepal_width', 'petal_length']]"
      ],
      "execution_count": 143,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9YFi_xu7bRCW"
      },
      "source": [
        "y = iris.species"
      ],
      "execution_count": 144,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qaAe_OmMbRCX"
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)"
      ],
      "execution_count": 145,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6gOK1YAbRCY"
      },
      "source": [
        "iris_dt = DecisionTreeClassifier().fit(X_train, y_train)"
      ],
      "execution_count": 146,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8VN61N39bRCZ"
      },
      "source": [
        "iris_dt_yhat = iris_dt.predict(X_test)"
      ],
      "execution_count": 147,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MKdjKFzMbRCa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa547056-d576-4842-94a6-d1742e0306f3"
      },
      "source": [
        "accuracy_score(iris_dt_yhat, y_test) # ROC AUC is for binary classifier"
      ],
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9"
            ]
          },
          "metadata": {},
          "execution_count": 148
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LSbCHSDSbRCa"
      },
      "source": [
        "from sklearn.ensemble import RandomForestClassifier"
      ],
      "execution_count": 149,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XM4PnPhBbRCb"
      },
      "source": [
        "rf_model = RandomForestClassifier(n_estimators=100) # n decision trees in forest"
      ],
      "execution_count": 150,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZdH728GebRCc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a9b901d-e108-4b49-e9c9-393d2a20453c"
      },
      "source": [
        "rf_model.fit(X_train, y_train)"
      ],
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier()"
            ]
          },
          "metadata": {},
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gj0UdpKsbRCd"
      },
      "source": [
        "rf_yhat = rf_model.predict(X_test)"
      ],
      "execution_count": 152,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hhjVA9z_bRCe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7036ade-5d16-495c-c8f2-89acb08382ba"
      },
      "source": [
        "accuracy_score(rf_yhat, y_test)"
      ],
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.96"
            ]
          },
          "metadata": {},
          "execution_count": 153
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lzm9A7bwbRCf"
      },
      "source": [
        "**Return to slides.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jpu53mFkbRCg"
      },
      "source": [
        "### Gradient-Boosted Trees"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lgfz5kkabRCi"
      },
      "source": [
        "import xgboost as xgb"
      ],
      "execution_count": 154,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_1twJezbRCj"
      },
      "source": [
        "XGBoost `DMatrix()` method requires numeric inputs, not strings: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9_r4ulQObRCj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff30b568-2797-4b34-ee20-0003895c2613"
      },
      "source": [
        "y_train[0:6]"
      ],
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "96     versicolor\n",
              "105     virginica\n",
              "66     versicolor\n",
              "0          setosa\n",
              "122     virginica\n",
              "67     versicolor\n",
              "Name: species, dtype: object"
            ]
          },
          "metadata": {},
          "execution_count": 155
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FDbSz7u0bRCk"
      },
      "source": [
        "y_train_int = y_train.replace(['setosa', 'versicolor', 'virginica'], [0, 1, 2])\n",
        "y_test_int = y_test.replace(['setosa', 'versicolor', 'virginica'], [0, 1, 2])"
      ],
      "execution_count": 156,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jKzJ2WBpbRCl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5577c6d-d7e9-44a7-ef16-713518f0d70a"
      },
      "source": [
        "y_train_int[0:6]"
      ],
      "execution_count": 157,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "96     1\n",
              "105    2\n",
              "66     1\n",
              "0      0\n",
              "122    2\n",
              "67     1\n",
              "Name: species, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 157
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ntrQLtLgbRCn"
      },
      "source": [
        "D_train = xgb.DMatrix(X_train, label=y_train_int)\n",
        "D_test = xgb.DMatrix(X_test, label=y_test_int)"
      ],
      "execution_count": 158,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pf1YBYMjbRCn"
      },
      "source": [
        "param = {\n",
        "    'eta': 0.1, # learning rate (0.1 to 0.3 are common)\n",
        "    'max_depth': 2, # I mean, we only have two features...\n",
        "    'objective': 'multi:softprob',\n",
        "    'num_class': 3\n",
        "}\n",
        "steps = 10"
      ],
      "execution_count": 159,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sr1liohYbRCo"
      },
      "source": [
        "xg_model = xgb.train(param, D_train, steps)"
      ],
      "execution_count": 160,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kSbjrMI2bRCp"
      },
      "source": [
        "xg_yhats = xg_model.predict(D_test)"
      ],
      "execution_count": 161,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nuiLEGs-bRCq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ea487ec-7720-444c-be67-03b668150ec4"
      },
      "source": [
        "xg_yhats[0] # supports >2 classes"
      ],
      "execution_count": 162,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.14787206, 0.64814967, 0.20397826], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 162
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gLdW2QDebRCs"
      },
      "source": [
        "xg_yhat = np.asarray([np.argmax(line) for line in xg_yhats])"
      ],
      "execution_count": 163,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n8KSTQSAbRCt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15ae9323-036d-407f-8a58-db6c6b5b2711"
      },
      "source": [
        "xg_yhat[0]"
      ],
      "execution_count": 164,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 164
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bapU-nE4bRCv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd9e53de-9022-44e6-e032-30a9db9f3075"
      },
      "source": [
        "accuracy_score(xg_yhat, y_test_int)"
      ],
      "execution_count": 165,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.98"
            ]
          },
          "metadata": {},
          "execution_count": 165
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fzs6y3UcLlYI"
      },
      "source": [
        "**Exercise**: Try training random forest and XGBoost models with additional iris features. Can you attain 100% accuracy on the test data set? "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hcMPnX4z7_R7"
      },
      "source": [
        "**Return to slides.**"
      ]
    }
  ]
}