semana_03/semana_03_machine_learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Semana 03 - Machine Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Verificar se a variável target está balanceada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "dados = pd.read_csv('../dados/dados_clientes_alura_voz.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    73.463013\n",
       "1    26.536987\n",
       "Name: churn, dtype: float64"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dados.churn.value_counts(normalize=True) * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As classes estão desbalanceadas. Portanto serão aplicadas técnicas de balanceamento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enconding as variáveis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "\n",
    "colunas_encoder = ['servico_internet', 'contrato', 'metodo_pagamento']\n",
    "encoder = OrdinalEncoder()\n",
    "dados[colunas_encoder] = encoder.fit_transform(dados[colunas_encoder])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seleção variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na análise exploratória realizada na semana anterior foram verificadas que algumas variáveis não trazem informações úteis para a solução do problema.\n",
    "\n",
    "* ID_cliente - é um identificador único de identificação do usuário\n",
    "* gastos_totais - esta variável é dependente do tempo que o cliente fica na empresa, obviamente quanto maior o tempo na empresa maiores os gastos totais\n",
    "* gastos_diarias - está altamente correlacionada com a variável gastos_totais já que foi derivada a partir da mesma\n",
    "* genero - Em ambos os grupos, com e sem churn, a proporção de homens e mulheres é de 50% aproximadamente\n",
    "* servico_telefone - Não há diferença na proporção de usuários que utilizam este serviço dos dois grupos, com e sem churn\n",
    "\n",
    "Totas as variáveis acima serão removidas da base de dados para simplificação do problema.\n",
    "\n",
    "Também foram verificadas os seguintes padrões:\n",
    "\n",
    "* A proporção dos clientes que contratam serviço de backup online é próxima dos que contratam proteção para dispositivo nos dois grupos\n",
    "* A proporção dos clientes que contratam serviço de streaming de TV é próxima dos que contratam streaming de filmes\n",
    "\n",
    "Considerando-se tais padrões serão criadas duas novas variáveis:\n",
    "\n",
    "* protecao - Representa se o cliente contrata algum serviço de proteção (backup ou proteção de dispositivo)\n",
    "* streaming - Representa se o cliente contrata algum serviço de streaming (TV ou filmes)\n",
    "\n",
    "Após a criação destas duas novas variáveis as variáveis originas (backup_online, protecao_dispositivo, streaming_TV e streaming_filmes) serão removidas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separação dos conjuntos X e y e remoção de variáveis irrelavantes\n",
    "X = dados.drop(['ID_cliente', 'churn', 'gastos_totais', 'gastos_diarios', 'genero', 'servico_telefone'], axis=1)\n",
    "y = dados['churn']\n",
    "\n",
    "# Criação da variável streaming\n",
    "f_streming = lambda x: 1 if x.streaming_TV or x.streaming_filmes else 0\n",
    "X['streaming'] = X.apply(f_streming, axis=1)\n",
    "\n",
    "# Criação da variável seguranca\n",
    "f_seguranca = lambda x: 1 if x.backup_online or x.protecao_dispositivo else 0\n",
    "X['seguranca'] = X.apply(f_seguranca, axis=1)\n",
    "\n",
    "# Remoção das variáveis redundantes\n",
    "X.drop(['backup_online', 'protecao_dispositivo', 'streaming_TV', 'streaming_filmes'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Balanceamento utilizando Under-Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "\n",
    "balanceador = RandomUnderSampler(random_state=101)\n",
    "\n",
    "X_resampled, y_resampled = balanceador.fit_resample(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testando modelos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serão testados os modelos: Random Forest, AdaBoost, Regressão Logística, Naive Bayes, KNN e Suport Vector Machine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=101)\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "# Função para rodar os modelos\n",
    "def run_modelo(modelo, X, y, cv):\n",
    "    X = scaler.fit_transform(X)\n",
    "    cv_results = cross_validate(modelo, X, y, cv=cv, n_jobs=-1, scoring=['precision', 'recall', 'accuracy'])\n",
    "    acuracia_media = round(cv_results['test_accuracy'].mean(), 3)\n",
    "    precisao_media =  round(cv_results['test_precision'].mean(), 3)\n",
    "    recall_medio = round(cv_results['test_recall'].mean(), 3)\n",
    "    return [acuracia_media, precisao_media, recall_medio]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForest\n",
      "AdaBoost\n",
      "LinearRegression\n",
      "NaiveBayes\n",
      "KNN\n",
      "SVM\n"
     ]
    },
    {
     "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>Acurácia</th>\n",
       "      <th>Precisão</th>\n",
       "      <th>Recall</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomForest</th>\n",
       "      <td>0.746</td>\n",
       "      <td>0.745</td>\n",
       "      <td>0.749</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost</th>\n",
       "      <td>0.766</td>\n",
       "      <td>0.743</td>\n",
       "      <td>0.813</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LinearRegression</th>\n",
       "      <td>0.747</td>\n",
       "      <td>0.742</td>\n",
       "      <td>0.758</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NaiveBayes</th>\n",
       "      <td>0.756</td>\n",
       "      <td>0.746</td>\n",
       "      <td>0.776</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNN</th>\n",
       "      <td>0.715</td>\n",
       "      <td>0.698</td>\n",
       "      <td>0.759</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SVM</th>\n",
       "      <td>0.750</td>\n",
       "      <td>0.739</td>\n",
       "      <td>0.775</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  Acurácia  Precisão  Recall\n",
       "RandomForest         0.746     0.745   0.749\n",
       "AdaBoost             0.766     0.743   0.813\n",
       "LinearRegression     0.747     0.742   0.758\n",
       "NaiveBayes           0.756     0.746   0.776\n",
       "KNN                  0.715     0.698   0.759\n",
       "SVM                  0.750     0.739   0.775"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "rfc = RandomForestClassifier(random_state=101, n_jobs=-1)\n",
    "adc = AdaBoostClassifier(random_state=101)\n",
    "lr = LogisticRegression(random_state=101)\n",
    "gnb = GaussianNB()\n",
    "knn = KNeighborsClassifier(n_jobs=-1)\n",
    "svc = SVC(random_state=101)\n",
    "\n",
    "modelos = [rfc, adc, lr, gnb, knn, svc]\n",
    "nome_modelos = ['RandomForest', 'AdaBoost', 'LinearRegression', 'NaiveBayes', 'KNN', 'SVM']\n",
    "resultados = []\n",
    "\n",
    "for i, modelo in enumerate(modelos):\n",
    "    print(nome_modelos[i])\n",
    "    resultados.append(run_modelo(modelo, X_resampled, y_resampled, skf))\n",
    "\n",
    "resultados = pd.DataFrame(resultados, index=nome_modelos, columns=['Acurácia', 'Precisão', 'Recall'])\n",
    "resultados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "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>Acurácia</th>\n",
       "      <th>Precisão</th>\n",
       "      <th>Recall</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AdaBoost</th>\n",
       "      <td>0.766</td>\n",
       "      <td>0.743</td>\n",
       "      <td>0.813</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NaiveBayes</th>\n",
       "      <td>0.756</td>\n",
       "      <td>0.746</td>\n",
       "      <td>0.776</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SVM</th>\n",
       "      <td>0.750</td>\n",
       "      <td>0.739</td>\n",
       "      <td>0.775</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LinearRegression</th>\n",
       "      <td>0.747</td>\n",
       "      <td>0.742</td>\n",
       "      <td>0.758</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomForest</th>\n",
       "      <td>0.746</td>\n",
       "      <td>0.745</td>\n",
       "      <td>0.749</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNN</th>\n",
       "      <td>0.715</td>\n",
       "      <td>0.698</td>\n",
       "      <td>0.759</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  Acurácia  Precisão  Recall\n",
       "AdaBoost             0.766     0.743   0.813\n",
       "NaiveBayes           0.756     0.746   0.776\n",
       "SVM                  0.750     0.739   0.775\n",
       "LinearRegression     0.747     0.742   0.758\n",
       "RandomForest         0.746     0.745   0.749\n",
       "KNN                  0.715     0.698   0.759"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultados.sort_values(by=['Acurácia', 'Recall', 'Precisão'], ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Melhor modelo é portanto o: AdaBoost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otimizando o modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=StratifiedKFold(n_splits=10, random_state=101, shuffle=True),\n",
       "             estimator=AdaBoostClassifier(random_state=101),\n",
       "             param_grid={'learning_rate': [0.25, 0.5, 0.75, 1.0, 1.25],\n",
       "                         'n_estimators': [50, 100, 150, 200, 250]})"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "parametros = {\n",
    "    'n_estimators': [50, 100, 150, 200, 250],\n",
    "    'learning_rate': [.25, .5, .75, 1., 1.25],\n",
    "}\n",
    "\n",
    "busca_parametros = GridSearchCV(\n",
    "    estimator = adc,\n",
    "    param_grid = parametros,\n",
    "    cv = skf\n",
    ")\n",
    "\n",
    "busca_parametros.fit(X_resampled, y_resampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AdaBoostClassifier(learning_rate=0.25, n_estimators=150, random_state=101)"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "busca_parametros.best_estimator_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acurácia | Precisão | Recall\n",
      "[0.766, 0.742, 0.816]\n"
     ]
    }
   ],
   "source": [
    "adc_best = AdaBoostClassifier(learning_rate=0.25, n_estimators=150, random_state=101)\n",
    "print('Acurácia | Precisão | Recall')\n",
    "print(run_modelo(adc_best, X_resampled, y_resampled, skf))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Acurácia    0.766\n",
       "Precisão    0.743\n",
       "Recall      0.813\n",
       "Name: AdaBoost, dtype: float64"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultados.loc['AdaBoost']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Devido a limitações de hardware não foi possível testar mais configurações para otimizar o modelo. Porém vê-se que houve uma pequena melhora no valor de recall."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Teste de outras configurações de balanceamento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modelo sem balanceamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.803, 0.665, 0.52]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_modelo(adc_best, X, y, skf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste caso a alta acurácia é deve-se apenas ao fato do desbalanceamento do modelo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utilizando over sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.767, 0.743, 0.818]"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from imblearn.over_sampling import RandomOverSampler\n",
    "\n",
    "ros = RandomOverSampler(random_state=101)\n",
    "X_oversampling, y_oversampling = ros.fit_resample(X, y)\n",
    "run_modelo(adc_best, X_oversampling, y_oversampling, skf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizando o a técnica de oversampling obte-ve resultado semelhante ao caso de undersampling."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusões"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A análise exploratória dos dados permitiu a redução de dimensionalidade e consequente a complexidade do mmodelo. Utilizando-se a técnica de undersampling consegui equilibrar as classes, assim diminuiu-se a probabilidade do modelo tornar-se tendencioso para uma determinada classe. Todos os modelos testador obtiveram resultados próximos de acurácia, apenas o KNN ficou mais distante dos demais. O modelo de AdaBoost destacouse por ser o de melhor desempenho tanto em recall (0,813) e Acurácia (0,766). Após aplicar-se técnicas de otimização pode-se obter um pequeno incremento no recall do AdaBoost (0,816). Talvez possa-se ter um incremento maior na performance do modelo mas limitações de hardware não permitiram testar esta hípotese. Ao utilizar os dados sem realizar técnica de balanceamento a acurácia foi bem elevada (0,803), porém, este resultado alto deve ao próprio desbalanceamento dos dados que faz o modelo tender a jogar mais valores para a classe dominante. Com a técnica de OverSampling, neste caso, foram obtidos resultados próximos aos do uso de Undersampling. Contudo, a técncia de oversampling deve ser utilizada com cuidado pois, quando o desbalanceamento entre as classes é muito grande, a quantidade de valores sintéticos pode comprometer as análises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f8982e1f4ab427bb87d5be74831db1f094ba5a856f389ce2aee8b2f4fb023e4a"
  },
  "kernelspec": {
   "display_name": "Python 3.8.10 ('base')",
   "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.8.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}