lab1_PR.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/es-abdalrhman/PatternRecognition/blob/Main/lab1_PR.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "09a0ee07",
      "metadata": {
        "id": "09a0ee07"
      },
      "source": [
        "# Part1, Part2"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "import os\n",
        "import zipfile\n",
        "\n",
        "# Upload the zip file containing the images\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Extract the uploaded zip file\n",
        "for filename in uploaded.keys():\n",
        "    with zipfile.ZipFile(filename, 'r') as zip_ref:\n",
        "        zip_ref.extractall('images')\n",
        "\n"
      ],
      "metadata": {
        "id": "viexQhZNKa9V",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "outputId": "dd4f78a1-ffaf-4eab-fe83-2c3af259f283"
      },
      "id": "viexQhZNKa9V",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-95b50290-9547-4e48-9272-c1b139e92225\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-95b50290-9547-4e48-9272-c1b139e92225\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving colab.zip to colab (1).zip\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "e7030f34",
      "metadata": {
        "id": "e7030f34",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0bb69dd1-1892-45c2-bb3a-a9951182000a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "DataFrame shape: (400, 10305)\n",
            "<bound method DataFrame.info of        0    1    2    3    4    5    6    7    8    9  ...  10295  10296  \\\n",
            "0     48   49   45   47   49   57   39   42   53   49  ...     44     40   \n",
            "1     60   60   62   53   48   51   61   60   71   68  ...     35     28   \n",
            "2     39   44   53   37   61   48   61   45   35   40  ...     30     36   \n",
            "3     63   53   35   36   33   34   31   35   39   43  ...    169    166   \n",
            "4     64   76   80   53   34   72   60   66   66   50  ...     28     34   \n",
            "..   ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...    ...    ...   \n",
            "395  123  121  126  122  127  127  123  124  123  127  ...     47     34   \n",
            "396  129  127  133  124  131  129  130  129  127  132  ...     92     93   \n",
            "397  125  119  124  125  124  121  123  125  123  123  ...     34     38   \n",
            "398  119  120  120  118  120  121  121  116  120  121  ...     88     87   \n",
            "399  125  124  124  126  123  125  127  123  124  124  ...     34     32   \n",
            "\n",
            "     10297  10298  10299  10300  10301  10302  10303  id  \n",
            "0       41     49     42     44     47     46     46   1  \n",
            "1       33     31     31     37     32     34     34   1  \n",
            "2       32     28     32     31     29     26     29   1  \n",
            "3      161    158    169    137     41     10     24   1  \n",
            "4       32     35     34     35     35     37     39   1  \n",
            "..     ...    ...    ...    ...    ...    ...    ...  ..  \n",
            "395     36     42     34     39     40     35     42  40  \n",
            "396     90     90     92     89     93     93     93  40  \n",
            "397     37     32     41     40     36     39     40  40  \n",
            "398     97    101     91     93     89     94     85  40  \n",
            "399     30     38     27     36     36     35     34  40  \n",
            "\n",
            "[400 rows x 10305 columns]>\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import cv2\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "base_dir = 'images/archive'\n",
        "\n",
        "data = []\n",
        "target = []\n",
        "\n",
        "for subject_id in range(1, 41):\n",
        "    subject_dir = os.path.join(base_dir, f's{subject_id}')\n",
        "\n",
        "    # print(subject_dir)\n",
        "\n",
        "    for img_id in range(1, 11):\n",
        "        img_path = os.path.join(subject_dir, f'{img_id}.pgm')\n",
        "\n",
        "        # print(img_path)\n",
        "        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)\n",
        "        # print(img)\n",
        "\n",
        "        if img is not None:\n",
        "\n",
        "            img_flat = img.flatten()\n",
        "\n",
        "            data.append(img_flat)\n",
        "\n",
        "            target.append(subject_id)\n",
        "\n",
        "data = np.array(data)\n",
        "target = np.array(target)\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "df['id'] = target\n",
        "\n",
        "print(\"DataFrame shape:\", df.shape)\n",
        "print(df.info)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "831b05f7",
      "metadata": {
        "id": "831b05f7"
      },
      "source": [
        "# Part3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "8edda1fa",
      "metadata": {
        "id": "8edda1fa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e2a97df7-b606-4153-95b0-e4738b34fb85"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Data:\n",
            "     0      1      2      3      4      5      6      7      8      9      \\\n",
            "1       60     60     62     53     48     51     61     60     71     68   \n",
            "3       63     53     35     36     33     34     31     35     39     43   \n",
            "5       43     50     41     58     78     83     67     48     44     46   \n",
            "7       44     43     32     32     30     30     38     40     48     66   \n",
            "9       34     34     33     32     38     40     39     49     54     57   \n",
            "..     ...    ...    ...    ...    ...    ...    ...    ...    ...    ...   \n",
            "391    127    131    128    129    127    128    127    128    128    129   \n",
            "393    130    123    127    125    126    126    127    125    125    127   \n",
            "395    123    121    126    122    127    127    123    124    123    127   \n",
            "397    125    119    124    125    124    121    123    125    123    123   \n",
            "399    125    124    124    126    123    125    127    123    124    124   \n",
            "\n",
            "     ...  10294  10295  10296  10297  10298  10299  10300  10301  10302  10303  \n",
            "1    ...     27     35     28     33     31     31     37     32     34     34  \n",
            "3    ...    173    169    166    161    158    169    137     41     10     24  \n",
            "5    ...    167    164    164    162    159    156    155    158    153    169  \n",
            "7    ...     37     42     42     40     33     29     37     43     43     37  \n",
            "9    ...     42     44     38     30     37     30     36     37     40     33  \n",
            "..   ...    ...    ...    ...    ...    ...    ...    ...    ...    ...    ...  \n",
            "391  ...     91     90     87     91     90     90     89     94     84     89  \n",
            "393  ...     39     34     33     37     34     38     41     33     37     40  \n",
            "395  ...     29     47     34     36     42     34     39     40     35     42  \n",
            "397  ...     40     34     38     37     32     41     40     36     39     40  \n",
            "399  ...     39     34     32     30     38     27     36     36     35     34  \n",
            "\n",
            "[200 rows x 10304 columns]\n",
            "Training Labels:\n",
            "1       1\n",
            "3       1\n",
            "5       1\n",
            "7       1\n",
            "9       1\n",
            "       ..\n",
            "391    40\n",
            "393    40\n",
            "395    40\n",
            "397    40\n",
            "399    40\n",
            "Name: id, Length: 200, dtype: int64\n",
            "\n",
            "Testing Data:\n",
            "     0      1      2      3      4      5      6      7      8      9      \\\n",
            "0       48     49     45     47     49     57     39     42     53     49   \n",
            "2       39     44     53     37     61     48     61     45     35     40   \n",
            "4       64     76     80     53     34     72     60     66     66     50   \n",
            "6       41     47     47     46     44     49     48     58     61     49   \n",
            "8       42     41     44     46     48     39     37     37     33     37   \n",
            "..     ...    ...    ...    ...    ...    ...    ...    ...    ...    ...   \n",
            "390    119    121    123    121    120    123    121    120    123    124   \n",
            "392    131    125    126    131    125    129    125    127    127    127   \n",
            "394    128    125    125    129    128    132    125    133    125    131   \n",
            "396    129    127    133    124    131    129    130    129    127    132   \n",
            "398    119    120    120    118    120    121    121    116    120    121   \n",
            "\n",
            "     ...  10294  10295  10296  10297  10298  10299  10300  10301  10302  10303  \n",
            "0    ...     39     44     40     41     49     42     44     47     46     46  \n",
            "2    ...     23     30     36     32     28     32     31     29     26     29  \n",
            "4    ...     31     28     34     32     35     34     35     35     37     39  \n",
            "6    ...     27     34     35     34     36     34     39     35     37     38  \n",
            "8    ...     42     33     39     39     40     41     43     42     43     41  \n",
            "..   ...    ...    ...    ...    ...    ...    ...    ...    ...    ...    ...  \n",
            "390  ...     34     34     34     38     39     35     36     36     40     36  \n",
            "392  ...     91     89     90     90     93     88     93     89     93     91  \n",
            "394  ...     87     86     87     92     88     85     91     85     90     84  \n",
            "396  ...     91     92     93     90     90     92     89     93     93     93  \n",
            "398  ...     63     88     87     97    101     91     93     89     94     85  \n",
            "\n",
            "[200 rows x 10304 columns]\n",
            "Testing Labels:\n",
            "0       1\n",
            "2       1\n",
            "4       1\n",
            "6       1\n",
            "8       1\n",
            "       ..\n",
            "390    40\n",
            "392    40\n",
            "394    40\n",
            "396    40\n",
            "398    40\n",
            "Name: id, Length: 200, dtype: int64\n"
          ]
        }
      ],
      "source": [
        "# Separate odd and even rows\n",
        "train_data = df.iloc[1::2]  # Odd rows for training\n",
        "test_data = df.iloc[::2]  # Even rows for testing\n",
        "\n",
        "train_labels = train_data['id']\n",
        "test_labels = test_data['id']\n",
        "\n",
        "train_data = train_data.drop(columns=['id'])\n",
        "test_data = test_data.drop(columns=['id'])\n",
        "\n",
        "print(\"Training Data:\")\n",
        "print(train_data)\n",
        "print(\"Training Labels:\")\n",
        "print(train_labels)\n",
        "print(\"\\nTesting Data:\")\n",
        "print(test_data)\n",
        "print(\"Testing Labels:\")\n",
        "print(test_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "baec2ba2",
      "metadata": {
        "id": "baec2ba2"
      },
      "source": [
        "# Part4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "74127f93",
      "metadata": {
        "id": "74127f93",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8968ce13-04b5-4cd6-8051-54a72bb78cf2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy for alpha=0.8: 0.93\n",
            "Accuracy for alpha=0.85: 0.94\n",
            "Accuracy for alpha=0.9: 0.945\n",
            "Accuracy for alpha=0.95: 0.935\n"
          ]
        }
      ],
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "def PCA(X):\n",
        "\n",
        "    X_mean = np.mean(X, axis=0)\n",
        "\n",
        "    X_centered = X - X_mean\n",
        "\n",
        "    cov_matrix = np.cov(X_centered, rowvar=False)\n",
        "\n",
        "    cov_matrix = (cov_matrix + cov_matrix.T) / 2  # Enforce symmetry\n",
        "    cov_matrix = np.around(cov_matrix, decimals=3)\n",
        "\n",
        "    eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)\n",
        "\n",
        "    return eigenvalues, eigenvectors\n",
        "\n",
        "def selectComponents_PCA(eigenvalues, eigenvectors):\n",
        "    sorted_indices = np.argsort(eigenvalues)[::-1]\n",
        "    total_variance = np.sum(eigenvalues)\n",
        "    cumulative_variance = np.cumsum(eigenvalues[sorted_indices]) / total_variance\n",
        "    k = np.argmax(cumulative_variance >= alpha) + 1\n",
        "    U = eigenvectors[:, sorted_indices[:k]]\n",
        "\n",
        "\n",
        "    # Normalize the eigenvectors\n",
        "    U_normalized = U / np.linalg.norm(U, axis=0)\n",
        "\n",
        "    return U_normalized\n",
        "\n",
        "def project_data(X, U):\n",
        "    return np.dot(X, U)\n",
        "\n",
        "\n",
        "def classify(X_train, y_train, X_test, k=1):\n",
        "    knn = KNeighborsClassifier(n_neighbors=k)\n",
        "    knn.fit(X_train, y_train)\n",
        "    return knn.predict(X_test)\n",
        "\n",
        "\n",
        "eigenvalues, eigenvectors = PCA(train_data)\n",
        "\n",
        "alphas = [0.8, 0.85, 0.9, 0.95]\n",
        "\n",
        "\n",
        "\n",
        "for alpha in alphas:\n",
        "    U = selectComponents_PCA(eigenvalues, eigenvectors)\n",
        "\n",
        "    # Project data\n",
        "    projected_train_pca = project_data(train_data, U)\n",
        "\n",
        "    projected_test_pca = project_data(test_data, U)\n",
        "\n",
        "    y_pred_pca = classify(projected_train_pca, train_labels, projected_test_pca)\n",
        "\n",
        "    accuracy_pca = accuracy_score(test_labels, y_pred_pca)\n",
        "\n",
        "    print(f\"Accuracy for alpha={alpha}: {accuracy_pca}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 5 LDA**"
      ],
      "metadata": {
        "id": "JUxQnAb4rwtL"
      },
      "id": "JUxQnAb4rwtL"
    },
    {
      "cell_type": "code",
      "source": [
        "# the problem is the use of not separating data using class in the beginning\n",
        "def LDA (data,labels):\n",
        "    overallsamplemean =np.mean(data ,axis=0)\n",
        "    # calculate Sb matrix instead of B to get the sperability between classes\n",
        "    num_features = data.shape[1]\n",
        "    classes = np.unique(labels)\n",
        "    n_classes =len( classes)\n",
        "    sb = np.zeros((num_features,num_features))\n",
        "    for class_item in classes:\n",
        "        class_items = data[labels == class_item]\n",
        "        mean_class = np.mean(class_items,axis=0)\n",
        "        n_items = class_items.shape[0]\n",
        "        mean_diff = np.array(mean_class-overallsamplemean).reshape(-1,1)\n",
        "        sb += n_items * np.dot(mean_diff,mean_diff.T)\n",
        "\n",
        "\n",
        "    # Calculate S = s1 + s2 + .... + sn\n",
        "    s = np.zeros((num_features, num_features))\n",
        "\n",
        "    # Calculate Si for each sample in this position I made assumation that the data is separated each 5 groups together that's not always the case\n",
        "    for class_item in classes:\n",
        "        class_items = data[labels == class_item]\n",
        "        mean_class  = np.mean(class_items,axis=0)\n",
        "        n_items = class_items.shape[0]\n",
        "        zi = np.array(class_items - mean_class)\n",
        "        s += np.dot(zi.T, zi)\n",
        "\n",
        "\n",
        "\n",
        "    eigenvalues , eigenvectors = np.linalg.eigh(np.linalg.pinv(s).dot(sb))\n",
        "    print('eigenvectors are ',eigenvectors)\n",
        "    return eigenvalues ,eigenvectors\n",
        "\n",
        "def selectComponents_LDA(eigenvalues, eigenvectors):\n",
        "    sorted_indices = np.argsort(eigenvalues)[::-1]\n",
        "    U = eigenvectors[:, sorted_indices]\n",
        "    # Normalize the eigenvectors\n",
        "    U_normalized = U / np.linalg.norm(U, axis=0)\n",
        "\n",
        "    return U_normalized[:,:39]\n",
        "\n",
        "def project_data(X, U):\n",
        "    return np.dot(X, U)\n",
        "\n",
        "\n",
        "def classify(X_train, y_train, X_test, k=1):\n",
        "    knn = KNeighborsClassifier(n_neighbors=k)\n",
        "    knn.fit(X_train, y_train)\n",
        "    return knn.predict(X_test)\n",
        "\n",
        "train_data = df.iloc[1::2]  # Odd rows for training\n",
        "test_data = df.iloc[::2]  # Even rows for testing\n",
        "\n",
        "train_labels = train_data['id']\n",
        "test_labels = test_data['id']\n",
        "\n",
        "train_data = train_data.drop(columns=['id'])\n",
        "test_data = test_data.drop(columns=['id'])\n",
        "eigenvalues , eigenvectors =  LDA (train_data,train_labels)\n",
        "\n",
        "# we need to drop column id before entering the loop\n",
        "\n",
        "\n",
        "U = selectComponents_LDA(eigenvalues, eigenvectors)\n",
        "\n",
        "# Project data\n",
        "projected_train_lda = project_data(train_data, U)\n",
        "\n",
        "projected_test_lda = project_data(test_data, U)\n",
        "\n",
        "y_pred_lda = classify(projected_train_lda, train_labels, projected_test_lda)\n",
        "\n",
        "accuracy_lda = accuracy_score(test_labels, y_pred_lda)\n",
        "\n",
        "print(f\"The LDA Accuracy {accuracy_lda}\")\n"
      ],
      "metadata": {
        "id": "piUfIU78ieF5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d4289fe-25d2-49f3-be3b-a0372786fcf9"
      },
      "id": "piUfIU78ieF5",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "eigenvectors are  [[-5.92244074e-02  4.73370719e-01 -3.77627005e-02 ...  1.16719236e-02\n",
            "  -4.02027138e-01 -2.70991902e-02]\n",
            " [-6.94702085e-02  5.90640837e-01 -4.92166566e-02 ...  8.03114019e-03\n",
            "  -3.01650009e-01 -2.24282855e-02]\n",
            " [ 3.22849180e-04 -2.17999751e-01  3.10611831e-02 ...  2.51471710e-02\n",
            "  -7.91259608e-01 -4.55836285e-02]\n",
            " ...\n",
            " [ 1.42294968e-03  4.97789378e-04  4.43650704e-03 ...  4.79259608e-03\n",
            "   2.45968337e-04 -1.77832996e-03]\n",
            " [-7.52056797e-03 -5.02526908e-04  7.35607741e-03 ...  6.99794296e-03\n",
            "  -9.30572348e-05  6.78007730e-03]\n",
            " [-2.27581355e-06  7.73645603e-04  1.12028717e-02 ...  1.17523243e-02\n",
            "   4.38832790e-04 -9.52541551e-04]]\n",
            "The LDA Accuracy 0.925\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Compare LDA with PCA**\n",
        "\n",
        "from the results we see that the accuracy of PCA is higher by less values from LDA\n",
        "As PCA give from 0.93 to 0.945 accuracy while LDA give 0.925\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "2porGrvF4s4h"
      },
      "id": "2porGrvF4s4h"
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 6**"
      ],
      "metadata": {
        "id": "MhljYwJb4g1d"
      },
      "id": "MhljYwJb4g1d"
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.metrics import accuracy_score\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "def classify(X_train, y_train, X_test, k):\n",
        "    knn = KNeighborsClassifier(n_neighbors=k)\n",
        "    knn.fit(X_train, y_train)\n",
        "\n",
        "    # Predict classes for test data\n",
        "    predicted_classes = knn.predict(X_test)\n",
        "\n",
        "    # If there's only one class with maximum probability, return that class\n",
        "    # Otherwise, use a secondary tie-breaking criterion (e.g., class with lowest index)\n",
        "    unique_classes = np.unique(y_train)  # Unique classes present in the training data\n",
        "    for i in range(len(predicted_classes)):\n",
        "        if np.sum(predicted_classes[i] == unique_classes) != 1:\n",
        "            # Multiple classes have the same maximum probability\n",
        "            # Use secondary tie-breaking criterion (class with lowest index)\n",
        "            predicted_classes[i] = np.min(np.where(predicted_classes[i] == unique_classes))\n",
        "\n",
        "    return predicted_classes\n",
        "\n",
        "\n",
        "\n",
        "# Define K values\n",
        "k_values = [1, 3, 5, 7]\n",
        "\n",
        "# Perform KNN classification and compute accuracy for each K value\n",
        "PCA_accuracies = []\n",
        "LDA_accuracies = []\n",
        "\n",
        "# print(projected_train_pca)\n",
        "# print(train_labels)\n",
        "# print(projected_test_pca)\n",
        "for k in k_values:\n",
        "    # Call classify function for PCA\n",
        "    y_pred_pca = classify(projected_train_pca, train_labels, projected_test_pca, k)\n",
        "    accuracy_pca = accuracy_score(test_labels, y_pred_pca)\n",
        "    print(accuracy_pca)\n",
        "    PCA_accuracies.append(accuracy_pca)\n",
        "\n",
        "    # Call classify function for LDA\n",
        "    y_pred_lda = classify(projected_train_lda, train_labels, projected_test_lda, k)\n",
        "    accuracy_lda = accuracy_score(test_labels, y_pred_lda)\n",
        "    LDA_accuracies.append(accuracy_lda)\n",
        "    print(accuracy_lda)\n",
        "\n",
        "# Plotting as bar graph\n",
        "plt.figure(figsize=(10, 6))\n",
        "\n",
        "# Width of the bars\n",
        "bar_width = 0.35\n",
        "\n",
        "# Position of the bars on the x-axis\n",
        "bar_positions_pca = np.arange(len(k_values))\n",
        "bar_positions_lda = bar_positions_pca + bar_width\n",
        "print('PCA_accuracies' , PCA_accuracies)\n",
        "print('LDA_accuracies' , LDA_accuracies)\n",
        "# Plotting bars for PCA\n",
        "plt.bar(bar_positions_pca, PCA_accuracies, bar_width, label='PCA')\n",
        "\n",
        "# Plotting bars for LDA\n",
        "plt.bar(bar_positions_lda, LDA_accuracies, bar_width, label='LDA')\n",
        "\n",
        "# Adding labels and titles\n",
        "plt.xlabel('K value')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Accuracy vs. K value for PCA and LDA')\n",
        "plt.xticks(bar_positions_pca + bar_width / 2, k_values)\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()\n",
        "\n"
      ],
      "metadata": {
        "id": "OAGxsyvD4l1u",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 738
        },
        "outputId": "9b9d4361-a36d-4abc-b6f2-d4638f443466"
      },
      "id": "OAGxsyvD4l1u",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.935\n",
            "0.925\n",
            "0.845\n",
            "0.86\n",
            "0.815\n",
            "0.8\n",
            "0.74\n",
            "0.745\n",
            "PCA_accuracies [0.935, 0.845, 0.815, 0.74]\n",
            "LDA_accuracies [0.925, 0.86, 0.8, 0.745]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.10.9"
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "accelerator": "TPU"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}