COMP472Project1 (1).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cnJILptRLPqU"
      },
      "source": [
        "**COMP 472 Project 1**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MPJUJzd_LO3a"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib as plt\n",
        "import math\n",
        "from sklearn import tree\n",
        "from sklearn import preprocessing\n",
        "import graphviz"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "74c01J_WNfXF"
      },
      "outputs": [],
      "source": [
        "url = 'https://raw.githubusercontent.com/CombatLawyer/COMP472/main/data.csv' \n",
        "df = pd.read_csv(url)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CAwHJH0nLuVB",
        "outputId": "afffe611-70a9-478c-f964-304ea4e21389"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   Unnamed: 0  Alt  Bar  Fri  Hun   Pat Price Rain  Res     Type    Est  \\\n",
            "0          x1  Yes   No   No  Yes  Some   $$$   No  Yes   French   0-10   \n",
            "1          x2  Yes   No   No  Yes  Full     $   No   No     Thai  30-60   \n",
            "2          x3   No  Yes   No   No  Some     $   No   No   Burger   0-10   \n",
            "3          x4  Yes   No  Yes  Yes  Full     $  Yes   No     Thai  30-60   \n",
            "4          x5  Yes   No  Yes   No  Full   $$$   No  Yes   French    >60   \n",
            "5          x6   No  Yes   No  Yes  Some    $$  Yes  Yes  Italian   0-10   \n",
            "6          x7   No  Yes   No   No  None     $  Yes   No   Burger   0-10   \n",
            "7          x8   No   No   No  Yes  Some    $$  Yes  Yes     Thai   0-10   \n",
            "8          x9   No  Yes  Yes   No  Full     $  Yes   No   Burger    >60   \n",
            "9         x10  Yes  Yes  Yes  Yes  Full   $$$   No  Yes  Italian  30-60   \n",
            "10        x11   No   No   No   No  None     $   No   No     Thai   0-10   \n",
            "11        x12  Yes  Yes  Yes  Yes  Full     $   No   No   Burger  30-60   \n",
            "\n",
            "   WillWait  \n",
            "0       Yes  \n",
            "1        No  \n",
            "2       Yes  \n",
            "3       Yes  \n",
            "4        No  \n",
            "5       Yes  \n",
            "6        No  \n",
            "7       Yes  \n",
            "8        No  \n",
            "9        No  \n",
            "10       No  \n",
            "11      Yes  \n"
          ]
        }
      ],
      "source": [
        "print(df)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vEcTIVv7MNne",
        "outputId": "3fd55deb-ee02-4fcc-a8b6-82fbc14c4863"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entropy values:\n",
            "Alt = Yes: 1.0\n",
            "Alt = No: 1.0\n",
            "Bar = No: 1.0\n",
            "Bar = Yes: 1.0\n",
            "Fri = No: 0.9852281360342515\n",
            "Fri = Yes: 0.9709505944546686\n",
            "Hun = Yes: 0.863120568566631\n",
            "Hun = No: 0.7219280948873623\n",
            "Pat = Some: 0.0\n",
            "Pat = Full: 0.9182958340544896\n",
            "Pat = None: 0.0\n",
            "Price = $$$: 0.9182958340544896\n",
            "Price = $: 0.9852281360342515\n",
            "Price = $$: 0.0\n",
            "Rain = No: 0.9852281360342515\n",
            "Rain = Yes: 0.9709505944546686\n",
            "Res = Yes: 0.9709505944546686\n",
            "Res = No: 0.9852281360342515\n",
            "Type = French: 1.0\n",
            "Type = Thai: 1.0\n",
            "Type = Burger: 1.0\n",
            "Type = Italian: 1.0\n",
            "Est = 0-10: 0.9182958340544896\n",
            "Est = 30-60: 1.0\n",
            "Est = >60: 0.0\n",
            "final_entropy 1.0\n"
          ]
        }
      ],
      "source": [
        "def calculate_entropy(dataset):\n",
        "    entropy_values = []\n",
        "\n",
        "    # Calculate the total count of instances\n",
        "    total_count = len(dataset)\n",
        "\n",
        "    # Exclude the first column\n",
        "    columns = dataset.columns[1:-1]\n",
        "\n",
        "    # Iterate over each column in the datatset\n",
        "    for column in columns:\n",
        "\n",
        "        # Take the dataset by the sepcific column and the last column (only the column and the class label)\n",
        "        column_values = dataset[[column, dataset.columns[-1]]]\n",
        "\n",
        "        # Determine the unique values in the column\n",
        "        values = dataset[column].unique()\n",
        "\n",
        "        # For every unique value\n",
        "        for uniqueValue in values:\n",
        "\n",
        "            # For the given unique value take only the class label\n",
        "            filteredValues = column_values[column_values[column] == uniqueValue][column_values.columns[-1]]\n",
        "\n",
        "            # The probability of a given class label is then taken by finding the individual count of the label divided by the length of the filtered dataset\n",
        "            probabilities = filteredValues.value_counts() / len(filteredValues)\n",
        "\n",
        "            # Entropy is then calculated (+ 0 is used to correct for negative 0 values)\n",
        "            entropy = - (probabilities * probabilities.apply(math.log2)).sum() + 0\n",
        "\n",
        "            # Result is stored as a tuple into the list\n",
        "            entropy_values.append((column, uniqueValue, entropy))\n",
        "\n",
        "    # Handle the last column separately\n",
        "    last_column = dataset.columns[-1]\n",
        "    last_column_values = dataset[last_column]\n",
        "\n",
        "    # Convert all values in the last column to lowercase\n",
        "    last_column_values = last_column_values.str.lower()\n",
        "\n",
        "    # Calculate the total count of \"yes\" and \"no\" in the last column\n",
        "    total_yes_count = last_column_values.str.contains('yes').sum()\n",
        "    total_no_count = last_column_values.str.contains('no').sum()\n",
        "    # Calculate the total probability of \"yes\" and \"no\"\n",
        "    total_yes_probability = total_yes_count / total_count\n",
        "    total_no_probability = total_no_count / total_count\n",
        "\n",
        "    # Calculate the entropy for the last column based on the total probabilities of \"yes\" and \"no\"\n",
        "    final = 0.0\n",
        "    if total_yes_probability != 0:\n",
        "        final -= total_yes_probability * math.log2(total_yes_probability)\n",
        "    if total_no_probability != 0:\n",
        "        final -= total_no_probability * math.log2(total_no_probability)\n",
        "    return final,entropy_values\n",
        "\n",
        "final_entropy, entropies = calculate_entropy(df)\n",
        "print(\"Entropy values:\")\n",
        "for entropyTuple in entropies:\n",
        "    print(f'{entropyTuple[0]} = {entropyTuple[1]}: {entropyTuple[2]}')\n",
        "print(\"final_entropy\",final_entropy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "AxIinjdK86lv",
        "outputId": "a3f357e0-e48b-4907-f8d2-bdb66accee6c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Pat'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 33
        }
      ],
      "source": [
        "def findBestGain(dataset):\n",
        "  # Remove the first and the last column (x labels and class labels)\n",
        "  features = dataset.iloc[:,1:-1]\n",
        "\n",
        "  # Used to keep track of the current best gain\n",
        "  bestGain = 0 # Starts at 0 to ensure any gain larger will register\n",
        "  bestFeature = \"\" # Returns an empty string if all features provide no larger gain\n",
        "\n",
        "  # For each feature column find entropies\n",
        "  for col in features.columns:\n",
        "\n",
        "    # Begin gain at 1\n",
        "    gain = 1\n",
        "\n",
        "    # For each different value of each feature reduce the gain by the amount of entropy of the feature scaled\n",
        "    for value in dataset[col].unique():\n",
        "      gain -= calculate_entropy(dataset[dataset[col] == value])[0] * len(dataset[dataset[col] == value]) / len(dataset)\n",
        "    \n",
        "    # If the gain is larger than the previous best, save the name of the feature that results in the best gain\n",
        "    if gain > bestGain:\n",
        "      bestGain = gain\n",
        "      bestFeature = col\n",
        "\n",
        "  # Return the feature which allows the biggest gain when splitting on\n",
        "  return bestFeature\n",
        "\n",
        "findBestGain(df)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 770
        },
        "id": "KxrL1Wi2iJgr",
        "outputId": "a8ff3211-9309-418e-c673-cf7642ef41ec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Class labels has been reassigned to the tree. See mytree1.pdf\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([Text(0.6, 0.9, 'x[4] <= 1.5\\nentropy = 1.0\\nsamples = 12\\nvalue = [6, 6]'),\n",
              "  Text(0.4, 0.7, 'x[3] <= 0.5\\nentropy = 0.811\\nsamples = 8\\nvalue = [6, 2]'),\n",
              "  Text(0.2, 0.5, 'entropy = 0.0\\nsamples = 4\\nvalue = [4, 0]'),\n",
              "  Text(0.6, 0.5, 'x[7] <= 0.5\\nentropy = 1.0\\nsamples = 4\\nvalue = [2, 2]'),\n",
              "  Text(0.4, 0.3, 'x[2] <= 0.5\\nentropy = 0.918\\nsamples = 3\\nvalue = [1, 2]'),\n",
              "  Text(0.2, 0.1, 'entropy = 0.0\\nsamples = 1\\nvalue = [1, 0]'),\n",
              "  Text(0.6, 0.1, 'entropy = 0.0\\nsamples = 2\\nvalue = [0, 2]'),\n",
              "  Text(0.8, 0.3, 'entropy = 0.0\\nsamples = 1\\nvalue = [1, 0]'),\n",
              "  Text(0.8, 0.7, 'entropy = 0.0\\nsamples = 4\\nvalue = [0, 4]')],\n",
              " DecisionTreeClassifier(criterion='entropy'),\n",
              " {0: LabelEncoder(),\n",
              "  1: LabelEncoder(),\n",
              "  2: LabelEncoder(),\n",
              "  3: LabelEncoder(),\n",
              "  4: LabelEncoder(),\n",
              "  5: LabelEncoder(),\n",
              "  6: LabelEncoder(),\n",
              "  7: LabelEncoder(),\n",
              "  8: LabelEncoder(),\n",
              "  9: LabelEncoder()})"
            ]
          },
          "metadata": {},
          "execution_count": 34
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Function that takes in a dataset and label encodes each columns' data \n",
        "# to then create a classifier object using entropy as the criterion in order to build a decision tree\n",
        "# it also creates a file with the proper associated class labels named \"mytree1.pdf\"\n",
        "def train_using_entropy(dataset):\n",
        "  # Retrieve our features and target\n",
        "  features = dataset.iloc[:,1:-1].values\n",
        "  target = dataset.iloc[:, -1].values\n",
        "\n",
        "  # Convert all non numerical columns to numerical values\n",
        "  le = preprocessing.LabelEncoder()\n",
        "\n",
        "  # Loop to label encode each column for the feature vector\n",
        "  encoders = {}\n",
        "  for i in range(len(features[0])):\n",
        "      encoders[i] = preprocessing.LabelEncoder()\n",
        "      features[:, i] = encoders[i].fit_transform(features[:, i])\n",
        "  target = le.fit_transform(target)\n",
        "  \n",
        "  # Create classifier object using entropy as the criterion\n",
        "  dtc = tree.DecisionTreeClassifier(criterion=\"entropy\")\n",
        "\n",
        "  # Train classifier to build the tree\n",
        "  dtc.fit(features, target)\n",
        "\n",
        "  # Export the tree to a file and reassign tree labels\n",
        "  dot_data = tree.export_graphviz(dtc, out_file=None,\n",
        "  feature_names=['Alt',  'Bar',  'Fri',  'Hun',   'Pat', 'Price', 'Rain',  'Res', 'Type', 'Est'],\n",
        "  class_names=le.classes_,\n",
        "  filled=True, rounded=True)\n",
        "  graph = graphviz.Source(dot_data)\n",
        "  graph.render(\"mytree1\")\n",
        "\n",
        "  print(\"Class labels has been reassigned to the tree. See mytree1.pdf\")\n",
        "\n",
        "  # Return the tree\n",
        "  return tree.plot_tree(dtc), dtc, encoders\n",
        "\n",
        "train_using_entropy(df)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "6x-h39UxpNyx",
        "outputId": "b52671ee-b069-42de-b1c1-c787ad18c038"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome to our decision tree program!\n",
            "Do you wish to provide a csv file for your dataset ? (answer y/n) y\n",
            "Please provide the path to the csv which contains your dataset. Make sure that the syntax for your dataset is proper! https://raw.githubusercontent.com/CombatLawyer/COMP472/main/data.csv\n",
            "Calculating entropy for the given dataset\n",
            "Alt = Yes: 1.0\n",
            "Alt = No: 1.0\n",
            "Bar = No: 1.0\n",
            "Bar = Yes: 1.0\n",
            "Fri = No: 0.9852281360342515\n",
            "Fri = Yes: 0.9709505944546686\n",
            "Hun = Yes: 0.863120568566631\n",
            "Hun = No: 0.7219280948873623\n",
            "Pat = Some: 0.0\n",
            "Pat = Full: 0.9182958340544896\n",
            "Pat = None: 0.0\n",
            "Price = $$$: 0.9182958340544896\n",
            "Price = $: 0.9852281360342515\n",
            "Price = $$: 0.0\n",
            "Rain = No: 0.9852281360342515\n",
            "Rain = Yes: 0.9709505944546686\n",
            "Res = Yes: 0.9709505944546686\n",
            "Res = No: 0.9852281360342515\n",
            "Type = French: 1.0\n",
            "Type = Thai: 1.0\n",
            "Type = Burger: 1.0\n",
            "Type = Italian: 1.0\n",
            "Est = 0-10: 0.9182958340544896\n",
            "Est = 30-60: 1.0\n",
            "Est = >60: 0.0\n",
            "final_entropy 1.0\n",
            "Finding the best gain for the given dataset\n",
            "Pat\n",
            "Creating the decision tree for the given dataset\n",
            "Class labels has been reassigned to the tree. See mytree1.pdf\n",
            "Do you wish to classify some data? (y/n) y\n",
            "Please specify a format for the data you wish to classify. (Manual or csv) csv\n",
            "Please provide the path to the csv which contains the data to classify. Make sure that the syntax for your dataset is proper! classify.csv\n",
            "Customer 1 will likely stay and wait for a table. (encoded as 1)\n",
            "Customer 2 will likely not stay. (encoded as 0)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Code for demo \n",
        "def demoRundown():\n",
        "  print(\"Welcome to our decision tree program!\")\n",
        "\n",
        "  # Let user provide dataset manually or through a csv file url\n",
        "  answer = input(\"Do you wish to provide a csv file for your dataset ? (answer y/n) \")\n",
        "\n",
        "  # Csv file method for dataset\n",
        "  if answer in ['y', 'Y', 'yes', 'Yes', 'YES']:\n",
        "    filename = input(\"Please provide the path to the csv which contains your dataset. Make sure that the syntax for your dataset is proper! \")\n",
        "    try:\n",
        "      dataset = pd.read_csv(filename)\n",
        "    except Exception:\n",
        "      print(\"Could not read csv file, try checking the file again.\")\n",
        "  # Manual method for dataset\n",
        "  else:\n",
        "    dataset = input(\"Please provide the dataset manually. Make sure that the syntax for your dataset is proper!\")\n",
        "\n",
        "  # Calculate the entropy using the provided dataset\n",
        "  try:\n",
        "    print(\"Calculating entropy for the given dataset\")\n",
        "    final_entropy, entropies = calculate_entropy(dataset)\n",
        "    for entropyTuple in entropies:\n",
        "      print(f'{entropyTuple[0]} = {entropyTuple[1]}: {entropyTuple[2]}')\n",
        "    print(\"final_entropy\",final_entropy)\n",
        "  except Exception:\n",
        "    print(\"Could not calculate the entropy...\")\n",
        "  \n",
        "  # Find the best gain\n",
        "  try:\n",
        "    print(\"Finding the best gain for the given dataset\")\n",
        "    print(findBestGain(dataset))\n",
        "  except Exception:\n",
        "    print(\"Could not find the best gain...\")\n",
        "  \n",
        "  # Draw the tree using entropy as the criterion\n",
        "  try:\n",
        "    print(\"Creating the decision tree for the given dataset\")\n",
        "    tree, dtc, encoders = train_using_entropy(dataset)\n",
        "  except Exception:\n",
        "    print(\"Could not create the decision tree...\")\n",
        "\n",
        "  # Provide oppurtunity to input data\n",
        "  decision = input(\"Do you wish to classify some data? (y/n) \")\n",
        "\n",
        "  if decision in ['y', 'Y', 'yes', 'Yes', 'YES']:\n",
        "    decision = input(\"Please specify a format for the data you wish to classify. (Manual or csv) \")\n",
        "    if decision.lower() == 'manual':\n",
        "\n",
        "      # Manual data entry\n",
        "      print(\"Please enter the data point with the features.\")\n",
        "      data = []\n",
        "      data.append(input(\"Was there an alternative dining spot lined up (Yes/No): \").capitalize())\n",
        "      data.append(input(\"Is there a bar (Yes/No): \").capitalize())\n",
        "      data.append(input(\"Is it a Friday (Yes/No): \").capitalize())\n",
        "      data.append(input(\"Are the customers hungry (Yes/No): \").capitalize())\n",
        "      data.append(input(\"Are there other patrons (None/Some/Full): \").capitalize())\n",
        "      data.append(input(\"What price point were they expecting ($/$$/$$$): \"))\n",
        "      data.append(input(\"Was it raining (Yes/No): \").capitalize())\n",
        "      data.append(input(\"Did they have a reservation (Yes/No): \").capitalize())\n",
        "      data.append(input(\"What kind of food were they ordering (Burger/French/Italian/Thai): \").capitalize())\n",
        "      data.append(input(\"What was the estimated wait time (0-10/10-30/30-60/>60): \"))\n",
        "\n",
        "      # Using the encoders which previously were used to build the tree, encode this new data point\n",
        "      data = np.array(data).reshape(1, -1)\n",
        "      for i in range(len(data[0])):\n",
        "        data[:, i] = encoders[i].transform(data[:, i])\n",
        "      \n",
        "      # Prediction translated from encoding\n",
        "      if dtc.predict(data)[0] == 1:\n",
        "        print(\"The prediction is that the customers will stay and wait for a table. (encoded as 1)\")\n",
        "      else:\n",
        "        print(\"The prediction is that the customers will not stay. (encoded as 0)\")\n",
        "\n",
        "    # Importing data using a csv file\n",
        "    elif decision.lower() == 'csv':\n",
        "      classify = input(\"Please provide the path to the csv which contains the data to classify. Make sure that the syntax for your dataset is proper! \")\n",
        "      classify = pd.read_csv(classify).values\n",
        "\n",
        "      # Using the encoders which previously were used to build the tree, encode this new data point\n",
        "      for i in range(len(classify[0])):\n",
        "        classify[:, i] = encoders[i].transform(classify[:, i])\n",
        "\n",
        "      # Prediction translated from encoding\n",
        "      predictions = dtc.predict(classify)\n",
        "      for i in range(len(predictions)):\n",
        "        if predictions[i] == 1:\n",
        "          print(f\"Customer {i + 1} will likely stay and wait for a table. (encoded as 1)\")\n",
        "        else:\n",
        "          print(f\"Customer {i + 1} will likely not stay. (encoded as 0)\")\n",
        "\n",
        "    else:\n",
        "      print(\"Invalid input please restart.\")\n",
        "  elif decision in ['n', 'N', 'no', 'No', 'NO']:\n",
        "    print(\"Thank you for using the decision tree program.\")\n",
        "  else:\n",
        "    print(\"Invalid input, terminating program.\")\n",
        "\n",
        "demoRundown()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# New Section"
      ],
      "metadata": {
        "id": "l8NJ1x1l6MIB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RAxd0izCAscL"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}