Naive_Bayes_Class_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNzBUyHfNbcdZmg4NpSYfiK",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/beginner003/developing-with-github/blob/master/Naive_Bayes_Class_Classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8w58nwNexKIB",
        "outputId": "f37d2acb-d3d6-4ca0-9932-51eebbd38a67"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "if __name__ == '__main__':\n",
        "  from google.colab import drive\n",
        "  drive.mount(\"/content/drive\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd \"/content/drive/MyDrive/COMP 2211/Lab2\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FIQYpROLx_L5",
        "outputId": "57ce39f0-3df9-449f-d444-b824670b0ce4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/COMP 2211/Lab2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%ls"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C_uNO-AqyN51",
        "outputId": "40a7f0d0-f110-4841-fa84-5d33bc96b0fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lab2_review.ipynb  Lab2work.ipynb     test_labels.csv     train_labels.csv\n",
            "lab2_task.ipynb    test_features.csv  train_features.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n"
      ],
      "metadata": {
        "id": "rj8n0RfuyT6o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if __name__ == '__main__':\n",
        "  X_train = np.loadtxt(\"train_features.csv\", delimiter=\",\", skiprows=1)\n",
        "  X_test = np.loadtxt(\"test_features.csv\", delimiter=\",\", skiprows=1)\n",
        "  y_train = np.loadtxt(\"train_labels.csv\", delimiter=\",\", skiprows=1)\n",
        "  y_test = np.loadtxt(\"test_labels.csv\", delimiter=\",\", skiprows=1)"
      ],
      "metadata": {
        "id": "ecaN1NNsyexl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Task 1: Estimate priors\n",
        "\n",
        "def estimate_priors(y_train):\n",
        "  # y_train: a 1D numpy array with shape (num_train_samples, )\n",
        "\n",
        "  # TODO start\n",
        "  trainsize= len(y_train)\n",
        "  classes= np.unique(y_train)\n",
        "  class_priors = np.empty((len(classes),))\n",
        "  classindex=0\n",
        "  for i in classes:\n",
        "    count=0\n",
        "    for j in y_train:\n",
        "      if i==j:count+=1\n",
        "\n",
        "    class_priors[classindex]=count/trainsize\n",
        "    classindex+=1\n",
        "\n",
        "  # TODO end\n",
        "\n",
        "  return class_priors\n",
        "  # class priors: a 1D numpy array with shape (num_classes, )"
      ],
      "metadata": {
        "id": "KcGmWOX1yjvk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# trainsize= len(y_train)\n",
        "# classes= np.unique(y_train)\n",
        "# class_priors=np.empty((len(classes),))\n",
        "# classindex=0\n",
        "# for i in classes:\n",
        "#   count=0\n",
        "#   for j in y_train:\n",
        "#     if i==j:\n",
        "#       count+=1\n",
        "#   class_priors[classindex]=count/trainsize\n",
        "#   classindex+=1\n",
        "\n",
        "# print(class_priors)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4rStXw0Lyq1q",
        "outputId": "cf917110-8aa5-4c43-b89f-19b2de672b27"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.88446963 0.11553037]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Task 2: Likelihood for categorical feature\n",
        "\n",
        "def cat_likelihood(X_train_feature, y_train, X_test_feature):\n",
        "  # X_train_feature: a 1D numpy array with shape (num_train_samples, )\n",
        "  # y_train: a 1D numpy array with shape (num_train_samples, )\n",
        "  # X_test_feature: a 1D numpy array with shape (num_test_samples, )\n",
        "\n",
        "  # TODO start\n",
        "  feat_class = np.unique(X_train_feature)\n",
        "  feat_class = np.sort(feat_class)\n",
        "\n",
        "  belief= np.unique(y_train)\n",
        "  belief=np.sort(belief)\n",
        "  feat_likelihood = np.empty((len(X_test_feature),len(belief)))\n",
        "\n",
        "  likelihoodarr=np.empty((len(feat_class),len(belief)))\n",
        "  for i in range(0,len(feat_class)):\n",
        "    for j in range(0,len(belief)):\n",
        "      likelihoodarr[i,j]= (np.dot(X_train_feature == feat_class[i], (y_train == belief[j] ).astype(int))+1)/(np.sum(y_train == belief[j])+len(feat_class))\n",
        "\n",
        "  for i in range(0,len(X_test_feature)):\n",
        "      feat_likelihood[i]= likelihoodarr[int(X_test_feature[i])]\n",
        "\n",
        "  # TODO end\n",
        "\n",
        "  return feat_likelihood\n",
        "  # feat_likelihood: a 2D numpy array with shape (num_test_samples, num_classes)"
      ],
      "metadata": {
        "id": "y2ny0CSEeERg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# feat_class = np.unique(X_train[:, 0])\n",
        "# np.sort(feat_class)\n",
        "# print(feat_class)\n",
        "\n",
        "# belief= np.unique(y_train)\n",
        "# likelihoodarr=np.empty((len(feat_class),len(belief)))\n",
        "\n",
        "# for i in range(0,len(feat_class)):\n",
        "#   for j in range(0,len(belief)):\n",
        "#     likelihoodarr[i,j]= (np.dot(X_train[:,0] == feat_class[i], (y_train == belief[j] ).astype(int))+1)/(np.sum(y_train == belief[j])+len(feat_class))\n",
        "\n",
        "# X_test_feat = X_test[:,0]\n",
        "# feat_likelihood = np.empty((len(X_test_feat),len(belief)))\n",
        "# for i in range(0,13007):\n",
        "\n",
        "#   feat_likelihood[i]= likelihoodarr[int(X_test_feat[i])]\n",
        "\n",
        "# print(likelihoodarr)\n",
        "# print(feat_likelihood)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E0fgEh9Uic8n",
        "outputId": "ad141f8b-a0ea-4118-9542-38425a7b515d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0. 1. 2.]\n",
            "[[0.2737297  0.35423197]\n",
            " [0.61026673 0.5292106 ]\n",
            " [0.11600358 0.11655742]]\n",
            "[[0.2737297  0.35423197]\n",
            " [0.61026673 0.5292106 ]\n",
            " [0.11600358 0.11655742]\n",
            " ...\n",
            " [0.2737297  0.35423197]\n",
            " [0.61026673 0.5292106 ]\n",
            " [0.61026673 0.5292106 ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Task 3:\n",
        "def num_likelihood(X_train_feature, y_train, X_test_feature):\n",
        "  # X_train_feature: a 1D numpy array with shape (num_train_samples, )\n",
        "  # y_train: a 1D numpy array with shape (num_train_samples, )\n",
        "  # X_test_feature: a 1D numpy array with shape (num_test_samples, )\n",
        "  belief = np.unique(y_train)\n",
        "  belief = np.sort(belief)\n",
        "  def feature_mean(X_train_feature, y_train):\n",
        "    # TODO Part 1 start\n",
        "\n",
        "    mean = np.empty((len(belief),))\n",
        "    for i in range(0,len(belief)):\n",
        "      mean[i]=np.dot(X_train_feature,(y_train == belief[i]).astype(int))/np.sum(y_train==belief[i])\n",
        "    # TODO Part 1 end\n",
        "    return mean\n",
        "    # mean: a 1D numpy array with shape (num_classes, )\n",
        "\n",
        "  def feature_var(X_train_feature, y_train):\n",
        "    # TODO Part 2 start\n",
        "    var = np.empty((len(belief)))\n",
        "    for i in range(0,len(belief)):\n",
        "      mask = X_train_feature[(y_train==belief[i])]\n",
        "\n",
        "      mask = [(x-mean[i])**2 for x in mask]\n",
        "\n",
        "      var[i]=np.sum(mask)/len(mask)\n",
        "    # TODO Part 2 end\n",
        "    return var\n",
        "    # var: a 1D numpy array with shape (num_classes, )\n",
        "\n",
        "  mean = feature_mean(X_train_feature, y_train)\n",
        "\n",
        "  var = feature_var(X_train_feature, y_train)\n",
        "\n",
        "  # TODO Part 3 start\n",
        "  feat_likelihood=np.empty((len(X_test_feature),len(belief)))\n",
        "  for i in range(0,len(belief)):\n",
        "    temp = [(-((x-mean[i])**2)/(2*var[i]))for x in X_test_feature]\n",
        "    temp= np.exp(temp)\n",
        "    temp = [(x/np.sqrt(2*np.pi*var[i]))for x in temp]\n",
        "    feat_likelihood[:,i]=np.transpose(temp)\n",
        "  # TODO Part 3 end\n",
        "\n",
        "  return feat_likelihood\n",
        "  # feat_likelihood: a 2D numpy array with shape (num_test_samples, num_classes)"
      ],
      "metadata": {
        "id": "4ed2CSKGohBn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# x=np.array([53.8,43.2,67.9,67.2,90.3,20.2])\n",
        "# y=np.array([1,0,1,0,1,1])\n",
        "# xtest=np.array([90.5,78.2,44.4,33.3,60.2])\n",
        "# num_likelihood(x,y,xtest)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MUrhCR0tx49a",
        "outputId": "111e19f0-d72d-4ac3-eef8-35b7d531b578"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.0004392 , 0.00695081],\n",
              "       [0.00529681, 0.01146028],\n",
              "       [0.02217377, 0.01358119],\n",
              "       [0.00628771, 0.00976944],\n",
              "       [0.03048103, 0.0156288 ]])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "#Task 4:\n",
        "def predict(X_train, y_train, X_test, feat_type_list):\n",
        "  # X_train: a 2D numpy array with shape (num_train_samples, num_features)\n",
        "  # y_train: a 1D numpy array with shape (num_train_samples, )\n",
        "  # X_test: a 2D numpy array with shape (num_test_samples, num_features)\n",
        "  # feat_type_list: a list of feature types in string form in the order of features in X_train and X_test\n",
        "    # For example: feat_type_list = [ 'cat', 'cat', 'cat', 'cat', 'num', 'num', 'num']\n",
        "  belief = np.unique(y_train)\n",
        "  belief = np.sort(belief)\n",
        "  sum=np.zeros((len(X_test),len(belief)))\n",
        "  beliefprob = estimate_priors(y_train)\n",
        "  print(beliefprob)\n",
        "  for i in range(0,len(belief)):\n",
        "    sum[:,i]=beliefprob[i]\n",
        "\n",
        "  sum=np.log(sum)\n",
        "  # print(sum)\n",
        "\n",
        "  # TODO start\n",
        "  for i in range(len(feat_type_list)):\n",
        "    if feat_type_list[i]=='cat':\n",
        "      # print(\"Category:\")\n",
        "      sum+=np.log(cat_likelihood(X_train[:,i],y_train,X_test[:,i]))\n",
        "    elif feat_type_list[i]=='num':\n",
        "      # print(\"Numerical\")\n",
        "      sum+=np.log(num_likelihood(X_train[:,i],y_train,X_test[:,i]))\n",
        "    # print(sum)\n",
        "\n",
        "  test_predict=[np.argmax(x)for x in sum]\n",
        "  # print(test_predict)\n",
        "  # TODO end\n",
        "\n",
        "  return test_predict\n",
        "  # test_predict: a 1D numpy array with shape (num_test_samples, )"
      ],
      "metadata": {
        "id": "xFkA_x_cJ3Y8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# x=np.array([[0.2,1.1],\n",
        "#    [2.2,3.4],\n",
        "#    [4.4,5.2]])\n",
        "\n",
        "# y=np.array([2.2,3.3])\n",
        "\n",
        "# for i in range(0,2):\n",
        "#   x[:,i]=y[i]\n",
        "\n",
        "# print(x)\n",
        "\n",
        "# x=np.array(\n",
        "#     [[5,6],\n",
        "#    [4,3],\n",
        "#    [3,2]])\n",
        "\n",
        "# sum=[np.max(i)for i in x]\n",
        "# print(sum)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "roXHMlUHTmQW",
        "outputId": "3f6e1021-c026-4d0d-b955-95041fb4c36f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[2.2 3.3]\n",
            " [2.2 3.3]\n",
            " [2.2 3.3]]\n",
            "[6, 4, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "XQ85cuh7o6jj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# if __name__ == '__main__':\n",
        "#   # Task 1\n",
        "#   priors = estimate_priors(y_train)\n",
        "#   print('The priors are ', priors) # [0.88446963 0.11553037]\n",
        "\n",
        "#   # Task 2\n",
        "#   feat_likelihood = cat_likelihood(X_train[:, 0], y_train, X_test[:, 0])\n",
        "#   print('The likelihood values for \"marital status\" for the first 5 test samples are', feat_likelihood[:5, :])\n",
        "#   '''[[0.2737297  0.35423197]\n",
        "#       [0.61026673 0.5292106 ]\n",
        "#       [0.11600358 0.11655742]\n",
        "#       [0.61026673 0.5292106 ]\n",
        "#       [0.11600358 0.11655742]]'''\n",
        "\n",
        "#   # Task 3\n",
        "#   feat_likelihood = num_likelihood(X_train[:, 4], y_train, X_test[:, 4])\n",
        "#   print('The likelihood values for \"age\" for the first 5 test samples are', feat_likelihood[:5, :])\n",
        "#   '''[[0.00032595 0.00217531]\n",
        "#       [0.01257581 0.01682234]\n",
        "#       [0.03691429 0.02835094]\n",
        "#       [0.03851424 0.03006992]\n",
        "#       [0.01664062 0.0195927 ]]'''\n",
        "\n",
        "#   # Task 4\n",
        "#   y_pred = predict(X_train, y_train, X_test, feat_type_list=[ 'cat', 'cat', 'cat', 'cat', 'num', 'num', 'num'])\n",
        "#   accuracy_score = np.sum(y_pred == y_test) / y_test.shape[0]\n",
        "#   print('The ratio of correct predictions to the whole dataset is ', accuracy_score)\n",
        "#   # 0.8794495271776736\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "abyp0OkQHEVn",
        "outputId": "5ac0f55b-df24-4682-ea13-e400d6a1cffe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The priors are  [0.88446963 0.11553037]\n",
            "The likelihood values for \"marital status\" for the first 5 test samples are [[0.2737297  0.35423197]\n",
            " [0.61026673 0.5292106 ]\n",
            " [0.11600358 0.11655742]\n",
            " [0.61026673 0.5292106 ]\n",
            " [0.11600358 0.11655742]]\n",
            "The likelihood values for \"age\" for the first 5 test samples are [[0.00032595 0.00217531]\n",
            " [0.01257581 0.01682234]\n",
            " [0.03691429 0.02835094]\n",
            " [0.03851424 0.03006992]\n",
            " [0.01664062 0.0195927 ]]\n",
            "[0.88446963 0.11553037]\n",
            "The ratio of correct predictions to the whole dataset is  0.8794495271776736\n"
          ]
        }
      ]
    }
  ]
}