Assignment(MnP)_Gurnoor.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM2xm6vGlK4pPugt5H9ha38",
      "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/G-Sohal/CPP-2024/blob/main/Assignment(MnP)_Gurnoor.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# BASIC PYTHON"
      ],
      "metadata": {
        "id": "XfbjnkCTlVOn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. A)"
      ],
      "metadata": {
        "id": "X0qzr-rTMWA4"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T0i6h_6IPsCg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "outputId": "a43ca11b-08bf-4d4b-f30d-a87738503890"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------A---------\n",
            "--------BAB--------\n",
            "-------CBABC-------\n",
            "------DCBABCD------\n",
            "-----EDCBABCDE-----\n",
            "----FEDCBABCDEF----\n",
            "---GFEDCBABCDEFG---\n",
            "--HGFEDCBABCDEFGH--\n",
            "-IHGFEDCBABCDEFGHI-\n",
            "JIHGFEDCBABCDEFGHIJ\n",
            "-----A-----\n",
            "----BAB----\n",
            "---CBABC---\n",
            "--DCBABCD--\n",
            "-EDCBABCDE-\n",
            "FEDCBABCDEF\n"
          ]
        }
      ],
      "source": [
        "def F(n):\n",
        "    for i in range(n):\n",
        "       alpha = ''\n",
        "       for j in range(2*i+1): alpha += chr(ord('A')+abs(j-i))\n",
        "       print('-'*(n-i-1)+alpha+'-'*(n-i-1))\n",
        "    pass\n",
        "\n",
        "# Tests\n",
        "F(10)\n",
        "F(6)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. B)"
      ],
      "metadata": {
        "id": "ZvJZScLDMZE3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def F(d : dict):\n",
        "    for key in sorted(d.keys()):\n",
        "        print(f'-{key}-,-{d[key][0]}-,-{d[key][1]}-')\n",
        "    for key, (x,y) in sorted(d.items(), key = lambda item: item[1][0], reverse = True):\n",
        "        print(f'-{key}-,-{d[key][0]}-,-{d[key][1]}-')\n",
        "    for key, (x,y) in sorted(d.items(), key = lambda item: item[1][1] , reverse = False):\n",
        "        print(f'-{key}-,-{d[key][0]}-,-{d[key][1]}-')\n",
        "    pass\n",
        "\n",
        "# Tests\n",
        "F({1 : (1, 2), 2 : (-1, 4), 5 : (-4, 3), 4 : (2, 3)})\n",
        "F({-8 : (4, 2), 6 : (-3, 4), 7 : (2, 1), 5 : (9, -10)})"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "3pPHLKDdcMwJ",
        "outputId": "aeaf27de-6259-4860-b3ca-dbe788012fd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-1-,-1-,-2-\n",
            "-2-,--1-,-4-\n",
            "-4-,-2-,-3-\n",
            "-5-,--4-,-3-\n",
            "-4-,-2-,-3-\n",
            "-1-,-1-,-2-\n",
            "-2-,--1-,-4-\n",
            "-5-,--4-,-3-\n",
            "-1-,-1-,-2-\n",
            "-5-,--4-,-3-\n",
            "-4-,-2-,-3-\n",
            "-2-,--1-,-4-\n",
            "--8-,-4-,-2-\n",
            "-5-,-9-,--10-\n",
            "-6-,--3-,-4-\n",
            "-7-,-2-,-1-\n",
            "-5-,-9-,--10-\n",
            "--8-,-4-,-2-\n",
            "-7-,-2-,-1-\n",
            "-6-,--3-,-4-\n",
            "-5-,-9-,--10-\n",
            "-7-,-2-,-1-\n",
            "--8-,-4-,-2-\n",
            "-6-,--3-,-4-\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "E6gfDJAilzPQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# WORKING WITH STUDENT RECORDS"
      ],
      "metadata": {
        "id": "Ju973NXFlb4t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. A)"
      ],
      "metadata": {
        "id": "r9kbcy81Ofe9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"student_records.csv\", \"r\") as file:\n",
        "    lines = file.readlines()\n",
        "    rows = lines[1:11]\n",
        "\n",
        "for row in rows:\n",
        "    print(row.strip())"
      ],
      "metadata": {
        "id": "YY6PJXslOfHW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. B)"
      ],
      "metadata": {
        "id": "OX0VWqSkljxT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "grade_points = {\n",
        "    \"AP\": 10, \"AA\": 10, \"AB\": 9, \"BB\": 8, \"BC\": 7, \"CC\": 6, \"CD\": 5, \"DD\": 4, \"F\": 0\n",
        "}\n",
        "\n",
        "student = {}\n",
        "with open(\"student_records.csv\", \"r\") as file:\n",
        "    lines = file.readlines()[1:]\n",
        "    for line in lines:\n",
        "        roll_number, department, credit, course_name, course_type, grade = line.strip().split(\"\\t\")\n",
        "        credit = int(credit)\n",
        "        points = grade_points[grade]\n",
        "        if roll_number not in student:\n",
        "            student[roll_number] = {\"total_credits\": 0, \"weighted_sum\": 0}\n",
        "        student[roll_number][\"total_credits\"] += credit\n",
        "        student[roll_number][\"weighted_sum\"] += credit * points\n",
        "\n",
        "for roll, data in student.items():\n",
        "    total_credits = data[\"total_credits\"]\n",
        "    cpi = data[\"weighted_sum\"] / total_credits if total_credits > 0 else 0\n",
        "    print(f\"{roll}, {total_credits}, {cpi}\")"
      ],
      "metadata": {
        "id": "55KBgQ7nlhTZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. C)"
      ],
      "metadata": {
        "id": "g16IgaNQsH2B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "requirements = [20, 15, 10, 5]\n",
        "\n",
        "students = {}\n",
        "with open(\"student_records.csv\", \"r\") as file:\n",
        "    lines = file.readlines()[1:]\n",
        "    for line in lines:\n",
        "        roll_number, department, credit, course_name, course_type, grade = line.strip().split(\"\\t\")\n",
        "        credit = int(credit)\n",
        "        if roll_number not in students:\n",
        "            students[roll_number] = [0] * 4\n",
        "\n",
        "        if course_type == \"core_course\":\n",
        "            students[roll_number][0] += credit\n",
        "        elif course_type == \"department_elective\":\n",
        "            students[roll_number][1] += credit\n",
        "        elif course_type == \"flexible_elective\":\n",
        "            students[roll_number][2] += credit\n",
        "        elif course_type == \"hasmed_elective\":\n",
        "            students[roll_number][3] += credit\n",
        "        elif course_type == \"honours\":\n",
        "            students[roll_number][4] += credit\n",
        "        elif course_type == \"minor\":\n",
        "            students[roll_number][5] += credit\n",
        "\n",
        "\n",
        "for roll, credits in students.items():\n",
        "    if (credits[0] >= 20 and credits[1] >= 15 and credits[2] >= 10 and credits[3] >= 5):\n",
        "        print(roll)"
      ],
      "metadata": {
        "id": "MnImEdjPrmvU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. D)"
      ],
      "metadata": {
        "id": "i_oR5mGGsKN2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for roll, credits in students.items():\n",
        "    if credits[5] >= 10:\n",
        "        print(roll)"
      ],
      "metadata": {
        "id": "Nq58Bkoir8Nf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. E)"
      ],
      "metadata": {
        "id": "w82zN1GesNGX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for roll, credits in students.items():\n",
        "    if credits[4] >= 10 and credits[0] >= 20:\n",
        "        print(roll)"
      ],
      "metadata": {
        "id": "UL7HKD7Zr8sc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SciPy"
      ],
      "metadata": {
        "id": "c52YAFKIEidH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "PART A"
      ],
      "metadata": {
        "id": "agQPNKnmJzlL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from scipy.optimize import minimize\n",
        "\n",
        "def function(variables):\n",
        "    return (2 * (variables[0] - variables[1] - 3)**2 + 4 * (variables[0] + 2*variables[1] + 1)**4)\n",
        "\n",
        "constraints = [\n",
        "    {\"type\": \"ineq\", \"fun\": lambda variables: -variables[0] + variables[1] + 3},\n",
        "    {\"type\": \"ineq\", \"fun\": lambda variables: 5 - ((variables[0] + 2)**2 + (variables[1] + 1)**2)}\n",
        "]\n",
        "\n",
        "result = minimize(function, [0, 0], constraints=constraints)\n",
        "print(result.fun)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3guKLfwqEj8Q",
        "outputId": "61e95e78-5d6a-4a3b-ad81-984f98505710"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7.345026166648974\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "PART B"
      ],
      "metadata": {
        "id": "MHkGK2STJ4qj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from scipy.integrate import quad\n",
        "import numpy as np\n",
        "\n",
        "def f(t):\n",
        "    x = np.sqrt(3) * np.cos(t)\n",
        "    y = np.sqrt(3) * np.sin(t)\n",
        "    fn = x**2 + y**4\n",
        "    ds = np.sqrt(3)\n",
        "    return fn * ds\n",
        "\n",
        "I, err = quad(f, 0, 2 * np.pi)\n",
        "print(I)\n"
      ],
      "metadata": {
        "id": "_0j9--cYJ78D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NUMPY"
      ],
      "metadata": {
        "id": "xHNHZ9ireuSg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import time # to time the execution\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "jJhPSdCYevzH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 1\n",
        "### Load data from data_path\n",
        "### Check the input file spice_locations.txt to understand the Data Format\n",
        "### Return : np array of size Nx2\n",
        "\n",
        "def load_data(data_path):\n",
        "    data = np.loadtxt(data_path, delimiter=',')\n",
        "    return data"
      ],
      "metadata": {
        "id": "nyieoQk2fAO1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 2.1\n",
        "### If init_centers is None, initialize the centers by selecting K data points at random without replacement\n",
        "### Else, use the centers provided in init_centers\n",
        "### Return : np array of size Kx2\n",
        "\n",
        "def initialise_centers(data, K, init_centers=None):\n",
        "    if init_centers is None:\n",
        "        indices = np.random.choice(data.shape[0], K, replace=False)\n",
        "        return data[indices]\n",
        "    else:\n",
        "        return init_centers"
      ],
      "metadata": {
        "id": "-gVfDKkMjZWZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 2.2\n",
        "### Initialize the labels to all ones to size (N,) where N is the number of data points\n",
        "### Return : np array of size N\n",
        "\n",
        "def initialise_labels(data):\n",
        "    return np.ones(data.shape[0], dtype=int)"
      ],
      "metadata": {
        "id": "mWSCjT_ikEI2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 3.1 : E step\n",
        "### For Each data point, find the distance to each center\n",
        "### Return : np array of size NxK\n",
        "\n",
        "def calculate_distances(data, centers):\n",
        "    distances = []\n",
        "    for point in data:\n",
        "        dist = []\n",
        "        for center in centers:\n",
        "            dist.append(np.sqrt(sum((point - center) ** 2)))\n",
        "        distances.append(dist)\n",
        "    return np.array(distances)"
      ],
      "metadata": {
        "id": "fYJ5XU7MkNUQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 3.2 : E step\n",
        "### For Each data point, assign the label of the nearest center\n",
        "### Return : np array of size N\n",
        "\n",
        "def update_labels(distances):\n",
        "    labels = np.argmin(distances, axis=1)\n",
        "    return labels"
      ],
      "metadata": {
        "id": "hTa3iVbgkc3Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 4 : M step\n",
        "### Update the centers to the mean of the data points assigned to it\n",
        "### Return : np array of size Kx2\n",
        "\n",
        "def update_centers(data, labels, K):\n",
        "    return np.array([data[labels == k].mean(axis=0) for k in range(K)])"
      ],
      "metadata": {
        "id": "RlJuxwbvkkcu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 6 : Check convergence\n",
        "### Check if the labels have changed from the previous iteration\n",
        "### Return : True / False\n",
        "\n",
        "def check_termination(labels1, labels2):\n",
        "    return np.array_equal(labels1, labels2)"
      ],
      "metadata": {
        "id": "9A2OXQpvkt1t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### DON'T CHANGE ANYTHING IN THE FOLLOWING FUNCTION\n",
        "def kmeans(data_path:str, K:int, init_centers):\n",
        "    '''\n",
        "    Input :\n",
        "        data (type str): path to the file containing the data\n",
        "        K (type int): number of clusters\n",
        "        init_centers (type numpy.ndarray): initial centers. shape = (K, 2) or None\n",
        "    Output :\n",
        "        centers (type numpy.ndarray): final centers. shape = (K, 2)\n",
        "        labels (type numpy.ndarray): label of each data point. shape = (N,)\n",
        "        time (type float): time taken by the algorithm to converge in seconds\n",
        "    N is the number of data points each of shape (2,)\n",
        "    '''\n",
        "    data = load_data(data_path)\n",
        "    centers = initialise_centers(data, K, init_centers)\n",
        "    labels = initialise_labels(data)\n",
        "\n",
        "    start_time = time.time() # Time stamp\n",
        "\n",
        "    while True:\n",
        "        distances = calculate_distances(data, centers)\n",
        "        labels_new = update_labels(distances)\n",
        "        centers = update_centers(data, labels_new, K)\n",
        "        if check_termination(labels, labels_new): break\n",
        "        else: labels = labels_new\n",
        "\n",
        "    end_time = time.time() # Time stamp after the algorithm ends\n",
        "    return centers, labels, end_time - start_time"
      ],
      "metadata": {
        "id": "HHJeEhXDkzH3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### TODO 7\n",
        "def visualise(data_path, labels, centers):\n",
        "    data = load_data(data_path)\n",
        "\n",
        "    # Scatter plot of the data points\n",
        "    plt.scatter(data[:, 0], data[:, 1], c=labels, s=50, cmap='viridis')\n",
        "    plt.scatter(centers[:, 0], centers[:, 1], c='black', s=200, alpha=0.5)\n",
        "\n",
        "    ### Set title as 'K-means clustering'\n",
        "    plt.title('K-means clustering')\n",
        "    ### Set xlabel as 'Longitude'\n",
        "    plt.xlabel('Longitude')\n",
        "    ### Set ylabel as 'Latitude'\n",
        "    plt.ylabel('Latitude')\n",
        "    ### Save the plot as 'kmeans.png'\n",
        "    plt.savefig('kmeans.png')\n",
        "    ## DO NOT CHANGE THE FOLLOWING LINE\n",
        "    return plt"
      ],
      "metadata": {
        "id": "qA1cfNlnk6Sd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### After you have completed the above functions, run the following code to generate the plot\n",
        "data_path = 'spice_locations.txt'\n",
        "K, init_centers = 2, None\n",
        "centers, labels, time_taken = kmeans(data_path, K, init_centers)\n",
        "print('Time taken for the algorithm to converge:', time_taken)\n",
        "visualise(data_path, labels, centers)"
      ],
      "metadata": {
        "id": "jYxAA2EOk_PT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}