03_Aprendizado_Random_Forest_Nota.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4bc2f4c6",
   "metadata": {
    "run_control": {
     "marked": true
    }
   },
   "outputs": [],
   "source": [
    "# Python versão 3.8.8\n",
    "# Windows 10\n",
    "\n",
    "# biblioteca para interação com o sistema\n",
    "import os\n",
    "import shutil\n",
    "\n",
    "# biblioteca para manipulação de dados\n",
    "import pandas as pd # versão 1.3.2\n",
    "import numpy as np # versão 1.20.1\n",
    "\n",
    "# biblioteca para manipulação de banco de dados sqlite\n",
    "import sqlite3 # versão 2.6.0\n",
    "from sqlite3 import Error\n",
    "\n",
    "import researchpy as rp\n",
    "\n",
    "# biblioteca para visualização\n",
    "import plotly.express as px # versão 5.3.1\n",
    "import seaborn as sns # versão 0.11.1\n",
    "\n",
    "import plotly.express as px\n",
    "import plotly.figure_factory as ff\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore', category=UserWarning, module='openpyxl')\n",
    "\n",
    "import matplotlib.pyplot as plt  # versão 3.3.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a53e8153",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import rcParams\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier # Importa o classificador de árvore de decisão\n",
    "from sklearn import metrics #Importa métrica para calcular acurácia - módulo do scikit-learn\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import export_graphviz\n",
    "from sklearn.model_selection import KFold  \n",
    "from IPython.display import Image  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4b87b7c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#bibliotecas necessárias\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from math import sqrt\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error,mean_absolute_error\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "from sklearn import metrics "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "651c2677",
   "metadata": {},
   "outputs": [],
   "source": [
    "from category_encoders import TargetEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f87b6ed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Endereço do diretório onde se encontra o script python\n",
    "diretorio_atual = os.path.dirname(os.path.realpath('__file__')) + \"\\\\\"\n",
    "\n",
    "# Nome do Banco de Dados de onde serão importadas as tabelas\n",
    "nome_bd = \"Enade_DW.sqlite\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b3ed0433",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nova_conexao(path, nome_bd):\n",
    "\n",
    "    conec_bd = None\n",
    "    try:\n",
    "        conec_bd = sqlite3.connect(path + nome_bd)\n",
    "\n",
    "    except Error as erro:\n",
    "        print(erro)\n",
    "        return 0\n",
    "    \n",
    "    finally:\n",
    "        if conec_bd:\n",
    "            conec_bd.close()\n",
    "    return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2c05ce39",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Definindo função para plotar grafico de comparação\n",
    "def grafico(previsto,real,nome):\n",
    "    previsto = np.array(previsto)\n",
    "    real = np.array(real)\n",
    "    \n",
    "    mape = mean_absolute_error(real,previsto)\n",
    "    \n",
    "    y1 = previsto[:50]\n",
    "    x1 = range(len(y1))\n",
    "    y2 = real[:50]\n",
    "    x2 = range(len(y2))\n",
    "    \n",
    "\n",
    "    plt.title('Gráfico de Predições:'+nome)\n",
    "    plt.xlabel('mape: '+str(mape))\n",
    "    plt.ylabel('Valores')\n",
    "\n",
    "    plt.plot(x1,y1,color='#D90286',linestyle='--',label='Predita')\n",
    "    plt.plot(x2,y2,color='#0864AD',linestyle='-.', label = 'Esperada')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "becf8a5b",
   "metadata": {
    "run_control": {
     "marked": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conexão ao banco 'Enade_DW.sqlite' criada com sucesso.\n",
      "\n",
      "------------------------------------------------------------------------------------------\n",
      "Tabelas importadas com Sucesso.DadosEnade_DW.sqlite...\n",
      "                     \n",
      "------------------------------------------------------------------------------------------\n",
      "Conexão ao banco 'Enade_DW.sqlite' encerrada com sucesso.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Ininia a Conexão\n",
    "if (nova_conexao(diretorio_atual,  nome_bd)):\n",
    "    conec_bd = sqlite3.connect(diretorio_atual + nome_bd)\n",
    "    cursor = conec_bd.cursor()\n",
    "    print(\"Conexão ao banco '{}' criada com sucesso.\\n\".format(nome_bd))\n",
    "    print(\"-\" * 90)\n",
    "    conec_bd.commit()\n",
    "\n",
    "# Importa tabelas do Banco de Dados\n",
    "print(f\"Importando tabelas do Banco de Dados{nome_bd}...\", end=\"\\r\", flush=True)\n",
    "\n",
    "dim_aluno_econ = pd.read_sql_query('SELECT * FROM DIM_ALUNO_ECON ', conec_bd, index_col ='ID_ALUNO_ECONOMICO')\n",
    "dim_curso = pd.read_sql_query('SELECT * FROM DIM_CURSO ', conec_bd, index_col ='ID_CURSO')\n",
    "dim_ensino_medio = pd.read_sql_query('SELECT * FROM DIM_ENSINO_MEDIO ', conec_bd, index_col ='ID_ALUNO_ENSINO_MEDIO')\n",
    "dim_formacao_familiares = pd.read_sql_query('SELECT * FROM DIM_FORMACAO_FAMILIARES ', conec_bd, index_col ='ID_FORMACAO_FAMILIA')\n",
    "dim_ies = pd.read_sql_query('SELECT * FROM DIM_IES ', conec_bd, index_col ='ID_IES_ANO')\n",
    "dim_info_aluno = pd.read_sql_query('SELECT * FROM DIM_INFO_ALUNO ', conec_bd, index_col ='ID_ALUNO_INFO')\n",
    "dim_oportunidades = pd.read_sql_query('SELECT * FROM DIM_OPORTUNIDADES ', conec_bd, index_col ='ID_OPORTUNIDADES')\n",
    "dim_percepcao_prova = pd.read_sql_query('SELECT * FROM DIM_PERCEPCAO_PROVA ', conec_bd, index_col ='ID_PERCEPCAO_PROVA')\n",
    "dim_presenca = pd.read_sql_query('SELECT * FROM DIM_PRESENCA ', conec_bd, index_col ='ID_PRESENCA')\n",
    "dim_regiao = pd.read_sql_query('SELECT * FROM DIM_REGIAO ', conec_bd, index_col ='CO_MUNIC_CURSO')\n",
    "dim_tempo = pd.read_sql_query('SELECT * FROM DIM_TEMPO ', conec_bd, index_col ='ID_TEMPO')\n",
    "fato_prova = pd.read_sql_query('SELECT * FROM FATO_PROVA ', conec_bd, index_col ='ID_PROVA')\n",
    "\n",
    "print(f\"Tabelas importadas com Sucesso.\\n                     \")\n",
    "print(\"-\" * 90)\n",
    "\n",
    "# Encerra a Conexão\n",
    "conec_bd.close()\n",
    "print(f\"Conexão ao banco '{nome_bd}' encerrada com sucesso.\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "57bbe41e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# União de todas as dimensões com a Tabela Fato\n",
    "df_completo = fato_prova.merge(dim_info_aluno, how = \"left\", left_on = \"ID_ALUNO_INFO\" , right_index = True)\n",
    "\n",
    "df_completo = df_completo.merge(dim_aluno_econ, how = 'left', left_on = 'ID_ALUNO_ECONOMICO' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_curso, how = 'left', left_on = 'ID_CURSO' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_ensino_medio, how = 'left', left_on = 'ID_ALUNO_ENSINO_MEDIO' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_formacao_familiares, how = 'left', left_on = 'ID_FORMACAO_FAMILIA' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_ies, how = 'left', left_on = 'ID_IES_ANO' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_oportunidades, how = 'left', left_on = 'ID_OPORTUNIDADES' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_percepcao_prova, how = 'left', left_on = 'ID_PERCEPCAO_PROVA' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_presenca, how = 'left', left_on = 'ID_PRESENCA' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_regiao, how = 'left', left_on = 'CO_MUNIC_CURSO' , right_index = True)\n",
    "df_completo = df_completo.merge(dim_tempo, how = 'left', left_on = 'ID_TEMPO' , right_index = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "215189a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remoção das colunas Chaves\n",
    "df_completo = df_completo.drop(['ID_ALUNO_ECONOMICO',\n",
    "                                'ID_CURSO',\n",
    "                                'ID_ALUNO_ENSINO_MEDIO',\n",
    "                                'ID_FORMACAO_FAMILIA',\n",
    "                                'ID_IES_ANO',\n",
    "                                'ID_ALUNO_INFO',\n",
    "                                'ID_OPORTUNIDADES',\n",
    "                                'ID_PERCEPCAO_PROVA',\n",
    "                                'ID_PRESENCA',\n",
    "                                'CO_MUNIC_CURSO',\n",
    "                                'ID_TEMPO'], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "61414e3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1291771, 42)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_completo.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cd4a3a8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo_backup = df_completo.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d88bbcb",
   "metadata": {},
   "source": [
    "# Modelos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c910acba",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "76d73648",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo = df_completo_backup.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "194bba7c",
   "metadata": {},
   "source": [
    "### Tempo de Prova"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53e6abac",
   "metadata": {},
   "outputs": [],
   "source": [
    "dicionario_resposta = {'Não respondeu ' : 1.5,\n",
    "                         \"Resposta anulada\": 2}\n",
    "\n",
    "df_completo = df_completo.replace({\"TEMPO_GASTO_PROVA\": dicionario_resposta})\n",
    "df_completo.TEMPO_GASTO_PROVA = df_completo.TEMPO_GASTO_PROVA.astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9256c5f3",
   "metadata": {},
   "source": [
    "### Horas de Trabalho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "958b056d",
   "metadata": {},
   "outputs": [],
   "source": [
    "dicionario_resposta = {'Trabalho 40 horas semanais ou mais.' : 40,\n",
    "                       'Trabalho até 20 horas semanais.': 20,\n",
    "                       'Não estou trabalhando.': 0,\n",
    "                       'Trabalho de 21 a 39 horas semanais.': 30,\n",
    "                       'Trabalho eventualmente.': 5\n",
    "                      }\n",
    "\n",
    "df_completo = df_completo.replace({\"HORAS_TRABALHO\": dicionario_resposta})\n",
    "df_completo.HORAS_TRABALHO = df_completo.HORAS_TRABALHO.astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9a9252",
   "metadata": {},
   "source": [
    "### Avaliacao CE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d226f493",
   "metadata": {},
   "outputs": [],
   "source": [
    "dicionario_resposta = {'Resposta anulada': 0,\n",
    "                       'Muito difícil': 0,\n",
    "                       'Difícil': 3,\n",
    "                       'Não respondeu ': 2,\n",
    "                       'Médio': 5,\n",
    "                       'Fácil': 6,\n",
    "                       'Muito fácil': 1\n",
    "                      }\n",
    "\n",
    "df_completo = df_completo.replace({\"GRAU_DIFICULDADE_CE\": dicionario_resposta})\n",
    "df_completo.GRAU_DIFICULDADE_CE = df_completo.GRAU_DIFICULDADE_CE.astype(float)\n",
    "\n",
    "df_completo = df_completo.replace({\"GRAU_DIFICULDADE_FG\": dicionario_resposta})\n",
    "df_completo.GRAU_DIFICULDADE_FG = df_completo.GRAU_DIFICULDADE_FG.astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6d5d9fe",
   "metadata": {},
   "source": [
    "### Moram Junto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6d127256",
   "metadata": {},
   "outputs": [],
   "source": [
    "dicionario_resposta = {'Nenhuma': 0,\n",
    "                       'Uma': 1,\n",
    "                       'Duas': 2,\n",
    "                       'Três': 3,\n",
    "                       'Quatro': 4,\n",
    "                       'Cinco': 5,\n",
    "                       'Seis': 6,\n",
    "                       'Sete ou mais': 9\n",
    "                      }\n",
    "\n",
    "df_completo = df_completo.replace({\"PESSOAS_MORAM_JUNTO\": dicionario_resposta})\n",
    "df_completo.PESSOAS_MORAM_JUNTO = df_completo.PESSOAS_MORAM_JUNTO.astype(float)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60473e04",
   "metadata": {},
   "source": [
    "### Renda Familiar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "06da976a",
   "metadata": {},
   "outputs": [],
   "source": [
    "dicionario_resposta = {'Até 1,5 salário mínimo': 0.8,\n",
    "                       'De 1,5 a 3 salários mínimos': 2,\n",
    "                       'De 3 a 4,5 salários mínimos': 3.5,\n",
    "                       'De 4,5 a 6 salários mínimos': 5,\n",
    "                       'De 6 a 10 salários mínimos': 7.5,\n",
    "                       'De 10 a 30 salários mínimos': 20,\n",
    "                       'Acima de 30 salários mínimos': 35\n",
    "                      }\n",
    "\n",
    "\n",
    "df_completo = df_completo.replace({\"RENDA_FAMILIAR\": dicionario_resposta})\n",
    "df_completo.RENDA_FAMILIAR = df_completo.RENDA_FAMILIAR.astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a6800af",
   "metadata": {},
   "source": [
    "### Renda Familiar Per Capita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "bc05c8a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo[\"RENDA_PER_CAPITA\"] = df_completo.RENDA_FAMILIAR/(df_completo.PESSOAS_MORAM_JUNTO +1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b13ffcee",
   "metadata": {},
   "source": [
    "### Familiar Graduado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "23625f6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo['FAMILIAR_GRADUADO'] = np.where(df_completo['FAMILIAR_GRADUADO'] == 'Sim', 1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa6fe4f2",
   "metadata": {},
   "source": [
    "### Modalidade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "625247f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo['MODALIDADE_CURSO'] = np.where(df_completo['MODALIDADE_CURSO'] == 'Educação Presencial', 1, 0)\n",
    "\n",
    "df_completo.MODALIDADE_CURSO = df_completo.MODALIDADE_CURSO.astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb91021d",
   "metadata": {},
   "source": [
    "### Naturalidade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "53bbd378",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo['NACIONALIDADE'] = np.where(df_completo['NACIONALIDADE'] == 'Brasileira', 1, 0)\n",
    "\n",
    "df_completo.NACIONALIDADE = df_completo.NACIONALIDADE.astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acf7b118",
   "metadata": {},
   "source": [
    "### Colunas Categóricas Restantes - Mean Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f5f82f29",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Enconding da coluna TP_SEXO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['TP_SEXO'] = encoder.fit_transform(df_completo['TP_SEXO'], df_completo['NT_GER'])\n",
    "df_completo['TP_SEXO'] = encoder.fit_transform(df_completo['TP_SEXO'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ESTADO_CIVIL\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ESTADO_CIVIL'] = encoder.fit_transform(df_completo['ESTADO_CIVIL'], df_completo['NT_GER'])\n",
    "df_completo['ESTADO_CIVIL'] = encoder.fit_transform(df_completo['ESTADO_CIVIL'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna RAÇA\n",
    "encoder = TargetEncoder()\n",
    "df_completo['RAÇA'] = encoder.fit_transform(df_completo['RAÇA'], df_completo['NT_GER'])\n",
    "df_completo['RAÇA'] = encoder.fit_transform(df_completo['RAÇA'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna AUXILIO_RECEBIDO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['AUXILIO_RECEBIDO'] = encoder.fit_transform(df_completo['AUXILIO_RECEBIDO'], df_completo['NT_GER'])\n",
    "df_completo['AUXILIO_RECEBIDO'] = encoder.fit_transform(df_completo['AUXILIO_RECEBIDO'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ENTROU_POR_COTA\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ENTROU_POR_COTA'] = encoder.fit_transform(df_completo['ENTROU_POR_COTA'], df_completo['NT_GER'])\n",
    "df_completo['ENTROU_POR_COTA'] = encoder.fit_transform(df_completo['ENTROU_POR_COTA'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna GRUPO_CURSO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['GRUPO_CURSO'] = encoder.fit_transform(df_completo['GRUPO_CURSO'], df_completo['NT_GER'])\n",
    "df_completo['GRUPO_CURSO'] = encoder.fit_transform(df_completo['GRUPO_CURSO'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna TIPO_ESCOLA_EM\n",
    "encoder = TargetEncoder()\n",
    "df_completo['TIPO_ESCOLA_EM'] = encoder.fit_transform(df_completo['TIPO_ESCOLA_EM'], df_completo['NT_GER'])\n",
    "df_completo['TIPO_ESCOLA_EM'] = encoder.fit_transform(df_completo['TIPO_ESCOLA_EM'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna MODALIDADE_EM\n",
    "encoder = TargetEncoder()\n",
    "df_completo['MODALIDADE_EM'] = encoder.fit_transform(df_completo['MODALIDADE_EM'], df_completo['NT_GER'])\n",
    "df_completo['MODALIDADE_EM'] = encoder.fit_transform(df_completo['MODALIDADE_EM'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ESCOLARIZACAO_PAI\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ESCOLARIZACAO_PAI'] = encoder.fit_transform(df_completo['ESCOLARIZACAO_PAI'], df_completo['NT_GER'])\n",
    "df_completo['ESCOLARIZACAO_PAI'] = encoder.fit_transform(df_completo['ESCOLARIZACAO_PAI'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ESCOLARIZACAO_MAE\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ESCOLARIZACAO_MAE'] = encoder.fit_transform(df_completo['ESCOLARIZACAO_MAE'], df_completo['NT_GER'])\n",
    "df_completo['ESCOLARIZACAO_MAE'] = encoder.fit_transform(df_completo['ESCOLARIZACAO_MAE'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna NOME_IES\n",
    "encoder = TargetEncoder()\n",
    "df_completo['NOME_IES'] = encoder.fit_transform(df_completo['NOME_IES'], df_completo['NT_GER'])\n",
    "df_completo['NOME_IES'] = encoder.fit_transform(df_completo['NOME_IES'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna CATEGORIA_IES\n",
    "encoder = TargetEncoder()\n",
    "df_completo['CATEGORIA_IES'] = encoder.fit_transform(df_completo['CATEGORIA_IES'], df_completo['NT_GER'])\n",
    "df_completo['CATEGORIA_IES'] = encoder.fit_transform(df_completo['CATEGORIA_IES'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ORGANIZACAO_IES\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ORGANIZACAO_IES'] = encoder.fit_transform(df_completo['ORGANIZACAO_IES'], df_completo['NT_GER'])\n",
    "df_completo['ORGANIZACAO_IES'] = encoder.fit_transform(df_completo['ORGANIZACAO_IES'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ATIVIDADES_CURRICURALES_EXTERIOR\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ATIVIDADES_CURRICURALES_EXTERIOR'] = encoder.fit_transform(df_completo['ATIVIDADES_CURRICURALES_EXTERIOR'], df_completo['NT_GER'])\n",
    "df_completo['ATIVIDADES_CURRICURALES_EXTERIOR'] = encoder.fit_transform(df_completo['ATIVIDADES_CURRICURALES_EXTERIOR'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna IDIOMA_ESTRANGEIRO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['IDIOMA_ESTRANGEIRO'] = encoder.fit_transform(df_completo['IDIOMA_ESTRANGEIRO'], df_completo['NT_GER'])\n",
    "df_completo['IDIOMA_ESTRANGEIRO'] = encoder.fit_transform(df_completo['IDIOMA_ESTRANGEIRO'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna EXTENSAO_UNIVERSITARIA\n",
    "encoder = TargetEncoder()\n",
    "df_completo['EXTENSAO_UNIVERSITARIA'] = encoder.fit_transform(df_completo['EXTENSAO_UNIVERSITARIA'], df_completo['NT_GER'])\n",
    "df_completo['EXTENSAO_UNIVERSITARIA'] = encoder.fit_transform(df_completo['EXTENSAO_UNIVERSITARIA'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna ATIVIDADES_INVESTIGACAO_ACADEMICA\n",
    "encoder = TargetEncoder()\n",
    "df_completo['ATIVIDADES_INVESTIGACAO_ACADEMICA'] = encoder.fit_transform(df_completo['ATIVIDADES_INVESTIGACAO_ACADEMICA'], df_completo['NT_GER'])\n",
    "df_completo['ATIVIDADES_INVESTIGACAO_ACADEMICA'] = encoder.fit_transform(df_completo['ATIVIDADES_INVESTIGACAO_ACADEMICA'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna INTERCAMBIO_ESTAGIO_PAIS\n",
    "encoder = TargetEncoder()\n",
    "df_completo['INTERCAMBIO_ESTAGIO_PAIS'] = encoder.fit_transform(df_completo['INTERCAMBIO_ESTAGIO_PAIS'], df_completo['NT_GER'])\n",
    "df_completo['INTERCAMBIO_ESTAGIO_PAIS'] = encoder.fit_transform(df_completo['INTERCAMBIO_ESTAGIO_PAIS'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna INTERCAMBIO_ESTAGIO_FORA_DO_PAIS\n",
    "encoder = TargetEncoder()\n",
    "df_completo['INTERCAMBIO_ESTAGIO_FORA_DO_PAIS'] = encoder.fit_transform(df_completo['INTERCAMBIO_ESTAGIO_FORA_DO_PAIS'], df_completo['NT_GER'])\n",
    "df_completo['INTERCAMBIO_ESTAGIO_FORA_DO_PAIS'] = encoder.fit_transform(df_completo['INTERCAMBIO_ESTAGIO_FORA_DO_PAIS'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna PERCEPCAO_ESTUDO_CONTEUDO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['PERCEPCAO_ESTUDO_CONTEUDO'] = encoder.fit_transform(df_completo['PERCEPCAO_ESTUDO_CONTEUDO'], df_completo['NT_GER'])\n",
    "df_completo['PERCEPCAO_ESTUDO_CONTEUDO'] = encoder.fit_transform(df_completo['PERCEPCAO_ESTUDO_CONTEUDO'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna NOME_MUNICIPIO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['NOME_MUNICIPIO'] = encoder.fit_transform(df_completo['NOME_MUNICIPIO'], df_completo['NT_GER'])\n",
    "df_completo['NOME_MUNICIPIO'] = encoder.fit_transform(df_completo['NOME_MUNICIPIO'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna UF\n",
    "encoder = TargetEncoder()\n",
    "df_completo['UF'] = encoder.fit_transform(df_completo['UF'], df_completo['NT_GER'])\n",
    "df_completo['UF'] = encoder.fit_transform(df_completo['UF'], df_completo['NT_GER'])\n",
    "\n",
    "# Enconding da coluna REGIAO_CURSO\n",
    "encoder = TargetEncoder()\n",
    "df_completo['REGIAO_CURSO'] = encoder.fit_transform(df_completo['REGIAO_CURSO'], df_completo['NT_GER'])\n",
    "df_completo['REGIAO_CURSO'] = encoder.fit_transform(df_completo['REGIAO_CURSO'], df_completo['NT_GER'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c187ca1",
   "metadata": {},
   "source": [
    "### NOTA MAIOR QUE A NOTA MÉDIA DO ANO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "92f92abd",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_completo['NOTA_MEDIA_ANO'] = df_completo.groupby(['ANO'])['NT_GER'].transform('mean')\n",
    "df_completo[\"MAIOR_QUE_NOTA_MEDIA_ANO\"] = df_completo['NT_GER'] > df_completo['NOTA_MEDIA_ANO']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4974f978",
   "metadata": {},
   "source": [
    "## Modelo - Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e62859b6",
   "metadata": {
    "run_control": {
     "marked": true
    }
   },
   "outputs": [],
   "source": [
    "dataset_modelo = df_completo.select_dtypes(include=[\"number\",\"bool_\"]).drop(['NT_FG', 'NT_CE', 'NT_GER',\n",
    "                                                                             'PESSOAS_MORAM_JUNTO', 'RENDA_FAMILIAR', \n",
    "                                                                             'NOTA_MEDIA_ANO'], axis = 1).copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "84b8b18d",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = dataset_modelo[\"MAIOR_QUE_NOTA_MEDIA_ANO\"]\n",
    "dataset_modelo = dataset_modelo.drop(\"MAIOR_QUE_NOTA_MEDIA_ANO\", \n",
    "                                     axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "89c0a3e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Acurácia do modelo é de: 0.6946151821517595\n",
      "A Precisão do modelo é de: 0.6983859020516442\n"
     ]
    }
   ],
   "source": [
    "#split de dados\n",
    "x_treino, x_teste, y_treino, y_teste = train_test_split(dataset_modelo, y, test_size  = 0.1, shuffle = True)\n",
    "\n",
    "rfc = RandomForestClassifier(n_estimators = 5, random_state=0, criterion = \"entropy\", max_depth = 11)\n",
    "rfc.fit(x_treino, y_treino)\n",
    "\n",
    "\n",
    "y_pred = rfc.predict(x_teste)\n",
    "\n",
    "acuracia = metrics.accuracy_score(y_teste, y_pred)\n",
    "print(f\"A Acurácia do modelo é de: {acuracia}\")\n",
    "\n",
    "precisao = metrics.precision_score(y_teste, y_pred)\n",
    "print(f\"A Precisão do modelo é de: {precisao}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "aff48053",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tmp = pd.DataFrame({'Feature': dataset_modelo.columns.to_list(), \n",
    "                    'Importância da feature': rfc.feature_importances_})\n",
    "\n",
    "tmp = tmp.sort_values(by='Importância da feature',ascending=False)\n",
    "plt.figure(figsize = (7,4))\n",
    "plt.title('Importância da feature - Random Forest',fontsize=14)\n",
    "s = sns.barplot(x='Feature',y='Importância da feature',data=tmp)\n",
    "s.set_xticklabels(s.get_xticklabels(),rotation=90)\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e8cd0163",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAEGCAYAAAAg6I3HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmwUlEQVR4nO3deZgdVb3u8e/bnc48kIkQkjBJABkkDCKTyCQE5AqcB45REe6FI4OAehQOw8NFkAtHjiIIMsgkkzLKJAhhlkEgBAyEMEYTkpBAyEjmdO/+3T9qddhpunfvmK7e6e738zz1dO1Va1Wt2p3+ZdWqVasUEZiZWeurqnQFzMw6KgdYM7OcOMCameXEAdbMLCcOsGZmOelS6QrkYdCA6thkRE2lq2Fr4L03ela6CraGFjF/TkQMXpt9HLhPr5g7r1BW3lffWDE2IkavzfHaWocMsJuMqGHc2BGVroatgQM3HFXpKtgaeiLu+WBt9zF3XoFxYzcqK2/10PcHre3x2lqHDLBm1j4EUE99pauRGwdYM6uYIKiN8roI2iMHWDOrKLdgzcxyEASFDvy4vgOsmVVUPQ6wZmatLoCCA6yZWT7cgjUzy0EAte6DNTNrfUG4i8DMLBcBhY4bXx1gzaxysie5Oi4HWDOrIFFAla5EbhxgzaxisptcDrBmZq0uGwfrAGtmlot6t2DNzFqfW7BmZjkJRKEDv7nKAdbMKspdBGZmOQjEyqiudDVy4wBrZhWTPWjgLgIzs1z4JpeZWQ4iRCHcgjUzy0W9W7BmZq0vu8nVccNQx22bm9k6r+EmVzlLOSRVS/q7pIfS5/MkfShpQloOLsp7lqTJkt6VdGBR+k6SJqZtl0tSSu8m6c6U/rKkTVqqjwOsmVVUIVTWUqYfAW83Srs0Ikal5S8AkrYGxgDbAKOBqyQ1jBe7GjgeGJmW0Sn9OGB+RGwOXApc3FJlHGDNrGIanuQqZ2mJpOHAN4Dryzj0ocAdEbEiIqYAk4FdJA0F+kbEixERwC3AYUVlbk7r9wD7NbRum+MAa2YVVR9VZS3AIEnji5bjG+3qMuC/+Pwc3qdIekPSjZL6p7RhwPSiPDNS2rC03jh9tTIRUQcsBAaWOjcHWDOrmGyyl7JbsHMiYuei5dqG/Ug6BJgdEa82OsTVwBeAUcAs4JKGIs1Up7n0UmWa1XFv35nZOi8Qta3zqOwewDfTTazuQF9Jt0XEUQ0ZJF0HPJQ+zgBGFJUfDsxM6cObSC8uM0NSF6AfMK9UpdyCNbOKiYBCVJW1lN5PnBURwyNiE7KbV09FxFGpT7XB4cCbaf1BYEwaGbAp2c2scRExC1gkadfUv3o08EBRmWPS+hHpGG7Bmtm6Snk/aPA/kkaRXcpPBU4AiIhJku4C3gLqgJMjopDKnATcBPQAHkkLwA3ArZImk7Vcx7R0cAdYM6uYgFZ/VDYingGeSevfK5HvQuDCJtLHA9s2kb4cOHJN6uIAa2YV5Qm3zcxyEMgTbpuZ5SF7bXfHDUMd98zMrB2Q54M1M8tDQMNTWh2SA6yZVZRbsGZmOYiQW7BmZnnIbnL5rbJmZjnwO7nMzHKR3eRyH6yZWS78JJeZWQ78JJeZWY7KfaFhe+QAa2YVEwG19Q6wZmatLusicIA1M8uFn+SyVlcowKmjt2Dg0FouuGUK/5jUnSvOHMGyJVUMGb6SM678gF596vl0XjUXHL8J703oydf/fR6nXPThqn08fd963HHFECQYMKSWM674gH4DC1zzsw15/YU+AKxYLhbMqeHedyZW6lQ7hJ/8ehpf2X8RC+Z04YR9twTg7GumMvwLKwDo1bfAkk+r+cHXt2TI8JVc99d3mPHPbgC882ovLj8ze83T5tst5bTLptOtez3jnurL1f93Q0CsP2wlP/n1dPoNrGPRgmr+59SNmDOra0XOtS15mNa/SFIBKP6rPiwipjaTd3FE9M6rLuui+68fzIiRK1i6OLs8uuy0jfj+uR/ypd2WMPb2Adxz9foc818f0bV7cMzpHzH13e5Mfaf7qvKFOrj63GFc98w79BtY4PoLhvLg7wfzvdM+4sTzZ67K98ANg5j8Zo82P7+O5rE7B/Dg7wdx+m8+e9PzRSdusmr9+HNnsmTRZ5e6sz7oxg++vuXn9vPDX8zgN/81nLdf7cn/u20KO++ziPFP9+X7587kiXv688TdA9h+j0X8n7M+4pc/3CjXc1o3dOwugjzPbFlEjCpapuZ4rHblk5k1jHuyLwd9Z+6qtBn/6MZ2uy4BYIe9FvH8w+sB0L1nPdt+ZQldu63+brUIIMTyZVVEwJLF1QzcoPZzx3r6/v7sfdj83M6ls3jz5d4smt9ceyTY65sLePr+/iX3MWD9Wnr2qeftV3sB4ol7+rP76IUAbLzFciY8n7UxXn+hN7sduLAVa79uq0/v5WppaY/a7L8OSb0lPSnpNUkTJR3aRJ6hkp6VNEHSm5K+mtIPkPRiKnu3pHbd2r3mZ8P4j3NmoqJvf+Mtl/Pi2L4APPfQenwys6bkPrrUwKm/mM6J+27Fd3bYhmnvdefAb89dLc/HM2r4eHpXRu25uNXPwT6z7VeWMP+TLsyc0m1V2gYbreTKx97ll3+azLa7ZN//wA1qmTPrs9/rnJk1DEr/Kf7zrR7seXAWVPc4aCG9+tTTp39dG55FZWSjCKrLWtqjPANsjxQoJ0i6D1gOHB4ROwL7AJek1+IW+w4wNiJGAdsDEyQNAs4B9k9lxwM/aXwwScdLGi9p/CdzC403rzNeerwv6w2qY+SXlq2W/pNfT+PPNw3i5AO3YNniKrp0Lfk2YOpq4aFbBnHlY+/yx79PYtMvLuPOK4aslueZ+/uz5zcWUN0+/222G/sctoBn7l9v1ed5s7tw1Je/yMkHbMnvztuQM6+aRs/eBT73r53sLjrAtT/fkO12W8KVj73Ldrst4ZOZNRTq2merbU00PGhQztIe5XmTa1kKlABIqgEukrQXUA8MA4YAHxWVeQW4MeW9PyImSPoasDXwQorHXYEXGx8sIq4FrgXYefvupaNTBb31Si9eeqwvrzy5NStXiKWLqrn4lI0447fT+O87/glk3QUvP9m35H7+MSnrV91wk5UAfO2bC7jzt6sH2L8+sB4nXzQjh7OwBlXVwR4HL+SU0SNXpdWurKJ2ZdZ2mTyxJzOndmXYZiuYM6uGQUM/68YZtGEtcz/K/gTnfVzDBf+xCQDdexbY8+CFLF3UOf5nbK+X/+Voy1EE3wUGAztFRK2kqUD34gwR8WwKwN8ge//4L4H5wOMR8e02rGtujj17FseePQuA1//Wm3uuGcwZv53GgjldWG9QHfX18MffDOGQ780tuZ9BG9Qy7b3uLJhbzXoDC7z2bB9GjFy+avv0yd1YvLALW++8NNfz6ex2/Ooipk/uttod/34DspEA9fVig41WMGzTFXw0rSuLFnRh6eIqttpxCe+81pP9j5jPAzcOAqDvgDoWza8mQow5dTaP3TmgUqfUpjyKoPX0A2an4LoPsHHjDJI2Bj6MiOsk9QJ2JHtv+ZWSNo+IyZJ6AsMj4r02rHvunr5/Pf58U/bHtsdBCzlgzLxV247eZWuWLK6ibqV4cWw/Lrr9H2y8xQq++5OPOO3wkXSpCdYftpLTLpu2qswz9/fna4fOb/Ky1NbcmVd9wJd2W0y/AXXcNv4tbr1kCGNvH8jXDl29ewBgu10Xc/TpH1GoE4V6cfmZw1m0IPtTu+LM4Zx22XS6dq9n/NN9eOWpbDjdl3ZbzLFnzSICJr7cmyvPHtbWp1gxHXkUgSLyuZpuPPQq9aX+GagBJgB7AAdFxNSGvJKOAU4HaoHFwNERMUXSvsDFQMNdhHMi4sHmjr3z9t1j3NgRuZyX5ePADUdVugq2hp6Ie16NiJ3XZh/9t1o/9r3xiLLy3rvH1Wt9vLaWWwu28bjWiJgD7FYqb0TcDNzcxPangC/nUE0zq7DW7CKQVE12I/zDiDhE0gDgTmATYCrw7xExP+U9CzgOKAA/jIixKX0n4CagB/AX4EcREZK6AbcAOwFzgW+1NPy047bNzWyd19AH24qjCH4EvF30+UzgyYgYCTyZPiNpa2AMsA0wGrgqBWeAq4HjgZFpGZ3SjwPmR8TmwKVkV9UlOcCaWUW1VoCVNJzsBvn1RcmH8tlV8c3AYUXpd0TEioiYAkwGdpE0FOgbES9G1n96S6MyDfu6B9iviaGmq/FcBGZWMWs44fYgSeOLPl+bhmc2uAz4L6BPUdqQiJgFEBGzJK2f0ocBLxXlm5HSatN64/SGMtPTvuokLQQGAnOaq7ADrJlV1BqMg53T3E0uSYeQjVJ6VdLeZeyrqYNGifRSZZrlAGtmFRMBda0z4fYewDclHUw2vr6vpNuAjyUNTa3XocDslH8GUDzUaDgwM6UPbyK9uMwMSV3Ihp7OowT3wZpZRbVGH2xEnBURwyNiE7KbV09FxFHAg8AxKdsxwANp/UFgjKRukjYlu5k1LnUnLJK0a+pfPbpRmYZ9HZGO4Rasma2b2uClh78A7pJ0HDANOBIgIiZJugt4C6gDTo6IhklMTuKzYVqPpAXgBrInTCeTtVzHtHRwB1gzq6ho5QAbEc8Az6T1ucB+zeS7kOxJ0cbp44Ftm0hfTgrQ5XKANbOK8mQvZmY5iPBkL2ZmOREFv7bbzCwfrd0Huy5xgDWzivF8sGZmeYn0As8OygHWzCrKowjMzHIQvsllZpYfdxGYmeXEowjMzHIQ4QBrZpYbD9MyM8uJ+2DNzHIQiHqPIjAzy0cHbsA6wJpZBfkml5lZjjpwE9YB1swqqlO2YCVdQYn/WyLih7nUyMw6jQDq6zthgAXGt1ktzKxzCqAztmAj4ubiz5J6RcSS/KtkZp1JRx4H2+IANEm7SXoLeDt93l7SVbnXzMw6hyhzaYfKGeF7GXAgMBcgIl4H9sqxTmbWaYiI8pb2qKxRBBExXVrtBAv5VMfMOp122jotRzkBdrqk3YGQ1BX4Iam7wMxsrQREBx5FUE4XwYnAycAw4ENgVPpsZtYKVObS/rQYYCNiTkR8NyKGRMTgiDgqIua2ReXMrBNohZtckrpLGifpdUmTJJ2f0s+T9KGkCWk5uKjMWZImS3pX0oFF6TtJmpi2Xa7UPyqpm6Q7U/rLkjZp6dTKGUWwmaQ/S/pE0mxJD0jarKVyZmZlaZ1RBCuAfSNie7Kr7NGSdk3bLo2IUWn5C4CkrYExwDbAaOAqSdUp/9XA8cDItIxO6ccB8yNic+BS4OKWKlVOF8EfgbuAocCGwN3A7WWUMzMrreFBg3KWUrvJLE4fa9JSKiwfCtwRESsiYgowGdhF0lCgb0S8GBEB3AIcVlSm4fmAe4D9Glq3zSknwCoibo2IurTc1kLFzczKlr02puUFGCRpfNFyfPF+JFVLmgDMBh6PiJfTplMkvSHpRkn9U9owYHpR8RkpbVhab5y+WpmIqAMWAgNLnVupuQgGpNWnJZ0J3EEWWL8FPFxqp2ZmZSt/FMGciNi5uY0RUQBGSVoPuE/StmSX+xeQxa4LgEuAY2n6rlmUSKeFbU0qNUzr1UYHPKHRTi8otWMzs3Kola+HI2KBpGeA0RHxq1XHka4DHkofZwAjiooNB2am9OFNpBeXmSGpC9APmFeqLs12EUTEphGxWfrZePFNLjNbe+Xe4Gp5FMHg1HJFUg9gf+Cd1Kfa4HDgzbT+IDAmjQzYlOxm1riImAUskrRr6l89GnigqMwxaf0I4KnUT9ussp7kSk3trYHuDWkRcUs5Zc3MmtfyDawyDQVuTiMBqoC7IuIhSbdKGkUWoqeSrsQjYpKku4C3gDrg5NTFAHAScBPQA3gkLQA3ALdKmkzWch3TUqVaDLCSfgbsTRZg/wIcBDxPdnfNzGzttEIXQUS8AezQRPr3SpS5ELiwifTxwLZNpC8HjlyTepUziuAIYD/go4j4P8D2QLc1OYiZWbPqy1zaoXK6CJZFRL2kOkl9yYZAuA/WzNZeZ51wu8j41Hl8HdnIgsXAuDwrZWadR2uPIliXtBhgI+IHafUaSY+SPeXwRr7VMrNOozMGWEk7ltoWEa/lUyUzs46hVAv2khLbAti3levSat5/fwAHHfTtSlfD1kCf5z6pdBVsTe3ZOrvplF0EEbFPW1bEzDqhYE0elW13ynrQwMwsN52xBWtm1hY6ZReBmVmb6MABtpw3GkjSUZLOTZ83krRL/lUzs06hdd5osE4q51HZq4DdgIbb8ouAK3OrkZl1Goryl/aonC6Cr0TEjpL+DhAR89Pru83M1l4nH0VQm6YAC8jmXaTdTr1gZuua9to6LUc5XQSXA/cB60u6kGyqwotyrZWZdR4duA+2nLkI/iDpVbIpCwUcFhFv514zM+v42nH/ajnKmXB7I2Ap8OfitIiYlmfFzKyT6MwBluwNsg0vP+wObAq8C2yTY73MrJNQB76jU04XwXbFn9MsWyc0k93MzJI1fpIrIl6T9OU8KmNmnVBn7iKQ9JOij1XAjoDnljOztdfZb3IBfYrW68j6ZP+UT3XMrNPprAE2PWDQOyJOb6P6mFln0xkDrKQuEVFX6tUxZmZrQ3TeUQTjyPpbJ0h6ELgbWNKwMSLuzbluZtbRdfA+2HIelR0AzCV7B9chwP9KP83M1l4rPCorqbukcZJelzRJ0vkpfYCkxyW9n372LypzlqTJkt6VdGBR+k6SJqZtl0tSSu8m6c6U/rKkTVo6tVIBdv00guBNYGL6OSn9fLOlHZuZlaV15iJYAewbEdsDo4DRknYFzgSejIiRwJPpM5K2BsaQPTA1Grgq3XMCuBo4HhiZltEp/ThgfkRsDlwKXNxSpUoF2Gqgd1r6FK03LGZma6015oONzOL0sSYtARwK3JzSbwYOS+uHAndExIqImAJMBnaRNBToGxEvRkQAtzQq07Cve4D9Glq3zSnVBzsrIn5e+rTMzNZS+X2wgySNL/p8bURc2/AhtUBfBTYHroyIlyUNiYhZABExS9L6Kfsw4KWifc1IabVpvXF6Q5npaV91khYCA4E5zVW4VIDtuLPgmtm6IdZoFMGciNi52V1FFIBRktYD7pO0bYl9NRXfokR6qTLNKtVFsF+pgmZmraKV54ONiAXAM2R9px+ny37Sz9kp2wxgRFGx4cDMlD68ifTVykjqAvQD5pWqS7MBNiJKFjQzaw2t0QcraXBquSKpB7A/8A7wIHBMynYM8EBafxAYk0YGbEp2M2tc6k5YJGnX1L96dKMyDfs6Angq9dM2y6/tNrPKap1xsEOBm1M/bBVwV0Q8JOlF4C5JxwHTgCMBImKSpLuAt8imADg5dTEAnATcBPQAHkkLwA3ArZImk7Vcx7RUKQdYM6ucVnodTES8AezQRPpcmunujIgLgQubSB8PfK7/NiKWkwJ0uRxgzaxiRMd+kssB1swqygHWzCwvDrBmZjlxgDUzy0EHn03LAdbMKssB1swsH511wm0zs9y5i8DMLA+t9KDBusoB1swqywHWzKz1+UkuM7Mcqb7jRlgHWDOrHPfBmpnlx10EZmZ5cYA1M8uHW7BmZnlxgDUzy8GavVW23XGANbOK8ThYM7M8lX4xa7vmAGtmFeUWrLWqQYOWcNppL9O//3Ii4JFHvsADD2zJnntO46ij3mTEiE/58Y8P4P33BwDQpUuBU08dz8iR84gQ11yzAxMnDlltnz/72bNssMESTjrpIABqagr89KcvMXLkfD79tCv//d+7M3t27zY/144kCsHS7y9Ag6ro+T/9iE/rWfazRdR/VKBqg2p6/LwP6lNF/awCS46aT9VG1QBUb1ND99NW/+6XnvkpMbNAr1v6A7DyjmXUPrQcqkHrVdH9rN5UbVDd5ufY5jr4gwZVbXEQSQMlTUjLR5I+LPrctS3qsC4pFKq47rpRnHDCwfznf36dQw6ZzEYbLeSDD/pxwQV78uabg1fLP3r0PwH4wQ8O4uyz9+b735+Aiv7b33336Sxbtvr/lQcc8E8WL+7Kcccdwv33b8mxx76e/4l1cLV3L6dq48++5xW3LaN6pxp63z6A6p1qWHnbslXbqoZV0+v3/en1+/6fC661f12Bemi1tKotqul5/Xr0urk/Xfbuyoqrl+R7MusQ1Ze3tEdtEmAjYm5EjIqIUcA1wKUNnyNipaRO1ZKeP78H//hH1jpdtqyG6dP7MnDgMqZP78eHH/b9XP6NNlrIhAlZi3Xhwu4sWVLDyJHzAOjevZZ/+7d3ueOObVYrs9tuH/LEE5sC8NxzIxg16mM6dFMhZ/WzC9S9uJKaQ7qtSqt7fiU1o7sDUDO6O7XPrWxxP7E0qL1zGV2P7rFaepcdu6LuWdCt3qaG+tntNKL8CxxgcyDpJkm/lvQ0cLGk8ySdVrT9TUmbpPWjJI1LLd7fSeow107rr7+YL3xhPu++O7DZPFOmrMduu31IVVU9Q4YsZvPN5zN48FIAjj56IvfeuxXLl6/+lQwcuIw5c3oCUF9fxdKlNfTt23IAsKatuHwJ3X7Qa7W/mJhfT9WgLKFqUBUx/7MoUD+rwJJj57P0lAXUvV772X6uX0LNmB6rgmlTah9eTpddO8mFXZDd5CpnaYcqFmCTLYD9I+KnzWWQ9EXgW8AeqQVcAL7bRL7jJY2XNH5l3dK86tuqunev5ZxzXuB3v9uBpUtrms03duxmzJnTg8svf4wTTvg7b789iEJBbLbZfDbccDF/+9vwz5VRE3cO2um/0Yqre2El6l9F9ZblXWhpYBW97xlArxv70+3U3iz/+SJiST2F9+uo/7BAzV7dmi1bO3Y5hXfq6PrtHs3m6WgU5S0l9yGNkPS0pLclTZL0o5R+XqMuyYOLypwlabKkdyUdWJS+k6SJadvlkpTSu0m6M6W/3NAALKXSl+Z3R0ShhTz7ATsBr6Tz7AHMbpwpIq4FrgXo13PDdT6UVFfXc845L/D00xvzt7+NKJm3vr6Ka6/dcdXnSy55nJkz+7DddrPZfPN53HTTg1RXB/36reDii5/kjDP2Y86cngwatJQ5c3pSVVVPz561LFrUSVpFrawwsZa6F1ay+KV5sDKIJcGyny9C/auon5O1Yuvn1KP+WXtFXQVd0+X+ll2o2rCK+ukFCm/XUf9ugcVHzoNC1gJeeuoCel6xHgB141ey8tZl9LiiX7aPzqJ1/lrrgJ9GxGuS+gCvSno8bbs0In5VnFnS1sAYYBtgQ+AJSVukeHQ1cDzwEvAXYDTwCHAcMD8iNpc0BriYrPHXrEoH2OKe/DpWb1F3Tz8F3BwRZ7VZrXIX/PjH45g+vS/33bdVi7m7dasDYMWKLuyww0cUClVMm9aPadP68fDDI4Gsq+H885/jjDP2A+Cll4ax//5TeOedQXz1q9N5/fUhZF+lraluJ/ai24m9AKj7+0pW3r6MHuf2YfmVS6h9dDndjupJ7aPL6bJn9h9Y/fx61FeoWtTPLFA/o56qDaup3qqGrodnLdP6WQWWnfHpquBaeK+O5b9cTM9f9aOqf6UvLNtOaz1oEBGzgFlpfZGkt4FhJYocCtwRESuAKZImA7tImgr0jYgXASTdAhxGFmAPBc5L5e8BfitJEc1fG1Y6wBabChwCIGlHYNOU/iTwgKRLI2K2pAFAn4j4oDLVXHvbbDOH/fefypQp/fjtbx8F4Oabv0RNTT0nnfQq/fqt4Pzz/8o//9mfc87Zm379lnPhhX+lvl7MnduDX/1q1xaPMXbsZpx++kvccMNDLFrUlV/8Yve8T6vT6XZUD5adu4jFD8+jav1qelzQB4DC67WsvGEpVANV0P20Xqhv6aC54qolsCxYdu6nAGhINT1/8fkbnh1OxJpMuD1I0viiz9emK9fVpEv3HYCXgT2AUyQdDYwna+XOJwu+LxUVm5HSatN643TSz+lZtaNO0kJgIDCnuQqvSwH2T8DRkiYArwDvAUTEW5LOAR6TVEX2BZwMtNsAO2nSYA46aEyT25rqT509uzff//43Su5z9uzeq8bAAtTWVnPRRXusXUXtc7rs0JUuO2QtVfWroudv+n0uT83e3ajZu/l+VoCqodWrxsAC9Lzs8/vpNMpvwc6JiJ1LZZDUmyyW/DgiPpV0NXBBOsoFwCXAsTR9ORcl0mlhW5PaPMBGxHnNpC8DDmhm253AnTlWy8wqpLWe5JJUQxZc/xAR9wJExMdF268DHkofZwDFNz+GAzNT+vAm0ovLzEhDS/sB80rVqfN09pjZuieA+ihvKSHd6b8BeDsifl2UPrQo2+HAm2n9QWBMGhmwKTASGJf6chdJ2jXt82jggaIyx6T1I4CnSvW/wrrVRWBmnVHrtGD3AL4HTEzdjABnA9+WNCodZSpwAkBETJJ0F/AW2Q32k4tGNJ0E3EQ2YumRtEAWwG9NN8TmkY1CKMkB1swqqpVGETxP032kfylR5kLgwibSxwPbNpG+HDhyTerlAGtmFeXXdpuZ5aGDz6blAGtmFZM9aNBxI6wDrJlVVjudKascDrBmVlFuwZqZ5cF9sGZmeVmjuQjaHQdYM6ssdxGYmeUg2u/rYMrhAGtmleUWrJlZTjpufHWANbPKUn3H7SNwgDWzygn8oIGZWR5E+EEDM7PcOMCameXEAdbMLAfugzUzy49HEZiZ5SLcRWBmlovAAdbMLDcdt4fAAdbMKsvjYM3M8uIAa2aWgwgodNw+AgdYM6sst2DNzHLSgQNsVaUrYGadWAD1Ud5SgqQRkp6W9LakSZJ+lNIHSHpc0vvpZ/+iMmdJmizpXUkHFqXvJGli2na5JKX0bpLuTOkvS9qkpdNzgDWzCgqI+vKW0uqAn0bEF4FdgZMlbQ2cCTwZESOBJ9Nn0rYxwDbAaOAqSdVpX1cDxwMj0zI6pR8HzI+IzYFLgYtbqpQDrJlVTpDd5CpnKbWbiFkR8VpaXwS8DQwDDgVuTtluBg5L64cCd0TEioiYAkwGdpE0FOgbES9GRAC3NCrTsK97gP0aWrfNcYA1s8qKKG+BQZLGFy3HN7W7dOm+A/AyMCQiZmWHiVnA+inbMGB6UbEZKW1YWm+cvlqZiKgDFgIDS52ab3KZWWWVf5NrTkTsXCqDpN7An4AfR8SnJRqYTW2IEumlyjTLLVgzq6AyW69lBGFJNWTB9Q8RcW9K/jhd9pN+zk7pM4ARRcWHAzNT+vAm0lcrI6kL0A+YV6pODrBmVjkB1NeXt5SQ+kJvAN6OiF8XbXoQOCatHwM8UJQ+Jo0M2JTsZta41I2wSNKuaZ9HNyrTsK8jgKdSP22z3EVgZpXVOuNg9wC+B0yUNCGlnQ38ArhL0nHANODI7JAxSdJdwFtkIxBOjohCKncScBPQA3gkLZAF8FslTSZruY5pqVIOsGZWQa3zqGxEPE/TfaQA+zVT5kLgwibSxwPbNpG+nBSgy+UAa2aVExAtj3FttxxgzayyWnhKqz1zgDWzyurAcxE4wJpZ5US0OEKgPXOANbPKcgvWzCwPQRQKLWdrpxxgzaxyGqYr7KAcYM2ssjxMy8ys9QUQbsGameUgwi1YM7O8dOSbXGphMph2SdInwAeVrkdOBgFzKl0JWyMd9Xe2cUQMXpsdSHqU7Pspx5yIGN1ytnVHhwywHZmk8S1NOmzrFv/OOi/PB2tmlhMHWDOznDjAtj/XVroCtsb8O+uk3AdrZpYTt2DNzHLiAGtmlhM/aFBhkgrAxKKkwyJiajN5F0dE7zapmJUkaSDwZPq4AVAAPkmfd4mIlRWpmK1T3AdbYWsSNB1g102SzgMWR8SvitK6RERd5Wpl6wJ3EaxjJPWW9KSk1yRNlHRoE3mGSnpW0gRJb0r6ako/QNKLqezdkhyM25CkmyT9WtLTwMWSzpN0WtH2NyVtktaPkjQu/Q5/J6m6UvW2/DjAVl6P9Ec2QdJ9wHLg8IjYEdgHuERS49cRfwcYGxGjgO2BCZIGAecA+6ey44GftNlZWIMtyH4HP20ug6QvAt8C9ki/wwLw3bapnrUl98FW3rL0RwaApBrgIkl7AfXAMGAI8FFRmVeAG1Pe+yNigqSvAVsDL6R43BV4sW1OwYrcHREtzV6yH7AT8Er6XfUAZuddMWt7DrDrnu8Cg4GdIqJW0lSge3GGiHg2BeBvALdK+iUwH3g8Ir7d1hW21SwpWq9j9avEht+jgJsj4qw2q5VVhLsI1j39gNkpuO4DbNw4g6SNU57rgBuAHYGXgD0kbZ7y9JS0RRvW2z5vKtnvBkk7Apum9CeBIyStn7YNSL9T62Dcgl33/AH4s6TxwATgnSby7A2cLqkWWAwcHRGfSPrfwO2SuqV85wDv5V5ja86fgKMlTSDr1nkPICLeknQO8JikKqAWOJmOO8Vmp+VhWmZmOXEXgZlZThxgzcxy4gBrZpYTB1gzs5w4wJqZ5cQBtpOSVCiay+BuST3XYl83SToirV8vaesSefeWtPu/cIyp6XHgstIb5Vm8hsdabQ4Bs3+VA2zntSwiRkXEtsBK4MTijf/q5CMR8R8R8VaJLHsDaxxgzdojB1gDeA7YPLUun5b0R2CipGpJv5T0iqQ3JJ0AoMxvJb0l6WFg/YYdSXpG0s5pfXSa2ev1NEPYJmSB/D9T6/mrkgZL+lM6xiuS9khlB0p6TNLfJf2O7PHSkiTdL+lVSZMkHd9o2yWpLk9KGpzSviDp0VTmOUlbtcq3aZb4Sa5OTlIX4CDg0ZS0C7BtRExJQWphRHw5PR32gqTHgB2ALYHtyCaieQu4sdF+BwPXAXulfQ2IiHmSrqFo7tQUzC+NiOclbQSMBb4I/Ax4PiJ+LukbwGoBsxnHpmP0IJtI5U8RMRfoBbwWET+VdG7a9ylkLyM8MSLel/QV4Cpg33/hazRrkgNs59UjPcIJWQv2BrJL93ERMSWlHwB8qaF/lWyehJHAXsDtadaomZKeamL/uwLPNuwrIuY1U4/9ga2LZmTsK6lPOsa/pbIPS5pfxjn9UNLhaX1EqutcslnJ7kzptwH3Kpsrd3fg7qJjd8OsFTnAdl6rTZMIkAJN8WxQAk6NiLGN8h0MtPSMtcrIA1k31W4RsayJupT9HLekvcmC9W4RsVTSMzSahaxIpOMuaPwdmLUm98FaKWOBk9K8s0jaQlIv4FlgTOqjHUo2MXhjLwJfk7RpKjsgpS8C+hTle4zscp2Ub1RafZY0CbWkg4D+LdS1HzA/BdetyFrQDaqAhlb4d8i6Hj4Fpkg6Mh1DkrZv4Rhma8QB1kq5nqx/9TVJbwK/I7vquQ94n+xljVcDf21cMCI+Ies3vVfS63x2if5n4PCGm1zAD4Gd0020t/hsNMP5wF6SXiPrqpjWQl0fBbpIegO4gGz6xgZLgG0kvUrWx/rzlP5d4LhUv0nA517PY7Y2PJuWmVlO3II1M8uJA6yZWU4cYM3McuIAa2aWEwdYM7OcOMCameXEAdbMLCf/HzYla8JVIs+bAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(rfc,  x_teste, y_teste, values_format = '.0f')  \n",
    "plt.show()\n",
    "plt.rcParams[\"figure.figsize\"] = (80,14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f27cf278",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "       False       0.69      0.74      0.71     66696\n",
      "        True       0.70      0.65      0.67     62482\n",
      "\n",
      "    accuracy                           0.69    129178\n",
      "   macro avg       0.69      0.69      0.69    129178\n",
      "weighted avg       0.69      0.69      0.69    129178\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_teste, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b02fc5c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.roc_curve.RocCurveDisplay at 0x14bde442280>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams[\"figure.figsize\"] = (8,6)\n",
    "metrics.plot_roc_curve(rfc,  x_teste, y_teste) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "13a06e70",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'PAROU' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-33-41ad3a3874a3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mPAROU\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'PAROU' is not defined"
     ]
    }
   ],
   "source": [
    "PAROU"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a64a5b3",
   "metadata": {},
   "source": [
    "## Modelo após remoção de Colunas com baixa importancia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a096e931",
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp[tmp[\"Importância da feature\"]<0.001].Feature.to_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6744b7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_modelo_2 = dataset_modelo.drop(['TP_PR_OB_FG', 'FAMILIAR_GRADUADO', 'AUXILIO_RECEBIDO', 'NACIONALIDADE',\n",
    "                                       'TP_PR_OB_FG', 'TP_PR_DI_FG', 'TP_PR_OB_CE', 'TP_PR_DI_CE'], \n",
    "                                     axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a051fff",
   "metadata": {
    "run_control": {
     "marked": true
    }
   },
   "outputs": [],
   "source": [
    "#split de dados\n",
    "x_treino, x_teste, y_treino, y_teste = train_test_split(dataset_modelo_2, y, test_size  = 0.1, shuffle = True)\n",
    "\n",
    "rfc = RandomForestClassifier(n_estimators = 5, random_state=0, criterion = \"entropy\", max_depth = 11)\n",
    "rfc.fit(x_treino, y_treino)\n",
    "\n",
    "\n",
    "y_pred = rfc.predict(x_teste)\n",
    "\n",
    "acuracia = metrics.accuracy_score(y_teste, y_pred)\n",
    "print(f\"A Acurácia do modelo é de: {acuracia}\")\n",
    "\n",
    "precisao = metrics.precision_score(y_teste, y_pred)\n",
    "print(f\"A Precisão do modelo é de: {precisao}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b82be627",
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp = pd.DataFrame({'Feature': dataset_modelo_2.columns.to_list(), \n",
    "                    'Importância da feature': rfc.feature_importances_})\n",
    "\n",
    "tmp = tmp.sort_values(by='Importância da feature',ascending=False)\n",
    "plt.figure(figsize = (7,4))\n",
    "plt.title('Importância da feature - Random Forest',fontsize=14)\n",
    "s = sns.barplot(x='Feature',y='Importância da feature',data=tmp)\n",
    "s.set_xticklabels(s.get_xticklabels(),rotation=90)\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9509478",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(rfc,  x_teste, y_teste, values_format = '.0f')  \n",
    "plt.show()\n",
    "plt.rcParams[\"figure.figsize\"] = (80,14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6318b66",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(classification_report(y_teste, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d48cff21",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams[\"figure.figsize\"] = (8,6)\n",
    "metrics.plot_roc_curve(rfc,  x_teste, y_teste) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d3da40f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jupyter core     : 4.7.1\n",
      "jupyter-notebook : 6.3.0\n",
      "qtconsole        : 5.0.3\n",
      "ipython          : 7.22.0\n",
      "ipykernel        : 5.3.4\n",
      "jupyter client   : 6.1.12\n",
      "jupyter lab      : 3.0.14\n",
      "nbconvert        : 6.0.7\n",
      "ipywidgets       : 7.6.3\n",
      "nbformat         : 5.1.3\n",
      "traitlets        : 5.0.5\n"
     ]
    }
   ],
   "source": [
    "!jupyter --version"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}