pereceptron.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sample_submission.csv', 'test.csv', 'train.csv']\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os\n",
    "print(os.listdir(\"../input\"))\n",
    "\n",
    "# Any results you write to the current directory are saved as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import LabelEncoder,MinMaxScaler, StandardScaler\n",
    "from sklearn.model_selection import train_test_split, ParameterGrid\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, mean_squared_error, log_loss\n",
    "import operator\n",
    "import json\n",
    "from IPython import display\n",
    "import os\n",
    "import warnings\n",
    "from sklearn import preprocessing\n",
    "np.random.seed(0)\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "THRESHOLD = 4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_uuid": "987357b1d950f1176f3335878fda858fe0140bc0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of data points in train: 355\n",
      "Number of features in train: 99\n",
      "Number of data points in test: 119\n",
      "Number of features in test: 98\n"
     ]
    }
   ],
   "source": [
    "# # # read data from file\n",
    "#   train = pd.read_csv(io.BytesIO(uploaded['train.csv']))\n",
    "#   test = pd.read_csv(io.BytesIO(uploaded1['test.csv']))\n",
    "train = pd.read_csv(\"../input/train.csv\") \n",
    "test = pd.read_csv(\"../input/test.csv\")\n",
    "\n",
    "# check the number of features and data points in train\n",
    "print(\"Number of data points in train: %d\" % train.shape[0])\n",
    "print(\"Number of features in train: %d\" % train.shape[1])\n",
    "\n",
    "# check the number of features and data points in test\n",
    "print(\"Number of data points in test: %d\" % test.shape[0])\n",
    "print(\"Number of features in test: %d\" % test.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "_uuid": "1eab5d1e6aca844ac31ddc89d27296283d8fc3c4"
   },
   "outputs": [],
   "source": [
    "def data_clean(data):\n",
    "\n",
    "    \n",
    "\n",
    "    # Let's first remove all missing value features\n",
    "\n",
    "    columns_to_remove = ['Also Known As','Applications','Audio Features','Bezel-less display'\n",
    "\n",
    "                         'Browser','Build Material','Co-Processor','Browser'\n",
    "\n",
    "                         'Display Colour','Mobile High-Definition Link(MHL)',\n",
    "\n",
    "                         'Music', 'Email','Fingerprint Sensor Position',\n",
    "\n",
    "                         'Games','HDMI','Heart Rate Monitor','IRIS Scanner', \n",
    "\n",
    "                         'Optical Image Stabilisation','Other Facilities',\n",
    "\n",
    "                         'Phone Book','Physical Aperture','Quick Charging',\n",
    "\n",
    "                         'Ring Tone','Ruggedness','SAR Value','SIM 3','SMS',\n",
    "\n",
    "                         'Screen Protection','Screen to Body Ratio (claimed by the brand)',\n",
    "\n",
    "                         'Sensor','Software Based Aperture', 'Special Features',\n",
    "\n",
    "                         'Standby time','Stylus','TalkTime', 'USB Type-C',\n",
    "\n",
    "                         'Video Player', 'Video Recording Features','Waterproof',\n",
    "\n",
    "                         'Wireless Charging','USB OTG Support', 'Video Recording','Java']\n",
    "\n",
    "\n",
    "\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "\n",
    "    #Features having very low variance \n",
    "\n",
    "    columns_to_remove = ['Architecture','Audio Jack','GPS','Loudspeaker','Network','Network Support','VoLTE']\n",
    "\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "\n",
    "\n",
    "    # Multivalued:\n",
    "\n",
    "    columns_to_remove = ['Architecture','Launch Date','Audio Jack','GPS','Loudspeaker','Network','Network Support','VoLTE', 'Custom UI']\n",
    "\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "\n",
    "\n",
    "    # Not much important\n",
    "\n",
    "    columns_to_remove = ['Bluetooth', 'Settings','Wi-Fi','Wi-Fi Features']\n",
    "\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "    \n",
    "\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_uuid": "2397be3c35d88fdfbb132a46caa1011ca719f9ab"
   },
   "outputs": [],
   "source": [
    "train = data_clean(train)\n",
    "test = data_clean(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "_uuid": "8aa71515e3c601cf113018d27d4a2ba72ac0584b"
   },
   "outputs": [],
   "source": [
    "train = train[(train.isnull().sum(axis=1) <= 15)]\n",
    "# You shouldn't remove data points from test set\n",
    "#test = test[(test.isnull().sum(axis=1) <= 15)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_uuid": "6d017b7d83e56302845d05d59eae994fe731fc08"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of data points in train: 341\n",
      "Number of features in train: 47\n",
      "Number of data points in test: 119\n",
      "Number of features in test: 46\n"
     ]
    }
   ],
   "source": [
    "# check the number of features and data points in train\n",
    "print(\"Number of data points in train: %d\" % train.shape[0])\n",
    "print(\"Number of features in train: %d\" % train.shape[1])\n",
    "\n",
    "# check the number of features and data points in test\n",
    "print(\"Number of data points in test: %d\" % test.shape[0])\n",
    "print(\"Number of features in test: %d\" % test.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_uuid": "0342a2e414d3e964e398e7d9d0b70537a519e4b9"
   },
   "outputs": [],
   "source": [
    "def for_integer(test):\n",
    "    try:\n",
    "        test = test.strip()\n",
    "        return int(test.split(' ')[0])\n",
    "    except IOError:\n",
    "           pass\n",
    "    except ValueError:\n",
    "        pass\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "def for_string(test):\n",
    "    try:\n",
    "        test = test.strip()\n",
    "        return (test.split(' ')[0])\n",
    "    except IOError:\n",
    "        pass\n",
    "    except ValueError:\n",
    "        pass\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "def for_float(test):\n",
    "    try:\n",
    "        test = test.strip()\n",
    "        return float(test.split(' ')[0])\n",
    "    except IOError:\n",
    "        pass\n",
    "    except ValueError:\n",
    "        pass\n",
    "    except:\n",
    "        pass\n",
    "def find_freq(test):\n",
    "    try:\n",
    "        test = test.strip()\n",
    "        test = test.split(' ')\n",
    "        if test[2][0] == '(':\n",
    "            return float(test[2][1:])\n",
    "        return float(test[2])\n",
    "    except IOError:\n",
    "        pass\n",
    "    except ValueError:\n",
    "        pass\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "    \n",
    "def for_Internal_Memory(test):\n",
    "    try:\n",
    "        test = test.strip()\n",
    "        test = test.split(' ')\n",
    "        if test[1] == 'GB':\n",
    "            return int(test[0])\n",
    "        if test[1] == 'MB':\n",
    "#             print(\"here\")\n",
    "            return (int(test[0]) * 0.001)\n",
    "    except IOError:\n",
    "           pass\n",
    "    except ValueError:\n",
    "        pass\n",
    "    except:\n",
    "        pass\n",
    "    \n",
    "def find_freq(test):\n",
    "    try:\n",
    "        test = test.strip()\n",
    "        test = test.split(' ')\n",
    "        if test[2][0] == '(':\n",
    "            return float(test[2][1:])\n",
    "        return float(test[2])\n",
    "    except IOError:\n",
    "        pass\n",
    "    except ValueError:\n",
    "        pass\n",
    "    except:\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_uuid": "9d74a3debbbbe0e2f4d71799b6ed3e2ee8dab66a"
   },
   "outputs": [],
   "source": [
    "def data_clean_2(x):\n",
    "    data = x.copy()\n",
    "    \n",
    "    data['Capacity'] = data['Capacity'].apply(for_integer)\n",
    "\n",
    "    data['Height'] = data['Height'].apply(for_float)\n",
    "    data['Height'] = data['Height'].fillna(data['Height'].mean())\n",
    "\n",
    "    data['Internal Memory'] = data['Internal Memory'].apply(for_Internal_Memory)\n",
    "\n",
    "    data['Pixel Density'] = data['Pixel Density'].apply(for_integer)\n",
    "\n",
    "    data['Internal Memory'] = data['Internal Memory'].fillna(data['Internal Memory'].median())\n",
    "    data['Internal Memory'] = data['Internal Memory'].astype(int)\n",
    "\n",
    "    data['RAM'] = data['RAM'].apply(for_integer)\n",
    "    data['RAM'] = data['RAM'].fillna(data['RAM'].median())\n",
    "    data['RAM'] = data['RAM'].astype(int)\n",
    "\n",
    "    data['Resolution'] = data['Resolution'].apply(for_integer)\n",
    "    data['Resolution'] = data['Resolution'].fillna(data['Resolution'].median())\n",
    "    data['Resolution'] = data['Resolution'].astype(int)\n",
    "\n",
    "    data['Screen Size'] = data['Screen Size'].apply(for_float)\n",
    "\n",
    "    data['Thickness'] = data['Thickness'].apply(for_float)\n",
    "    data['Thickness'] = data['Thickness'].fillna(data['Thickness'].mean())\n",
    "    data['Thickness'] = data['Thickness'].round(2)\n",
    "\n",
    "    data['Type'] = data['Type'].fillna('Li-Polymer')\n",
    "\n",
    "    data['Screen to Body Ratio (calculated)'] = data['Screen to Body Ratio (calculated)'].apply(for_float)\n",
    "    data['Screen to Body Ratio (calculated)'] = data['Screen to Body Ratio (calculated)'].fillna(data['Screen to Body Ratio (calculated)'].mean())\n",
    "    data['Screen to Body Ratio (calculated)'] = data['Screen to Body Ratio (calculated)'].round(2)\n",
    "\n",
    "    data['Width'] = data['Width'].apply(for_float)\n",
    "    data['Width'] = data['Width'].fillna(data['Width'].mean())\n",
    "    data['Width'] = data['Width'].round(2)\n",
    "\n",
    "    data['Flash'][data['Flash'].isna() == True] = \"Other\"\n",
    "\n",
    "    data['User Replaceable'][data['User Replaceable'].isna() == True] = \"Other\"\n",
    "\n",
    "    data['Num_cores'] = data['Processor'].apply(for_string)\n",
    "    data['Num_cores'][data['Num_cores'].isna() == True] = \"Other\"\n",
    "\n",
    "\n",
    "    data['Processor_frequency'] = data['Processor'].apply(find_freq)\n",
    "    #because there is one entry with 208MHz values, to convert it to GHz\n",
    "    data['Processor_frequency'][data['Processor_frequency'] > 200] = 0.208\n",
    "    data['Processor_frequency'] = data['Processor_frequency'].fillna(data['Processor_frequency'].mean())\n",
    "    data['Processor_frequency'] = data['Processor_frequency'].round(2)\n",
    "\n",
    "    data['Camera Features'][data['Camera Features'].isna() == True] = \"Other\"\n",
    "\n",
    "    #simplifyig Operating System to os_name for simplicity\n",
    "    data['os_name'] = data['Operating System'].apply(for_string)\n",
    "    data['os_name'][data['os_name'].isna() == True] = \"Other\"\n",
    "\n",
    "    data['Sim1'] = data['SIM 1'].apply(for_string)\n",
    "\n",
    "    data['SIM Size'][data['SIM Size'].isna() == True] = \"Other\"\n",
    "\n",
    "    data['Image Resolution'][data['Image Resolution'].isna() == True] = \"Other\"\n",
    "\n",
    "    data['Fingerprint Sensor'][data['Fingerprint Sensor'].isna() == True] = \"Other\"\n",
    "\n",
    "    data['Expandable Memory'][data['Expandable Memory'].isna() == True] = \"No\"\n",
    "\n",
    "    data['Weight'] = data['Weight'].apply(for_integer)\n",
    "    data['Weight'] = data['Weight'].fillna(data['Weight'].mean())\n",
    "    data['Weight'] = data['Weight'].astype(int)\n",
    "\n",
    "    data['SIM 2'] = data['SIM 2'].apply(for_string)\n",
    "    data['SIM 2'][data['SIM 2'].isna() == True] = \"Other\"\n",
    "    \n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_uuid": "8651e8915e269ab853ba55328ef827d77cc5c4b1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of data points in train: 341\n",
      "Number of features in train: 51\n",
      "Number of data points in test: 119\n",
      "Number of features in test: 50\n"
     ]
    }
   ],
   "source": [
    "train = data_clean_2(train)\n",
    "test = data_clean_2(test)\n",
    "\n",
    "# check the number of features and data points in train\n",
    "print(\"Number of data points in train: %d\" % train.shape[0])\n",
    "print(\"Number of features in train: %d\" % train.shape[1])\n",
    "\n",
    "# check the number of features and data points in test\n",
    "print(\"Number of data points in test: %d\" % test.shape[0])\n",
    "print(\"Number of features in test: %d\" % test.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "_uuid": "0625b7008cedd4c2332f248c9795f063153ebf8f"
   },
   "outputs": [],
   "source": [
    "def data_clean_3(x):\n",
    "    \n",
    "    data = x.copy()\n",
    "\n",
    "    columns_to_remove = ['User Available Storage','SIM Size','Chipset','Processor','Autofocus','Aspect Ratio','Touch Screen',\n",
    "                        'Bezel-less display','Operating System','SIM 1','USB Connectivity','Other Sensors','Graphics','FM Radio',\n",
    "                        'NFC','Shooting Modes','Browser','Display Colour' ]\n",
    "\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "\n",
    "    columns_to_remove = [ 'Screen Resolution','User Replaceable','Camera Features',\n",
    "                        'Thickness', 'Display Type']\n",
    "\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "\n",
    "    columns_to_remove = ['Fingerprint Sensor', 'Flash', 'Rating Count', 'Review Count','Image Resolution','Type','Expandable Memory',\\\n",
    "                        'Colours','Width','Model']\n",
    "    columns_to_retain = list(set(data.columns)-set(columns_to_remove))\n",
    "    data = data[columns_to_retain]\n",
    "\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "_uuid": "f917dfbe071b237438009185cab68cbdb5ba2835"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of data points in train: 341\n",
      "Number of features in train: 18\n",
      "Number of data points in test: 119\n",
      "Number of features in test: 17\n"
     ]
    }
   ],
   "source": [
    "train = data_clean_3(train)\n",
    "test = data_clean_3(test)\n",
    "\n",
    "# check the number of features and data points in train\n",
    "print(\"Number of data points in train: %d\" % train.shape[0])\n",
    "print(\"Number of features in train: %d\" % train.shape[1])\n",
    "\n",
    "# check the number of features and data points in test\n",
    "print(\"Number of data points in test: %d\" % test.shape[0])\n",
    "print(\"Number of features in test: %d\" % test.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "_uuid": "f0c610c1cfc43534d344b0ccd07aa477cfed0194"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(460, 17)\n",
      "Index(['PhoneId', 'Processor_frequency', 'SIM 2', 'Height', 'Capacity',\n",
      "       'Screen to Body Ratio (calculated)', 'Weight', 'Screen Size',\n",
      "       'Resolution', 'Pixel Density', 'Brand', 'RAM', 'os_name',\n",
      "       'Internal Memory', 'Sim1', 'SIM Slot(s)', 'Num_cores'],\n",
      "      dtype='object')\n",
      "(460, 87)\n",
      "Index(['PhoneId', 'Processor_frequency', 'Height', 'Capacity',\n",
      "       'Screen to Body Ratio (calculated)', 'Weight', 'Screen Size',\n",
      "       'Resolution', 'Pixel Density', 'RAM', 'Internal Memory', 'SIM 2_2G',\n",
      "       'SIM 2_3G', 'SIM 2_4G', 'SIM 2_Other', 'Brand_10.or', 'Brand_Apple',\n",
      "       'Brand_Asus', 'Brand_Billion', 'Brand_Blackberry', 'Brand_Comio',\n",
      "       'Brand_Coolpad', 'Brand_Do', 'Brand_Gionee', 'Brand_Google',\n",
      "       'Brand_HTC', 'Brand_Honor', 'Brand_Huawei', 'Brand_InFocus',\n",
      "       'Brand_Infinix', 'Brand_Intex', 'Brand_Itel', 'Brand_Jivi',\n",
      "       'Brand_Karbonn', 'Brand_LG', 'Brand_Lava', 'Brand_LeEco',\n",
      "       'Brand_Lenovo', 'Brand_Lephone', 'Brand_Lyf', 'Brand_Meizu',\n",
      "       'Brand_Micromax', 'Brand_Mobiistar', 'Brand_Moto', 'Brand_Motorola',\n",
      "       'Brand_Nokia', 'Brand_Nubia', 'Brand_OPPO', 'Brand_OnePlus',\n",
      "       'Brand_Oppo', 'Brand_Panasonic', 'Brand_Razer', 'Brand_Realme',\n",
      "       'Brand_Reliance', 'Brand_Samsung', 'Brand_Sony', 'Brand_Spice',\n",
      "       'Brand_Tecno', 'Brand_Ulefone', 'Brand_VOTO', 'Brand_Vivo',\n",
      "       'Brand_Xiaomi', 'Brand_Xiaomi Poco', 'Brand_Yu', 'Brand_iVooMi',\n",
      "       'os_name_Android', 'os_name_Blackberry', 'os_name_KAI', 'os_name_Nokia',\n",
      "       'os_name_Other', 'os_name_Tizen', 'os_name_iOS', 'Sim1_2G', 'Sim1_3G',\n",
      "       'Sim1_4G', 'SIM Slot(s)_Dual SIM, GSM+CDMA',\n",
      "       'SIM Slot(s)_Dual SIM, GSM+GSM',\n",
      "       'SIM Slot(s)_Dual SIM, GSM+GSM, Dual VoLTE',\n",
      "       'SIM Slot(s)_Single SIM, GSM', 'Num_cores_312', 'Num_cores_Deca',\n",
      "       'Num_cores_Dual', 'Num_cores_Hexa', 'Num_cores_Octa', 'Num_cores_Other',\n",
      "       'Num_cores_Quad', 'Num_cores_Tru-Octa'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "train_ids = train['PhoneId']\n",
    "test_ids = test['PhoneId']\n",
    "\n",
    "cols = list(test.columns)\n",
    "cols.remove('PhoneId')\n",
    "cols.insert(0, 'PhoneId')\n",
    "\n",
    "combined = pd.concat([train.drop('Rating', axis=1)[cols], test[cols]])\n",
    "print(combined.shape)\n",
    "print(combined.columns)\n",
    "\n",
    "combined = pd.get_dummies(combined)\n",
    "print(combined.shape)\n",
    "print(combined.columns)\n",
    "\n",
    "train_new = combined[combined['PhoneId'].isin(train_ids)]\n",
    "test_new = combined[combined['PhoneId'].isin(test_ids)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "_uuid": "0390dce78eb7f2b334c28181ff68cf6522c16d36"
   },
   "outputs": [],
   "source": [
    "train_new = train_new.merge(train[['PhoneId', 'Rating']], on='PhoneId')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "_uuid": "5edc03e57f09584759ba6302dec6087ffe6956ad"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of data points in train: 341\n",
      "Number of features in train: 88\n",
      "Number of data points in test: 119\n",
      "Number of features in test: 87\n"
     ]
    }
   ],
   "source": [
    "# check the number of features and data points in train\n",
    "print(\"Number of data points in train: %d\" % train_new.shape[0])\n",
    "print(\"Number of features in train: %d\" % train_new.shape[1])\n",
    "\n",
    "# check the number of features and data points in test\n",
    "print(\"Number of data points in test: %d\" % test_new.shape[0])\n",
    "print(\"Number of features in test: %d\" % test_new.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "_uuid": "94aff47b10f60c6e652c40d4ca04e46fbccd7d1a"
   },
   "outputs": [],
   "source": [
    "train_new.describe()\n",
    "y_train  = train_new['Rating']\n",
    "train_new = train_new.drop(['Rating'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "_uuid": "8b0c7ef3b00764ddbfff9bd3aad7bf7f890e1f91"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    341.000000\n",
      "mean       4.072434\n",
      "std        0.377066\n",
      "min        2.500000\n",
      "25%        3.900000\n",
      "50%        4.100000\n",
      "75%        4.300000\n",
      "max        5.000000\n",
      "Name: Rating, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(y_train.describe())\n",
    "y_train = y_train.map(lambda x: 0 if x<=4.00 else 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "_uuid": "620b3f0c0958e167245a3b4201bd8dcc2b01817a"
   },
   "outputs": [],
   "source": [
    "# Binarised_X_train = pd.DataFrame()\n",
    "# for i in train_new.columns:\n",
    "#   Binarised_X_train[i] = train_new[i].map(lambda x: 1 if x< train_new[i].max()*0.10 else 0)\n",
    "# X_Binarised_train = np.asarray(Binarised_X_train)\n",
    "# Binarised_X_test = pd.DataFrame()\n",
    "# for i in test_new.columns:\n",
    "#   Binarised_X_test[i] = test_new[i].map(lambda x: 1 if x< test_new[i].max()*0.10 else 0)\n",
    "# X_Binarised_test = np.asarray(Binarised_X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "_uuid": "cc8716c54f5dff92b03b5621e8ccc7eddbefea6b"
   },
   "outputs": [],
   "source": [
    "columns = train_new.columns\n",
    "idcolo = test_new['PhoneId']\n",
    "\n",
    "X_train_normalize = preprocessing.normalize(np.asarray(train_new))\n",
    "X_test_normalize =  preprocessing.normalize(np.asarray(test_new))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "_uuid": "3373b6cad644624c06d154a62216fc43266b92b2"
   },
   "outputs": [],
   "source": [
    "# pd_binarised_X = train_new.apply(pd.cut,bins = 2 ,labels = [0,1])\n",
    "# X_Binarised_train = np.asarray(pd_binarised_X)\n",
    "# pd_binarised_X1 = test_new.apply(pd.cut,bins = 2 ,labels = [0,1])\n",
    "# X_Binarised_test = np.asarray(pd_binarised_X1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "_uuid": "5328d8a4f0f1f1fe9b8fea0a5d555c5ad33f77cf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   PhoneId         ...          Num_cores_Tru-Octa\n",
      "0        0         ...                           0\n",
      "1        1         ...                           0\n",
      "2        2         ...                           0\n",
      "3        4         ...                           0\n",
      "4        5         ...                           0\n",
      "\n",
      "[5 rows x 87 columns]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    341.000000\n",
       "mean       0.586510\n",
       "std        0.493183\n",
       "min        0.000000\n",
       "25%        0.000000\n",
       "50%        1.000000\n",
       "75%        1.000000\n",
       "max        1.000000\n",
       "Name: Rating, dtype: float64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(train_new.head())\n",
    "y_train.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "_uuid": "0d960d3968613e75b30bffb2db991f72fd277548"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_new.T[:],'*')\n",
    "# plt.plot(X_Binarised_train.T,'*')\n",
    "plt.xticks(rotation='vertical')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "_uuid": "20804c620761b2dfa237109a39c6d0c3cf98748b"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'X_Binarised_train' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-bad0d7b5d96d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_Binarised_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'*'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrotation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'vertical'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'X_Binarised_train' is not defined"
     ]
    }
   ],
   "source": [
    "plt.plot(X_Binarised_train.T,'*')\n",
    "plt.xticks(rotation='vertical')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "_uuid": "ecb0fa8bcebfd53ac25feece2ebc0571b7189b5f"
   },
   "outputs": [],
   "source": [
    "class perceptron:\n",
    "  def __init__(self):\n",
    "    self.b = None\n",
    "    self.w = None\n",
    " \n",
    "  def model(self,x):\n",
    "        return 1 if (np.dot(self.w,x)>= self.b) else 0\n",
    "  \n",
    "  def predict(self, X):\n",
    "    y = []\n",
    "    for x in X:\n",
    "      result = self.model(x)\n",
    "      y.append(result)\n",
    "    return np.asarray(y)\n",
    "  \n",
    "  def fit(self,X,Y ,epoches = 2 ,lr = 0.1):\n",
    "    self.w =  np.random.uniform(low=0, high=100, size=(X.shape[1],))\n",
    "    self.b = 0\n",
    "    \n",
    "    accuracy = [0]\n",
    "    \n",
    "    for i in range(epoches):\n",
    "      for x,y in zip(X,Y):\n",
    "        y_pred = self.model(x)\n",
    "        if y == 1 and y_pred == 0:\n",
    "          self.w = self.w + np.array(lr*x)\n",
    "          self.b = self.b + np.array(lr*1)\n",
    "        elif y == 0 and y_pred ==1:\n",
    "          self.w = self.w - np.array(lr*1)\n",
    "          self.b =self.b -  np.array(lr*1)\n",
    "      ac = accuracy_score(self.predict(X),Y)\n",
    "      if ac > max(accuracy):\n",
    "        checkpointw = self.w\n",
    "        checkpointb = self.b\n",
    "      accuracy.append(ac)\n",
    "    self.w = checkpointw\n",
    "    self.b = checkpointb\n",
    "    plt.plot(accuracy)\n",
    "    plt.show()\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "_uuid": "fee618a15b7f8cf269647a9becad7c477ce38a54"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "per = perceptron()\n",
    "per.fit((X_train_normalize), np.array(y_train) , 1000, 0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "_uuid": "48d5e97d07971bc4ec6eea7b8a5331872d2b3d6c"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PhoneId</th>\n",
       "      <th>Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>119.000000</td>\n",
       "      <td>119.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>240.176471</td>\n",
       "      <td>0.991597</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>136.804614</td>\n",
       "      <td>0.091670</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>130.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>245.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>348.500000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>473.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          PhoneId       Class\n",
       "count  119.000000  119.000000\n",
       "mean   240.176471    0.991597\n",
       "std    136.804614    0.091670\n",
       "min      3.000000    0.000000\n",
       "25%    130.000000    1.000000\n",
       "50%    245.000000    1.000000\n",
       "75%    348.500000    1.000000\n",
       "max    473.000000    1.000000"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submission = pd.DataFrame({'PhoneId':idcolo, 'Class':[0]*test_new.shape[0]})\n",
    "submission['Class'] = per.predict(X_test_normalize)\n",
    "submission = submission[['PhoneId', 'Class']]\n",
    "submission.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "_uuid": "0073318a47d864028f9c9bb3932ccad40fd612ba"
   },
   "outputs": [],
   "source": [
    "submission.to_csv(\"submission.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "_uuid": "389ae38709b0a99ab5a1f4aa1c8a67c5b6ff4c6c"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "_uuid": "e8d5e1c821905b98bf2cad96059b38df97e7e422"
   },
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}