01_linear_modelling.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating sample data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import datasets as d\n",
    "import numpy as np \n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 100)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#regression dataset\n",
    "reg_data = d.make_regression()\n",
    "reg_data[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 10)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#to generate complex dataset 1000 x 10 matrix with 5 features responsible for target creation, \n",
    "#underlying bias factor of 1.0 and 2 targets \n",
    "\n",
    "complex_reg_data = d.make_regression(1000,10,n_informative=5, bias=1.0, n_targets=2)\n",
    "complex_reg_data[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 89], dtype=int64)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creating an unbalanced classification dataset \n",
    "\n",
    "classification_set = d.make_classification(weights=[0.1])\n",
    "np.bincount(classification_set[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating a dataset for clustering \n",
    "\n",
    "blobs_data, blobs_target = d.make_blobs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x1f62e78d3a0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "%matplotlib inline \n",
    "plt.scatter(blobs_data[:,0],blobs_data[:,1],c=blobs_target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scaling dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import preprocessing \n",
    "from sklearn.datasets import load_boston \n",
    "boston = load_boston()\n",
    "X,y = boston.data, boston.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506, 13)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_california_housing\n",
    "housing = fetch_california_housing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X1,y1 = housing.data,housing.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20640, 8)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20640,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.61352356, 11.36363636, 11.13677866])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,:3].mean(axis=0) #mean of the first 3 features "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8.59304135, 23.29939569,  6.85357058])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,:3].std(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-8.78743718e-17, -6.34319123e-16, -2.68291099e-15])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Now scaling \n",
    "\n",
    "X_2 = preprocessing.scale(X[:,:3])\n",
    "X_2.mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_2.std(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQoUlEQVR4nO3dbYylZX3H8e+vrPjAWBbETMgu7dJKbCjbWplQG4yZlT6gGKGJIRBidy3NtglaWmnKal/gG1Jsq5YmrclWjGtCGSliIVJbCWVKfQHtriUuDyobXJQNsjU86KipXf33xdxbp8vMzsy55+zZc/H9JOSc+7qfrj/37G+vuc597k1VIUlqy0+MugOSpLVnuEtSgwx3SWqQ4S5JDTLcJalB60bdAYDTTjutNm3atOx23/3udznppJOG36ERsb7x1nJ9LdcG41vfnj17vlVVr15s3XER7ps2bWL37t3Lbjc7O8v09PTwOzQi1jfeWq6v5dpgfOtL8sRS65yWkaQGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBh0X31CV1N+mHXct2r7/houOcU90PHDkLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIatGy4J/l4koNJHlrQ9udJvpzkS0k+k2T9gnXvS7IvyVeS/MaQ+i1JOoqVjNw/AVx4RNvdwDlV9QvAV4H3ASQ5G7gM+Plun79JcsKa9VaStCLLhntV3Qc8c0Tb56vqULd4P7Cxe38xMFNV/11VXwP2AeetYX8lSSuwFnPuvw18rnu/AfjGgnVPdm2SpGOo1z+zl+RPgEPAzQPsux3YDjA5Ocns7Oyy+8zNza1ou3FlfeNt1PVds/nQou1r0adR1zZsLdY3cLgn2Qa8DbigqqprPgCcsWCzjV3bC1TVTmAnwNTUVE1PTy97ztnZWVay3biyvvE26vq2LfVvqF4x3fvYo65t2Fqsb6BpmSQXAn8MvL2qvrdg1Z3AZUlemuRM4Czg3/t3U5K0GsuO3JPcAkwDpyV5EriO+btjXgrcnQTg/qr6vap6OMmtwCPMT9dcVVU/HFbnJUmLWzbcq+ryRZpvOsr21wPX9+mUJKkfv6EqSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoOWDfckH09yMMlDC9pOTXJ3kse611O69iT5qyT7knwpyeuH2XlJ0uJWMnL/BHDhEW07gHuq6izgnm4Z4C3AWd1/24GPrk03JUmrsWy4V9V9wDNHNF8M7Ore7wIuWdD+yZp3P7A+yelr1FdJ0gqlqpbfKNkEfLaqzumWn6uq9d37AM9W1foknwVuqKovdOvuAa6tqt2LHHM786N7Jicnz52ZmVm2H3Nzc0xMTKywtPFjfeNt1PXtPfD8ou2bN5zc+9ijrm3YxrW+LVu27KmqqcXWret78KqqJMv/DfHC/XYCOwGmpqZqenp62X1mZ2dZyXbjyvrG26jr27bjrkXb918x3fvYo65t2Fqsb9C7ZZ4+PN3SvR7s2g8AZyzYbmPXJkk6hgYN9zuBrd37rcAdC9p/q7tr5g3A81X1VM8+SpJWadlpmSS3ANPAaUmeBK4DbgBuTXIl8ARwabf5PwJvBfYB3wPeNYQ+S5KWsWy4V9XlS6y6YJFtC7iqb6ckSf34DVVJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktSgXuGe5A+TPJzkoSS3JHlZkjOTPJBkX5JPJTlxrTorSVqZgcM9yQbg94GpqjoHOAG4DPgg8JGqeg3wLHDlWnRUkrRyfadl1gEvT7IOeAXwFPBm4LZu/S7gkp7nkCStUqpq8J2Tq4Hrge8DnweuBu7vRu0kOQP4XDeyP3Lf7cB2gMnJyXNnZmaWPd/c3BwTExMD9/d4Z33jbdT17T3w/KLtmzec3PvYo65t2Ma1vi1btuypqqnF1q0b9KBJTgEuBs4EngP+HrhwpftX1U5gJ8DU1FRNT08vu8/s7Cwr2W5cWd94G3V923bctWj7/iumex971LUNW4v19ZmW+VXga1X1X1X1P8DtwPnA+m6aBmAjcKBnHyVJq9Qn3L8OvCHJK5IEuAB4BLgXeEe3zVbgjn5dlCSt1sDhXlUPMP/B6ReBvd2xdgLXAu9Nsg94FXDTGvRTkrQKA8+5A1TVdcB1RzQ/DpzX57iSpH78hqokNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDeoV7knWJ7ktyZeTPJrkV5KcmuTuJI91r6esVWclSSvTd+R+I/BPVfVzwC8CjwI7gHuq6izgnm5ZknQMDRzuSU4G3gTcBFBVP6iq54CLgV3dZruAS/p1UZK0WqmqwXZMXgfsBB5hftS+B7gaOFBV67ttAjx7ePmI/bcD2wEmJyfPnZmZWfacc3NzTExMDNTfcWB9423U9e098Pyi7Zs3nNz72KOubdjGtb4tW7bsqaqpxdb1Cfcp4H7g/Kp6IMmNwLeB9ywM8yTPVtVR592npqZq9+7dy55zdnaW6enpgfo7DqxvvI26vk077lq0ff8NF/U+9qhrG7ZxrS/JkuHeZ879SeDJqnqgW74NeD3wdJLTuxOfDhzscQ5J0gAGDveq+ibwjSSv7ZouYH6K5k5ga9e2FbijVw8lSau2ruf+7wFuTnIi8DjwLub/wrg1yZXAE8ClPc8hSVqlXuFeVQ8Ci833XNDnuJKkfvyGqiQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJalDvcE9yQpL/TPLZbvnMJA8k2ZfkU0lO7N9NSdJqrMXI/Wrg0QXLHwQ+UlWvAZ4FrlyDc0iSVqFXuCfZCFwEfKxbDvBm4LZuk13AJX3OIUlavVTV4DsntwF/CrwS+CNgG3B/N2onyRnA56rqnEX23Q5sB5icnDx3ZmZm2fPNzc0xMTExcH+Pd9Y33kZd394Dzy/avnnDyb2PPerahm1c69uyZcueqppabN26QQ+a5G3Awarak2R6tftX1U5gJ8DU1FRNTy9/iNnZWVay3biyvvE26vq27bhr0fb9V0z3Pvaoaxu2FusbONyB84G3J3kr8DLgJ4EbgfVJ1lXVIWAjcKB/NyVJqzHwnHtVva+qNlbVJuAy4F+q6grgXuAd3WZbgTt691KStCrDuM/9WuC9SfYBrwJuGsI5JElH0Wda5v9U1Sww271/HDhvLY4rSRqM31CVpAYZ7pLUoDWZltGxtWmpW95uuOgY90TS8cqRuyQ1yHCXpAY5LaNFOfUjjTdH7pLUIMNdkhpkuEtSgwx3SWqQH6geBw5/eHnN5kP/77GtfnipUVjsw/TDP5v+TI4PR+6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBvklpiHwiYqSRs2RuyQ1yHCXpAYNHO5Jzkhyb5JHkjyc5Oqu/dQkdyd5rHs9Ze26K0laiT4j90PANVV1NvAG4KokZwM7gHuq6izgnm5ZknQMDfyBalU9BTzVvf9OkkeBDcDFwHS32S5gFri2Vy+PU0t9cKofW/j/aOFTL/1wWRquVFX/gySbgPuAc4CvV9X6rj3As4eXj9hnO7AdYHJy8tyZmZllzzM3N8fExETv/i5l74HnF23fvOHkVW2/lOWOM/lyePr7g593qe0HsVbnWHichfWtZV+PF8P++VzOMK7ZYYevXYvXDUZ/7Qa1ZcuWPVU1tdi63uGeZAL4V+D6qro9yXMLwzzJs1V11Hn3qamp2r1797Lnmp2dZXp6uld/j2a1tzCuduS+3HGu2XyID+1dt+LtV3r8QazVOY4cuR+ur8WR+7B/PpczjGt22OFr1+J1g9Ffu0ElWTLce90tk+QlwKeBm6vq9q756SSnd+tPBw72OYckafX63C0T4Cbg0ar68IJVdwJbu/dbgTsG754kaRB9vqF6PvBOYG+SB7u29wM3ALcmuRJ4Ari0Vw8lSavW526ZLwBZYvUFgx5XktSf31CVpAYZ7pLUIJ8KqZHwyZkvbl7/4XPkLkkNcuR+HFvtl6QcDUk6zJG7JDXIcJekBjU9LTPMZ21I0vHMkbskNchwl6QGNT0ts5QX2zTL0er1ThqpTY7cJalBL8qRu7QYvyeglhjuWhMvtqku6XjntIwkNciR+4ucI25paeN8M4LhfgwZpMeO8+d6sXNaRpIa5MhdY83fhjQujvVvk47cJalBhrskNchpGWlAR/6afc3mQ2zbcZcf2uq44Mhdkho0tJF7kguBG4ETgI9V1Q3DOI8fqEnSCw1l5J7kBOCvgbcAZwOXJzl7GOeSJL3QsKZlzgP2VdXjVfUDYAa4eEjnkiQdIVW19gdN3gFcWFW/0y2/E/jlqnr3gm22A9u7xdcCX1nBoU8DvrXG3T2eWN94a7m+lmuD8a3vp6vq1YutGNndMlW1E9i5mn2S7K6qqSF1aeSsb7y1XF/LtUGb9Q1rWuYAcMaC5Y1dmyTpGBhWuP8HcFaSM5OcCFwG3Dmkc0mSjjCUaZmqOpTk3cA/M38r5Mer6uE1OPSqpnHGkPWNt5bra7k2aLC+oXygKkkaLb+hKkkNMtwlqUFjE+5JLkzylST7kuwYdX/WWpL9SfYmeTDJ7lH3p68kH09yMMlDC9pOTXJ3kse611NG2cdBLVHbB5Ic6K7fg0neOso+9pHkjCT3JnkkycNJru7aW7l+S9XXzDWEMZlz7x5n8FXg14Anmb8b5/KqemSkHVtDSfYDU1U1jl+keIEkbwLmgE9W1Tld258Bz1TVDd1f0KdU1bWj7OcglqjtA8BcVf3FKPu2FpKcDpxeVV9M8kpgD3AJsI02rt9S9V1KI9cQxmfk7uMMxkxV3Qc8c0TzxcCu7v0u5v9AjZ0lamtGVT1VVV/s3n8HeBTYQDvXb6n6mjIu4b4B+MaC5Sdp72IU8Pkke7pHM7Rosqqe6t5/E5gcZWeG4N1JvtRN24zllMWRkmwCfgl4gAav3xH1QUPXcFzC/cXgjVX1euafpHlV96t/s2p+PvD4nxNcuY8CPwu8DngK+NBIe7MGkkwAnwb+oKq+vXBdC9dvkfqauobjEu7NP86gqg50rweBzzA/FdWap7v5zsPzngdH3J81U1VPV9UPq+pHwN8y5tcvyUuYD76bq+r2rrmZ67dYfa1dw3EJ96YfZ5DkpO6DHZKcBPw68NDR9xpLdwJbu/dbgTtG2Jc1dTj0Or/JGF+/JAFuAh6tqg8vWNXE9VuqvpauIYzJ3TIA3W1Jf8mPH2dw/Wh7tHaS/Azzo3WYfyTE3417fUluAaaZf5Tq08B1wD8AtwI/BTwBXFpVY/fB5BK1TTP/63wB+4HfXTA/PVaSvBH4N2Av8KOu+f3Mz0u3cP2Wqu9yGrmGMEbhLklauXGZlpEkrYLhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhr0v0hXa7Rzclz0AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd \n",
    "\n",
    "pd.Series(X[:,2]).hist(bins=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAATCElEQVR4nO3df6xfdX3H8ed7VH7IdS1Qd+3axkIkOqT7QW8YijH3itkqGMo2ZjBEW4fpzNSxyTLqTEayhIhb0GCcWxoh1MxwwYqDUZli7R3xj9a1DrhAVSpWpamtTqheJWrde3/cU/z29nt7vz/v9/TT5yNp7vmec77nvO659776uZ/vjxuZiSSpLL826ACSpN6z3CWpQJa7JBXIcpekAlnuklSgBYMOALB48eJcsWJFz473k5/8hDPPPLNnx+sVc7WvrtnM1R5zta+VbLt27fpBZr606cbMHPi/VatWZS9t27atp8frFXO1r67ZzNUec7WvlWzAzpylV52WkaQCWe6SVCDLXZIKZLlLUoEsd0kqkOUuSQWy3CWpQJa7JBXIcpekAtXi7QckdW/Fhi3csPIw6zZsOWr93luuGFAiDZIjd0kqkOUuSQWy3CWpQJa7JBXIcpekAlnuklQgy12SCmS5S1KBLHdJKpDlLkkFstwlqUCWuyQVyHKXpAJZ7pJUoDnLPSLuiIiDEfF4w7p/ioivRcRjEfHZiFjUsO39EbEnIr4eEX/Yp9ySpONoZeR+J7B6xrqHgAsz87eBbwDvB4iIC4BrgFdX9/l4RJzSs7SSpJbMWe6Z+TDwwxnrvpCZh6ub24Fl1fIaYDwzf5aZ3wL2ABf3MK8kqQW9mHP/M+DBankp8N2Gbc9U6yRJ8ygyc+6dIlYAD2TmhTPWfwAYAf44MzMiPgZsz8x/q7bfDjyYmZubHHM9sB5geHh41fj4eLefywumpqYYGhrq2fF6xVztq2u2Ouaa3HeI4TPgwPNHr1+5dOFgAjWo4/WC+uaC1rKNjY3tysyRZts6/huqEbEOeDNwWf7qf4h9wPKG3ZZV646RmRuBjQAjIyM5OjraaZRjTExM0Mvj9Yq52lfXbHXMta76G6q3Th79Y7332tHBBGpQx+sF9c0F3WfraFomIlYDfwtcmZk/bdh0P3BNRJwWEecC5wNf6TidJKkjc47cI+IuYBRYHBHPADcx/eyY04CHIgKmp2LelZlPRMQ9wJPAYeDdmfnLfoWXJDU3Z7ln5lubrL79OPvfDNzcTShJUnd8haokFchyl6QCWe6SVCDLXZIKZLlLUoEsd0kqkOUuSQWy3CWpQJa7JBXIcpekAlnuklQgy12SCmS5S1KBLHdJKpDlLkkFstwlqUCWuyQVyHKXpAJZ7pJUIMtdkgpkuUtSgSx3SSqQ5S5JBZqz3CPijog4GBGPN6w7OyIeioinqo9nVesjIj4aEXsi4rGIuKif4SVJzbUycr8TWD1j3QZga2aeD2ytbgO8CTi/+rce+JfexJQktWPOcs/Mh4Efzli9BthULW8CrmpY/8mcth1YFBFLepRVktSiyMy5d4pYATyQmRdWt5/LzEXVcgDPZuaiiHgAuCUzv1xt2wrcmJk7mxxzPdOje4aHh1eNj4/35jMCpqamGBoa6tnxesVc7atrtjrmmtx3iOEz4MDzR69fuXThYAI1qOP1gvrmgtayjY2N7crMkWbbFnQbIDMzIub+H+LY+20ENgKMjIzk6Ohot1FeMDExQS+P1yvmal9ds9Ux17oNW7hh5WFunTz6x3rvtaODCdSgjtcL6psLus/W6bNlDhyZbqk+HqzW7wOWN+y3rFonSZpHnZb7/cDaanktcF/D+rdXz5q5BDiUmfu7zChJatOc0zIRcRcwCiyOiGeAm4BbgHsi4jrg28Bbqt0/B1wO7AF+CryjD5klSXOYs9wz862zbLqsyb4JvLvbUJKk7vgKVUkqkOUuSQWy3CWpQJa7JBXIcpekAlnuklQgy12SCmS5S1KBLHdJKpDlLkkFstwlqUCWuyQVyHKXpAJZ7pJUIMtdkgpkuUtSgSx3SSqQ5S5JBbLcJalAlrskFchyl6QCWe6SVKCuyj0i/joinoiIxyPirog4PSLOjYgdEbEnIu6OiFN7FVaS1JqOyz0ilgJ/CYxk5oXAKcA1wIeAj2TmK4Bnget6EVSS1Lpup2UWAGdExALgxcB+4A3A5mr7JuCqLs8hSWpTZGbnd464HrgZeB74AnA9sL0atRMRy4EHq5H9zPuuB9YDDA8PrxofH+84x0xTU1MMDQ317Hi9Yq721TVbHXNN7jvE8Blw4Pmj169cunAwgRrU8XpBfXNBa9nGxsZ2ZeZIs20LOj1xRJwFrAHOBZ4DPg2sbvX+mbkR2AgwMjKSo6OjnUY5xsTEBL08Xq+Yq311zVbHXOs2bOGGlYe5dfLoH+u9144OJlCDOl4vqG8u6D5bN9MybwS+lZnfz8xfAPcClwKLqmkagGXAvi7OIUnqQDfl/h3gkoh4cUQEcBnwJLANuLraZy1wX3cRJUnt6rjcM3MH0w+cfhWYrI61EbgReF9E7AHOAW7vQU5JUhs6nnMHyMybgJtmrH4auLib40qSuuMrVCWpQJa7JBXIcpekAlnuklQgy12SCmS5S1KBLHdJKpDlLkkFstwlqUCWuyQVyHKXpAJZ7pJUIMtdkgpkuUtSgSx3SSqQ5S5JBbLcJalAlrskFchyl6QCWe6SVCDLXZIKZLlLUoEsd0kqUFflHhGLImJzRHwtInZHxGsi4uyIeCginqo+ntWrsJKk1nQ7cr8N+M/MfBXwO8BuYAOwNTPPB7ZWtyVJ86jjco+IhcDrgdsBMvPnmfkcsAbYVO22Cbiqu4iSpHZFZnZ2x4jfBTYCTzI9at8FXA/sy8xF1T4BPHvk9oz7rwfWAwwPD68aHx/vKEczU1NTDA0N9ex4vWKu9tU1Wx1zTe47xPAZcOD5o9evXLpwMIEa1PF6QX1zQWvZxsbGdmXmSLNt3ZT7CLAduDQzd0TEbcCPgPc2lnlEPJuZx513HxkZyZ07d3aUo5mJiQlGR0d7drxeMVf76pqtjrlWbNjCDSsPc+vkgqPW773ligEl+pU6Xi+oby5oLVtEzFru3cy5PwM8k5k7qtubgYuAAxGxpDrxEuBgF+eQJHWg43LPzO8B342IV1arLmN6iuZ+YG21bi1wX1cJJUltWzD3Lsf1XuBTEXEq8DTwDqb/w7gnIq4Dvg28pctzSJLa1FW5Z+YjQLP5nsu6Oa4kqTu+QlWSCmS5S1KBLHdJKpDlLkkFstwlqUCWuyQVyHKXpAJZ7pJUIMtdkgpkuUtSgSx3SSqQ5S5JBbLcJalAlrskFchyl6QCWe6SVCDLXZIKZLlLUoEsd0kqkOUuSQWy3CWpQJa7JBWo63KPiFMi4n8i4oHq9rkRsSMi9kTE3RFxavcxJUnt6MXI/Xpgd8PtDwEfycxXAM8C1/XgHJKkNnRV7hGxDLgC+ER1O4A3AJurXTYBV3VzDklS+yIzO79zxGbgg8BLgL8B1gHbq1E7EbEceDAzL2xy3/XAeoDh4eFV4+PjHeeYaWpqiqGhoZ4dr1fM1b66Zqtjrsl9hxg+Aw48f/T6lUsXDiZQgzpeL6hvLmgt29jY2K7MHGm2bUGnJ46INwMHM3NXRIy2e//M3AhsBBgZGcnR0bYPMauJiQl6ebxeMVf76pqtjrnWbdjCDSsPc+vk0T/We68dHUygBnW8XlDfXNB9to7LHbgUuDIiLgdOB34duA1YFBELMvMwsAzY18U5JEkd6HjOPTPfn5nLMnMFcA3wpcy8FtgGXF3ttha4r+uUkqS29ON57jcC74uIPcA5wO19OIck6Ti6mZZ5QWZOABPV8tPAxb04riSpM75CVZIKZLlLUoF6Mi2j+bViw5am6/fecsU8J5FUV47cJalAlrskFchpGTXl1I90YnPkLkkFstwlqUCWuyQVyHKXpAL5gGoN+OCl6mS270fwe/JE4shdkgpkuUtSgSx3SSqQ5S5JBbLcJalAlrskFchyl6QCWe6SVCBfxNQHs70I5M7VZ85zEkknK0fuklQgy12SCtRxuUfE8ojYFhFPRsQTEXF9tf7siHgoIp6qPp7Vu7iSpFZ0M3I/DNyQmRcAlwDvjogLgA3A1sw8H9ha3ZYkzaOOH1DNzP3A/mr5xxGxG1gKrAFGq902ARPAjV2lrKnjvXuepvmOl9JgRGZ2f5CIFcDDwIXAdzJzUbU+gGeP3J5xn/XAeoDh4eFV4+PjXec4YmpqiqGhobbvN7nvUNP1K5cubGv/2Zy78JSmuXp13tn2n0uz69Wrc3R7nE6/lv1Wx1yT+w4xfAYceP7o9b36mnVyrCPqeL2gvrmgtWxjY2O7MnOk2bauyz0ihoD/Am7OzHsj4rnGMo+IZzPzuPPuIyMjuXPnzq5yNJqYmGB0dLTt+7U7ymx35H7n6jOb5urVeTsdDTe7Xr06R7fH6fRr2W91zLViwxZuWHmYWyeP/oW8V1+zTo51RB2vF9Q3F7SWLSJmLfeuni0TES8CPgN8KjPvrVYfiIgl1fYlwMFuziFJal83z5YJ4HZgd2Z+uGHT/cDaanktcF/n8SRJnejmFaqXAm8DJiPikWrd3wG3APdExHXAt4G3dJVQktS2bp4t82UgZtl8WafHlSR1z1eoSlKBLHdJKpDvCqmB8MVNJze//v3nyF2SCuTIvcbafZGUoyFJRzhyl6QCWe6SVKCip2X6/f4oklRXjtwlqUCWuyQVqOhpmdmcbNMs/XgLV0n15shdkgp0Uo7cpWZ8nYBKYrmrJ062qS6p7pyWkaQCOXI/yR35u5vrHHlLxziRn4xguc+jyX2HLNF54vy5TnZOy0hSgRy564TmA7k6Ucz3b5OO3CWpQJa7JBXIaRmpQz5oqzpz5C5JBerbyD0iVgO3AacAn8jMW/pxnmajJ5+3Lelk15eRe0ScAvwz8CbgAuCtEXFBP84lSTpWv6ZlLgb2ZObTmflzYBxY06dzSZJmiMzs/UEjrgZWZ+Y7q9tvA34/M9/TsM96YH1185XA13sYYTHwgx4er1fM1b66ZjNXe8zVvlayvTwzX9psw8CeLZOZG4GN/Th2ROzMzJF+HLsb5mpfXbOZqz3mal+32fo1LbMPWN5we1m1TpI0D/pV7v8NnB8R50bEqcA1wP19OpckaYa+TMtk5uGIeA/weaafCnlHZj7Rj3PNoi/TPT1grvbVNZu52mOu9nWVrS8PqEqSBstXqEpSgSx3SSpQEeUeEX8aEU9ExP9FxKxPHYqIvRExGRGPRMTOGuVaHRFfj4g9EbFhHnKdHREPRcRT1cezZtnvl9W1eiQi+vaA+Fyff0ScFhF3V9t3RMSKfmVpM9e6iPh+wzV65zzluiMiDkbE47Nsj4j4aJX7sYi4qCa5RiPiUMP1+vt5yrU8IrZFxJPVz+P1TfaZ92vWYq7Or1lmnvD/gN9i+oVQE8DIcfbbCyyuUy6mH3D+JnAecCrwKHBBn3P9I7ChWt4AfGiW/abm4RrN+fkDfwH8a7V8DXB3TXKtAz42X99PDed9PXAR8Pgs2y8HHgQCuATYUZNco8ADA7heS4CLquWXAN9o8rWc92vWYq6Or1kRI/fM3J2ZvXyFa0+0mGsQb9WwBthULW8Crurz+Y6nlc+/Me9m4LKIiBrkGojMfBj44XF2WQN8MqdtBxZFxJIa5BqIzNyfmV+tln8M7AaWztht3q9Zi7k6VkS5tyGBL0TErurtD+pgKfDdhtvP0MMv8CyGM3N/tfw9YHiW/U6PiJ0RsT0irupTllY+/xf2yczDwCHgnD7laScXwJ9Uv8ZvjojlTbYPwiC+p1r1moh4NCIejIhXz/fJqym93wN2zNg00Gt2nFzQ4TU7Yf5YR0R8EXhZk00fyMz7WjzM6zJzX0T8BvBQRHytGm0MOlfPHS9X443MzIiY7fmwL6+u13nAlyJiMjO/2eusJ7D/AO7KzJ9FxJ8z/dvFGwacqc6+yvT31FREXA78O3D+fJ08IoaAzwB/lZk/mq/zzmWOXB1fsxOm3DPzjT04xr7q48GI+CzTv3p3Ve49yNWXt2o4Xq6IOBARSzJzf/Wr58FZjnHkej0dERNMjyx6Xe6tfP5H9nkmIhYAC4H/7XGOtnNlZmOGTzD9WEYd1PLtPxqLKzM/FxEfj4jFmdn3N+6KiBcxXaCfysx7m+wykGs2V65urtlJMy0TEWdGxEuOLAN/ADR9VH+eDeKtGu4H1lbLa4FjfsOIiLMi4rRqeTFwKfBkH7K08vk35r0a+FJWjzb10Zy5ZszJXsn0nGkd3A+8vXoGyCXAoYZpuIGJiJcdeawkIi5mun/6/Z801TlvB3Zn5odn2W3er1krubq6Zv1+RHg+/gF/xPQc2c+AA8Dnq/W/CXyuWj6P6Wc8PAo8wfS0ycBz5a8eqf8G06Pi+ch1DrAVeAr4InB2tX6E6b+aBfBaYLK6XpPAdX3Mc8znD/wDcGW1fDrwaWAP8BXgvHn6vpor1wer76VHgW3Aq+Yp113AfuAX1ffXdcC7gHdV24PpP5bzzeprN+szyOY513sartd24LXzlOt1TD/e9hjwSPXv8kFfsxZzdXzNfPsBSSrQSTMtI0knE8tdkgpkuUtSgSx3SSqQ5S5JBbLcJalAlrskFej/Aevl0i4q8NiPAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.Series(preprocessing.scale(X[:,2])).hist(bins=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-8.78743718e-17, -6.34319123e-16, -2.68291099e-15])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Another ways of scaling \n",
    "\n",
    "my_scaler = preprocessing.StandardScaler()\n",
    "my_scaler.fit(X[:,:3])\n",
    "my_scaler.transform(X[:,:3]).mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_scaler.transform(X[:,:3]).std(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_minmax_scaler = preprocessing.MinMaxScaler()\n",
    "my_minmax_scaler.fit(X[:,:3])\n",
    "my_minmax_scaler.transform(X[:,:3]).max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_minmax_scaler.transform(X[:,:3]).min(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.14, 3.14, 3.14])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#To change Min and Max of MinMaxSccaler\n",
    "\n",
    "my_odd_scaler = preprocessing.MinMaxScaler(feature_range=(-3.14,3.14)) \n",
    "my_odd_scaler.fit(X[:,:3])\n",
    "my_odd_scaler.transform(X[:,:3]).max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.14, -3.14, -3.14])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_odd_scaler.transform(X[:,:3]).min(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Normalization - It scales each samples to have a length of ONE\n",
    "\n",
    "normalized_X = preprocessing.normalize(X[:,:3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Creating Binary features through THRESHOLDING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#With thresholding, we can turn a regression problem into a classification problem \n",
    "\n",
    "import numpy as np \n",
    "from sklearn.datasets import load_boston \n",
    "\n",
    "boston = load_boston()\n",
    "X, y = boston.data, boston.target.reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506, 13)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.],\n",
       "       [0.],\n",
       "       [1.],\n",
       "       [1.],\n",
       "       [1.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#If we want to create a threshold value of the mean. \n",
    "#If the value is greater than the mean, produce 1; otherwise 0\n",
    "\n",
    "from sklearn import preprocessing \n",
    "new_target = preprocessing.binarize(y,threshold = boston.target.mean())\n",
    "new_target[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [0],\n",
       "       [1],\n",
       "       [1],\n",
       "       [1]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#to check\n",
    "(y[:5] > y.mean()).astype(int)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Another way is `Binarizer`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.],\n",
       "       [0.],\n",
       "       [1.],\n",
       "       [1.],\n",
       "       [1.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binar = preprocessing.Binarizer(threshold=y.mean())\n",
    "new_target = binar.fit_transform(y)\n",
    "new_target[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Cannot binarize a sparse matrix with threshold < 0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\konar\\OneDrive\\Documents\\GitHub\\ml_scikit\\linear_modelling.ipynb Cell 37\u001b[0m in \u001b[0;36m<cell line: 6>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/konar/OneDrive/Documents/GitHub/ml_scikit/linear_modelling.ipynb#X51sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mscipy\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msparse\u001b[39;00m \u001b[39mimport\u001b[39;00m coo \n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/konar/OneDrive/Documents/GitHub/ml_scikit/linear_modelling.ipynb#X51sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m spar \u001b[39m=\u001b[39m coo\u001b[39m.\u001b[39mcoo_matrix(np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mbinomial(\u001b[39m1\u001b[39m,\u001b[39m.25\u001b[39m,\u001b[39m100\u001b[39m))\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/konar/OneDrive/Documents/GitHub/ml_scikit/linear_modelling.ipynb#X51sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m preprocessing\u001b[39m.\u001b[39;49mbinarize(spar, threshold\u001b[39m=\u001b[39;49m\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m)\n",
      "File \u001b[1;32mc:\\Python39\\lib\\site-packages\\sklearn\\preprocessing\\_data.py:1995\u001b[0m, in \u001b[0;36mbinarize\u001b[1;34m(X, threshold, copy)\u001b[0m\n\u001b[0;32m   1993\u001b[0m \u001b[39mif\u001b[39;00m sparse\u001b[39m.\u001b[39missparse(X):\n\u001b[0;32m   1994\u001b[0m     \u001b[39mif\u001b[39;00m threshold \u001b[39m<\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[1;32m-> 1995\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mCannot binarize a sparse matrix with threshold < 0\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m   1996\u001b[0m     cond \u001b[39m=\u001b[39m X\u001b[39m.\u001b[39mdata \u001b[39m>\u001b[39m threshold\n\u001b[0;32m   1997\u001b[0m     not_cond \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mlogical_not(cond)\n",
      "\u001b[1;31mValueError\u001b[0m: Cannot binarize a sparse matrix with threshold < 0"
     ]
    }
   ],
   "source": [
    "#In Sparse Matrices zeros aren't stored, so for the binarizer \n",
    "# a special condition of sparse metrices in that the thrseshold cannot be less than zero. \n",
    "\n",
    "from scipy.sparse import coo \n",
    "spar = coo.coo_matrix(np.random.binomial(1,.25,100))\n",
    "preprocessing.binarize(spar, threshold=-1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Working with categorical variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import datasets \n",
    "import numpy as np \n",
    "iris = datasets.load_iris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = iris.data \n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#creating an encoder\n",
    "from sklearn import preprocessing \n",
    "cat_encoder = preprocessing.OneHotEncoder()\n",
    "cat_encoder.fit_transform(y.reshape(-1,1)).toarray()[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Next we will use multi-output regression and then compare it with multiclass classification \n",
    "\n",
    "from sklearn.linear_model import Ridge \n",
    "ridge_inst = Ridge() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.multioutput import MultiOutputRegressor \n",
    "multi_ridge = MultiOutputRegressor(ridge_inst, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "cat_encoder = preprocessing.OneHotEncoder()\n",
    "y_multi = cat_encoder.fit_transform(y.reshape(-1,1)).toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split \n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y_multi, stratify=y, random_state=7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiOutputRegressor(estimator=Ridge(), n_jobs=-1)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Fitting the multi-output estimator \n",
    "multi_ridge.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.81327059,  0.37348962, -0.1867602 ],\n",
       "       [ 0.9524035 ,  0.17877376, -0.13117727],\n",
       "       [-0.01657826,  0.36538441,  0.65119386],\n",
       "       [ 0.1772412 ,  0.47768186,  0.34507695],\n",
       "       [ 0.87693053,  0.14905609, -0.02598662]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#predict the multi-outout target on the testing set: \n",
    "\n",
    "y_multi_pre = multi_ridge.predict(X_test)\n",
    "y_multi_pre[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [0., 0., 1.],\n",
       "       [0., 0., 0.],\n",
       "       [1., 0., 0.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Using binarize to turn each number into an integer 0 or 1 \n",
    "\n",
    "from sklearn import preprocessing \n",
    "y_multi_prediction = preprocessing.binarize(y_multi_pre, threshold=0.5)\n",
    "y_multi_prediction[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9198717948717948"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Next measure over-all multi-output performance with the roc_auc_score \n",
    "\n",
    "from sklearn.metrics import roc_auc_score \n",
    "roc_auc_score(y_test, y_multi_pre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multi-Output Scores for the Iris Flowers: \n",
      "Accuracy Score of flower 0 1.0\n",
      "AUC Score of flower 0 1.0\n",
      "\n",
      "Accuracy Score of flower 1 0.7368421052631579\n",
      "AUC Score of flower 1 0.6523076923076923\n",
      "\n",
      "Accuracy Score of flower 2 0.9736842105263158\n",
      "AUC Score of flower 2 0.9807692307692308\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Doing it flower by flower, column by column\n",
    "\n",
    "from sklearn.metrics import accuracy_score \n",
    "\n",
    "print(\"Multi-Output Scores for the Iris Flowers: \")\n",
    "for column_number in range(0,3):\n",
    "    print(\"Accuracy Score of flower \" + str(column_number),\n",
    "          accuracy_score(y_test[:,column_number], y_multi_prediction[:,column_number]))\n",
    "    print(\"AUC Score of flower \" + str(column_number),roc_auc_score(y_test[:,column_number],y_multi_prediction[:,column_number]))\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This, however, is because we assumed there is a fourth column wher flower is of none of the three types\n",
    "#In these type of cases we can drop the last column and assume flower has to be one of the three types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#DICT-VECTORIZER - It can be used to directly convert strings to features \n",
    "\n",
    "from sklearn.feature_extraction import DictVectorizer \n",
    "dv = DictVectorizer()\n",
    "my_dict = [{'species':iris.target_names[i]} for i in y]\n",
    "dv.fit_transform(my_dict).toarray()[:5]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.9.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}