ml/class/rf/Random-Forest.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest\n",
    "Random Forest é um tipo de algoritmo de classificação ou regressão, ou seja, seu objetivo é predizer a classe a que um dado pertence. E como o nome pode intuir ele usa uma floresta, no caso uma floresta de [árvores de decisão](\"https://medium.com/machine-learning-beyond-deep-learning/%C3%A1rvores-de-decis%C3%A3o-3f52f6420b69\"), que já foram explicadas anteriormente. Essas árvores são usadas para chegar ao resultado final do conjunto.\n",
    "\n",
    "Essa random forest é uma técnica de [conjunto](\"https://de.wikipedia.org/wiki/Ensemble_learning\"), ou seja, ela usa múltiplos modelos preditivos menores, no caso árvores de decisão e a partir de suas múltiplas predições a floresta estabelece a sua predição final.\n",
    "\n",
    "E com essa formação, podemos ter uma predição mais precisa pois assim o erro de uma árvore pode ser corrigido pelo resto da floresta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para criarmos uma [Random Forest](\"https://medium.com/machina-sapiens/o-algoritmo-da-floresta-aleat%C3%B3ria-3545f6babdf8\") temos que treinar cada árvore individualmente para enfim fazermos a floresta funcionar, que é o objetivo do algoritimo, ter varios votos com vieses diferentes para juntos termos o melhor resultado. \n",
    "\n",
    "Para treinarmos cada uma das árvores, precisamos realizar o Bootstrap, ou o [Bagging](\"https://en.wikipedia.org/wiki/Bootstrap_aggregating\"), que um processo de seleção de casos de treinamento, que são usados para treinar cada árvore individualmente.\n",
    "\n",
    "O resultado dado pela floresta pode ser a predição mais frequente entre as árvores ou a média das predições:\n",
    "\n",
    "$\\hat{f} = \\frac{1}{B}\\sum_{b=1}^{B} f_b (x')$\n",
    "\n",
    "$\\hat{f}$ representa a média das árvores, B é o número de árvores, $f_b$ é a árvore treinada no bagging $b$ e $x'$ é um caso de teste.\n",
    "\n",
    "Podemos também estimar a incerteza da predição a partir da fórmula do desvio padrão:\n",
    "\n",
    "$\\sigma = \\sqrt{\\frac{1}{B-1}\\sum_{b=1}^{B}(f_b(x')-f)^2}$\n",
    "\n",
    "Abaixo temos um exemplo de um pseudocódigo de uma random forest, em que não é menor que o total de exemplos, X são os atributos, Y são rótulos e f são as árvores a serem criadas. A primeira linha estabelece os conjuntos de dados. A segunda linha cria um laço de repetição que irá criar as árvores da floresta, criando um bag, e a partir dele treinando uma árvore f nele. Depois estabelece o resultado final a partir da floresta toda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pseudocódigo:\n",
    "Dado um conjunto de dados X = x¹, x², x³... e Y = y¹, y², y³...\n",
    "\n",
    "Para b = 1, 2, 3, ...B, repita:\n",
    "> Crie uma amostra bootstrap (X', Y') com n exemplos de (X, Y).\n",
    "\n",
    "\n",
    "> Ajuste uma árvore de decisão $f_b$ para o conjunto de treinamento (X', Y'), utilizando m atributos para a escolha de cada nó.\n",
    "\n",
    "Cria o modelo final: $\\hat{f} = \\frac{1}{B}\\sum_{b=1}^{B} f_b (x')$, que calcula os votos obtidos por cada modelo $f_b$, que tem como classificação final a mais votada.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementação\n",
    "\n",
    "## Parâmetros\n",
    "\n",
    "A seguir será mostrado como utilizar o código do sklearn para [random forest de classificação](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier) ela recebe diversos parâmetros para o algoritmo de predição vamos começar mostrando os principais parâmetros:\n",
    "\n",
    "\n",
    "### n_estimators\n",
    "Esse parâmetro é a forma de controlar a quantidade de árvores na floresta permitindo assim definir o custo do programa além de permitir caso necessário aumentar a precisão do programa. Isso muitas vezes não quer dizer necessariamente melhorar a acurácia, pois ao aumentar a quantidade de árvores pode ocorrer o problema de overfitting por existir árvores muito parecidas no programa.\n",
    "\n",
    "### criterion \n",
    "Esse parâmetro define o critério utilizado pelas árvores de decisão na floresta que será utilizado para reduzir a impureza da árvore, permitindo uma maior liberdade no programa convergir, para certos casos e possível que um seja menos custoso ou mais preciso que os outros, porem isso varia de base para base. Os valores que a implementação do sklearn aceita seriam:\n",
    ">“[gini]( https://en.wikipedia.org/wiki/Decision_tree_learning#Gini_impurity )” que tenta isolar um rotulo verificando o produto da probabilidade de em uma decisão, o que significa a chance de tal variável ficar isolada vezes a probabilidade dela não ficar isolada, pois se esse valor se aproxima de 0 o programa conseguiu isolar o atributo,\n",
    "\n",
    "> “[entropy]( https://en.wikipedia.org/wiki/Decision_tree_learning#Information_gain)” que utiliza a variação da entropia como já mostrado em árvore de decisão.\n",
    "\n",
    "### max_depth\n",
    "O max_depth permite limitar a altura das árvores da floresta, o que permite limitar a complexidade da árvore, pois, ao limitar a altura também é limitada a quantidade possível de decisões na árvore o que permite impedir overfitting e diminuir o custo de memória do programa.\n",
    "\n",
    "### max_leaf_nodes\n",
    "Max_leaf_nodes limita a quantidade de folhas na árvore. Isso implica a limitação da quantidade de nós de decisão permitindo controle da complexidade, diminuição de custo, controle de overfitting e também de diminuir o custo operacional, porem é necessário ter cuidado para não causar underfitting.\n",
    "\n",
    "### min_impurity_decrease\n",
    "Essa variável define o valor mínimo de impureza para a transformação de uma folha em um nó, fazendo com que fique mais difícil da árvore fazer uma decisão ruim como overfitting, porém pode causar underfitting.\n",
    "\n",
    "### bootstrap\n",
    "Essa variável define se ocorre o bagging ou não, se ela for \"false\" todas as árvores são treinadas com o conjunto de treino inteiro, fazendo com que as árvores fiquem mais parecidas.\n",
    "\n",
    "### oob_score\n",
    "Essa variável define se o programa deve, pegar exemplos de dentro das bags para avaliar o programa. Ou seja o programa vai pegar alguns exemplos do conjunto de treinamento e misturar com o de teste para avaliar a predição, o que pode dar mais valor para o seu programa caso ele tenha recebido muitos outliers no conjunto de treinamento. Mas também ele poderia dar mais pontuação em um caso de overfitting.\n",
    "\n",
    "### [random_state]( https://scikit-learn.org/stable/glossary.html#term-random-state)\n",
    "Essa variável permite a repetibilidade do processo de predição, pois ao receber um número ele utilizara esse número como [semente](https://en.wikipedia.org/wiki/Random_seed) para a função de aleatoriedade do programa que seria o processo de bagging e de divisão da árvore. Porém quando em 'NONE' ele vai gerar um valor aleatório que será utilizado de semente o que impede que mesmo que tenha o data set e use os mesmos parâmetros tenha o mesmo resultado ao executar o programa.\n",
    "\n",
    "### max_samples\n",
    "Define o número máximo de exemplos a ser lido por cada estimador se o bootstrap for igual true. Ou seja, se o processo de bagging for permitido, esse valor indica o número máximo de exemplos em cada “bag”. Caso contrário ele diz quantos exemplos as árvores podem ler de todo o conjunto de treinamento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos\n",
    "\n",
    "Agora que já vimos os parâmetros vamos agora mostrar como utilizar a random forest do sklearn.\n",
    "\n",
    "\n",
    "### [fit(X, y , sample_weight=None)]( https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier.fit)\n",
    "Essa e a função de treinamento do algoritmo que recebe os atributos preditivos (X) e os rótulos (y) do conjunto de treinamento e a importância dos exemplos (sample_weight), com esses dados o algoritmo faz o processo de bagging com a variável X. Caso ele for permitido, pela variável bootstrap, formando n_estimators bags que são usados para treinar  n_estimators árvores na floresta aleatoriamente a partir da semente random_state. Com os pesos definidos por sample_weight que ajuda a definir os exemplos mais importantes para predição, possibilitando um ajuste caso a base seja desbalanceada.\n",
    "\n",
    "\n",
    "### [predict(X)]( https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier.predict)\n",
    "Essa e a função de utilizar o classificador para predizer a classe de cada termo da entrada passando eles por cada árvore da floresta e selecionando pra cada termo a classe mas votada para ele, e retorna um vetor com cada predição de rótulo na ordem de entrada.\n",
    "\n",
    "### [apply(X)]( https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier.apply)\n",
    "Essa função permite receber separadamente para cada elemento de X as predições feitas como se fosse usando a função predict de cada uma das árvores na floresta em um formato de matriz (quantidade de elementos em X, quantidade de árvores).\n",
    "\n",
    "### [predict_proba(X)]( https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier.predict_proba)\n",
    "Parecida com a predict a predict_proba utiliza o estimador para predizer o rótulo de cada termo da entrada, porem diferentemente do predict que retorna um vetor com cada rótulo ele retorna uma matriz com a probabilidade de ser cada classe (quantidade de elementos em X, quantidade de classes).\n",
    "\n",
    "### [score(X, y)]( https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier.score)\n",
    "Essa e a função fornecida pela random forest do sklearn que permite uma auto avaliação do programa e retorna à acurácia media do processo de predição dos elementos X utilizando como base a variável y que seriam os rótulos de X.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aplicação\n",
    "\n",
    "O hospital Albert Einstein, em São Paulo, disponibilizou uma [base de dados](https://www.kaggle.com/einsteindata4u/covid19) de pacientes anônimos que fizeram o teste para o COVID-19, a base possui diversos dados clínicos dos pacientes junto ao resultado dos testes feitos.\n",
    "\n",
    "Para demonstrar o uso do algoritmo de classificação Random Forest em um problema real, a base do COVID-19 foi utilizada para treinar um classificador utilizando a implementação do algoritmo disponível na biblioteca sklearn. O classificador possui o intuito de prever a condição de pacientes com a doença utilizando seus dados clínicos como sinais, sintomas, testes de outras doenças, entre outras informações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split, KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de pacientes: 5644\n",
      "Número de atributos: 111\n"
     ]
    }
   ],
   "source": [
    "# Importando o dataset do Covid-19.\n",
    "data = pd.read_excel('dataset.xlsx')\n",
    "\n",
    "# Mostra o número de pacientes e atributos antes das transformações feitas.\n",
    "print(f'Número de pacientes: {data.shape[0]}')\n",
    "print(f'Número de atributos: {data.shape[1]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de utilizar o classificador, é necessário tratar os dados ausentes e os atributos desnecessários, em grande quantidade nesta base. Para isso selecionamos apenas os atributos que possuem dados presentes em mais de 20% dos pacientes, e selecionamos apenas os pacientes sem dados ausentes nesses atributos. Porcentagens mais altas que 20% selecionariam uma quantidade muito pequena de atributos, e mais baixas que 20% uma quantidade muito pequena de pacientes, inviabilizando a análise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    0.91716\n",
      "1    0.08284\n",
      "Name: SARS-Cov-2 exam result, dtype: float64\n",
      "-------------------------\n",
      "Número de pacientes: 1352\n",
      "Número de atributos: 22\n",
      "-------------------------\n",
      "Atributos selecionados:\n",
      "Patient age quantile, SARS-Cov-2 exam result, Patient addmited to regular ward (1=yes, 0=no), Patient addmited to semi-intensive unit (1=yes, 0=no), Patient addmited to intensive care unit (1=yes, 0=no), Respiratory Syncytial Virus, Influenza A, Influenza B, Parainfluenza 1, CoronavirusNL63, Rhinovirus/Enterovirus, Coronavirus HKU1, Parainfluenza 3, Chlamydophila pneumoniae, Adenovirus, Parainfluenza 4, Coronavirus229E, CoronavirusOC43, Inf A H1N1 2009, Bordetella pertussis, Metapneumovirus, Parainfluenza 2\n"
     ]
    }
   ],
   "source": [
    "# Retira os atributos que possuem dados presentes em menos de 20% dos pacientes.\n",
    "data_notnull = data.notnull().mean()*100\n",
    "useful = data_notnull[data_notnull > 20]\n",
    "data = data[[col for col in data.columns if col in useful]]\n",
    "\n",
    "# Retira os pacientes que possuem algum dado ausente nos atributos selecionados.\n",
    "data.dropna(subset=data.columns, inplace=True)\n",
    "\n",
    "# Retira o atributo de identificação, irrelevante para a análise.\n",
    "data.drop(columns=['Patient ID'], inplace=True)\n",
    "\n",
    "# Transforma dados categóricos em numéricos.\n",
    "data = data.replace({'positive': 1, 'negative': 0,\n",
    "                     'detected': 1, 'not_detected': 0})\n",
    "\n",
    "# Mostra a proporção de pacientes com e sem a doença na base de dados.\n",
    "print(data['SARS-Cov-2 exam result'].value_counts(normalize=True))\n",
    "print('-------------------------')\n",
    "\n",
    "# Mostra o número de pacientes e atributos após as transformações feitas.\n",
    "print(f'Número de pacientes: {data.shape[0]}')\n",
    "print(f'Número de atributos: {data.shape[1]}')\n",
    "print('-------------------------')\n",
    "\n",
    "# Mostra os atributos selecionados.\n",
    "print('Atributos selecionados:')\n",
    "print(', '.join(list(data)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma vez com os dados tratados em mãos, separamos o rótulo e os atributos preditivos a serem considerados pelo classificador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resultado do exame.\n",
    "y = data['SARS-Cov-2 exam result']\n",
    "\n",
    "# Dados clínicos selecionados, sem o resultado do exame.\n",
    "X = data.drop(columns=['SARS-Cov-2 exam result'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para treinar e testar o classificador, dividimos a base de dados em duas, uma com 70% dos pacientes para treinamento, e outra com 30% dos pacientes para testes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 70% para treinamento e 30% para teste.\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para gerar o classificador utilizamos o `RandomForestClassifier` da biblioteca sklearn, e alguns parâmetros descritos abaixo:\n",
    "\n",
    "* __Quantidade de árvores__ (`n_estimators` = 100);\n",
    "* __Semente da função de aleatoriedade__ (random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "classificador = RandomForestClassifier(n_estimators=100, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o método `fit` treinamos o classificador com os elementos de treino, e utilizamos o método `predict` para predizer os resultados dos elementos de teste, utilizando do classificador treinado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16, 36, 81, 86, 185, 191, 224, 233, 255, 262, 265, 277, 291, 318, 349]\n"
     ]
    }
   ],
   "source": [
    "classificador.fit(X_train, y_train)\n",
    "\n",
    "y_pred = classificador.predict(X_test)\n",
    "\n",
    "# Índices dos pacientes preditos com positivos pelo classificador.\n",
    "print([i for i, val in enumerate(y_pred) if val])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível visualizar a predição de cada uma das árvores utilizando a função `apply`, que retorna uma matriz com os índices das folhas, onde cada linha representa uma amostra utilizada, e em cada coluna os índices das predições das amostras para uma árvore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 18, 115,  99, ...,  86,  78,  85],\n",
       "       [ 57,  62,  41, ...,  40,  50,  40],\n",
       "       [ 64,  69,  46, ...,  46,  58,  46],\n",
       "       ...,\n",
       "       [ 53,  54,  39, ...,  33,  48,  36],\n",
       "       [ 72,  72,  63, ...,  51,  64,  67],\n",
       "       [ 64,  67,  44, ...,  44,  54,  45]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classificador.apply(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resultados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparando os resultados obtidos com os de teste, podemos calcular a acurácia do classificador utilizando a função `score`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acurácia do classificador: 91.13%\n"
     ]
    }
   ],
   "source": [
    "acuracia = classificador.score(X_test, y_test)*100\n",
    "\n",
    "print(f'Acurácia do classificador: {acuracia:.2f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Devido a abordagem aleatória adotada pelo algoritmo Random Forest, utilizar do algoritmo múltiplas vezes pode não gerar resultados iguais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acurácia do classificador: 91.63%\n"
     ]
    }
   ],
   "source": [
    "classificador = RandomForestClassifier(n_estimators=100)\n",
    "classificador.fit(X_train, y_train)\n",
    "y_pred = classificador.predict(X_test)\n",
    "acuracia = classificador.score(X_test, y_test)*100\n",
    "print(f'Acurácia do classificador: {acuracia:.2f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O parâmetro `random_state` pode ser utilizado para gerar um classificador com as mesmas características, pois utilizando de uma mesma seed o vetor aleatório utilizado no processo de bagging é o mesmo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acurácia do classificador: 91.13%\n"
     ]
    }
   ],
   "source": [
    "classificador = RandomForestClassifier(n_estimators=100, random_state=0) # Mesmo valor utilizado\n",
    "classificador.fit(X_train, y_train)\n",
    "y_pred = classificador.predict(X_test)\n",
    "acuracia = classificador.score(X_test, y_test)*100\n",
    "print(f'Acurácia do classificador: {acuracia:.2f}%') # Mesma acurácia obtida"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizando a validação cruzada K-Folds é possível obter um resultado mais conciso da acurácia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acurácia média: 92.10%\n"
     ]
    }
   ],
   "source": [
    "scores = []\n",
    "cv = KFold(n_splits=100, random_state=0, shuffle=True)\n",
    "for train_index, test_index in cv.split(X):\n",
    "\n",
    "    train_idx = [True if i in train_index else False for i in range(data.shape[0])]\n",
    "    cv_idx = [True if i in test_index else False for i in range(data.shape[0])]\n",
    "    \n",
    "    X_train, X_cv, y_train, y_cv = X[train_idx], X[cv_idx], y[train_idx], y[cv_idx]\n",
    "    \n",
    "    classificador = RandomForestClassifier(n_estimators=100, random_state=0)\n",
    "    classificador.fit(X_train, y_train)\n",
    "    y_cv_pred = classificador.predict(X_test)\n",
    "    scores.append(classificador.score(X_cv, y_cv)*100)\n",
    "        \n",
    "print(f'Acurácia média: {sum(scores)/len(scores):.2f}%') # Média das acurácias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para visualizar a importância dos dados dos paciente analisados pelo classificador, é possível utililzar o atributo `feature_importances_`, um vetor com valores de importância para cada um dos atributos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fe6fe4a6690>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "feat_importances = pd.Series(classificador.feature_importances_, index=X_test.columns)\n",
    "feat_importances.nlargest(10).plot(kind='barh')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o gráfico acima podemos observar algumas coisas do dataset que antes não pareciam tão obvias e um pouco contra intuitivas. Vemos que os atributos mais relevantes são a idade do paciente, se ele está em um tratamento adequado, em uma unidade intensiva e o teste de algumas outras doenças. Esses resultados podem indicar algumas coisas interessantes e possivelmente responder um pouco a questão do dataset que era saber se existia algum atributo ali presente que indicasse melhor se a pessoa possuía corona vírus ou não. Vamos fazer uma analize individual influentes:\n",
    "> A idade de um paciente é um pouco com plicada de afirmar que intui se a pessoa tem corona vírus ou não já que é sabido que essa doença ataca mais pessoas idosas e por tanto vão mais ao hospital. E tambem é estranho dizer que apartir de uma idade apenas a pessoa tem coronaviŕus. \n",
    "> Se a pessoa está em um leito regular também não vai dizer se a pessoa tem corona vírus de cara tendo em vista que qualquer um pode estar em um leito regular ou não, isso seria um problema dos hospital e varias doenças podem levar a esse tipo de leito.\n",
    "> Já os enterovírus/Rinovírus que são testes de fato, ou seja, que não coisas aleatórias para pessoas, ele é um teste medico e a partir dele conseguimos indicar melhor de a pessoa tem a doença ou não, mas seu valor de importancia é quase a metade dos últimos dois.                  Mas agora a combinação de todos esses atributos em conjunto podem levar a uma suposição acurada sobre o individuo ter ou não coronavírus, inclusive elas levão, segundo o random forest. E isso faz sentido já que realmente a doença ataca mais idosos, e a regularidade de um leito pode ser pelos medicos do hospital de tentar colocar suspeitos de covid-19 em leitos regulares e o teste ser uma pequena indicação sobre o estado da pessoa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apesar da acurácia alta nos testes feitos, em bancos de dados desbalanceados a acurácia pode não ser uma boa métrica para apurar sua eficiência. Para visualizar melhor os resultados, utilizamos uma [__matriz de confusão__](https://en.wikipedia.org/wiki/Confusion_matrix) e as métricas [__precision e recall__](https://en.wikipedia.org/wiki/Precision_and_recall):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "\n",
    "# Mostra a matriz de confusão dos resultados obtidos.\n",
    "def show_confusion(y_test, y_pred):\n",
    "        cf_matrix = confusion_matrix(y_test, y_pred)\n",
    "        group_names = ['Verdadeiro Negativo','Falso Positivo','Falso Negativo','Verdadeiro Positivo']\n",
    "        group_counts = [\"{0:0.0f}\".format(value) for value in\n",
    "                        cf_matrix.flatten()]\n",
    "        group_percentages = [\"{0:.2%}\".format(value) for value in\n",
    "                             cf_matrix.flatten()/np.sum(cf_matrix)]\n",
    "        labels = [f\"{v1}\\n{v2}\\n{v3}\" for v1, v2, v3 in\n",
    "                  zip(group_names,group_counts,group_percentages)]\n",
    "        labels = np.asarray(labels).reshape(2,2)\n",
    "        sns.heatmap(cf_matrix, annot=labels, fmt='', cmap='Blues')\n",
    "        \n",
    "show_confusion(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.92      0.98      0.95       367\n",
      "           1       0.60      0.23      0.33        39\n",
      "\n",
      "    accuracy                           0.91       406\n",
      "   macro avg       0.76      0.61      0.64       406\n",
      "weighted avg       0.89      0.91      0.89       406\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "\n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É possível perceber que apesar da acurácia alta, os valores de `precision` e `recall` para os resultados positivos são muito baixos, um resultado pouco desejado tendo em vista o contexto do classificador. Um valor baixo de `recall` mostra que o classificador errou a condição de grande parte dos pacientes com COVID-19 (Falso negativo), um resultado distante do ideal já que pacientes não alertados podem proliferar mais o vírus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para melhorar o `recall` é possível utilizar do parâmetro `sample_weight` e adicionar um peso maior para os pacientes com COVID-19. Dessa forma é possível aumentar o número de __verdadeiros positivos__ (pacientes com COVID-19 corretamente preditos pelo classificador), em detrimento de um aumento no número de __falsos positivos__ (pacientes sem COVID-19 erroneamente preditos pelo classificador) e de uma piora no valor da métrica `precision`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.96      0.77      0.86       367\n",
      "           1       0.25      0.72      0.37        39\n",
      "\n",
      "    accuracy                           0.77       406\n",
      "   macro avg       0.61      0.75      0.62       406\n",
      "weighted avg       0.89      0.77      0.81       406\n",
      "\n",
      "Acurácia do classificador: 76.85%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAD4CAYAAADSIzzWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3dd3xN9x/H8dc3UySEEHsTm9pae69Se9QeNSr2qL0prVltUXtvYtVetVsUNRLEFsQmZMj4/v64cSW/RCSEm3t9nh7n4d5zzznf70l455vv+Z7vUVprhBBCfHpWpq6AEEJ8riSAhRDCRCSAhRDCRCSAhRDCRCSAhRDCRGw+dgEOhbvJMAsRxc5VY0xdBZEAlc2ZXH3oMeKSOQGnfvvg8j6EtICFEMJEPnoLWAghPillPu1KCWAhhGWxsjZ1DWJNAlgIYVmUSbt140QCWAhhWaQLQgghTERawEIIYSLSAhZCCBORFrAQQpiIjIIQQggTkS4IIYQwEemCEEIIE5EWsBBCmIgEsBBCmIi1XIQTQgjTkD5gIYQwEemCEEIIE5EWsBBCmIi0gIUQwkSkBSyEECYityILIYSJSBeEEEKYiHRBCCGEiZhRC9h8aiqEELGhrGK/xHQYpTIqpfYppS4opc4rpXqGrx+plPJRSp0OX2pF2GeQUspbKXVRKVX9XVWVFrAQwrLE30W4EKCv1vpfpVQS4KRSalf4Z1O11pMibqyUygs0A/IB6YDdSqmcWuvQt1Y1vmoqhBAJglKxX2Kgtb6rtf43/LUf4Amkj2GXusBKrXWQ1voa4A2UiKkMCWAhhGWJQxeEUqqTUupEhKVTtIdUKgtQGPg7fFU3pdR/Sqn5Sqnk4evSA7ci7HabmANbAlgIYWHi0ALWWs/WWheLsMyOejjlBKwDemmtnwMzgexAIeAuMPl9qyp9wEIIi6LicRiaUsoWQ/gu01qvB9Ba+0b4fA6wJfytD5Axwu4Zwte9lbSAhRAWRSkV6+Udx1HAPMBTaz0lwvq0ETarD5wLf70JaKaUsldKZQXcgH9iKkNawEIIi6Ks4q0FXBpoBZxVSp0OXzcY+FYpVQjQwHWgM4DW+rxSajVwAcMICveYRkCABLAQwsLEVxeE1voQEN3BtsawzzhgXGzLkAAWQliU+OwD/tgkgIUQFkUCWAghTMV88lcCWAhhWaQFLIQQJmJlZT6jayWAhRAWxZxawAn+R8X22T2o8lWeSOu6Na/AL4ObvvcxW9YpydQBjeO0j9efo0iRzDHGbTx+/R5nJ4f3rteOOT05tOwH4/sieTOxY07P9z7e27SsU5K0rs7G9zOGNyd3tjTxXo456Fi3FKN6tDIuD33vvHXbh753GO7e/IPLHNChHiO6tWBE9xZMGdaDZ08exfkYG5bO5sJpwxj/XRtXEhQYaPxs2sje+L/w++B6mi0Vh8XEEnwLePX2kzSuXpTdRz2N6xpXL8rgXzbE+hjKcM/3x6heJPW7z/zg8lMld6Ja6bzsPHwhPqsWSatvvuTClbvcffAMgK6jl3+0shI6Ozt7Rkxf8snL7Tfud5I4J2P94pn8uXohzTv3jdP+9Vq+mTNm96aVfFmhBvaJEgHQa+TUeK2ruTGnFnCCD2CP3acY4V4bWxtrgkNCyZTWhbSuzhz+9woAvVtXpmG1ItjZ2rBp3xnGztpKprQubJ7hzvFz1ymcJxP1u8+gfPFc9G9fjWd+/vx3yYdXr0IAqFUuPwO/q4GtrTWPn72k3eBF3H/sh4uzI4vGtyVdqmT8/d+1SN/UZrWK4/5teWxtbTh+9jo9x68iLEzj9ecoSrf4GUcH+yjlf/lFNvq3r45SsP3geYZO3xjt+U5dvIcBHapHCWArK8XYHnUpV8wNO1sb/lh9gHnrDqOUYurAxlQonpPbvk8JDgll8cajeOw+zaBONfi6XAES2dty7Mw1uo1dQf0qhSiSNxMLxrUhICiYCm0ms/G3rgya6kGRvJnIliElg6cZfri1rFOSonkz0funNfRoWYnWdb8EYKHHEX5bvj+ev9MJx0PfO8ybMoqgwAAAmnfpR448BSNt43PjKgt+GUtoSDBhOoyug8aTOl0mdm5YzqFdhqkBylb7hqp1m8VYVs58hdi9eTUAf/+1k61rFqG1pmDxUjRq242w0FAWTh/HdW8vlFKUrlKbavW+Zf7U0RQsUYanjx7w9PFDJg1xxympM/1/nMGADvUYOmUhOzyW4eKamkpfNwJg4/I5JEqUmGr1m7N2wW+cPXkUpRRfN21LibJV4/vLaDISwPHoyXN/Tpy7QfUyedmy/yxNahRl3a5TAFT+MjfZM6WiTMuJKKVYO60zpYtk59bdJ+TI5ErH4Uv45+x10qRMyrAutSjV4mee+QWwY04PznjdBuDIqSuUa22YV7lt/a/o07YKA6d4MKRzTY6cvsL42dupUSYf7eqXAiBX1tQ0qlaEiu2mEBISxrRBTWhWqzjLt0S+5Tti+WldnRnboy6lWvzMk+f+bJnhTp0KBdm8/78o5/v3f9f4pmJByhVz44V/kHF923qlePYigDItJ2Jna8PehX3YfdSLInkzkjldCgo3HEcqFydOrR/G4o1HAZi18gDjZ28HYN6Y1tQqlx+P3afp0rQ8g6Z68O+Fm5HK3rDnNPsX9jUGcKPqRfh57g4K58lIq2++pFyrSSgFB5b05+BJb85cvP3B319Te/UqiFE9WgGQMnU63If8RBJnF/qMmY6tnT2+d24ye+Jwhk1dGGm/v7avp8o3TfiyQg1CgoMJCwvlurcXh3f/yZDJ89Ba82PfDuTKX5hM2XO9tfwzxw+TIUt2nj56wLqFvzNs2kISOyVh6vCenDr6F8ldU/Pk8QNG/274LeX/uxaqfNOUXRtXGFvUEZUoW4WVc6YZA/jEoT30HvUL/x7Zx81rlxg5fQl+z58yrk97cuYrTDKXlB/65UwQ4vFW5I8uwQcwwJrtJ2hcvShb9p+lUfWifD9qGQBVvspDla9yc2zlQACcHOzJkSkVt+4+4ebdx/xz9joAxfNn4cDJyzx88gKAtTv/xS1TKgDSp07Okp/akyalM3a21lz3MfTHlS6Sg2Z95wCw/dB5Hj97CUDFErkokjcTh5Ya+mod7G158PhFlDpHLL9ovkyRyl+57QRliuaINoABJszdwcDvakRqJVf5Kjf53dJTv0phAJydEpEjkyulCmVn/a5TaK3xfeTHgeOXjPuUL56TPm2q4JDIDhfnxHhevcvWA+eilPfawycvuObzkBIFsuB98wG5sqTmyOmruH9bgU37zuAf+AqAjXtPU7pIdosI4Oi6IEJDQ1jy+yRuXbuMlZUVvj43o+yXPVcB/ly9kCcP71OkVAVSp8uE94UzFP6yPPaJDNcBipSqwKXzp6MN4ElD3LGysiJDlhzUb9mZi+dOkatAEZI4G6aWLVm+OpfOn6J2s/Y8vHeH5X9MomCx0uQtXDLW55Ypey6eP3vM00cP8Hv+lMROSXBxTc3ODSsoWa4aVtbWOCdPQc78hbl++QKFSpaLy5cuwZIWcDzbvP8/furXkEK5M5A4kR2nPA1zHisFE+fvZN66w5G2z5TWhZcBr2J17CkDGjN96V7+/OssZYu6MbRLrRi3V0qxdPPfDP91U4zbxbb86Px1/BIj3WtTokCWSOX2+WlNpL5wgBpl8kV7DHs7G6YNakKZFj9z2/cpQzrXwt7O9p1lr9lxkobVinDxmi+b9kX/A8LS7dq4gqTJXBgxfQlah/F9g/JRtilZoTpZc+Xjv+OH+WVkH1q5D4xTGdG1WKPj6JSUEdOXcP7fY+zf5sHxQ3to13NorMspVroyJw7v5fnTxxQvUyVOdTRX5hTACX4UBBjC7MDxS8wa2ZLV208Y1+864kmbul/h6GAHQDpXZ1yTO0XZ//i565Qt6oaLsyM2NlY0CG9FAiR1SsSd+08BQ5/na4f/9aZpzWIAVCudFxdnwwiIff9cpH6VQsZykidNTKa0yYnJiXM3KFvUjRTJHLGyUjSpUZSDJy/HuM+Eudvp0+bNf5hdRzzp1LgMNjaGb1mOTKlInMiOo6evUq9yIZRSpHJJQtlibgAkCg/bh09f4uhgR/0qhYzH8nsZiFNi+2jL3bT3DLXLF6BJjaKs2X7S8LU45U2dCgVxSGRL4kR2fFPxC2MfvCUKePkSZ5cUWFlZcXTfdsLCok5o9eCeD65p0lPlm6YUKlmO29e9ccv7Baf+/ougwECCAgP49+hf5MxXKJoSosqaMy8Xz53C79lTwkJD+efATnLmL4Lfs6dorSlauhL1W3Xm5pWLUfZN5OBIYIB/tMctXrYKxw/u5uThvRQrUxkAt3xfcPzgbsJCQ/F79oRL50+TNWf0P8jNUXxNR/kpmEULGAyjIVZP7UTrgQuM6/Yc8yJ31jTsX9QPgJcBQbQbsojQ0LBI+957+Jyxs7ayf1Ffnvn5c+bimzmSx/2xlWU/d+DJc3/+On6JLOlThK/fxqLxbWmythjHzlzl5t3HAHhdvceo37eweWY3rJQiOCSU3hNWc/Puk7fW/d7D5wybvpHts3saL8Jt2X82xvPdcegCD5686dpY4HGEzOlcOLp8IEoZugua9JmNx57TVCiZi1PrhnDb9ymnvW7xzC+QZy8CWLD+CCfXDMb30XNOnn/za/TSzX/z65BmxotwET31C8Drmi95sqXhxPkbAJz2us3SzX9zcEl/wHARzhK6H96m4tcNmDF+EEf3biN/0S+NXQoRHT+4h2P7tmFtY0PS5Cmo1aQNTkmcKV35a8b1bQ8YLsLF1P8bUTKXlDRs05VJQ9yNF+EKf1mOW9cus2DaGOMomgatv4+yb7nqdZk2shfJXFLS/8cZkT5LnzkbgQH+JEvhauzjLfJVBa56nWNkj1YopWjUzh3n5Cni9DVKyBJCsMaW+tjDsxwKd/v4478+c44OdrwMeIWLsyMHl/SjUrsp+D5K2ONAd64aY+oqiASobM7kH5ye6bqsj3Xm3JnVwKRpbTYtYPF266d/j3MSB+xsrRk/Z3uCD18hPia5FVl8UtU7/mLqKgiRYJhTF4QEsBDCsphP/koAx5cMqZMxd0xrUqVIgtYwf91hfl+xn4I50/PrkGbY29sSEhpGrx9XGS9uARTNm4n9i/rSetACPHafjqEEYQl2bljBoZ2bQCkyZMlOu55DWTZrEtcve6LRpEmXiXa9hpHIIbGpq2q2pAX8GQoJDWPglPWc9rqNU2J7jiwfwJ6/vRjXqx7jZm9j5+ELVC+Tl3G96hm7DKysFGN71mX3MS8T1158Ck8e3Wfv5tWMnrECO/tEzJowhH8O7KLpd71wSGwY5rhq7jT2bllLrcatTVxb82VRAayUyg3UBdKHr/IBNmmtPd++1+fn3sPn3Hv4HIAX/kF4XbtHOtdkaA1JHQ2TpDg7ORgnwAHo2qw8G/acoWi+TCaps/j0QsNCefUqCGsbG14FBZLMxdUYvlprXr0KwozyI0GymABWSg0AvgVW8ub59hmAFUqplVrrCR+5fmYpU1oXCuXKwPFz1+k/aS2bf3dnfO/6WFkpKrY1jLtN5+rMN5W+oHrH6fyRr4WJayw+heQpUlG9fgsGtK+HrZ09+QqXIF8Rw80/86eN4ezJI6TLmJUm7eN/CtLPiTnNBfGu8RodgOJa6wla66XhywSgRPhn0VJKdVJKnVBKnQh5eD4+65vgOTrYsWLSd/SftA6/l4F0alyWHyavx63mMH6YtI6ZIwxhO7F/Q4b+svGTTJMpEoaXL55z+u8DTJi7nkmLthAUGMjRfdsAaN9rGJMXbiFthiwcP7TbxDU1b+Z0J9y7AjgMSBfN+rThn0VLaz1ba11Ma13MJqXl3OL4LjY2VqyY1JFV206wce8ZAFrULsmGPYaLa+t2naJYvsyAYbL1xRPa4fXnKOpXKcy0QU2pU6HgW48tzJ/n6eOkTJ2OJM7JsbGxoUipClzxfHNHpJW1NSXKVeXfw/tMWEvzZ04B/K4+4F7AHqXUZeBW+LpMQA6g28esmDmaNaIFF6/dY/rSvcZ1dx88o2xRNw6evEyFEjnxvvkAgDy1Rxq3mT2qJdsOnnvr7GjCMri4puaq1zmCAgOxs7fH88wJsuTIje+dW6ROlxGtNaf/PkiaDJlNXVWzlgByNdZiDGCt9XalVE4MXQ4RL8Id11pHnaHkM1aqUDZa1C7J2Us+xukxR/y2Cfcxy5nYvxE2NlYEBYXQbewKE9dUmEq2XPkpWroSY3q1wcramkzZclKuRj0mDXEn0N8frTUZs+agZdcBpq6qWUsILdvYkrkghEnIXBAiOvExF0SuATtinTkXf6ouc0EIIUR8MaMGsASwEMKyWJnRMDQJ4FhydnJg5ojm5M2eFq2hy6hl+Ae+4tchzXB0sOfGnUe0G7IIv5eBUfZ1/7YC7RqUQinFgvWHjQ+0HNK5Fu0blDLO+zvit03sOHSBr77Ixi+Dm/IqJJQ2gxZw5eYDnJ0cWPpze75xnyFD1xKIxw98mTd1FM+fPkahKFejHlW+acoLv2f88fNQHvneJUXqtHQZMA5Hp6TRHiPA/yXDuzaj0JfladGlX6TPfh3Tjwf37hifB7d2oeFBmpmy5qRDnxEAHN23jRfPn73z4Z+fE3NqAZvPvG0mNumHRuw8coFCDcZSoul4vK7eY+bw5gydvpHiTX5k074z9G5TOcp+ebOnpV2DUpRtNZESTcdTs1x+smV88/DDX5fu48tmE/iy2QR2HDI8Cblnq0rU7z6THyaupWOjMgAM7FiDn+ftlPBNQKysrWnSvgdjZqxk8KS57PtzLXduXmPb2sXkKVicH2evJU/B4mxbu/itx9iw9A/c8hWOsv7kkX3YJ3ozH4T/yxfcuHKRUb8uw9rGhtvXvXkVFMjh3X9SMfyhm8LAnIahSQDHQlKnRJQpkp2FHoanDQeHhPLsRQA5MqXi0ElvAPYe86Je5aiPn8mdNQ3Hz10nIDCY0NAwDp70pl6lmB9TExwSikMiOxwS2REcEkrWDCnJkDrZOx9jJD6tZC4pyZwjNwCJEjuSNmMWnjy6z+m/D1KqsuHZgqUq1+LUsQPR7n/d24vnTx+Tr3CJSOsDA/zZtWEFtZu2M66zUorQkBDD7cpBQVhb27DDYzmVazfGxkZ+kY1IqdgvMR9HZVRK7VNKXVBKnVdK9Qxf76KU2qWUuhz+d/Lw9UopNV0p5a2U+k8pVeRddZUAjoUs6VLw8MkLZo9qydEVA5gxvDmJE9nhefWu8eaJBlWLkCF11GfDnb9yh9KFc+Di7IhDIltqlMlHhjRvtuvSrBz/rBrErBEtSJbE8OibifN3Mm9MK/q3r8aslQcY1a0OI2ds+TQnK97LQ9873LxyiWy58vP86WPj43+ck6fg+dPHUbYPCwtj9bxfaNy+R5TPNiydTbX6zbGzf/PcvkSJHSlQrBSje7bG2SUFDo5OXLt4nsJfRX1g6OfOysoq1ss7hAB9tdZ5gS8Bd6VUXmAgsEdr7QbsCX8PUBNwC186ATPfWdf3O8XPi42NNYVyZ2TOmoN89e1P+AcE0a99VTqPXEanJmU5vOwHnBLb8yo46tDoi9d8mbxwF5tnuLPpd3fOXLxtfGbdnDUHyVtnJCWbTeDew+dM6NMAgP8u+VC+zWRqdJpOlgwpuPfgGQrFkgntmD+2NalcknzS8xcxCwzwZ8b4QTTt+GZWs9eUUqhoJqjdv3UdBYqVwiVlqkjrb169xIN7tynyVYUo+9Rs2IoR05fQtENPNiz9g7otOnJgx0ZmTRjCllXz4/WczFl8tYC11ne11v+Gv/YDPDHcD1EXWBS+2SKgXvjrusBibXAMSKaUShtTGfK7Syz4+D7B5/5Tjp8zzOPrsfs0fdtVZfSMP6nT9XfA8JTimmWjv+160YajLNpg6L4Y1a0OPr6GpzDff/zm0UHz1x9m/fQuUfYd+F0NWg9cwJQBjRnyywYypUtB128rMPL3zfF6juL9hISEMHP8IL6sUJ2ipSoCkDSZC08fPySZS0qePn5IkmRRfzO64nWWy+fPsH/rOoICAggJCcY+kQMpUqXhurcXAzrUIyw0lOfPnvDzoO/5YfybxtTrJyOnyZCZ9Ytn0nv0L8yfNgbfOzdJnU5m1otL365SqhOG1uprs7XWs6PZLgtQGPgbSK21vhv+0T0gdfjr9Ly5Yxjgdvi6u7yFBHAs+D7y4/a9J7hlTsXlG/epUCIXXlfv4ZrciQdPXqCUYmDH6sxZeyja/V9vlzFNcupW+oLyrQ0zoqVJmdQ4hWXdSl9w4Urk71OLOiXZceg8T577kziRHWFhGh2mSZzI9uOesIgVrTWLpo8jbcYsVKvX3Li+UImyHNmzlVqNW3Nkz1YKlSwbZd+O/UYbXx/evYXr3l40ausOQMVaDQFDt8b00f0ihS8YuihadxtIaEgIYWGG37qsrKx4FRQU7+dojuJybS08bKMEbuTjKSdgHdBLa/08YsBrrbVS6r2vjEsAx1Kfn9aw4Me22NlYc93nIZ1GLKVF7ZJ0bloOgI17T7N44zEA0ro6M2N4c+p3N/zHWTHpO1ySORIcEkqvCat59iIAgHE961EwVwa01ty4+5juEW5TdkhkS6s6Jand9TcApi/di8evXXkVHELbwQs/4ZmLt/G+cIaj+7aRPkt2RvVoBUD91t9Ts1FrZv00hEO7NpEiVRo6DxgHwPXLnuzftp62PYa8d5mnjv5FZrfcJEvhCkDGrDkZ0a0FGbJkJ2NWtw8/KQsQn6MblFK2GMJ3mdZ6ffhqX6VUWq313fAuhvvh632AjBF2zxC+7u3Hl1uRhSnIrcgiOvFxK3KxsftinTknhlZ8a3nKkOSLgMda614R1k8EHmmtJyilBgIuWusflFJfY5ikrBZQEpiutS4R3bFfkxawEMKixOOdcKWBVsBZpdTrBzYOBiYAq5VSHYAbQJPwz7ZiCF9vwB9oxztIAAshLEp8dUForQ/x9mcsR7nrShu6E9zjUoYEsBDCoiSAG9xiTQJYCGFREsItxrElASyEsChmlL8SwEIIyyLTUQohhIlIF4QQQpiIBLAQQpiIGeWvBLAQwrJIC1gIIUzEjPJXAlgIYVlkFIQQQpiIlRk1gSWAhRAWxYzyVwJYCGFZ5CKcEEKYiBl1AUsACyEsi1yEE0IIE4nuKdQJlQSwEMKimFEDWAJYCGFZ5CKcEEKYiBnlrwSwEMKyyI0YQghhIjIKQgghTMSMGsASwEIIyyJdEEIIYSLmE78SwEIICyPD0IQQwkTM6BqcBLAQwrLIKAghhDAR6YIQQggTMaMGsASwEMKySAtYCCFMxHziF6xMXQEhhIhP1lYq1su7KKXmK6XuK6XORVg3Uinlo5Q6Hb7UivDZIKWUt1LqolKq+ruOLy1gIYRFiecuiIXAb8Di/1s/VWs96f/KzQs0A/IB6YDdSqmcWuvQtx1cWsBCCIuiVOyXd9FaHwAex7LousBKrXWQ1voa4A2UiGkHCWAhhEWxUirWi1Kqk1LqRISlUyyL6aaU+i+8iyJ5+Lr0wK0I29wOX/f2ur7H+QkhRIIVlxaw1nq21rpYhGV2LIqYCWQHCgF3gcnvW9eP3gf85PhvH7sIYYZeBIaYugrCQn3sYWhaa98IZc0BtoS/9QEyRtg0Q/i6t5IWsBDColgrFevlfSil0kZ4Wx94PUJiE9BMKWWvlMoKuAH/xHQsGQUhhLAo8XknnFJqBVABSKmUug2MACoopQoBGrgOdAbQWp9XSq0GLgAhgHtMIyBAAlgIYWHiM4C11t9Gs3peDNuPA8bF9vgSwEIIiyK3IgshhInIZDxCCGEiZtQAlgAWQlgWGzNKYAlgIYRFMaP8lQAWQlgWeSy9EEKYiBnlrwSwEMKyyCgIIYQwkdhMtJ5QSAALISyKGeWvBLAQwrIoM3oqnASwEMKiSAtYCCFMRAJYCCFMRCbjEUIIE7E2o8dMSAALISyK3AknhBAmIn3AQghhImbUAJYAFkJYFisZByyEEKYhLWAhhDARGzPqBJYAFkJYFGkBCyGEicgwNCGEMBEzyl8JYCGEZTGjG+EkgIUQlkW6IIQQwkQkgIUQwkTMJ34lgIUQFsaMGsASwEIIyyLzAQshhImY0ygIc6qrEEK8k5VSsV7eRSk1Xyl1Xyl1LsI6F6XULqXU5fC/k4evV0qp6Uopb6XUf0qpIu+s6wedqRBCJDBKqVgvsbAQqPF/6wYCe7TWbsCe8PcANQG38KUTMPNdB5cAFkJYFKs4LO+itT4APP6/1XWBReGvFwH1IqxfrA2OAcmUUmnfVVchhLAYcWkBK6U6KaVORFg6xaKI1Frru+Gv7wGpw1+nB25F2O52+Lq3sugALlwgD00a1DUuPj6337qtj89tGtSt/cFl1qxaiT49uxvf79qxnWGDB8awx/tZunghAQEBxvfuXTry/PnzeC/HHHTr1Ja/jxyKtG7V8sVM/HH0ex/zz00eTP5pbJz2aVi7Kk+fPIlxm749uuDn9/7fp26d2tKswde0aVafLu1bcOP6tTgfw2PtKrZt2QgYzvPBg/vGz8aPHs61q97vXb+EQMVh0VrP1loXi7DMjktZWmsN6Petq0WPgrC3T8Tq9Rs/ebmeF85zxdub7DlyfLQyli1ZzNd1vsHBwQGA32fN+WhlJXRVa9Ri985tlCxVxrhu945tuPfsG6v9tdZorbGy+vjtkcnTZ31w+SPG/kSevPnZuH41v/8yiZ+n/h6nOtRv1NT4etuWjWTL4YarayoABg1//x9aCYX1xx+G5quUSqu1vhvexfD6J5gPkDHCdhnC172VRQdwdHx8bjNk4A/G1uOgIcMoVDjyxUpv78sMHzKIkOBgwnQYk6f9SubMWVi8cAEbPNYB0KBhI1q2bhttGa3atmPu7JmM/3lypPX+/v5M+HEM3pcvExISwvfu3ahYqQoBAQEMHzIQ78uXyZw1Kw/u32fw0OHky1+AsaNHcP7cWQIDg6harTpdu/Vg2dLF3L9/n+/atSFZsmTMW7iEmlUrsXz1WhYtmE+aNGlp1rwFADN//5XEiRPTum17pk7+mUMHD6KUomPn76lRs1Y8f3VNo2Llasye8SvBwa+wtbXj7vSiajIAABSmSURBVB0fHj24zxeFiwKwbPF89u7aTvCrYMpVrMx3Xbpx944Pvbt1Il/+gnh5nmfy9FmcPP43SxbMwSlJEnK45cLWzg6AQwf2sWjuHwSHBOPsnIwRY3/CJUVKnj19yojB/XnwwJf8BQphaAwZ7Ni6mTUrlxIcHEy+/AXpO3AY1tbWNKxdlXlLVhMQ4B+l/LNnTrF4/hw0mlJlytG1R8w/QAoVLsbq5UsAOPHPMX6bNpHQkFDy5MtPv0HDsbOzY+b0KRw6sA9raxtKfFmKbr37M++P33FwSEzadOnwunCOUUMHYG9vz+wFy+nbowvuvfrhdeE8Prdv0a1XP8DQUvbyPE/fAUNZuXQhWzZ5AFCnXkOaNm8d79/TD/EJhgFvAtoAE8L/3hhhfTel1EqgJPAsQldFtCy6CyIoKNDY/dCrhzsALi4p+GPuAlat9eDnyVP5aXzUXzPXrFpJi1atWb1+IytWrSN16jRcOH+OjRvWs3TFapYuX8W6tWvw9LwQbbnVq9fE0/MCN2/ciLR+7uxZlCj5JctXrWXugsVMmTQRf39/Vq9cTpKkznhs3op79554Xjhv3Kd7j96sWL2etR6bOHniOJcuetGiZWtSpUrF3AWLmLdwSeSya9Zi545txvc7t2+jeo1a7Nm1k4teXqxZv5HZcxcwddLPkX71NGdJnZORN18Bjh02dEPs3rGVSlVroJTi76OHuX3zBnMXr2LhinVc9LzA6X9PAHD75g3qN27GsjWbsLGxZd6s35g5fykz5y3h+rUrxuMXLFSE2YtWsHD5OipXq8myRfMBmD97BgULFWbZmk2Ur1gZ33uG/2vXr11hz85tzJq3lEUr1mNlZcXObVui1Dti+dY2NsycPoXpf8xn4fJ1eJ4/x4F9e2I870MH95MtR06CgoIYN3IIo8dPZsnqDYSGhuKxdiXPnj7lr/17WLpmE4tXedDmu86R9q9YpTq58+ZnxNifWLRiPfaJEhk/q1C5Kgf27Ta+37trO1Wq1cTL8zx/btrAnEUrmL1wOZs81nLJyzMu366PTsXhzzuPpdQK4CiQSyl1WynVAUPwVlVKXQaqhL8H2ApcBbyBOUDXdx3folvA0XVBhISEMH7caC56eWFtZcWNG9ej7PfFF4WYM3sWvvfuUblqNTJnzsKpf09SqXIVEidODEDlKlX59+QJ8uTJG2V/K2sr2rTrwLy5f1CmTDnj+qNHDrF/314WLzD8B34VFMS9u3c59e9Jmrc0tCLc3HLiljOXcZ8dO7axbs1qQkNDePjgAVeuXCFnrtxvPec8efLy+PEj7t/35cnjJyRNmpQ0adOyZNECatT6Gmtra1KkTEnR4sU5f/YsFSpVjv0XNAGrUr0Wu3dupWyFSuzeuY1Bw8cAcPzYEf45doS2zRsCEODvz62bN0idJi1p0qYjf4EvALhw7j8KFytB8uQuAFSuWpObN68D8MDXl+ED+/Ho4QOCQ4JJl85wXeX0qRP8OPEXAEqVLU+SpEkBQ2vUy/MCHVobftUPCgoiuUuKKHWOWL7X+XORyq9WszanT52gXMWo35/XLda0adPT+4fB3LxxjbTp0pMpcxYAatauy7rVK2jYpDn2dnaMHz2MUmXLU7ps+Vh/PZMndyFd+oycO3uGjBkzc+P6NQoWKsKaFUspV7EyDg6G/wflK1bhzKmT5MydJ9bH/tjiswWstf72LR9F+caE9we7x+X4Fh3A0Vm6eCEpUqRkzfqNhIWFUaJIwSjb1KpdhwIFv+DAgf1069KJoSNGxbmc2nXqMn/ObHLkyGlcpzVMmTadLFmzxeoYt2/fYvGC+SxftZakzs4MGzyQV0FB79yvarUa7Nq5g0cPH1LNQroZ3qVshYpMn/ITFz0vEBQYSO48+QBD/2qrdh2p17BJpO3v3vEhUXj/+btMnfgjTVu0pmz5Svx74h/mz54R4/ZaG0Lw++69Y9wutuX/v9d9wK89f/4s2u1sbGyYs3gVJ/45xv49O1m3ajm//rEg1uVUqV6Tvbu2kzlLVspVrGw2t/ia01ORLboLIjov/PxI6eqKlZUVWzZvJDQ0NMo2t2/dIkPGjLRo2ZoKlSpz+dJFihQtxr69uwkICMDf35+9e3ZTpGixt5Zja2tLy9ZtWLp4oXFdqdJlWL5sqbGv8HUXRqHCRYzdBle8vfG+fAmAly9e4uDggFOSJDx6+JBDhw4Yj5XY0ZGXL19GW3b1mrXYsW0ru3buoFp1wxjywkWLsWPbNkJDQ3n8+DH/njhB/gJRf/iYq8SJHSlSrAQ/jh5KlepvfuiU+Ko0f25cj7+/4Wv14L4vTx4/irJ/3vwFOXXyOM+ePiUkOJi9u3cYP3vxwg/XVIaRRq9HD4ChD3bX9j8BOHr4IH7ho1CKlSjJ/j07jeU8f/aUe3fvxFj/PPkKcOrkcZ4+eUJoaCi7d2ylcJHisTr3TJmzcu+OD7dvGbq8tv+5icJFiuHv/5KXL/woVaYcPfoMwPvyxSj7Jk6cGP+3/DsqV7EyB/fvY9f2rVSpVhOALwoX5eD+vQQGBBAQ4M+B/XuMfe0JhVKxX0zts2sBN/m2OX17dWfLxg2UKlPW+KtURDu2b2PL5o3Y2tiQImVKvuvYGedkyfimbgNaNGsMGC7CRdf9EFH9ho2Z88ebm2E6denKzxN+pFH9bwgLCyN9hgz8NuMPmjRrzrDBA6lfpxZZsmUje/YcOCVJQubMWcidJy91a9ckTZo0kS4WNmzchK6dv8PVNVWUfuAcOdx4+fIlqVKlMl7drlylKv+dOUXjBnVRStGrb39Surq+99cxIapavRaD+vVg9I+TjOtKflWaG9eu0rmt4aKkQ+LEDB8zAWtr60j7pnR1pUNndzq3a45TkiS45XzTzdOhkzvDBvQhSZKkFClekrt3DBe223fqyojB/WnR+BsKFCxE6jSGMfdZs+WgY9ce9HLviA7T2NjY0GfgUNKkTffWuqd0deX77r3p3rmd8SJc2QqVYnXe9vb2DB45jqED+hgvwtVr1JTnz54xsG83XgW9QmtN994/RNm3Zp16TBw/2ngRLqKkSZ3JkjUb169dIW9+ww/rXHnyUqtOXb5r0wwwXIRLSN0PYF7zAauIV24/hsCQ9x8j97kIDQ0lJCQEe3t7bt28Safv2rJpy3bjVXhL9CIwxNRVEAlQSiebD07PPV4PY505lXOnNGlaf3Yt4IQoMDCA79q1JiQ4BI1myLARFh2+QnxMsRndkFBIACcAjo5OrFi93tTVEMIimFEPxOd3Ee5TGT50EBXKfhXp9uadO7ZR/5uvKZQ/N+fPnTVh7YSp+N67S7dObWnRqA4tGn9jvJHi0kVPOrb5ljbfNqB9yyZcOPefiWtqvuJzHPDHJgH8kdSt14CZf8yNtC5HjpxM/eVXihaL3dVtYXmsrW3o3vsHlq3dzOyFK1i/ZgXXrnoz45cptO/UlUUr1vNdl27MmD7F1FU1W1Yq9oupSRfER1K0WPEok/9ky57dRLURCUVKV1fj6BNHR0cyZ83Gg/v3UQpevnwBwMsXfqRMaVkjVD4lcxoFIQEshIncvePDZS9P8uUvSM9+A+nj3onfp00iLCyMPxYsM3X1zJb5xO8HdEEopdrF8Jlxjs15c+I0u5sQnwV//5cM6d+LHv0G4ujkhMeaVXTvOwCPrXvo0WcA40cPM3UVzVZ8PpLoo9f1A/Z96/25EefY7NAxNvMbC/H5CAkOZkj/XlSr+TUVKlUFDHfYvX5dqWp1LpyXi7TvKy7zAZtajF0QSqm3XYpVvJkFXggRS1prxo8ZTuas2WjWsq1xfUrXVJw6eZwixUpw8vjfZMyY2XSVNHcJIVljKcY74ZRSvkB14P+n+VfAEa312++tDPe53gk3oF8fThz/h6dPn+CSIgXfu3fH2TkZE34cw5PHj0mSNCm5cuVh1px5pq6qSXyud8KdOXWSrt+1JnuOnKjwy/Cd3Xvh6OjIL5MmEBoagp2dPX0HDTNOKPQ5iY874f65+izWmVMim7NJ4/pdATwPWKC1PhTNZ8u11s3fVcDnGsAiZp9rAIuYxUcAH49DABc3cQDH2AWhte4Qw2fvDF8hhPjkzKgLQoahCSEsSkK4wy22JICFEBYlAYwuizUJ4Di6d/cuQwb9wONHj0ApGjVuQotWbSJts3D+XLZu2QxASGgo165eYf/BozgnS8bwoYM48Nd+XFxSsH7jm+eETZ08kcOHDpArdx7Gjf8ZgC2bN/L0yZO3PvxTJCx+fs+ZMGY4V729UUoxeMQY8hcsZPz8+fNnjB81DJ/bt7Czt2Pw8LFky+EGwLEjB5k2aQJhoaHUqdeQVu06AjByyA9c9b5MqbLl6dKtFwAL584iW3a3aB9XJMyqB0Lmgograxtr+v0wEI/NW1m6YhUrVyznird3pG3atv+O1es3snr9Rnr06kPRYsVxTpYMiH6OCD8/P7w8L7DWYzO2trZcvnSRwMBANnqsp+m3LT7ZuYkPM23ieEp+VYYV67ewaOU6Mv/fo6cWz5+DW67cLF7lwbBR45k2aTxgmA968oRxTJ4+i2VrN7F7x1auXfXG+/JF7O0TsXiVB54XzvHCz4+HDx5w4dx/Er4xUErFejE1CeA4cnVNRZ68huFBjo5OZMuWjfv3fd+6/fatf1Kz1psZ0YoWK05SZ+dI21hZKUJCQtBaExgQiI2NDYsWzOPbFq2wtbX9OCci4tULPz/OnDpJnXqGh3/a2tqRJEnSSNtcv3qFIsVLApA5azbu3rnD40cP8Tx/lgwZM5I+Q0Zsbe2oXK0WB/fvw8bGhqCgQMLCwggNCcHK2oq5s36lQ+dun/z8zIk5PZJIAvgD+PjcxsvTkwIFv4j284CAAA4fOkiVqtViPI6joxNlypajacN6pHR1xSlJEs6e/Y9Klat8jGqLj+DOndskS56ccSOH0LZ5Q8aPHk5AgH+kbXLkzMVfe3cBhqcw+967w/37vjy470uq1GmN26VKnZoHD3zJkjU7yZInp12LRpQuW4Hbt26itSbXOx6F9bmzmDvhxNv5v3xJ31496D9wME5OTtFu89f+fRQqXMTY/RCTdh060q5DeL/f8CG4d+vB+rVrOHrkEG45c9GpS9d4rb+IX6GhoVzy8qR3/yHkK1CQaRPHs2TBXDp17WHcplXb75g2aTxtvm1A9hw5ccuVGyurmNtAvfoNMr7+oVdX+g8ZyaJ5f+B96SLFS37FNw0af7RzMlsJIVljSVrA7yE4OJg+vXpQ6+s6MbZut2/7k5q1vo7TsT09L6C1JnOWrOzcsZ2JU37h1q1b3Lhx/QNrLT6mVKlS45oqNfnCnzRdoUo1Lnl5RtrG0cmJISPHsWjFeoaNHs/TJ09Inz4jrqlSc9/3rnG7+76+uLpGvtP/4P695MqTjwB/f3xu32LMT1PYt2cngQEBH//kzIxMyG7BtNaMHD6EbNmy0brtWyeEw8/Pj5PHj1OhUtwulvz+6y+4d+9JSEgIYWGhgKGPODAg8IPqLT6uFCldSZU6DTeuXwPg5D/HyJIt8vzPfn7PCQ5+BcBmj7UUKlIMRycncufNz+1bN7njc5vg4Ffs2bmVMuUrGvcLCQ5m1fLFtGjdnqCgQOPFo7CwMIJDgj/RGZoPc+oDli6IODr170m2bNqIW86cNGlQF4Duvfpw9+4dAJo0/RaAvbt38VXp0iROHPmx9xHniKhaqRzfu3enQUPDr5F79+wmX778pEplaP3kyp2HhvXqkDNnTnLlzo1I2Hr/MJhRQwcQEhxMuvQZGDxyLB5rVwFQv1FTbly7ytgRg0EpsmbLwaDhowGwsbGh9w9D6NOtE6GhYdSuW59s2XMYj7tuzQpq1q5LIgcHcrjlIjAwgFZN6vFVmbJRLvSJhBGssSWPpRcmIXNBiOjEx1wQ531exjpz8qV3TLhzQQghhLkxpxawBLAQwqKYUf5KAAshLIwZJbAEsBDCoiSEZ73FlgSwEMKixGf8KqWuA35AKBCitS6mlHIBVgFZgOtAE631/z81KFZkHLAQwrLE/73IFbXWhbTWxcLfDwT2aK3dgD3h79+LBLAQwqJ8gjvh6gKLwl8vAuq974EkgIUQFiUud8IppToppU5EWDr93+E0sFMpdTLCZ6m11q/vHb/HBzwhXvqAhRAWJS7tWq31bGB2DJuU0Vr7KKVSAbuUUl7/t79WSr33zWbSAhZCWJT4nJBda+0T/vd9wAMoAfgqpdKGl5UWuP++dZUAFkJYlPiajEcp5aiUSvL6NVANOAdsAl4/h6wNsPF96ypdEEIIixKPw9BSAx7hLWUbYLnWertS6jiwWinVAbgBNHnfAiSAhRCWJZ4SWGt9FYjyuBut9SMgXh7KJwEshLAoCWGi9diSABZCWBQzuhNZAlgIYVmsJICFEMJUzCeBJYCFEBZFuiCEEMJEzCh/JYCFEJZFWsBCCGEisbnFOKGQABZCWBTziV8JYCGEhTGjBrAEsBDCssidcEIIYSrmk78SwEIIy2JG+SsBLISwLPJYeiGEMBEzyl95IoYQQpiKtICFEBbFnFrAEsBCCIsiw9CEEMJEpAUshBAmIgEshBAmIl0QQghhItICFkIIEzGj/JUAFkJYGDNKYAlgIYRFMadbkZXW2tR1+GwopTpprWebuh4iYZF/F58vuRX50+pk6gqIBEn+XXymJICFEMJEJICFEMJEJIA/LennE9GRfxefKbkIJ4QQJiItYCGEMBEJYCGEMBEJ4E9EKVVDKXVRKeWtlBpo6voI01NKzVdK3VdKnTN1XYRpSAB/Akopa+B3oCaQF/hWKZXXtLUSCcBCoIapKyFMRwL40ygBeGutr2qtXwErgbomrpMwMa31AeCxqeshTEcC+NNID9yK8P52+DohxGdMAlgIIUxEAvjT8AEyRnifIXydEOIzJgH8aRwH3JRSWZVSdkAzYJOJ6ySEMDEJ4E9Aax0CdAN2AJ7Aaq31edPWSpiaUmoFcBTIpZS6rZTqYOo6iU9LbkUWQggTkRawEEKYiASwEEKYiASwEEKYiASwEEKYiASwEEKYiASwEEKYiASwEEKYyP8AYid6x+4xAYMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Gera um vetor com pesos 1 para pacientes negativos e 10 para pacientes positivos para COVID-19.\n",
    "pesos = [10 if i else 1 for i in y_train]\n",
    "\n",
    "classificador = RandomForestClassifier(n_estimators=100, random_state=0)\n",
    "classificador.fit(X_train, y_train, sample_weight=pesos)\n",
    "y_pred = classificador.predict(X_test)\n",
    "acuracia = classificador.score(X_test, y_test)*100\n",
    "\n",
    "# Mostra as métricas.\n",
    "print(classification_report(y_test, y_pred))\n",
    "print(f'Acurácia do classificador: {acuracia:.2f}%')\n",
    "show_confusion(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A melhoria no `recall` causou um resultado pior na acurácia do classificador, aumentando muito a quantidade de falsos positivos e consequentemente abaixando o valor da métrica `precision`, porém exibindo melhores resultados em detectar pacientes com a doença em relação a abordagem anterior."
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}