17_8_2022Assignment1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "17-8-2022Assignment1.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOs+6TCNI6xOJKkdg9t6YFu",
      "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/SWi7CHbladE/Pattern-Recognition-Assigment/blob/main/17_8_2022Assignment1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount(\"/content/gdrive/\",force_remount = True)"
      ],
      "metadata": {
        "id": "dfo6vlhNWlF5",
        "outputId": "d215634b-7922-4e0c-fae3-a6cf85aa3e04",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive/\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dqzxTBdFyXyx",
        "outputId": "1cea5864-8069-4e40-8b10-62d7d975f861"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'index': 'R', 'mean': 9.933684462532918, 'standard deviation': 3.2237830658212117, 'min': 1.0, 'max': 29.0}, {'index': 'L', 'mean': 0.5239920995930094, 'standard deviation': 0.12007853620602839, 'min': 0.075, 'max': 0.815}, {'index': 'D', 'mean': 0.40788125448886764, 'standard deviation': 0.09922798609936374, 'min': 0.055, 'max': 0.65}, {'index': 'H', 'mean': 0.13951639932966242, 'standard deviation': 0.04182204947769995, 'min': 0.0, 'max': 1.13}, {'index': 'WW', 'mean': 0.8287421594445774, 'standard deviation': 0.4903303136137728, 'min': 0.002, 'max': 2.8255}, {'index': 'SW', 'mean': 0.35936748862820206, 'standard deviation': 0.22193637778166947, 'min': 0.001, 'max': 1.488}, {'index': 'VW', 'mean': 0.18059360785252573, 'standard deviation': 0.10960112830473714, 'min': 0.0005, 'max': 0.76}, {'index': 'LW', 'mean': 0.23883085946851806, 'standard deviation': 0.13918600552884794, 'min': 0.0015, 'max': 1.005}]\n",
            "\n",
            "\n",
            "Data in Output2.csv\n"
          ]
        }
      ],
      "source": [
        "import csv                                                                  # Library to process csv files\n",
        "import copy\n",
        "import math\n",
        "\n",
        "def mean(*inp):\n",
        "    length = len(inp)\n",
        "    tmp1 = math.fsum(inp)/length\n",
        "    return(tmp1)\n",
        "\n",
        "def std_dev(*inp):\n",
        "    mn = mean(*inp)\n",
        "    length = len(inp)\n",
        "    tmp = []\n",
        "    for i in inp:                                                           # Store the squares of all the numbers on a list\n",
        "        t = i - mn\n",
        "        tmp.append(math.pow(t,2))\n",
        "    t2 = math.fsum(tmp)/length                                              # Find the variance of the list \n",
        "    res = math.sqrt(t2)                                                     # Standard Deviation = sqrt(variance)\n",
        "    return res\n",
        "\n",
        "\n",
        "def max(*inp):                                                              # Returns the \n",
        "    tmp = [] \n",
        "    tmp.extend(inp)\n",
        "    tmp.sort()\n",
        "    return tmp[-1]\n",
        "\n",
        "\n",
        "def min(*inp):\n",
        "    tmp = [] \n",
        "    tmp.extend(inp)\n",
        "    tmp.sort()\n",
        "    return tmp[0] \n",
        "\n",
        "\n",
        "tuple_index = []\n",
        "out_table = []                                                              # stores the tuples of the output table\n",
        "with open('/content/gdrive/MyDrive/Colab_Files/abalonedata.csv', mode='r') as csv_file:\n",
        "    csv_Dict = csv.DictReader(csv_file)                                     # csv.DictReader(<file_object>) reads through the csv file as a dictionary row by row, where the indices are the first row elements\n",
        "    line_count = 0\n",
        "    tmp = []\n",
        "    for row in csv_Dict:                                                    # Creates a list which contains the dictionaries of all tuples as dictionaries indexed by the indices of the first row\n",
        "        tmp.append(row)\n",
        "        out_table.extend(copy.deepcopy(tmp))\n",
        "        tmp.clear()\n",
        "\n",
        "with open('/content/gdrive/MyDrive/Colab_Files/abalonedata.csv', mode='r') as csv_file:\n",
        "    csv_reader = csv.reader(csv_file)                                       # csv.reader(<file_object>) Reads csv file as list\n",
        "    line_count = 0\n",
        "    for row in csv_reader:\n",
        "        if line_count == 0:\n",
        "            line_count = 1\n",
        "            for x in row:\n",
        "                tuple_index.append(x)\n",
        "            tuple_index.remove(\"S\")                                         # allows only the indices required in the output table\n",
        "\n",
        "\n",
        "\n",
        "database = []\n",
        "for ind in tuple_index:\n",
        "    table = {}\n",
        "    tmp1 = []\n",
        "    for tup in out_table:\n",
        "        tmp1.append(copy.deepcopy(tup[ind]))\n",
        "    for i in tmp1:\n",
        "        tmp.append(float(i))                                                # convert everything to float\n",
        "    table[\"index\"] = str(ind)\n",
        "    table[\"mean\"] = mean(*tmp)\n",
        "    table[\"standard deviation\"] = std_dev(*tmp)\n",
        "    table[\"min\"] = min(*tmp)\n",
        "    table[\"max\"] = max(*tmp)\n",
        "    tmp.clear()\n",
        "    database.append(copy.deepcopy(table))\n",
        "    table.clear()\n",
        "\n",
        "with open(\"output2.csv\",\"w\") as csv_out:                                   # Prints the database to a csv file\n",
        "    writer = csv.writer(csv_out)\n",
        "    flag = 0\n",
        "    for row in database:\n",
        "        if flag==0:\n",
        "            writer.writerow(row)                                           # Prints the indices to the csv file\n",
        "            flag += 1\n",
        "        writer.writerow(row.values())                                      # Prints the contents to the csv file\n",
        "\n",
        "print(database)\n",
        "\n",
        "print(\"\\n\\nData in Output2.csv\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import csv                                                                  # Library to process csv files\n",
        "import copy\n",
        "import math\n",
        "\n",
        "def mean(*inp):\n",
        "    length = len(inp)\n",
        "    tmp1 = math.fsum(inp)/length\n",
        "    return(tmp1)\n",
        "\n",
        "def std_dev(*inp):\n",
        "    mn = mean(*inp)\n",
        "    length = len(inp)\n",
        "    tmp = []\n",
        "    for i in inp:                                                           # Store the squares of all the numbers on a list\n",
        "        t = i - mn\n",
        "        tmp.append(math.pow(t,2))\n",
        "    t2 = math.fsum(tmp)/length                                              # Find the variance of the list \n",
        "    res = math.sqrt(t2)                                                     # Standard Deviation = sqrt(variance)\n",
        "    return res\n",
        "\n",
        "\n",
        "def max(*inp):                                                              # Returns the \n",
        "    tmp = [] \n",
        "    tmp.extend(inp)\n",
        "    tmp.sort()\n",
        "    return tmp[-1]\n",
        "\n",
        "\n",
        "def min(*inp):\n",
        "    tmp = [] \n",
        "    tmp.extend(inp)\n",
        "    tmp.sort()\n",
        "    return tmp[0] \n",
        "\n",
        "\n",
        "tuple_index = []\n",
        "out_table = []                                                              # stores the tuples of the output table\n",
        "with open('/content/gdrive/MyDrive/Colab_Files/abalonedata.csv', mode='r') as csv_file:\n",
        "    csv_Dict = csv.DictReader(csv_file)                                     # csv.DictReader(<file_object>) reads through the csv file as a dictionary row by row, where the indices are the first row elements\n",
        "    line_count = 0\n",
        "    tmp = []\n",
        "    for row in csv_Dict:                                                    # Creates a list which contains the dictionaries of all tuples as dictionaries indexed by the indices of the first row\n",
        "        tmp.append(row)\n",
        "        out_table.extend(copy.deepcopy(tmp))\n",
        "        tmp.clear()\n",
        "\n",
        "with open('/content/gdrive/MyDrive/Colab_Files/abalonedata.csv', mode='r') as csv_file:\n",
        "    csv_reader = csv.reader(csv_file)                                       # csv.reader(<file_object>) Reads csv file as list\n",
        "    line_count = 0\n",
        "    for row in csv_reader:\n",
        "        if line_count == 0:\n",
        "            line_count = 1\n",
        "            for x in row:\n",
        "                tuple_index.append(x)\n",
        "            tuple_index.remove(\"S\")                                         # allows only the indices required in the output table\n",
        "\n",
        "\n",
        "\n",
        "diff = set([])\n",
        "\n",
        "for i in out_table:                                                         # extracts all possible values of 'S'\n",
        "    diff.add(i['S'])\n",
        "diff = list(diff)\n",
        "\n",
        "\n",
        "\n",
        "database = []\n",
        "t = []\n",
        "table = {}\n",
        "tmp1 = []\n",
        "tmp = []\n",
        "for i in diff:\n",
        "    for ind in tuple_index:\n",
        "        for tup in out_table:\n",
        "            if i == tup['S']:\n",
        "                tmp1.append(copy.deepcopy(tup[ind]))\n",
        "        for x in tmp1:\n",
        "            tmp.append(float(x))\n",
        "        table[\"index\"] = str(ind)\n",
        "        table[\"mean\"] = mean(*tmp)\n",
        "        table[\"standard deviation\"] = std_dev(*tmp)\n",
        "        table[\"min\"] = min(*tmp)\n",
        "        table[\"max\"] = max(*tmp)\n",
        "        tmp1.clear()\n",
        "        t.append(copy.deepcopy(table))    \n",
        "        table.clear()\n",
        "    database.append(copy.deepcopy(t))\n",
        "    t.clear()\n",
        "\n",
        "\n",
        "print(diff)\n",
        "\n",
        "\n",
        "with open(\"output3.csv\",\"w\") as csv_out:                                   # Prints the database to a csv file\n",
        "    writer = csv.writer(csv_out)\n",
        "    flag = 0\n",
        "    flag1 = 0\n",
        "    for item in database:\n",
        "        writer.writerow(diff[flag1])\n",
        "        flag1 += 1\n",
        "        flag = 0\n",
        "        for row in item:\n",
        "            if flag==0:\n",
        "                writer.writerow(row)                                           # Prints the indices to the csv file\n",
        "                flag += 1\n",
        "            writer.writerow(row.values())                                      # Prints the contents to the csv file\n",
        "\n",
        "print(database)\n",
        "\n",
        "\n",
        "print(\"\\n\\nData in Output3.csv\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R06Eztdkzi7T",
        "outputId": "e2ef4857-0b56-4506-ebd9-9406fae2d8b1"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['F', 'M', 'I']\n",
            "[[{'index': 'R', 'mean': 11.129303749043611, 'standard deviation': 3.1030685095176738, 'min': 5.0, 'max': 29.0}, {'index': 'L', 'mean': 5.854198546289212, 'standard deviation': 5.713576890368721, 'min': 0.275, 'max': 29.0}, {'index': 'D', 'mean': 4.054376434583014, 'standard deviation': 5.3144805395110115, 'min': 0.195, 'max': 29.0}, {'index': 'H', 'mean': 3.0802850038255545, 'standard deviation': 4.902013797835218, 'min': 0.015, 'max': 29.0}, {'index': 'WW', 'mean': 2.673534429992349, 'standard deviation': 4.46347192519127, 'min': 0.015, 'max': 29.0}, {'index': 'SW', 'mean': 2.30230999744963, 'standard deviation': 4.159057833807728, 'min': 0.015, 'max': 29.0}, {'index': 'VW', 'mean': 2.006364083506394, 'standard deviation': 3.918356462647606, 'min': 0.015, 'max': 29.0}, {'index': 'LW', 'mean': 1.7933198163733743, 'standard deviation': 3.708640539717238, 'min': 0.015, 'max': 29.0}], [{'index': 'R', 'mean': 2.9296522029372496, 'standard deviation': 4.6907663291651955, 'min': 0.015, 'max': 29.0}, {'index': 'L', 'mean': 2.6618381438721137, 'standard deviation': 4.480934663025272, 'min': 0.015, 'max': 29.0}, {'index': 'D', 'mean': 2.436036369680851, 'standard deviation': 4.300052341023956, 'min': 0.015, 'max': 29.0}, {'index': 'H', 'mean': 2.22533178416224, 'standard deviation': 4.149970228892378, 'min': 0.015, 'max': 29.0}, {'index': 'WW', 'mean': 2.1211453912466847, 'standard deviation': 3.988033996424238, 'min': 0.015, 'max': 29.0}, {'index': 'SW', 'mean': 1.9896957042397065, 'standard deviation': 3.8567525371323366, 'min': 0.0065, 'max': 29.0}, {'index': 'VW', 'mean': 1.8615327392208776, 'standard deviation': 3.7432295113535354, 'min': 0.003, 'max': 29.0}, {'index': 'LW', 'mean': 1.755114175485009, 'standard deviation': 3.636713760634702, 'min': 0.003, 'max': 29.0}], [{'index': 'R', 'mean': 2.0978681833319457, 'standard deviation': 3.850245962573158, 'min': 0.003, 'max': 29.0}, {'index': 'L', 'mean': 2.0095026218262104, 'standard deviation': 3.7656925021411265, 'min': 0.003, 'max': 29.0}, {'index': 'D', 'mean': 1.9249299595596494, 'standard deviation': 3.688283371562749, 'min': 0.003, 'max': 29.0}, {'index': 'H', 'mean': 1.837995917712493, 'standard deviation': 3.6198068621093578, 'min': 0.0, 'max': 29.0}, {'index': 'WW', 'mean': 1.773766519224226, 'standard deviation': 3.548895088857, 'min': 0.0, 'max': 29.0}, {'index': 'SW', 'mean': 1.704652056488351, 'standard deviation': 3.485686047411521, 'min': 0.0, 'max': 29.0}, {'index': 'VW', 'mean': 1.6371779166926481, 'standard deviation': 3.4272531665140664, 'min': 0.0, 'max': 29.0}, {'index': 'LW', 'mean': 1.5765760414172851, 'standard deviation': 3.370816285607049, 'min': 0.0, 'max': 29.0}]]\n",
            "\n",
            "\n",
            "Data in Output3.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "data = pd.read_csv(\"/content/gdrive/MyDrive/Colab_Files/abalonedata.csv\")\n",
        "data.corr().to_csv(\"output4.csv\")\n",
        "print(data.corr())\n",
        "print(\"\\n\\nData in Output4.csv\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJ_dYUcoztwE",
        "outputId": "b83eff60-d586-429e-a017-1724a7d49678"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "           R         L         D         H        WW        SW        VW  \\\n",
            "R   1.000000  0.556720  0.574660  0.557467  0.540390  0.420884  0.503819   \n",
            "L   0.556720  1.000000  0.986812  0.827554  0.925261  0.897914  0.903018   \n",
            "D   0.574660  0.986812  1.000000  0.833684  0.925452  0.893162  0.899724   \n",
            "H   0.557467  0.827554  0.833684  1.000000  0.819221  0.774972  0.798319   \n",
            "WW  0.540390  0.925261  0.925452  0.819221  1.000000  0.969405  0.966375   \n",
            "SW  0.420884  0.897914  0.893162  0.774972  0.969405  1.000000  0.931961   \n",
            "VW  0.503819  0.903018  0.899724  0.798319  0.966375  0.931961  1.000000   \n",
            "LW  0.627574  0.897706  0.905330  0.817338  0.955355  0.882617  0.907656   \n",
            "\n",
            "          LW  \n",
            "R   0.627574  \n",
            "L   0.897706  \n",
            "D   0.905330  \n",
            "H   0.817338  \n",
            "WW  0.955355  \n",
            "SW  0.882617  \n",
            "VW  0.907656  \n",
            "LW  1.000000  \n",
            "\n",
            "\n",
            "Data in Output4.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "data = pd.read_csv(\"/content/gdrive/MyDrive/Colab_Files/abalonedata.csv\")\n",
        "print(data.boxplot(column = [\"L\",\"D\",\"H\",\"WW\",\"SW\",\"VW\",\"LW\"]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "GOHsioFfzxbU",
        "outputId": "8de7bcfe-557b-4332-dcda-f4f988de127f"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AxesSubplot(0.125,0.125;0.775x0.755)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(data.boxplot(column = [\"R\"]))"
      ],
      "metadata": {
        "id": "yD4N-wIVz-09",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "outputId": "0016004b-65ce-4ade-9c74-96cb8b2a2e26"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AxesSubplot(0.125,0.125;0.775x0.755)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "xyx4ZvFrwSlx"
      },
      "execution_count": 6,
      "outputs": []
    }
  ]
}