Predicciones usando redes neuronales.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.legend import Legend\n",
    "import matplotlib.patches as mpatches\n",
    "import seaborn as sns\n",
    "#from statsmodels.graphics.mosaicplot import mosaic\n",
    "import io\n",
    "import requests\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "#import xgboost as xgb\n",
    "#from xgboost import XGBClassifier\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import accuracy_score\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import tree\n",
    "\n",
    "from sklearn.metrics import log_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectura de datos del CSV y seteo del tipo para cada columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "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>Pricing, Delivery_Terms_Quote_Appr</th>\n",
       "      <th>Pricing, Delivery_Terms_Approved</th>\n",
       "      <th>Bureaucratic_Code_0_Approval</th>\n",
       "      <th>Bureaucratic_Code_0_Approved</th>\n",
       "      <th>Submitted_for_Approval</th>\n",
       "      <th>Account_Created_Date_Day</th>\n",
       "      <th>Account_Created_Date_Month</th>\n",
       "      <th>Account_Created_Date_Year</th>\n",
       "      <th>Opportunity_ID</th>\n",
       "      <th>Sales_Contract_No</th>\n",
       "      <th>...</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_0</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_1</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_2</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_3</th>\n",
       "      <th>Bit_Prod_Category_A_0</th>\n",
       "      <th>Bit_ASP_Currency_0</th>\n",
       "      <th>Bit_ASP_Currency_1</th>\n",
       "      <th>Bit_ASP_Currency_2</th>\n",
       "      <th>Bit_ASP_Currency_3</th>\n",
       "      <th>Bit_ASP_(converted)_Currency_0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2017</td>\n",
       "      <td>960</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2017</td>\n",
       "      <td>959</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2017</td>\n",
       "      <td>961</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2017</td>\n",
       "      <td>956</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>19</td>\n",
       "      <td>9</td>\n",
       "      <td>2014</td>\n",
       "      <td>6985</td>\n",
       "      <td>3681</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 315 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pricing, Delivery_Terms_Quote_Appr  Pricing, Delivery_Terms_Approved  \\\n",
       "0                                   0                                 0   \n",
       "1                                   0                                 0   \n",
       "2                                   0                                 0   \n",
       "3                                   0                                 0   \n",
       "4                                   0                                 0   \n",
       "\n",
       "   Bureaucratic_Code_0_Approval  Bureaucratic_Code_0_Approved  \\\n",
       "0                             0                             0   \n",
       "1                             0                             0   \n",
       "2                             0                             0   \n",
       "3                             0                             0   \n",
       "4                             0                             0   \n",
       "\n",
       "   Submitted_for_Approval  Account_Created_Date_Day  \\\n",
       "0                       0                         1   \n",
       "1                       0                         1   \n",
       "2                       0                         1   \n",
       "3                       0                         1   \n",
       "4                       0                        19   \n",
       "\n",
       "   Account_Created_Date_Month  Account_Created_Date_Year  Opportunity_ID  \\\n",
       "0                           3                       2017             960   \n",
       "1                           3                       2017             959   \n",
       "2                           3                       2017             961   \n",
       "3                           3                       2017             956   \n",
       "4                           9                       2014            6985   \n",
       "\n",
       "   Sales_Contract_No  ...  Bit_Total_Taxable_Amount_Currency_0  \\\n",
       "0                  0  ...                                    0   \n",
       "1                  0  ...                                    0   \n",
       "2                  0  ...                                    0   \n",
       "3                  0  ...                                    0   \n",
       "4               3681  ...                                    0   \n",
       "\n",
       "   Bit_Total_Taxable_Amount_Currency_1  Bit_Total_Taxable_Amount_Currency_2  \\\n",
       "0                                    0                                    0   \n",
       "1                                    0                                    0   \n",
       "2                                    0                                    0   \n",
       "3                                    0                                    0   \n",
       "4                                    0                                    0   \n",
       "\n",
       "   Bit_Total_Taxable_Amount_Currency_3  Bit_Prod_Category_A_0  \\\n",
       "0                                    1                      1   \n",
       "1                                    1                      1   \n",
       "2                                    1                      1   \n",
       "3                                    1                      1   \n",
       "4                                    1                      1   \n",
       "\n",
       "   Bit_ASP_Currency_0  Bit_ASP_Currency_1  Bit_ASP_Currency_2  \\\n",
       "0                   0                   0                   0   \n",
       "1                   0                   0                   0   \n",
       "2                   0                   0                   0   \n",
       "3                   0                   0                   0   \n",
       "4                   0                   0                   0   \n",
       "\n",
       "  Bit_ASP_Currency_3  Bit_ASP_(converted)_Currency_0  \n",
       "0                  1                               1  \n",
       "1                  1                               1  \n",
       "2                  1                               1  \n",
       "3                  1                               1  \n",
       "4                  1                               1  \n",
       "\n",
       "[5 rows x 315 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url_train=\"https://raw.githubusercontent.com/joacols/TP_orga_de_datos/main/Train_Preprocesado_TP2_Datos_2020-2C-encodeado.csv\"\n",
    "s_train=requests.get(url_train).content\n",
    "df_train=pd.read_csv(io.StringIO(s_train.decode('utf-8')),\n",
    "\n",
    "#df = pd.read_csv('Entrenamieto_ECI_2020.csv',\n",
    "dtype={\n",
    "'ID': np.int64,\n",
    "'Pricing, Delivery_Terms_Quote_Approval': np.int64,\n",
    "'Pricing, Delivery_Terms_Approved': np.int64,\n",
    "'Bureaucratic_Code_0_Approval': np.int64,\n",
    "'Bureaucratic_Code_0_Approved': np.int64,\n",
    "'Submitted_for_Approval': np.int64,\n",
    "'Opportunity_ID': np.int64,\n",
    "#'Sales_Contract_No': np.int64,\n",
    "'Delivery_Year': np.int64,\n",
    "'Total_Power': np.int64,\n",
    "#'Price':np.float64,\n",
    "'ASP':np.float64,\n",
    "'ASP_(converted)':np.float64,\n",
    "'Total_Amount':np.float64},\n",
    "#parse_dates=[\n",
    "#'Account_Created_Date',\n",
    "#'Planned_Delivery_Start_Date',\n",
    "#'Planned_Delivery_End_Date',\n",
    "#'Opportunity_Created_Date',\n",
    "#'Last_Activity',\n",
    "#'Quote_Expiry_Date',\n",
    "#'Actual_Delivery_Date',\n",
    "#'Last_Modified_Date'\n",
    "#]\n",
    ")\n",
    "\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "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>Pricing, Delivery_Terms_Quote_Appr</th>\n",
       "      <th>Pricing, Delivery_Terms_Approved</th>\n",
       "      <th>Bureaucratic_Code_0_Approval</th>\n",
       "      <th>Bureaucratic_Code_0_Approved</th>\n",
       "      <th>Submitted_for_Approval</th>\n",
       "      <th>Account_Created_Date_Day</th>\n",
       "      <th>Account_Created_Date_Month</th>\n",
       "      <th>Account_Created_Date_Year</th>\n",
       "      <th>Opportunity_ID</th>\n",
       "      <th>Sales_Contract_No</th>\n",
       "      <th>...</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_0</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_1</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_2</th>\n",
       "      <th>Bit_Total_Taxable_Amount_Currency_3</th>\n",
       "      <th>Bit_Prod_Category_A_0</th>\n",
       "      <th>Bit_ASP_Currency_0</th>\n",
       "      <th>Bit_ASP_Currency_1</th>\n",
       "      <th>Bit_ASP_Currency_2</th>\n",
       "      <th>Bit_ASP_Currency_3</th>\n",
       "      <th>Bit_ASP_(converted)_Currency_0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>20</td>\n",
       "      <td>2</td>\n",
       "      <td>2017</td>\n",
       "      <td>12173</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>22</td>\n",
       "      <td>8</td>\n",
       "      <td>2018</td>\n",
       "      <td>12172</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>22</td>\n",
       "      <td>8</td>\n",
       "      <td>2018</td>\n",
       "      <td>11408</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>2019</td>\n",
       "      <td>12232</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>2019</td>\n",
       "      <td>12233</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 315 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pricing, Delivery_Terms_Quote_Appr  Pricing, Delivery_Terms_Approved  \\\n",
       "0                                   0                                 0   \n",
       "1                                   0                                 0   \n",
       "2                                   0                                 0   \n",
       "3                                   0                                 0   \n",
       "4                                   0                                 0   \n",
       "\n",
       "   Bureaucratic_Code_0_Approval  Bureaucratic_Code_0_Approved  \\\n",
       "0                             0                             0   \n",
       "1                             0                             0   \n",
       "2                             0                             0   \n",
       "3                             0                             0   \n",
       "4                             0                             0   \n",
       "\n",
       "   Submitted_for_Approval  Account_Created_Date_Day  \\\n",
       "0                       0                        20   \n",
       "1                       0                        22   \n",
       "2                       0                        22   \n",
       "3                       0                         4   \n",
       "4                       0                         4   \n",
       "\n",
       "   Account_Created_Date_Month  Account_Created_Date_Year  Opportunity_ID  \\\n",
       "0                           2                       2017           12173   \n",
       "1                           8                       2018           12172   \n",
       "2                           8                       2018           11408   \n",
       "3                           4                       2019           12232   \n",
       "4                           4                       2019           12233   \n",
       "\n",
       "   Sales_Contract_No  ...  Bit_Total_Taxable_Amount_Currency_0  \\\n",
       "0                  0  ...                                    0   \n",
       "1                  0  ...                                    0   \n",
       "2                  0  ...                                    0   \n",
       "3                  0  ...                                    0   \n",
       "4                  0  ...                                    0   \n",
       "\n",
       "   Bit_Total_Taxable_Amount_Currency_1  Bit_Total_Taxable_Amount_Currency_2  \\\n",
       "0                                    0                                    0   \n",
       "1                                    0                                    0   \n",
       "2                                    0                                    0   \n",
       "3                                    0                                    0   \n",
       "4                                    0                                    0   \n",
       "\n",
       "   Bit_Total_Taxable_Amount_Currency_3  Bit_Prod_Category_A_0  \\\n",
       "0                                    1                      1   \n",
       "1                                    1                      1   \n",
       "2                                    1                      1   \n",
       "3                                    1                      1   \n",
       "4                                    1                      1   \n",
       "\n",
       "   Bit_ASP_Currency_0  Bit_ASP_Currency_1  Bit_ASP_Currency_2  \\\n",
       "0                   0                   0                   0   \n",
       "1                   0                   0                   0   \n",
       "2                   0                   0                   0   \n",
       "3                   0                   0                   0   \n",
       "4                   0                   0                   0   \n",
       "\n",
       "   Bit_ASP_Currency_3  Bit_ASP_(converted)_Currency_0  \n",
       "0                   1                               1  \n",
       "1                   1                               1  \n",
       "2                   1                               1  \n",
       "3                   1                               1  \n",
       "4                   1                               1  \n",
       "\n",
       "[5 rows x 315 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url_test=\"https://raw.githubusercontent.com/joacols/TP_orga_de_datos/main/Test_Preprocesado_TP2_Datos_2020-2C-encodeado.csv\"\n",
    "s_test=requests.get(url_test).content\n",
    "df_test=pd.read_csv(io.StringIO(s_test.decode('utf-8')),\n",
    "\n",
    "#df = pd.read_csv('Entrenamieto_ECI_2020.csv',\n",
    "dtype={\n",
    "'ID': np.int64,\n",
    "'Pricing, Delivery_Terms_Quote_Approval': np.int64,\n",
    "'Pricing, Delivery_Terms_Approved': np.int64,\n",
    "'Bureaucratic_Code_0_Approval': np.int64,\n",
    "'Bureaucratic_Code_0_Approved': np.int64,\n",
    "'Submitted_for_Approval': np.int64,\n",
    "'Opportunity_ID': np.int64,\n",
    "#'Sales_Contract_No': np.int64,\n",
    "'Delivery_Year': np.int64,\n",
    "'Total_Power': np.int64,\n",
    "#'Price':np.float64,\n",
    "'ASP':np.float64,\n",
    "'ASP_(converted)':np.float64,\n",
    "'Total_Amount':np.float64},\n",
    "#parse_dates=[\n",
    "#'Account_Created_Date',\n",
    "#'Planned_Delivery_Start_Date',\n",
    "#'Planned_Delivery_End_Date',\n",
    "#'Opportunity_Created_Date',\n",
    "#'Last_Activity',\n",
    "#'Quote_Expiry_Date',\n",
    "#'Actual_Delivery_Date',\n",
    "#'Last_Modified_Date'\n",
    "#]\n",
    ")\n",
    "\n",
    "df_test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Realizamos el preprocesamiento sobre los datos "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from sklearn import preprocessing\n",
    "lbl = preprocessing.LabelEncoder()\n",
    "df2_train = df_train\n",
    "df2_train['Region'] = lbl.fit_transform(df2_train['Region'].astype(str))\n",
    "df2_train['Territory'] = lbl.fit_transform(df2_train['Territory'].astype(str))\n",
    "df2_train['Bureaucratic_Code'] = lbl.fit_transform(df2_train['Bureaucratic_Code'].astype(str))\n",
    "df2_train['Source '] = lbl.fit_transform(df2_train['Source '].astype(str))\n",
    "df2_train['Billing_Country'] = lbl.fit_transform(df2_train['Billing_Country'].astype(str))\n",
    "df2_train['Account_Name'] = lbl.fit_transform(df2_train['Account_Name'].astype(str))\n",
    "df2_train['Opportunity_Name'] = lbl.fit_transform(df2_train['Opportunity_Name'].astype(str))\n",
    "df2_train['Account_Owner'] = lbl.fit_transform(df2_train['Account_Owner'].astype(str))\n",
    "df2_train['Opportunity_Owner'] = lbl.fit_transform(df2_train['Opportunity_Owner'].astype(str))\n",
    "df2_train['Account_Type'] = lbl.fit_transform(df2_train['Account_Type'].astype(str))\n",
    "df2_train['Opportunity_Type'] = lbl.fit_transform(df2_train['Opportunity_Type'].astype(str))\n",
    "df2_train['Quote_Type'] = lbl.fit_transform(df2_train['Quote_Type'].astype(str))\n",
    "df2_train['Delivery_Terms'] = lbl.fit_transform(df2_train['Delivery_Terms'].astype(str))\n",
    "df2_train['Brand'] = lbl.fit_transform(df2_train['Brand'].astype(str))\n",
    "df2_train['Product_Type'] = lbl.fit_transform(df2_train['Product_Type'].astype(str))\n",
    "df2_train['Size'] = lbl.fit_transform(df2_train['Size'].astype(str))\n",
    "df2_train['Product_Category_B'] = lbl.fit_transform(df2_train['Product_Category_B'].astype(str))\n",
    "df2_train['Price'] = lbl.fit_transform(df2_train['Price'].astype(str))\n",
    "df2_train['Currency'] = lbl.fit_transform(df2_train['Currency'].astype(str))\n",
    "df2_train['Last_Modified_By'] = lbl.fit_transform(df2_train['Last_Modified_By'].astype(str))\n",
    "#df2_train['Product_Family'] = lbl.fit_transform(df2_train['Product_Family'].astype(str))\n",
    "#df2_train['Product_Name'] = lbl.fit_transform(df2_train['Product_Name'].astype(str))\n",
    "df2_train['ASP_Currency'] = lbl.fit_transform(df2_train['ASP_Currency'].astype(str))\n",
    "df2_train['ASP_(converted)_Currency'] = lbl.fit_transform(df2_train['ASP_(converted)_Currency'].astype(str))\n",
    "#df2_train['Month'] = lbl.fit_transform(df2_train['Month'].astype(str))\n",
    "#df2_train['Delivery_Quarter'] = lbl.fit_transform(df2_train['Delivery_Quarter'].astype(str))\n",
    "df2_train['Total_Amount_Currency'] = lbl.fit_transform(df2_train['Total_Amount_Currency'].astype(str))\n",
    "df2_train['Total_Taxable_Amount_Currency'] = lbl.fit_transform(df2_train['Total_Taxable_Amount_Currency'].astype(str))\n",
    "df2_train['Prod_Category_A'] = lbl.fit_transform(df2_train['Prod_Category_A'].astype(str))\n",
    "\n",
    "#df2_train['Account_Created_Date'] = lbl.fit_transform(df2_train['Account_Created_Date'].astype(str))\n",
    "#df2_train['Opportunity_Created_Date'] = lbl.fit_transform(df2_train['Opportunity_Created_Date'].astype(str))\n",
    "#df2_train['Last_Activity'] = lbl.fit_transform(df2_train['Last_Activity'].astype(str))\n",
    "#df2_train['Quote_Expiry_Date'] = lbl.fit_transform(df2_train['Quote_Expiry_Date'].astype(str))\n",
    "#df2_train['Last_Modified_Date'] = lbl.fit_transform(df2_train['Last_Modified_Date'].astype(str))\n",
    "#df2_train['Planned_Delivery_Start_Date'] = lbl.fit_transform(df2_train['Planned_Delivery_Start_Date'].astype(str))\n",
    "#df2_train['Planned_Delivery_End_Date'] = lbl.fit_transform(df2_train['Planned_Delivery_End_Date'].astype(str))\n",
    "#df2_train['Actual_Delivery_Date'] = lbl.fit_transform(df2_train['Actual_Delivery_Date'].astype(str))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "df2_test = df_test\n",
    "df2_test['Region'] = lbl.fit_transform(df2_test['Region'].astype(str))\n",
    "df2_test['Territory'] = lbl.fit_transform(df2_test['Territory'].astype(str))\n",
    "df2_test['Bureaucratic_Code'] = lbl.fit_transform(df2_test['Bureaucratic_Code'].astype(str))\n",
    "df2_test['Source '] = lbl.fit_transform(df2_test['Source '].astype(str))\n",
    "df2_test['Billing_Country'] = lbl.fit_transform(df2_test['Billing_Country'].astype(str))\n",
    "df2_test['Account_Name'] = lbl.fit_transform(df2_test['Account_Name'].astype(str))\n",
    "df2_test['Opportunity_Name'] = lbl.fit_transform(df2_test['Opportunity_Name'].astype(str))\n",
    "df2_test['Account_Owner'] = lbl.fit_transform(df2_test['Account_Owner'].astype(str))\n",
    "df2_test['Opportunity_Owner'] = lbl.fit_transform(df2_test['Opportunity_Owner'].astype(str))\n",
    "df2_test['Account_Type'] = lbl.fit_transform(df2_test['Account_Type'].astype(str))\n",
    "df2_test['Opportunity_Type'] = lbl.fit_transform(df2_test['Opportunity_Type'].astype(str))\n",
    "df2_test['Quote_Type'] = lbl.fit_transform(df2_test['Quote_Type'].astype(str))\n",
    "df2_test['Delivery_Terms'] = lbl.fit_transform(df2_test['Delivery_Terms'].astype(str))\n",
    "df2_test['Brand'] = lbl.fit_transform(df2_test['Brand'].astype(str))\n",
    "df2_test['Product_Type'] = lbl.fit_transform(df2_test['Product_Type'].astype(str))\n",
    "df2_test['Size'] = lbl.fit_transform(df2_test['Size'].astype(str))\n",
    "df2_test['Product_Category_B'] = lbl.fit_transform(df2_test['Product_Category_B'].astype(str))\n",
    "df2_test['Price'] = lbl.fit_transform(df2_test['Price'].astype(str))\n",
    "df2_test['Currency'] = lbl.fit_transform(df2_test['Currency'].astype(str))\n",
    "df2_test['Last_Modified_By'] = lbl.fit_transform(df2_test['Last_Modified_By'].astype(str))\n",
    "#df2_train['Product_Family'] = lbl.fit_transform(df2_train['Product_Family'].astype(str))\n",
    "#df2_train['Product_Name'] = lbl.fit_transform(df2_train['Product_Name'].astype(str))\n",
    "df2_test['ASP_Currency'] = lbl.fit_transform(df2_test['ASP_Currency'].astype(str))\n",
    "df2_test['ASP_(converted)_Currency'] = lbl.fit_transform(df2_test['ASP_(converted)_Currency'].astype(str))\n",
    "#df2_train['Month'] = lbl.fit_transform(df2_train['Month'].astype(str))\n",
    "#df2_train['Delivery_Quarter'] = lbl.fit_transform(df2_train['Delivery_Quarter'].astype(str))\n",
    "df2_test['Total_Amount_Currency'] = lbl.fit_transform(df2_test['Total_Amount_Currency'].astype(str))\n",
    "df2_test['Total_Taxable_Amount_Currency'] = lbl.fit_transform(df2_test['Total_Taxable_Amount_Currency'].astype(str))\n",
    "df2_test['Prod_Category_A'] = lbl.fit_transform(df2_test['Prod_Category_A'].astype(str))\n",
    "\n",
    "#df2_train['Account_Created_Date'] = lbl.fit_transform(df2_train['Account_Created_Date'].astype(str))\n",
    "#df2_train['Opportunity_Created_Date'] = lbl.fit_transform(df2_train['Opportunity_Created_Date'].astype(str))\n",
    "#df2_train['Last_Activity'] = lbl.fit_transform(df2_train['Last_Activity'].astype(str))\n",
    "#df2_train['Quote_Expiry_Date'] = lbl.fit_transform(df2_train['Quote_Expiry_Date'].astype(str))\n",
    "#df2_train['Last_Modified_Date'] = lbl.fit_transform(df2_train['Last_Modified_Date'].astype(str))\n",
    "#df2_train['Planned_Delivery_Start_Date'] = lbl.fit_transform(df2_train['Planned_Delivery_Start_Date'].astype(str))\n",
    "#df2_train['Planned_Delivery_End_Date'] = lbl.fit_transform(df2_train['Planned_Delivery_End_Date'].astype(str))\n",
    "#df2_train['Actual_Delivery_Date'] = lbl.fit_transform(df2_train['Actual_Delivery_Date'].astype(str))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9841, 315)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1567, 315)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_test.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2_train=df_train\n",
    "df2_test=df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "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>nulls</th>\n",
       "      <th>porcentaje</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [nulls, porcentaje]\n",
       "Index: []"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "faltantes=pd.DataFrame(df2_train.isnull().sum().sort_values(ascending=False),columns=['nulls'])\n",
    "filas=len(df2_train)\n",
    "faltantes['porcentaje']=round(100*faltantes['nulls']/filas,2)\n",
    "faltantes[faltantes['nulls']!=0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Separamos la variable a predecir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3_train = df2_train.drop(['Last_Activity_Day_mean','Last_Activity_Day_std','Last_Activity_Day_min','Last_Activity_Day_max',\n",
    "                            'Last_Activity_Month_mean','Last_Activity_Month_std','Last_Activity_Month_min','Last_Activity_Month_max', \n",
    "                                   'Last_Activity_Year_mean','Last_Activity_Year_std','Last_Activity_Year_min','Last_Activity_Year_max', \n",
    "                            'Actual_Delivery_Date_Day_mean','Actual_Delivery_Date_Day_std','Actual_Delivery_Date_Day_min','Actual_Delivery_Date_Day_max',\n",
    "                                   'Actual_Delivery_Date_Month_mean','Actual_Delivery_Date_Month_std','Actual_Delivery_Date_Month_min','Actual_Delivery_Date_Month_max', \n",
    "                                   'Actual_Delivery_Date_Year_mean','Actual_Delivery_Date_Year_std','Actual_Delivery_Date_Year_min','Actual_Delivery_Date_Year_max'], axis=1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df3_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df4_train = df3_train.dropna()                                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df4_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "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>nulls</th>\n",
       "      <th>porcentaje</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [nulls, porcentaje]\n",
       "Index: []"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "faltantes=pd.DataFrame(df4_train.isnull().sum().sort_values(ascending=False),columns=['nulls'])\n",
    "filas=len(df4_train)\n",
    "faltantes['porcentaje']=round(100*faltantes['nulls']/filas,2)\n",
    "faltantes[faltantes['nulls']!=0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df4_train['Is_closed_won']=(df4_train['Stage']=='Closed Won')\n",
    "df4_train['Is_closed_won']=df4_train['Stage'].apply(lambda x: 1 if x=='Closed Won' else 0)\n",
    "df4_train=df4_train.drop(['Stage'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df4_train.drop(['Is_closed_won','Sales_Contract_No'], axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df4_train['Is_closed_won']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#X.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#y.value_counts()#.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creamos set de entrenamiento y test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = \\\n",
    "    train_test_split(X, y, test_size=0.2, random_state=123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "clfLR = LogisticRegression(random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\licha\\Miniconda3\\envs\\orgadatos\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='warn',\n",
       "          n_jobs=None, penalty='l2', random_state=0, solver='warn',\n",
       "          tol=0.0001, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 1, 1, 1], dtype=int64)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_validation\n",
    "#y_test.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6567    1\n",
       "4695    1\n",
       "3973    1\n",
       "8323    1\n",
       "7390    1\n",
       "6903    1\n",
       "7       1\n",
       "5208    1\n",
       "1533    0\n",
       "9567    1\n",
       "444     1\n",
       "7729    0\n",
       "2354    1\n",
       "8624    0\n",
       "8024    1\n",
       "4418    0\n",
       "9215    1\n",
       "6219    1\n",
       "3638    1\n",
       "4827    1\n",
       "3205    1\n",
       "6732    1\n",
       "1426    0\n",
       "5331    0\n",
       "1554    1\n",
       "9763    0\n",
       "2492    0\n",
       "6784    1\n",
       "9600    1\n",
       "7367    1\n",
       "       ..\n",
       "1067    1\n",
       "5583    0\n",
       "9180    0\n",
       "3107    1\n",
       "9259    1\n",
       "5005    0\n",
       "1011    0\n",
       "8570    0\n",
       "5749    1\n",
       "3087    1\n",
       "7210    0\n",
       "1268    0\n",
       "1108    1\n",
       "7323    1\n",
       "1614    0\n",
       "7017    1\n",
       "84      1\n",
       "2607    0\n",
       "7956    1\n",
       "7721    1\n",
       "3468    0\n",
       "5069    0\n",
       "5393    1\n",
       "5346    0\n",
       "3568    0\n",
       "1892    0\n",
       "3906    0\n",
       "4873    1\n",
       "1435    0\n",
       "6129    0\n",
       "Name: Is_closed_won, Length: 1969, dtype: int64"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5769426104621636"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.60136355, 0.60712555, 0.57258027, ..., 0.60254926, 0.61251617,\n",
       "       0.59769061])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_validation_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6706774099386827"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3_test = df2_test.drop(['Last_Activity_Day_mean','Last_Activity_Day_std','Last_Activity_Day_min','Last_Activity_Day_max',\n",
    "                            'Last_Activity_Month_mean','Last_Activity_Month_std','Last_Activity_Month_min','Last_Activity_Month_max', \n",
    "                                   'Last_Activity_Year_mean','Last_Activity_Year_std','Last_Activity_Year_min','Last_Activity_Year_max', \n",
    "                            'Actual_Delivery_Date_Day_mean','Actual_Delivery_Date_Day_std','Actual_Delivery_Date_Day_min','Actual_Delivery_Date_Day_max',\n",
    "                                   'Actual_Delivery_Date_Month_mean','Actual_Delivery_Date_Month_std','Actual_Delivery_Date_Month_min','Actual_Delivery_Date_Month_max', \n",
    "                                   'Actual_Delivery_Date_Year_mean','Actual_Delivery_Date_Year_std','Actual_Delivery_Date_Year_min','Actual_Delivery_Date_Year_max'], axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "df4_test = df3_test.dropna()                                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Pricing, Delivery_Terms_Quote_Appr',\n",
       "       'Pricing, Delivery_Terms_Approved', 'Bureaucratic_Code_0_Approval',\n",
       "       'Bureaucratic_Code_0_Approved', 'Submitted_for_Approval',\n",
       "       'Account_Created_Date_Day', 'Account_Created_Date_Month',\n",
       "       'Account_Created_Date_Year', 'Opportunity_ID',\n",
       "       'Opportunity_Created_Date_Day',\n",
       "       ...\n",
       "       'Bit_Total_Taxable_Amount_Currency_0',\n",
       "       'Bit_Total_Taxable_Amount_Currency_1',\n",
       "       'Bit_Total_Taxable_Amount_Currency_2',\n",
       "       'Bit_Total_Taxable_Amount_Currency_3', 'Bit_Prod_Category_A_0',\n",
       "       'Bit_ASP_Currency_0', 'Bit_ASP_Currency_1', 'Bit_ASP_Currency_2',\n",
       "       'Bit_ASP_Currency_3', 'Bit_ASP_(converted)_Currency_0'],\n",
       "      dtype='object', length=289)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Pricing, Delivery_Terms_Quote_Appr',\n",
       "       'Pricing, Delivery_Terms_Approved', 'Bureaucratic_Code_0_Approval',\n",
       "       'Bureaucratic_Code_0_Approved', 'Submitted_for_Approval',\n",
       "       'Account_Created_Date_Day', 'Account_Created_Date_Month',\n",
       "       'Account_Created_Date_Year', 'Opportunity_ID', 'Sales_Contract_No',\n",
       "       ...\n",
       "       'Bit_Total_Taxable_Amount_Currency_0',\n",
       "       'Bit_Total_Taxable_Amount_Currency_1',\n",
       "       'Bit_Total_Taxable_Amount_Currency_2',\n",
       "       'Bit_Total_Taxable_Amount_Currency_3', 'Bit_Prod_Category_A_0',\n",
       "       'Bit_ASP_Currency_0', 'Bit_ASP_Currency_1', 'Bit_ASP_Currency_2',\n",
       "       'Bit_ASP_Currency_3', 'Bit_ASP_(converted)_Currency_0'],\n",
       "      dtype='object', length=291)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df4_test.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.3937541 , 0.39374642, 0.39115949, ..., 0.61434069, 0.60821459,\n",
       "       0.38515457])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "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>Opportunity_ID</th>\n",
       "      <th>Target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12173</td>\n",
       "      <td>0.393754</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>12172</td>\n",
       "      <td>0.393746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>11408</td>\n",
       "      <td>0.391159</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>12232</td>\n",
       "      <td>0.394922</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>12233</td>\n",
       "      <td>0.393528</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Opportunity_ID    Target\n",
       "0           12173  0.393754\n",
       "1           12172  0.393746\n",
       "2           11408  0.391159\n",
       "3           12232  0.394922\n",
       "4           12233  0.393528"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./LogisticRegression.csv',index=False , header=True)\n",
    "prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 3 capas de 50 neuronas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probamos ahora con una red neuronal con 3 capas ocultas con 50 neuronas cada una:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neural_network import MLPClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "nro_neuronas=100#150\n",
    "capas=1#3\n",
    "#clfLR = MLPClassifier(hidden_layer_sizes=(nro_neuronas,capas50),random_state=1)#solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)\n",
    "clfLR = MLPClassifier(hidden_layer_sizes=(50,50,50 ),random_state=1)#solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(50, 50, 50), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5129507364144236"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.465270349405756"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MPL3capas50neuronas.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 2 capas de 100 neuronas y 2 capas de 75 neuronas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probamos ahora con una red neuronal con 4 capas ocultas, 2 con 100 neuronas y 2 con 75 neuronas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(100,100,75,75),random_state=1)#solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(100, 100, 75, 75), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6190959878110716"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.004370812069694"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MPL2capas100neuronas2capas75neuronas.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 100 neuronas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probamos ahora con una red neuronal con 4 capas ocultas con 100 neuronas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(100,100,100,100),random_state=1)#solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(100, 100, 100, 100), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.665312341289995"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6305334409524919"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MPL4capas100neuronas.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 200 neuronas funcion tanh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1,activation='tanh')#, alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6317927882173692"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6332297835667907"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MPL4capas200neuronas_tanh.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 200 neuronas funcion tanh alpha 0,00001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1,alpha=0.00001,activation='tanh')#, alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='tanh', alpha=1e-05, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6841036058913154"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6033469731032436"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MLP4capas200neuronas_tanh_alfa_0,00001.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression con class_weight='Balanced'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "clfLR = LogisticRegression(random_state=0,class_weight=\"balanced\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\licha\\Miniconda3\\envs\\orgadatos\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight='balanced', dual=False,\n",
       "          fit_intercept=True, intercept_scaling=1, max_iter=100,\n",
       "          multi_class='warn', n_jobs=None, penalty='l2', random_state=0,\n",
       "          solver='warn', tol=0.0001, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5738953783646521"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6702551242506127"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3_test = df2_test.drop(['Last_Activity_Day_mean','Last_Activity_Day_std','Last_Activity_Day_min','Last_Activity_Day_max',\n",
    "                            'Last_Activity_Month_mean','Last_Activity_Month_std','Last_Activity_Month_min','Last_Activity_Month_max', \n",
    "                                   'Last_Activity_Year_mean','Last_Activity_Year_std','Last_Activity_Year_min','Last_Activity_Year_max', \n",
    "                            'Actual_Delivery_Date_Day_mean','Actual_Delivery_Date_Day_std','Actual_Delivery_Date_Day_min','Actual_Delivery_Date_Day_max',\n",
    "                                   'Actual_Delivery_Date_Month_mean','Actual_Delivery_Date_Month_std','Actual_Delivery_Date_Month_min','Actual_Delivery_Date_Month_max', \n",
    "                                   'Actual_Delivery_Date_Year_mean','Actual_Delivery_Date_Year_std','Actual_Delivery_Date_Year_min','Actual_Delivery_Date_Year_max'], axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df4_test = df3_test.dropna()                                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./LogisticRegression_class_weight=Balanced.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO probar tambien multilayer perceptron escalando los datos de train y test con StandardScaler "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 100 neuronas (estandarizando los datos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\licha\\Miniconda3\\envs\\orgadatos\\lib\\site-packages\\sklearn\\preprocessing\\data.py:645: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "C:\\Users\\licha\\Miniconda3\\envs\\orgadatos\\lib\\site-packages\\sklearn\\base.py:464: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, **fit_params).transform(X)\n",
      "C:\\Users\\licha\\Miniconda3\\envs\\orgadatos\\lib\\site-packages\\ipykernel_launcher.py:4: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by StandardScaler.\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler \n",
    "sc_X = StandardScaler()\n",
    "X_trainscaled=sc_X.fit_transform(X_train)\n",
    "X_testscaled=sc_X.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probamos ahora con una red neuronal con 4 capas ocultas con 100 neuronas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(100,100,100,100),random_state=1)#solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(100, 100, 100, 100), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_trainscaled, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_testscaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.814118842051803"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_testscaled)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.181590607283636"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MLP4capas100neuronas(DatosEstandarizados).csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 200 neuronas funcion tanh (estandarizando los datos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1,activation='tanh')#, alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_trainscaled, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_testscaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8324022346368715"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_testscaled)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.1365617545276594"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MLP4capas200neuronas_tanh(DatosEstandarizados).csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 200 neuronas funcion tanh alpha 0,00001 (estandarizando los datos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1,alpha=0.00001,activation='tanh')#, alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='tanh', alpha=1e-05, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_trainscaled, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_testscaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8395124428643982"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_testscaled)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.1019599272665879"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MLP4capas200neuronas_tanh_alfa_0,00001(DatosEstandarizados).csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Layer Perceptrón con 4 capas de 200 neuronas funcion relu (estandarizando los datos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1)#, alpha=1e-5,hidden_layer_sizes=(5, 2), random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clfLR.fit(X_trainscaled, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clfLR.predict(X_testscaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8252920264093448"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clfLR.predict_proba(X_testscaled)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0245772609672683"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clfLR.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels\n",
    "prediccion.to_csv(r'./MLP4capas200neuronas(DatosEstandarizados).csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ensamble de Multi Layer Perceptrón con 4 capas de 200 neuronas funcion tanh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import BaggingClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1,activation='tanh')\n",
    "clf = BaggingClassifier(clfLR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Ensamble de Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BaggingClassifier(base_estimator=MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False),\n",
       "         bootstrap=True, bootstrap_features=False, max_features=1.0,\n",
       "         max_samples=1.0, n_estimators=10, n_jobs=None, oob_score=False,\n",
       "         random_state=None, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Ensamble de Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6109700355510411"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clf.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6314719329221374"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Ensamble de Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clf.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels \n",
    "prediccion.to_csv(r'./EnsambleMLP4capas200neuronas_tanh.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ensamble de Multi Layer Perceptrón con 4 capas de 200 neuronas funcion tanh alpha 0,00001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import BaggingClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfLR = MLPClassifier(hidden_layer_sizes=(200,200,200,200),random_state=1,alpha=0.00001,activation='tanh')\n",
    "clf = BaggingClassifier(clfLR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento usando Ensamble de Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BaggingClassifier(base_estimator=MLPClassifier(activation='tanh', alpha=1e-05, batch_size='auto', beta_1=0.9,\n",
       "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
       "       hidden_layer_sizes=(200, 200, 200, 200), learning_rate='constant',\n",
       "       learning_rate_init=0.001, max_iter=200, momentum=0.9,\n",
       "       n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,\n",
       "       random_state=1, shuffle=True, solver='adam', tol=0.0001,\n",
       "       validation_fraction=0.1, verbose=False, warm_start=False),\n",
       "         bootstrap=True, bootstrap_features=False, max_features=1.0,\n",
       "         max_samples=1.0, n_estimators=10, n_jobs=None, oob_score=False,\n",
       "         random_state=None, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validación usando Ensamble de Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation =clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6455053326561706"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validation_probs = clf.predict_proba(X_test)[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6187579457637101"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_loss(y_test, y_validation_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicción usando Ensamble de Multi Layer Perceptrón"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_probs =clf.predict_proba(df4_test.drop(['Sales_Contract_No','Stage'], axis=1))[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creo un dataframe con el formato ( id , precio (El precio predecido ))\n",
    "prediccion = df4_test['Opportunity_ID'].to_frame()\n",
    "prediccion.insert(1,'Target', y_pred_probs , True) \n",
    "#Exportamos la prediccion en formato csv sin labels \n",
    "prediccion.to_csv(r'./EnsambleMLP4capas200neuronas_tanh_alfa_0,00001.csv',index=False , header=True)\n",
    "#prediccion.head()"
   ]
  },
  {
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}