04. Incerteza/2020_2_AP_04_RBayes_GrupoF.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "2020.2_AP_04_RBayes_GrupoF_WendelMarques.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "UGx1isXhsUu2",
        "AgOiENPBExaT"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mLKPZajBKe3L"
      },
      "source": [
        "**Instituto de Informática - UFG**\n",
        "\n",
        "Disciplina: Inteligência Artificial\n",
        "\n",
        "Prof. Cedric Luiz de Carvalho\n",
        "\n",
        "---\n",
        "\n",
        "Aluna(o): Wendel Marques de Jesus Souza\n",
        "\n",
        "---\n",
        "\n",
        "Grupo (F)\n",
        "\n",
        "---\n",
        "\n",
        "Papel no grupo: Engenheiro de Conhecimento\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_bZhd8FMiSa"
      },
      "source": [
        "##Especificação do problema : Incerteza"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YTE0x5IrTiwN"
      },
      "source": [
        "As doenças cardiovasculares são a maior causa de morte no planeta. Milhões de pessoas morrem anualmente por problemas cardíacos.  O assunto tem sido objeto de pesquisa tanto na academia quanto na indústria. Por exemplo, [Saheki e outros](http://sites.poli.usp.br/p/fabio.cozman/Publications/Article/saheki-sharovsky-cozman-coupe-enia2003.pdf) desenvolveram uma rede bayesiana para tratar do assunto.\n",
        "\n",
        "A partir do estudo de trabalhos já desenvolvidos e da [base de dados](https://www.kaggle.com/andrewmvd/heart-failure-clinical-data) disponibilizada, construa uma rede bayesiana que permita fazer predições de óbitos por essas doenças.\n",
        "\n",
        "**Observação**: O trabalho deve ser feito em grupo, mas a avaliação será feita individualmente. O grupo deve dividir o trabalho de forma que um dos membros implemente uma análise exploratória dos dados e o outro se encarregue de implementar o modelo, o qual deve ser definido em conjunto pelo grupo.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UX618MS7CVUl"
      },
      "source": [
        "## Instruções de uso\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xu-Ue28U6NM2"
      },
      "source": [
        "\n",
        "Para que seja possível utilizar o modelo, antes de tudo deve-se criar uma conta do Google ($accounts.google.com$). Em seguida, se necessário, salve o arquivo $.ipynb$ no Google Drive. Após isso, abra o arquivo com Google Colaboratory.\n",
        "\n",
        "\n",
        "Siga os passos abaixo:\n",
        "\n",
        "* Bibliotecas necessárias: Excute a célula dessa seção para carregar as bibliotecas necessárias.\n",
        "\n",
        "* Upload de arquivo - Realize o $upload$ da base de dados para o sistema de arquivos local. Execute a célula em questão e clique em *Escolher arquivos*. Em seguida selecione a base de dados. \n",
        "\n",
        "* Preparação dos dados - Todas conversões e limpeza são realizadas nessa etapa. Gera os conjuntos de dados para a implementação do modelo.\n",
        "\n",
        "* Implementação do modelo - Etapa em que a bayesiana é criada.\n",
        "\n",
        "* Arquitetura da rede - Execute as células dessa seção para obter informações sobre a arquitetura da rede. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CtjeyPswr4cS"
      },
      "source": [
        "##Informações gerais"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UGx1isXhsUu2"
      },
      "source": [
        "###Balanceamento"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P6Snc2yTstwx"
      },
      "source": [
        "Cogitamos o uso da técnica de Random Undersampling para realizar o desbalanceamento das classes. A técnica exclui aleatoriamente exemplos da classe majoritária. Apesar da base já ser pequena, cogitamos seu uso pelo fato do SMOTE gera amostras sintéticas fora do padrão. Além disso, o modelo Naive Bayes lida muito bem com uma base de dados pequena.\n",
        "\n",
        "Considerando isso e os resultados da análise exploratória do dados, testamos o seu uso, mas os resultado não foram satisfatórios. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qFG7o7bBCc-y",
        "outputId": "6881c2e8-bbd8-4d13-b573-89cb4ac4449a"
      },
      "source": [
        "df_exemplos = pd.read_csv('heart_failure_clinical_records_dataset.csv')\n",
        "y = df_exemplos['DEATH_EVENT']\n",
        "print(pd.Series(y).value_counts())\n",
        "print('\\n\\n')\n",
        " \n",
        "#Plota a distribuição da classe target\n",
        "sns.countplot(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0    203\n",
            "1     96\n",
            "Name: DEATH_EVENT, dtype: int64\n",
            "\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f9fc2e1f790>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OBinVgcfVidm"
      },
      "source": [
        "#### Este código seria responsavel realizar o balancemento das classes\n",
        "\n",
        "# instantiating the random undersampler\n",
        "# rus = RandomUnderSampler() \n",
        "# # resampling X, y\n",
        "# x_train, y_train = rus.fit_sample(x_train, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AgOiENPBExaT"
      },
      "source": [
        "### Discretização"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pSRLOcDhFFYk"
      },
      "source": [
        "A discretização fornece uma maneira de particionar recursos contínuos em valores discretos. \n",
        "\n",
        "Utilizamos o [KBinsDiscretizer](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.KBinsDiscretizer.html) para dividir os dados contínuos em intervalos.  \n",
        "\n",
        "As manipulações referentes ao processo de discretização foram implementadas com base no trabalho [Comparing performance of 13 Classifiers | F1-score](https://www.kaggle.com/para24/comparing-performance-of-13-classifiers-f1-score). As funções to_categorical e return_categoricals, que são responsáveis por detectar colunas do tipo \"category\" e converter colunas para esse mesmo tipo, foram utilizadas na integra.\n",
        "  \n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDVsum4t0573"
      },
      "source": [
        "### Modelo Utilizado"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "az7aLgmc09e2"
      },
      "source": [
        "\n",
        "\n",
        "O classificador Naive Bayes categórico é adequado para classificação com recursos discretos que são categoricamente distribuídos. As categorias de cada recurso são tiradas de uma distribuição categórica. Ele é um classificador ingênuo para dados distribuídos categoricamente. Ele pressupõe que cada recurso, que é descrito pelo índice, tem sua própria distribuição categórica.\n",
        "\n",
        "Como a maioria dos recursos são categóricos e seguem uma distribuição categórica, usaremos o NB Categórico ([CategoricalNB](https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.CategoricalNB.html#sklearn.naive_bayes.CategoricalNB)). Os dados continuos serão discretizados."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFQLZKjQ0ly_"
      },
      "source": [
        "### Seleção de atributos\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YoW4PP3l1Zvc"
      },
      "source": [
        "A suposição fundamental feita por Naive Bayes em relação aos dados é a independência condicional de classe dos recursos. Nesse sentido, optamos por utilizar todos os recursos disponíveis. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VyVzNrgJHoNx"
      },
      "source": [
        "##Bibliotecas necessárias"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kHXdX2kBFSpL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c4fd2482-06b6-41d4-ffa4-3c59fb62b097"
      },
      "source": [
        "from google.colab import files\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "from imblearn.over_sampling import SMOTE\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.preprocessing import OneHotEncoder, StandardScaler, LabelEncoder\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.pipeline import Pipeline \n",
        "from sklearn.naive_bayes import CategoricalNB, GaussianNB \n",
        "from sklearn.preprocessing import KBinsDiscretizer, OrdinalEncoder\n",
        "from sklearn import metrics\n",
        "from sklearn.model_selection import train_test_split\n",
        "from imblearn.under_sampling import RandomUnderSampler\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score, \\\n",
        "                            precision_recall_curve, roc_curve, accuracy_score\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import accuracy_score, plot_confusion_matrix, classification_report, plot_roc_curve\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/externals/six.py:31: FutureWarning: The module is deprecated in version 0.21 and will be removed in version 0.23 since we've dropped support for Python 2.7. Please rely on the official version of six (https://pypi.org/project/six/).\n",
            "  \"(https://pypi.org/project/six/).\", FutureWarning)\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:144: FutureWarning: The sklearn.neighbors.base module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n",
            "  warnings.warn(message, FutureWarning)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SVKpmK3y23Au"
      },
      "source": [
        "## Upload de arquivo\n",
        "Realize o upload da base de dados para o sistema de arquivos local. O caminho é automaticamente configurado para o arquivo enviado."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HeJ4cBHNJBoX",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "e5943dad-4e15-4aed-9870-fbf001f97ff2"
      },
      "source": [
        "#Carrega os dados para a plataforma\n",
        "uploaded = files.upload()\n",
        "df = pd.read_csv('heart_failure_clinical_records_dataset.csv')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-2c6a4111-3d59-4c20-b110-719aebf21aca\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-2c6a4111-3d59-4c20-b110-719aebf21aca\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving heart_failure_clinical_records_dataset.csv to heart_failure_clinical_records_dataset.csv\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7-CLC_rSu6D"
      },
      "source": [
        "##Preparação dos dados\n",
        "######Limpeza, seleção de amostras, balanceamento e discretização"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdDBWz3IM2YI"
      },
      "source": [
        "#Converte as colunas para o tipo de dados \"category\"\n",
        "def to_categorical(columns, df):\n",
        "    for col in columns:\n",
        "        df[col] = df[col].astype('category')\n",
        "    return df\n",
        "\n",
        "#Retorna uma lista de colunas que têm menos ou igual ao número de limite de níveis categóricos únicos\n",
        "def return_categoricals(df, threshold):\n",
        "    return list(filter(lambda c: c if len(df[c].unique()) <= threshold else None,\n",
        "                       df.columns))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zhGVBFjEFkQd"
      },
      "source": [
        "#Carrega os dados\n",
        "df = pd.read_csv('heart_failure_clinical_records_dataset.csv')\n",
        "\n",
        "#Eliminavalores missing (caso seja necessário)\n",
        "df.dropna(inplace=True)\n",
        "\n",
        "#Remove de duplicates, se necessário\n",
        "df.drop_duplicates(keep=False, inplace=True)\n",
        "\n",
        "#Recupera uma lista de colunas que possuem um número máximo de 5 níveis categóricos únicos\n",
        "to_cast = return_categoricals(df, threshold=3)\n",
        "#Converte as colunas para o tipo de dados \"category\"\n",
        "df = to_categorical(to_cast, df)\n",
        "\n",
        "#Separa a váriavel target das demais váriaveis \n",
        "x = df.iloc[:, :-1]\n",
        "y = df['DEATH_EVENT']\n",
        "\n",
        "#Construção de uma lista de colunas do tipo \"category\" e \"Numeric\", respectivamente\n",
        "categorical_columns = list(x.select_dtypes(include='category').columns)\n",
        "numeric_columns = list(x.select_dtypes(exclude='category').columns)\n",
        "\n",
        "#Inicio do processo de discretização dos dados\n",
        "##Criação de um Pipeline de transformações \n",
        "numeric_trans_nb = Pipeline(steps=[('kbn', KBinsDiscretizer(n_bins=3, encode='ordinal'))])\n",
        "categorical_trans_nb = Pipeline(steps=[\n",
        "    ('ordinal', OrdinalEncoder(dtype=np.int64))])~\n",
        "\n",
        "#Separação de dados treino e dados de teste\n",
        "#Proporção de 25% para teste\n",
        "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state=0, shuffle=True, stratify=y)\n",
        "\n",
        "#Transformador de colunas\n",
        "preprocessor_nb = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_trans_nb, numeric_columns),\n",
        "        ('cat', categorical_trans_nb, categorical_columns)],\n",
        "    remainder='passthrough')\n",
        "\n",
        "#Aplicação do transformador de colunas\n",
        "x_train = preprocessor_nb.fit_transform(x_train)\n",
        "x_test = preprocessor_nb.transform(x_test) \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d8SLO0OZDtNA"
      },
      "source": [
        "##Implementação"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 760
        },
        "id": "hCUDiXCqDsp4",
        "outputId": "43f88d17-f466-4de0-8552-fde69981b1b8"
      },
      "source": [
        "#Criando objeto CategoricalNB\n",
        "predict_cardio = CategoricalNB()\n",
        "\n",
        "#Treina o modelo  \n",
        "predict_cardio.fit(x_train,y_train)\n",
        "\n",
        "#Executa a predição no conjunto de teste\n",
        "y_test_pred = predict_cardio.predict(x_test)\n",
        "\n",
        "#Cálculo de métricas de avaliação\n",
        "metricas = accuracy_score(y_test,y_test_pred)\n",
        "\n",
        "#Exibe  métricas de avaliação\n",
        "print(\"======================= RELATÓRIO DE CLASSIFICAÇÃO =======================\\n\")\n",
        "print(f\"Tamanho do Treino: {x_train.shape[0]} amostras\")\n",
        "print(f\"Tamanho do Teste: {x_test.shape[0]} amostras\\n\")\n",
        "print(f\"\\nTaxa de sucesso: {round(metricas*100,2)}%\\n\")\n",
        "print(classification_report(y_test,y_test_pred))\n",
        "print(\"\\n\\n\\n\")\n",
        "\n",
        "#Realiza plotagens \n",
        "print(\"======================= PLOTS =======================\\n\\n\")\n",
        "fig, ax = plt.subplots(1,2,figsize=(12,5))\n",
        "plot_confusion_matrix(predict_cardio,x_test,y_test,cmap='Blues',ax=ax[0])\n",
        "ax[0].set_title(\"Matriz de confusão\",fontsize=16)\n",
        "ax[0].set_xticks([0,0], [\"Heart Not Failed\",\"Heart Fail\"])\n",
        "ax[0].set_yticks([0,1], [\"Heart Not Failed\",\"Heart Fail\"])\n",
        "ax[0].grid(False)\n",
        "\n",
        "plot_roc_curve(predict_cardio,x_test,y_test,ax=ax[1])\n",
        "ax[1].set_title(\"ROC Curve\",fontsize=16)\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "======================= RELATÓRIO DE CLASSIFICAÇÃO =======================\n",
            "\n",
            "Tamanho do Treino: 224 amostras\n",
            "Tamanho do Teste: 75 amostras\n",
            "\n",
            "\n",
            "Taxa de sucesso: 82.67%\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.83      0.94      0.88        51\n",
            "           1       0.82      0.58      0.68        24\n",
            "\n",
            "    accuracy                           0.83        75\n",
            "   macro avg       0.83      0.76      0.78        75\n",
            "weighted avg       0.83      0.83      0.82        75\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "======================= PLOTS =======================\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x360 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uHSOi5ZYkCR5"
      },
      "source": [
        "##Resultados e discussão"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vy5Qz7Rw8Isg"
      },
      "source": [
        "###Resultados:\n",
        "\n",
        "A matriz de confusão relaciona a classe esperada com a classe obtida pelo modelo, permitindo a análise de erro. Classe 1 significa \"óbito\" e classe 0 significa \"não óbito\". \n",
        "\n",
        "* Os falsos positivos (3 classificações), representa que o algoritmo concluiu que 3 pacientes iriam óbito, sendo que a classificão correta seria de que eles não iriam a óbito. \n",
        "\n",
        "* Os falsos negativos (10 classificações), representa que o algoritmo concluiu que 3 pacientes não iriam óbito, sendo que a classificaão correta seria de que eles iriam a óbito. \n",
        "\n",
        "* accuracy: a matriz de confussão indica que a classificação obteve uma taxa de sucesso igual a 82.67%.\n",
        "\n",
        "* precision: quando ele prevê um \"não óbito\", ele está certo em 83% dos casos; quando ele prevê um \"óbito\", ele está certo em 82% dos casos. \n",
        "\n",
        "* recall: quando a resposta da classe é \"não óbito\", ele classificar corrretamente em 94% dos casos; quando a resposta da classe é \"óbito\", ele classifica corretamente 58% dos casos. \n",
        "\n",
        "* A curva AUC - ROC é uma medida de desempenho para os problemas de classificação. ROC é uma curva de probabilidade e AUC representa o grau ou medida de separabilidade. Quanto mais alta a AUC, melhor o modelo distingue entre pacientes com que iriam a óbito e os pacientes que não iriam a óbito.  Uma AUC próximo de 88% significa que o modelo tem uma boa medida de separabilidade.\n",
        "\n",
        "##Discussão:\n",
        "Embora recall de 58% é preocupante, uma vez que um sistema de predições de óbitos deva detectar quem tem maior probabilidade de falecer para que medidas de intervenção tomadas. Apesar disso, uma precisão de 82% é um bom valor, tendo em vista que 82% vidas poderiam ser salvas.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LXgkORxSc73w"
      },
      "source": [
        "##Arquitetura da rede"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0SFU0NVmdtba",
        "outputId": "142f8f7c-737b-4c8a-f945-38ba64034716"
      },
      "source": [
        "#Exibe a probabilidade das categorias, considerando o respectivo recurso e classe P(x_i|y), onde xi é o recurso e y é a classe\n",
        "\n",
        "columns_name = ['age',\t'anaemia',\t'creatinine_phosphokinase',\t'diabetes',\t'ejection_fraction',\t'high_blood_pressure',\t\n",
        "                'platelets',\t'serum_creatinine',\t'serum_sodium',\t'sex',\t'smoking'\t,'time']\n",
        "count = 0\n",
        "count_2 = 0\n",
        "\n",
        "for amostras in predict_cardio.feature_log_prob_ :\n",
        "  print('=============== '+columns_name[count]+' ===============\\n')\n",
        "  print('\\tClasse \"Não óbito (0)\":')\n",
        "\n",
        "  count_2 = 0\n",
        "  for aux in amostras[0]:\n",
        "    print(f'\\t\\t\\t{count_2}: {round(np.exp(aux)*100,2)}%')\n",
        "    count_2+=1\n",
        "\n",
        "\n",
        "  print('\\n\\tClasse \"Óbito (1)\":')\n",
        "  count_2 = 0\n",
        "  for aux in amostras[1]:\n",
        "    print(f'\\t\\t\\t{count_2}: {round(np.exp(aux)*100,2)}%')\n",
        "    count_2+=1\n",
        "\n",
        "  count+=1\n",
        "  print('\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "=============== age ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 38.06%\n",
            "\t\t\t1: 29.68%\n",
            "\t\t\t2: 32.26%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 24.0%\n",
            "\t\t\t1: 29.33%\n",
            "\t\t\t2: 46.67%\n",
            "\n",
            "\n",
            "=============== anaemia ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 35.48%\n",
            "\t\t\t1: 29.03%\n",
            "\t\t\t2: 35.48%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 29.33%\n",
            "\t\t\t1: 34.67%\n",
            "\t\t\t2: 36.0%\n",
            "\n",
            "\n",
            "=============== creatinine_phosphokinase ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 20.0%\n",
            "\t\t\t1: 33.55%\n",
            "\t\t\t2: 46.45%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 58.67%\n",
            "\t\t\t1: 21.33%\n",
            "\t\t\t2: 20.0%\n",
            "\n",
            "\n",
            "=============== diabetes ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 30.32%\n",
            "\t\t\t1: 34.84%\n",
            "\t\t\t2: 34.84%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 40.0%\n",
            "\t\t\t1: 29.33%\n",
            "\t\t\t2: 30.67%\n",
            "\n",
            "\n",
            "=============== ejection_fraction ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 35.48%\n",
            "\t\t\t1: 35.48%\n",
            "\t\t\t2: 29.03%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 9.33%\n",
            "\t\t\t1: 28.0%\n",
            "\t\t\t2: 62.67%\n",
            "\n",
            "\n",
            "=============== high_blood_pressure ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 20.65%\n",
            "\t\t\t1: 33.55%\n",
            "\t\t\t2: 45.81%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 42.67%\n",
            "\t\t\t1: 29.33%\n",
            "\t\t\t2: 28.0%\n",
            "\n",
            "\n",
            "=============== platelets ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 17.42%\n",
            "\t\t\t1: 36.77%\n",
            "\t\t\t2: 45.81%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 65.33%\n",
            "\t\t\t1: 24.0%\n",
            "\t\t\t2: 10.67%\n",
            "\n",
            "\n",
            "=============== serum_creatinine ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 58.44%\n",
            "\t\t\t1: 41.56%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 47.3%\n",
            "\t\t\t1: 52.7%\n",
            "\n",
            "\n",
            "=============== serum_sodium ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 58.44%\n",
            "\t\t\t1: 41.56%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 55.41%\n",
            "\t\t\t1: 44.59%\n",
            "\n",
            "\n",
            "=============== sex ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 66.88%\n",
            "\t\t\t1: 33.12%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 60.81%\n",
            "\t\t\t1: 39.19%\n",
            "\n",
            "\n",
            "=============== smoking ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 33.77%\n",
            "\t\t\t1: 66.23%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 37.84%\n",
            "\t\t\t1: 62.16%\n",
            "\n",
            "\n",
            "=============== time ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t\t0: 66.88%\n",
            "\t\t\t1: 33.12%\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t\t0: 71.62%\n",
            "\t\t\t1: 28.38%\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cpCC-1hIkHk9",
        "outputId": "8e2079d7-d3b7-4894-e76f-bd248f97cde8"
      },
      "source": [
        "#Exibe o número de amostras encontradas para cada classe e categoria de recurso específico\n",
        "count = 0\n",
        "count_2 = 0\n",
        "for amostras in predict_cardio.category_count_:\n",
        "  print('=============== ' + columns_name[count] +' ===============\\n')\n",
        "  print('\\tClasse \"Não óbito (0)\":')\n",
        "\n",
        "  count_2 = 0\n",
        "  for aux in amostras[0]:\n",
        "    print(f'\\t\\t{count_2}: {int(aux)} amostras')\n",
        "    count_2+=1\n",
        "\n",
        "\n",
        "  print('\\n\\tClasse \"Óbito (1)\":')\n",
        "  count_2 = 0\n",
        "  for aux in amostras[1]:\n",
        "    print(f'\\t\\t{count_2}: {int(aux)} amostras')\n",
        "    count_2+=1\n",
        "\n",
        "  count+=1\n",
        "  print('\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "=============== age ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 58 amostras\n",
            "\t\t1: 45 amostras\n",
            "\t\t2: 49 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 17 amostras\n",
            "\t\t1: 21 amostras\n",
            "\t\t2: 34 amostras\n",
            "\n",
            "\n",
            "=============== anaemia ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 54 amostras\n",
            "\t\t1: 44 amostras\n",
            "\t\t2: 54 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 21 amostras\n",
            "\t\t1: 25 amostras\n",
            "\t\t2: 26 amostras\n",
            "\n",
            "\n",
            "=============== creatinine_phosphokinase ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 30 amostras\n",
            "\t\t1: 51 amostras\n",
            "\t\t2: 71 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 43 amostras\n",
            "\t\t1: 15 amostras\n",
            "\t\t2: 14 amostras\n",
            "\n",
            "\n",
            "=============== diabetes ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 46 amostras\n",
            "\t\t1: 53 amostras\n",
            "\t\t2: 53 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 29 amostras\n",
            "\t\t1: 21 amostras\n",
            "\t\t2: 22 amostras\n",
            "\n",
            "\n",
            "=============== ejection_fraction ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 54 amostras\n",
            "\t\t1: 54 amostras\n",
            "\t\t2: 44 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 6 amostras\n",
            "\t\t1: 20 amostras\n",
            "\t\t2: 46 amostras\n",
            "\n",
            "\n",
            "=============== high_blood_pressure ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 31 amostras\n",
            "\t\t1: 51 amostras\n",
            "\t\t2: 70 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 31 amostras\n",
            "\t\t1: 21 amostras\n",
            "\t\t2: 20 amostras\n",
            "\n",
            "\n",
            "=============== platelets ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 26 amostras\n",
            "\t\t1: 56 amostras\n",
            "\t\t2: 70 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 48 amostras\n",
            "\t\t1: 17 amostras\n",
            "\t\t2: 7 amostras\n",
            "\n",
            "\n",
            "=============== serum_creatinine ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 89 amostras\n",
            "\t\t1: 63 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 34 amostras\n",
            "\t\t1: 38 amostras\n",
            "\n",
            "\n",
            "=============== serum_sodium ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 89 amostras\n",
            "\t\t1: 63 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 40 amostras\n",
            "\t\t1: 32 amostras\n",
            "\n",
            "\n",
            "=============== sex ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 102 amostras\n",
            "\t\t1: 50 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 44 amostras\n",
            "\t\t1: 28 amostras\n",
            "\n",
            "\n",
            "=============== smoking ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 51 amostras\n",
            "\t\t1: 101 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 27 amostras\n",
            "\t\t1: 45 amostras\n",
            "\n",
            "\n",
            "=============== time ===============\n",
            "\n",
            "\tClasse \"Não óbito (0)\":\n",
            "\t\t0: 102 amostras\n",
            "\t\t1: 50 amostras\n",
            "\n",
            "\tClasse \"Óbito (1)\":\n",
            "\t\t0: 52 amostras\n",
            "\t\t1: 20 amostras\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W4Cxycg7kbRI",
        "outputId": "c492801f-0c98-4bf4-b7f4-45b57515d409"
      },
      "source": [
        "# Número de amostras encontradas para cada classe durante a adaptação\n",
        "n_ob = predict_cardio.class_count_[0]\n",
        "ob = predict_cardio.class_count_[1]\n",
        "\n",
        "print('Número de amostras encontradas para cada classe durante a adaptação:\\n')\n",
        "print(f'Classe \"Não óbito (0)\": {n_ob}')\n",
        "print(f'Classe \"Óbito (1)\": {ob}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Número de amostras encontradas para cada classe durante a adaptação:\n",
            "\n",
            "Classe \"Não óbito (0)\": 152.0\n",
            "Classe \"Óbito (1)\": 72.0\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}