Copy_of_OPPE1_Practice__MLT.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of OPPE1 Practice_ MLT.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "tBdrLSfaFLd2",
        "3lP6fE39GM3z",
        "Tbil4gOpdvUl",
        "Di1l0Fvzg08l",
        "G3Up34ZTmQ1S",
        "BPzCemcHnNZz",
        "fY-LxXlFpu6t",
        "3e8bnDyZs3AA",
        "nMR7MEKKJBaX",
        "9RJARlH9LYTf",
        "v85rBOSZOs6c",
        "u6IwELHzSLbG",
        "aZ7NoXxOTzw6",
        "Hj8MyD_aZRHJ",
        "713tOyAuZpEY",
        "VdjsNyNXbQZN"
      ],
      "authorship_tag": "ABX9TyPAUzEv0/jkD0m+ofeKF75X",
      "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/samapatil1729/Machine-Learning-techniques/blob/main/Copy_of_OPPE1_Practice__MLT.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd"
      ],
      "metadata": {
        "id": "ZhcESZ_JAoqf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#WEEK_1\n",
        "##PPA1\n",
        "Write a function named vec_addition(u,v) which takes two vectors u and v as input and returns their vector addition.\n",
        " \n",
        "  1. Inputs: u and v are two numerical numpy arrays. \n",
        "  2. Output: a vector representing sum of u and v, if they have consistent shapes, None otherwise."
      ],
      "metadata": {
        "id": "epg6WhiAAZvz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def vec_addition(u,v):\n",
        "  if u.shape==v.shape:\n",
        "    return u+v\n",
        "  else:\n",
        "      return None"
      ],
      "metadata": {
        "id": "kGMuv2TUAiOy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "u=np.array([1,2,3])\n",
        "v=np.array([4,5,6])\n",
        "vec_addition(u,v)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a7VJ3v2MBbCo",
        "outputId": "cfa77b8c-ca9b-4b41-ac96-b53648b0e3da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 7, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x=np.array([1,2,3])\n",
        "y=np.array([5,6])\n",
        "vec_addition(x,y)"
      ],
      "metadata": {
        "id": "8fLzf4Z7Bped"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "YA024XgrCeEE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPA2\n",
        "write a function named scalar_multiply(u,k) which takes a vector u and a scalar k as input and returns k times u as output\n",
        " \n",
        "  1. Inputs: A vector u and a scalar k\n",
        "  2. Output: Returns a vector which is k times u"
      ],
      "metadata": {
        "id": "E_Q9sL8mCzxJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def scalar_multiply(u,k):\n",
        "  return u*k"
      ],
      "metadata": {
        "id": "R6lA5G2jC4T6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x=np.array([1,2,3])\n",
        "scalar_multiply(u,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5c2aEA5iDK2j",
        "outputId": "4b2a1cb0-e112-4b79-99d4-d779da36578f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 6, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPA3\n",
        "Write a function hadamard(u,v) which takes two vectors u and v as input and returns hadamard product of u and v.\n",
        "Hdamard product is obtained via multiplying two matrices/vectors elementwise.\n",
        " \n",
        "  1. Inputs: Two vectors u and v\n",
        "  2. Output: Hadamard product of u and v if the dimensions of u and v are consistent, otherwise None"
      ],
      "metadata": {
        "id": "ELpaTIcfDbHn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def hadmard(u,v):\n",
        "  if u.shape==v.shape:\n",
        "    return u*v\n",
        "  else:\n",
        "    return None"
      ],
      "metadata": {
        "id": "fgFrNwvKDSUx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "u=np.array([1,2,3])\n",
        "v=np.array([4,5,6])\n",
        "hadmard(u,v)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wL339zTzD5HI",
        "outputId": "5e8a3ba5-9f2a-43a7-cf52-3f7cb725d450"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 4, 10, 18])"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "8TqXGm0UEO5L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 1\n",
        "Write a function dot_product(u,v) which take two vectors u and v as input and returns inner product of u and v as output\n",
        " \n",
        "  1. Inputs: vectors u and v \n",
        "  2. Output: dot product of u and v if u and v have consistent dimension otherwise None"
      ],
      "metadata": {
        "id": "DXqaWtClEZDK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def dot_product(u,v):\n",
        "  if u.shape==v.shape:\n",
        "    return np.dot(u,v)\n",
        "  else:\n",
        "    return None"
      ],
      "metadata": {
        "id": "xjyqtnCzEeYy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "u=np.array([1,2,3])\n",
        "v=np.array([4,5,6])\n",
        "dot_product(u,v)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k78GrDHzEw-q",
        "outputId": "ffd9091f-1a06-4236-bf60-420bdcab79f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 2\n",
        "Write a function add_constant(u,k) which adds a constant k to each element of u\n",
        " \n",
        "  1. Inputs: u is a vector,k is a scalar \n",
        "  2. Output: C is a vector"
      ],
      "metadata": {
        "id": "tBdrLSfaFLd2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_constant(u,k):\n",
        "  return k+u"
      ],
      "metadata": {
        "id": "VzjNJKMnHIuP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "u=np.array([1,2,3])\n",
        "add_constant(u,7)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DvhJnUocFm71",
        "outputId": "3ba3a88e-7622-4a10-91b6-5c6d50198b11"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 8,  9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 3\n",
        "Write a function add_matrix(X,Y) to add two matrices X and Y.\n",
        " \n",
        "  1. Inputs: X is a matrix, Y is a matrix \n",
        "  2. Output: Z is a matrix representing (X+Y) if X and Y have consistent dimension otherwise None"
      ],
      "metadata": {
        "id": "3lP6fE39GM3z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_matrix(X,Y):\n",
        "  if X.shape==Y.shape:\n",
        "    return X+Y\n",
        "  else:\n",
        "    return None"
      ],
      "metadata": {
        "id": "w1m5P0X3GWpI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "B=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "add_matrix(A,B)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lzyHqVeBGtqE",
        "outputId": "12af6538-3d74-49a1-dc1d-ce929ba7a456"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2,  4,  6],\n",
              "       [ 8, 10, 12],\n",
              "       [14, 16, 18]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#**WEEK_2**\n",
        "##PPA 1\n",
        "Write a function add_one(X) to include first column with all elements 1 in X.\n",
        " \n",
        "  1. Inputs: A matrix X\n",
        "  2. Output: updated matrix with a column having elements 1 added as first column to X."
      ],
      "metadata": {
        "id": "iXcB4egabAK5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_one(X):\n",
        "  n = len(X)\n",
        "  return np.c_[np.ones(n), X]\n",
        "\n",
        "def add_zeros(X):\n",
        "  n = len(X)\n",
        "  return np.c_[np.zeros(n), X]\n"
      ],
      "metadata": {
        "id": "O69xGfSbHwuc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A=[[1,2,3],[4,5,6],[7,8,9]]\n",
        "add_one(A)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g8JZ8IMZb7OL",
        "outputId": "354ca7c7-ca19-4a7b-d01c-e0462f9c257a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 2., 3.],\n",
              "       [1., 4., 5., 6.],\n",
              "       [1., 7., 8., 9.]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "add_zeros(A)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gOFyvyqKcIwo",
        "outputId": "fa78008b-ed5b-41ea-fdb4-b6c737111d45"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 1., 2., 3.],\n",
              "       [0., 4., 5., 6.],\n",
              "       [0., 7., 8., 9.]])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##To include first column with all elements 'a' in X."
      ],
      "metadata": {
        "id": "Tbil4gOpdvUl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_number(X,a):\n",
        "  n = len(X)\n",
        "  return np.c_[a+np.zeros(n), X]"
      ],
      "metadata": {
        "id": "J3qRz4cgcykx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A=[[1,2,3],[4,5,6],[7,8,9]]\n",
        "add_number(A,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f3LfGF3xdR5W",
        "outputId": "84f8b180-5cae-457d-8039-427900e20770"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3., 1., 2., 3.],\n",
              "       [3., 4., 5., 6.],\n",
              "       [3., 7., 8., 9.]])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#PPA 2\n",
        "Write a function multiply(X,w) to Multiply feature matrix(X) and weight vector(w) after addition of dummy feature to feature matrix.\n",
        "\n",
        "Inputs: Feature matrix X and weight vector w\n",
        "Output: Product of X and w after adding dummy feature to feature matrix X. If the dimensions are not consistent return None."
      ],
      "metadata": {
        "id": "sKs-ASFEeWJb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def multiply(X,w):  \n",
        "  A = np.c_[np.ones(len(X)),X]\n",
        "  if (A.shape[-1])==w.shape[0]:\n",
        "    return (A)@w\n",
        "  else:\n",
        "    return None"
      ],
      "metadata": {
        "id": "kJgF6XoHdX_l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A=[[1,2,3],[4,5,6],[7,8,9]]\n",
        "w = np.array([1,2,3,4])\n",
        "multiply(A,w)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WU_0YVAPe3pa",
        "outputId": "67456f16-5e24-4137-8304-11a19ce307f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([21., 48., 75.])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPA 3\n",
        "Write a function loss(X,w,y) which takes feature matrix(X), weight vector(w) and output label vector(y) and returns sum squared loss while implementing regression model.(Note: Do necessary preprocessing of X)\n",
        " \n",
        "  1. Inputs: Feature matrix X and weight vector w and output label vector y\n",
        "  2. Output: sum squared loss if dimensions of inputs are consistent, otherwise None"
      ],
      "metadata": {
        "id": "Di1l0Fvzg08l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loss(X,w,y):\n",
        "  A = np.c_[np.ones(len(X)),X]\n",
        "  if A.shape[-1]==w.shape[0]:\n",
        "    y_pred = A@w\n",
        "    return np.sum((y_pred-y)**2)*0.5\n",
        "  else:\n",
        "    return None"
      ],
      "metadata": {
        "id": "DoBtBv5egk9v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#OR"
      ],
      "metadata": {
        "id": "27XCCERwmHgG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loss(X,w,y):\n",
        "  N = len(X)\n",
        "  A=np.c_[ np.ones(N), X]\n",
        "  if A.shape[-1]!=w.shape[0]:\n",
        "    return None\n",
        "  e = (A @ w)-y\n",
        "  return  (1/2) * (np.transpose(e) @ e)"
      ],
      "metadata": {
        "id": "jl-Bzkixis2W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 1\n",
        "Write a function compatibility(X,w) to find whether X and w can be multiplied or not.\n",
        " \n",
        "  1. Inputs: Feature matrix X and weight vector w,\n",
        "  2. Output: return \"C\" if X and w can be multiplied otherwise None."
      ],
      "metadata": {
        "id": "G3Up34ZTmQ1S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def compatibility(X,w):\n",
        "  A = np.c_[np.ones(len(X)),X]\n",
        "  if A.shape[-1]==w.shape[0]:\n",
        "    return \"C\"\n",
        "  return None"
      ],
      "metadata": {
        "id": "tmsohBpSmZZ1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X.shape, y.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EDVkv_ensMum",
        "outputId": "2659f308-64d0-4212-c18f-b0590ab54fa7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((500,), (500,))"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 2\n",
        "Write a function gradient(X,w,y) to calculate gradient of loss function w.r.t weight vector given that X is the feature matrix, w is the weight vector and y is the output vector.\n",
        "(Note: do necessary preprocessing of X)\n",
        " \n",
        "  1. Inputs: Feature matrix X, weight vector w, and output label vector y.\n",
        "  2. Output: gradient if dimesnsions of inputs are consistent, otherwise None\n",
        "\n",
        "Note: Preprocess X, if necessary."
      ],
      "metadata": {
        "id": "BPzCemcHnNZz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gradient(X,w,y):\n",
        "  A = np.c_(np.zeros(len(X)),X)\n",
        "  if A.shape[-1]!=w.shape[0]:\n",
        "    return None\n",
        "  y_pred = A@w-y\n",
        "  return np.transpose(A)@ y_pred\n"
      ],
      "metadata": {
        "id": "wcLZahgNnUJL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 3\n",
        "Write a function weight_update(X,w,y,lr) to get updated weight after one iteration of gradient descent given that X is the feature matrix, w is the weight vector and y is the output label vector.\n",
        "(Note: Do necessary preprocessing of X)\n",
        " \n",
        "  1. Inputs: Feature matrix X, weight vector w, output label vector y and learning rate lr\n",
        "  2. Output: weight updates after gradient calculation if dimensions of inputs are consistent, otherwise None"
      ],
      "metadata": {
        "id": "fY-LxXlFpu6t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def weight_update(X,w,y,lr):\n",
        "  A = np.c_[np.zeors(len(x)),X]\n",
        "  if A.shape[-1]!=w.shape[0]:\n",
        "    return None\n",
        "  y_pred = (A@w)-y\n",
        "  Grd = np.transpose(A) @ y_pred\n",
        "  return w - lr*Grd"
      ],
      "metadata": {
        "id": "ShUSFHW4oVay"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Practice Assignment"
      ],
      "metadata": {
        "id": "3e8bnDyZs3AA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gen_data(n):\n",
        "    #obtain y=6+5x+noise\n",
        "    w0=6\n",
        "    w1=5\n",
        "    X=10*np.random.rand(2*n,)\n",
        "    y=w0+w1*X+np.random.randn(2*n,)\n",
        "    return X,y\n",
        "\n",
        "X,y=gen_data(250)"
      ],
      "metadata": {
        "id": "KHIBmYQ4r1OL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#**WEEK_3**\n",
        "##PPA 1\n",
        "\n",
        "Consider input feature vector X. The shape of X is fixed (1 x 3) and the degree of the polynomial is a random number (between 2 to 10).\n",
        "\n",
        "Write a function named 'polynomial_transform' which takes the feature vector and degree of the polynomial as inputs and returns the transformed polynomial feature as output as a numpy array."
      ],
      "metadata": {
        "id": "WwOKbms4riYJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import itertools\n",
        "import functools\n",
        "\n",
        "def polynomial_transform(X, degree):\n",
        "  if X.ndim==1:\n",
        "    X = X[:,None]\n",
        "  X_t = X.transpose()\n",
        "  features = [np.ones(len(X))]\n",
        "  for degree in range(1, degree+1):\n",
        "    for items in itertools.combination_with_replacement(X_t, degree):\n",
        "      features.append(functools.reduce(lambda x, y: x * y, items))\n",
        "  return np.asarray(features).transpose()"
      ],
      "metadata": {
        "id": "TMiN1CGFrQSm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPA 2\n",
        "Consider input feature matrix X, label y and weight w. The size of X, y and w are fixed to (10 x 3), (10 x 1) and (4 x 1).\n",
        "\n",
        "Write a loss function named 'ridge_loss' to compute ridge regression loss. This function should take the feature matrix (X), label vector (y), weight vector(w) and regularization rate (l) as inputs and return the loss value as output. Note: Add a dummy feature to X."
      ],
      "metadata": {
        "id": "nMR7MEKKJBaX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "def ridge_loss(X, y, w,l):\n",
        "  A = np.c_[np.ones(len(X)),X]  # A= np.column_stack((np.ones(X.shape[0]), X))\n",
        "  e = A@w-y\n",
        "  return (0.5*(e.T@e)+1/2*(w.T@w))\n"
      ],
      "metadata": {
        "id": "69mYplAszNRN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 1\n",
        "Government of India is taking several steps to ensure that we are well prepared to face the challenges and threats posed by COVID-19. With active support of citizens of India, Goverment have been able to mitigate the spread of the virus so far.\n",
        "\n",
        "One of the most important factors in the fight with the virus is to vaccinate maximum people and enable them to take precautions as per the advisories being issued by different Ministries.\n",
        "\n",
        "Total 50 month's data and total vaccination in each month is given.\n",
        "\n",
        "After initial data exploration you got to know that the given data don't follow linear model.\n",
        "\n",
        "Now You have to define function \"model_error\" which will fit the given data on linear regression model with appropriate degree and return RMSE error."
      ],
      "metadata": {
        "id": "9RJARlH9LYTf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "import itertools\n",
        "import functools\n",
        "\n",
        "def polynomial_transformation(X,degree):\n",
        "  if X.ndim==1:\n",
        "    X=X[:,None]\n",
        "  X_t = X.transpose()\n",
        "  feature = np.c_[np.ones(len(X))]\n",
        "  for degrees in range(1,degree+1):\n",
        "    for items in itertools.combination_with_replacement(X_t,degree):\n",
        "      feature.append(functools.reduce(lambda x,y: x*y, items))\n",
        "  return np.asarray(feature).transpose()\n",
        "  \n",
        "def model_error(X, y,degree):\n",
        "    X = polynomial_transform(X, degree)\n",
        "    w = np.linalg.pinv(X) @ y\n",
        "    y_pred = X @ w\n",
        "    e = y - y_pred\n",
        "    return np.sqrt(2/X.shape[0] * 0.5 *(e.T @ e))"
      ],
      "metadata": {
        "id": "989wO2KdKd4U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#OR"
      ],
      "metadata": {
        "id": "HbMZHBeFOlp6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "def model_error(X, y,degree):\n",
        " \n",
        "  from sklearn.linear_model import LinearRegression\n",
        "  transformed_features = polynomial_transform(X, degree)\n",
        "  polyreg = LinearRegression()\n",
        "  w_nonlin = polyreg.fit(transformed_features, y)\n",
        "  y_pred=w_nonlin.predict(polynomial_transform(X,degree))\n",
        "  training_error=y_pred-y\n",
        "  train_loss = (1/2) * (np.transpose(training_error) @ training_error) \n",
        "  rmse = np.sqrt((2/X.shape[0])*train_loss)\n",
        "  return rmse"
      ],
      "metadata": {
        "id": "iafEpDH_Ok9E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 2\n",
        "Consider input feature matrix X having size of (20 x 3).\n",
        "\n",
        "You do not have to generate these values.\n",
        "\n",
        "Write a function named additional_vector which will creates a list of size 20 having 1 at even place and zero at odd place.(e.g-[0,1,0,1]) Then later it returns new updated matrix by stacking X and new vector columnwise."
      ],
      "metadata": {
        "id": "v85rBOSZOs6c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "def additional_vector(X):\n",
        "  a = [0,1]*10\n",
        "  return np.c_[X,a]"
      ],
      "metadata": {
        "id": "wKdswi-nO0Du"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X = np.random.randn(60).reshape(20,3)"
      ],
      "metadata": {
        "id": "90Z2Umm8PPSh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X\n",
        "additional_vector(X)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x_E9UfixQh4N",
        "outputId": "2f0e3767-3164-4155-a9c2-f7ae45650454"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-1.12212861, -0.63641018,  1.20616768,  0.        ],\n",
              "       [-0.1770258 ,  0.26445015, -0.71097816,  1.        ],\n",
              "       [ 2.09355572, -1.47539808, -1.29224608,  0.        ],\n",
              "       [ 1.08773104,  1.3761815 , -0.87431539,  1.        ],\n",
              "       [ 0.51490593, -0.41369065, -2.07694976,  0.        ],\n",
              "       [ 0.14054936,  0.5331968 , -0.14404453,  1.        ],\n",
              "       [ 0.10571367, -0.70076279, -0.66831391,  0.        ],\n",
              "       [-0.24428736,  0.75911327,  0.60715278,  1.        ],\n",
              "       [-0.12566327, -1.08349975,  0.81340167,  0.        ],\n",
              "       [ 1.07083354, -0.2401016 , -0.19769106,  1.        ],\n",
              "       [-0.04752153, -1.62286183, -0.48656501,  0.        ],\n",
              "       [-0.24247971,  1.40551753, -0.69367678,  1.        ],\n",
              "       [-0.32274941, -0.53445035,  0.4555553 ,  0.        ],\n",
              "       [-0.92956533, -0.41447247,  0.74725911,  1.        ],\n",
              "       [-0.85831918, -0.73690225,  0.04832185,  0.        ],\n",
              "       [-1.14282935, -1.06944727, -1.39772761,  1.        ],\n",
              "       [ 0.39974982, -0.72021775,  0.58833289,  0.        ],\n",
              "       [ 0.43296581,  0.6601847 , -0.6654739 ,  1.        ],\n",
              "       [-1.23467686,  0.90548375,  0.02010728,  0.        ],\n",
              "       [-0.34661337, -0.04157987, -0.13335181,  1.        ]])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 3\n",
        "Consider input feature matrix X, label y and weight w. The size of X, y and w are fixed to (20 x 3), (20 x 1) and (3 x 1) respectively and these will have random values.\n",
        "\n",
        "You do not have to generate these values.\n",
        "\n",
        "Write a function named mean_abs to compute mean absolute error. This function should take the feature matrix, label vector, weight vector as inputs and return the mean absolute value as output."
      ],
      "metadata": {
        "id": "u6IwELHzSLbG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "def mean_abs(X,y,w):\n",
        "  y_pred = X @ w\n",
        "  return 0.5*np.sum((y_pred-y)**2)"
      ],
      "metadata": {
        "id": "0FB9lsogREMy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##OR"
      ],
      "metadata": {
        "id": "aZ7NoXxOTzw6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "def mean_abs(X,y,w):\n",
        "  predicted_y= X@w\n",
        "  error= y-predicted_y\n",
        "  abs_error=abs(error)\n",
        "  mean_matrix=(1/len(X))* (abs_error)\n",
        "  mean_sum=np.sum(np.sum(mean_matrix, axis=1))\n",
        "  return mean_sum"
      ],
      "metadata": {
        "id": "0zC3nK7DTygQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#WEEK_4\n",
        "##PPA 1\n",
        "Define a function `ConfusionMatrix(y,y_hat)` for binary classification and return a matrix in the following format: `[[TN,FP],[FN,TP]]`\n",
        " \n",
        "  1. Inputs:  y: 1 x n, y_hat: 1 x n \n",
        "  2. Output: 2D numpy array. <br>"
      ],
      "metadata": {
        "id": "q5ucmcETVRr9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "def ConfusionMatrix(y,y_hat):\n",
        "  TN = np.where((y==0) & (y_hat==0),1,0).sum()\n",
        "  FP = np.where((y==0) & (y_hat==1),1,0).sum()\n",
        "  FN = np.where((y==1) & (y_hat==0),1,0).sum()\n",
        "  TP = np.where((y==1) & (y_hat==1),1,0).sum()\n",
        "  return np.array([[TN,FP],[FN,TP]])"
      ],
      "metadata": {
        "id": "KGk1Q85jT2R7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPA 2\n",
        "Define a function `is_binary(y)` to check whether the label vector y belongs to binary classification or not. If the labels are binary then return True (i.e., state=True (Boolean))  else return False (i.e., state = False).\n",
        "\n",
        "All elements in y are integer numbers (not the datatype). "
      ],
      "metadata": {
        "id": "Hj8MyD_aZRHJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "def is_binary(y):\n",
        "    if len(np.unique(y)) == 2:\n",
        "        return True\n",
        "    return False"
      ],
      "metadata": {
        "id": "TN2rr0O1XOMH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##PPA 3\n",
        "Write a function `percep_loss(X,w,y,i)` to compute the perceptron loss for all \n",
        "the sample in $X$ and return the loss for individual samples in a vector."
      ],
      "metadata": {
        "id": "713tOyAuZpEY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "def percep_loss(x,w,y):\n",
        "  samplewise_loss = None\n",
        "  z = x @ w\n",
        "  y_predict = np.where (z >= 0, 1, -1)\n",
        "  samplewise_loss = np.maximum(-1 * y_predict * y, np.zeros(y.shape[0]))\n",
        "  return samplewise_loss"
      ],
      "metadata": {
        "id": "y2GaA44uZs4c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##GrPA 1\n",
        "Write a function OneHotEncode(y) to convert integer labels to one hot-encoded labels."
      ],
      "metadata": {
        "id": "VdjsNyNXbQZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "b = np.array([1,2,-3])\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VpUsSBIpbTjl",
        "outputId": "d4f2b8f3-00a7-4c1a-d520-4a7d2c952a6b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  2, -3])"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sum(np.abs(b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "spN1FM3RhOhW",
        "outputId": "3d068638-a1b7-4e4e-bc97-22fec95bd75a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "kvaGodQ-hXmg"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}