ML_for_Patient_Absence.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Author: Geoffrey Porto - https://www.linkedin.com/in/geoffreyporto/"
      ],
      "metadata": {
        "id": "oCexpq9T6qha"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install scikit-fuzzy"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MKDFQuH57Y2d",
        "outputId": "9b65b35d-7ab2-4746-9e4e-e8bdb0aac8c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: scikit-fuzzy in /usr/local/lib/python3.10/dist-packages (0.4.2)\n",
            "Requirement already satisfied: numpy>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from scikit-fuzzy) (1.25.2)\n",
            "Requirement already satisfied: scipy>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from scikit-fuzzy) (1.11.4)\n",
            "Requirement already satisfied: networkx>=1.9.0 in /usr/local/lib/python3.10/dist-packages (from scikit-fuzzy) (3.2.1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vEiNB0cL6iCy"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import skfuzzy as fuzz\n",
        "from skfuzzy import control as ctrl\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.DEBUG)\n",
        "logger = logging.getLogger(__name__)"
      ],
      "metadata": {
        "id": "tIJCiXIIdgmO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Clases de Wrapper\n",
        "Criamos uma classe wrapper que encapsule o sistema de controle difuso e implemente os métodos fit e predict de acordo com a API do scikit-learn.\n",
        "\n",
        "O bloco try-except no método predict captura exceções ValueError e TypeError. Quando ocorre um erro durante a computação do sistema de controle difuso, um valor padrão de 0 é atribuído à previsão.\n",
        "\n",
        "Podemos ajustar o valor padrão (0) de acordo com o seu caso específico. Além disso,podemos adicionar mensagens de log ou depuração para identificar os casos em que a computação do sistema de controle difuso está falhando.\n",
        "\n",
        "Lembremos de revisar cuidadosamente a definição das variáveis de entrada, funções de pertinência e regras do seu sistema de controle difuso para garantir que estejam corretas e consistentes."
      ],
      "metadata": {
        "id": "yHXlvvT9f0ka"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.base import BaseEstimator, ClassifierMixin\n",
        "class FuzzyControlSystemWrapper(BaseEstimator, ClassifierMixin):\n",
        "    def __init__(self, control_system, idade_jovem_mean=20, idade_jovem_std=5,\n",
        "                 idade_meia_idade_mean=40, idade_meia_idade_std=5):\n",
        "        self.control_system = control_system\n",
        "        self.sim = ctrl.ControlSystemSimulation(control_system)\n",
        "\n",
        "        self.idade_jovem_mean = idade_jovem_mean\n",
        "        self.idade_jovem_std = idade_jovem_std\n",
        "        self.idade_meia_idade_mean = idade_meia_idade_mean\n",
        "        self.idade_meia_idade_std = idade_meia_idade_std\n",
        "\n",
        "        # Atualizar as funções de pertinência com os parâmetros fornecidos\n",
        "        idade['Jovem'] = fuzz.gaussmf(idade.universe, self.idade_jovem_mean, self.idade_jovem_std)\n",
        "        idade['Meia-idade'] = fuzz.gaussmf(idade.universe, self.idade_meia_idade_mean, self.idade_meia_idade_std)\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self\n",
        "\n",
        "    def predict(self, X):\n",
        "        previsoes = []\n",
        "        for index, row in X.iterrows():\n",
        "            self.sim.input['Idade'] = row['Idade']\n",
        "            self.sim.input['Gravidade'] = row['Gravidade']\n",
        "            self.sim.input['Renda'] = row['Renda']\n",
        "            self.sim.input['Distancia'] = row['Distancia']\n",
        "            self.sim.input['Frequencia'] = row['Frequencia']\n",
        "\n",
        "            try:\n",
        "                self.sim.compute()\n",
        "                previsoes.append(self.sim.output['Risco'])\n",
        "            except (ValueError, TypeError) as e:\n",
        "                logger.error(f\"Falha na computação do sistema de controle difuso para a linha {index}\")\n",
        "                logger.error(f\"Valores de entrada: {row}\")\n",
        "                logger.error(f\"Mensagem de erro: {str(e)}\")\n",
        "                previsoes.append(0)  # Valor padrão para falha na computação\n",
        "\n",
        "        limite = 7\n",
        "        previsoes_rotulos = ['Alto' if x >= limite else 'Baixo' for x in previsoes]\n",
        "        return previsoes_rotulos\n"
      ],
      "metadata": {
        "id": "MtKH-1_FZrCe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Pré-processamento dos dados\n",
        "Realize a normalização ou o escalonamento dos dados de entrada para garantir que estejam na mesma escala e evitar a dominância de certas variáveis.\n",
        "Lide com outliers e valores discrepantes que possam afetar o desempenho do modelo."
      ],
      "metadata": {
        "id": "eMaxyw3zTRkU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo de normalização dos dados\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "\n",
        "scaler = MinMaxScaler()\n",
        "X_scaled = scaler.fit_transform(X)"
      ],
      "metadata": {
        "id": "EZImdUFKTJ_W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_fQ8DOt-TQ9_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Google Drive\n",
        "\n",
        "**Dataset**\n",
        "\n",
        "- Idade: A idade do paciente em anos\n",
        "- Gravidade: A gravidade da condição do paciente (Leve, Moderada ou Grave).\n",
        "- Renda: A renda mensal do paciente em reais.\n",
        "- Distancia: A distância em quilômetros entre a residência do paciente e o hospital.\n",
        "- Frequencia: A frequência do paciente às consultas agendadas, expressa em porcentagem.\n",
        "- Risco: O risco de absenteísmo do paciente (Baixo, Medio ou Alto).\n",
        "\n",
        "```\n",
        "# Esto tiene formato de código\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "dULU0wwc6rtu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "from google.colab import files  #biblioteca utilizada para carregar os dados para o google colab\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RLvjnRlr6sF4",
        "outputId": "43c5edcd-f54f-4d93-d11a-b788a382cbc2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Carpeta base\n",
        "base_path = '/content/drive/MyDrive/Colab Notebooks/Datasets/Health/'\n",
        "\n",
        "#Base de dados completo\n",
        "data_patients = base_path+'/Patients/'\n",
        "\n",
        "\n",
        "os.listdir(data_patients)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TT6Ym6EA7n-v",
        "outputId": "f970110b-177a-4cc8-c365-ea055ccdb747"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['patients.csv', 'processed_patients.csv', 'patients_complex.gsheet']"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Carregar dados de um arquivo CSV\n",
        "#dados = pd.read_csv(data_patients+'patients.csv', delimiter=',', engine='pyarrow')\n",
        "dados = pd.read_csv(data_patients+'patients.csv', delimiter=',', engine='pyarrow')\n",
        "print(dados.head())\n",
        "print(dados.columns)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wgCqVgND8cVA",
        "outputId": "21b8a850-2ae2-43db-a8c9-4b1dffe86fd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   Idade Gravidade  Renda  Distancia  Frequencia  Risco\n",
            "0     32      Leve  45000        5.2          95  Baixo\n",
            "1     68     Grave  18000       12.8          60   Alto\n",
            "2     25  Moderada  32000        2.1          85  Baixo\n",
            "3     54  Moderada  28000        8.9          70  Medio\n",
            "4     42      Leve  56000        3.7          90  Baixo\n",
            "Index(['Idade', 'Gravidade', 'Renda', 'Distancia', 'Frequencia', 'Risco'], dtype='object')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Verificar se o DataFrame 'dados' está vazio\n",
        "if dados.empty:\n",
        "    print(\"O DataFrame 'dados' está vazio. Verifique o arquivo CSV.\")\n",
        "    exit()\n",
        "\n",
        "# Verificar se as colunas necessárias estão presentes no DataFrame 'dados'\n",
        "colunas_necessarias = ['Idade', 'Gravidade', 'Renda', 'Distancia', 'Frequencia', 'Risco']\n",
        "if not all(col in dados.columns for col in colunas_necessarias):\n",
        "    print(\"Uma ou mais colunas necessárias estão ausentes no DataFrame 'dados'.\")\n",
        "    exit()\n",
        "\n",
        "# Dividir os dados em conjuntos de treinamento e teste\n",
        "X = dados[['Idade', 'Gravidade', 'Renda', 'Distancia', 'Frequencia']]\n",
        "y = dados['Risco']\n",
        "print(X.shape)\n",
        "print(y.shape)\n",
        "print(X.head())\n",
        "print(y.head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k2pqNBV1Mi_2",
        "outputId": "a246d3fc-eef2-4d64-d59b-481a4ff014ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(20, 5)\n",
            "(20,)\n",
            "   Idade Gravidade  Renda  Distancia  Frequencia\n",
            "0     32      Leve  45000        5.2          95\n",
            "1     68     Grave  18000       12.8          60\n",
            "2     25  Moderada  32000        2.1          85\n",
            "3     54  Moderada  28000        8.9          70\n",
            "4     42      Leve  56000        3.7          90\n",
            "0    Baixo\n",
            "1     Alto\n",
            "2    Baixo\n",
            "3    Medio\n",
            "4    Baixo\n",
            "Name: Risco, dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Idade:\", dados['Idade'])\n",
        "print(\"Gravidade:\", dados['Gravidade'])\n",
        "print(\"Renda:\", dados['Renda'])\n",
        "print(\"Distancia:\", dados['Distancia'])\n",
        "print(\"Frequencia:\", dados['Frequencia'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "acjrckwz-w6P",
        "outputId": "4dcba681-153f-47ca-9fb6-5d3ed836fe0b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Idade: 0     32\n",
            "1     68\n",
            "2     25\n",
            "3     54\n",
            "4     42\n",
            "5     78\n",
            "6     37\n",
            "7     61\n",
            "8     29\n",
            "9     50\n",
            "10    71\n",
            "11    46\n",
            "12    58\n",
            "13    39\n",
            "14    64\n",
            "15    33\n",
            "16    52\n",
            "17    75\n",
            "18    28\n",
            "19    44\n",
            "Name: Idade, dtype: int64\n",
            "Gravidade: 0         Leve\n",
            "1        Grave\n",
            "2     Moderada\n",
            "3     Moderada\n",
            "4         Leve\n",
            "5        Grave\n",
            "6         Leve\n",
            "7        Grave\n",
            "8         Leve\n",
            "9     Moderada\n",
            "10       Grave\n",
            "11        Leve\n",
            "12    Moderada\n",
            "13        Leve\n",
            "14       Grave\n",
            "15        Leve\n",
            "16    Moderada\n",
            "17       Grave\n",
            "18        Leve\n",
            "19    Moderada\n",
            "Name: Gravidade, dtype: object\n",
            "Renda: 0     45000\n",
            "1     18000\n",
            "2     32000\n",
            "3     28000\n",
            "4     56000\n",
            "5     12000\n",
            "6     62000\n",
            "7     22000\n",
            "8     39000\n",
            "9     48000\n",
            "10    16000\n",
            "11    58000\n",
            "12    31000\n",
            "13    51000\n",
            "14    20000\n",
            "15    47000\n",
            "16    36000\n",
            "17    14000\n",
            "18    40000\n",
            "19    53000\n",
            "Name: Renda, dtype: int64\n",
            "Distancia: 0      5.2\n",
            "1     12.8\n",
            "2      2.1\n",
            "3      8.9\n",
            "4      3.7\n",
            "5     15.6\n",
            "6      6.4\n",
            "7     10.3\n",
            "8      1.8\n",
            "9      7.1\n",
            "10    13.5\n",
            "11     4.9\n",
            "12     9.6\n",
            "13     2.5\n",
            "14    11.2\n",
            "15     4.3\n",
            "16     6.8\n",
            "17    14.1\n",
            "18     1.5\n",
            "19     5.7\n",
            "Name: Distancia, dtype: float64\n",
            "Frequencia: 0     95\n",
            "1     60\n",
            "2     85\n",
            "3     70\n",
            "4     90\n",
            "5     50\n",
            "6     80\n",
            "7     65\n",
            "8     92\n",
            "9     78\n",
            "10    55\n",
            "11    88\n",
            "12    72\n",
            "13    94\n",
            "14    62\n",
            "15    91\n",
            "16    76\n",
            "17    52\n",
            "18    96\n",
            "19    82\n",
            "Name: Frequencia, dtype: int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Pré-processar os dados\n",
        "dados = dados.dropna()  # Remover registros com valores ausentes\n",
        "dados['Gravidade'] = dados['Gravidade'].map({'Leve': 1, 'Moderada': 2, 'Grave': 3})\n",
        "dados['Distancia'] = dados['Distancia'] / dados['Distancia'].max()  # Normalizar a distância\n",
        "\n",
        "# Definir variáveis de entrada e saída\n",
        "idade = ctrl.Antecedent(np.arange(0, 101, 1), 'Idade')\n",
        "gravidade = ctrl.Antecedent(np.arange(1, 4, 1), 'Gravidade')\n",
        "renda = ctrl.Antecedent(np.arange(0, 100001, 1), 'Renda')\n",
        "distancia = ctrl.Antecedent(np.arange(0, 1.1, 0.1), 'Distancia')\n",
        "frequencia = ctrl.Antecedent(np.arange(0, 101, 1), 'Frequencia')\n",
        "risco = ctrl.Consequent(np.arange(0, 11, 1), 'Risco')\n",
        "\n",
        "# Definir funções de pertinência difusas para cobrir melhor o espaço de entrada\n",
        "\n",
        "# Ajustar as funções de pertinência\n",
        "idade['Jovem'] = fuzz.trapmf(idade.universe, [0, 0, 25, 35])\n",
        "idade['Meia-idade'] = fuzz.trapmf(idade.universe, [30, 40, 50, 60])\n",
        "idade['Idoso'] = fuzz.trapmf(idade.universe, [55, 65, 100, 100])\n",
        "\n",
        "gravidade['Leve'] = fuzz.trapmf(gravidade.universe, [1, 1, 1, 2])\n",
        "gravidade['Moderada'] = fuzz.trapmf(gravidade.universe, [1, 2, 2, 3])\n",
        "gravidade['Grave'] = fuzz.trapmf(gravidade.universe, [2, 3, 3, 3])\n",
        "\n",
        "renda['Baixa'] = fuzz.trapmf(renda.universe, [0, 0, 20000, 30000])\n",
        "renda['Media'] = fuzz.trapmf(renda.universe, [20000, 30000, 50000, 60000])\n",
        "renda['Alta'] = fuzz.trapmf(renda.universe, [50000, 60000, 100000, 100000])\n",
        "\n",
        "distancia['Perto'] = fuzz.trapmf(distancia.universe, [0, 0, 0.3, 0.5])\n",
        "distancia['Media'] = fuzz.trapmf(distancia.universe, [0.3, 0.5, 0.7, 0.9])\n",
        "distancia['Longe'] = fuzz.trapmf(distancia.universe, [0.7, 0.9, 1, 1])\n",
        "\n",
        "frequencia['Boa'] = fuzz.trapmf(frequencia.universe, [70, 90, 100, 100])\n",
        "frequencia['Regular'] = fuzz.trapmf(frequencia.universe, [30, 50, 70, 90])\n",
        "frequencia['Ruim'] = fuzz.trapmf(frequencia.universe, [0, 0, 30, 50])\n",
        "\n",
        "risco['Baixo'] = fuzz.trimf(risco.universe, [0, 0, 5])\n",
        "risco['Medio'] = fuzz.trimf(risco.universe, [0, 5, 10])\n",
        "risco['Alto'] = fuzz.trimf(risco.universe, [5, 10, 10])\n"
      ],
      "metadata": {
        "id": "9VodBzL48tzJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Definir regras difusas\n",
        "regra1 = ctrl.Rule(idade['Idoso'] & (gravidade['Grave'] | gravidade['Moderada']) & distancia['Longe'], risco['Alto'])\n",
        "#regra1 = ctrl.Rule(idade['Idoso'] & gravidade['Grave'] & distancia['Longe'], risco['Alto'])\n",
        "regra2 = ctrl.Rule(renda['Baixa'] & frequencia['Ruim'], risco['Alto'])\n",
        "regra3 = ctrl.Rule(idade['Jovem'] & gravidade['Leve'] & distancia['Perto'], risco['Baixo'])\n",
        "regra4 = ctrl.Rule(renda['Alta'] & frequencia['Boa'], risco['Baixo'])\n",
        "regra5 = ctrl.Rule(idade['Meia-idade'] & gravidade['Moderada'] & distancia['Media'] & frequencia['Regular'], risco['Medio'])\n",
        "regra6 = ctrl.Rule(idade['Jovem'] & gravidade['Leve'] & distancia['Longe'] & renda['Media'], risco['Medio'])\n",
        "regra7 = ctrl.Rule(idade['Meia-idade'] & gravidade['Leve'] & distancia['Media'] & renda['Media'], risco['Medio'])\n",
        "regra8 = ctrl.Rule(idade['Idoso'] & gravidade['Moderada'] & frequencia['Regular'], risco['Alto'])\n",
        "regra9 = ctrl.Rule(idade['Jovem'] & gravidade['Moderada'] & frequencia['Boa'], risco['Medio'])\n"
      ],
      "metadata": {
        "id": "zLoJm6u7Fy1N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "sistema_controle = ctrl.ControlSystem()\n",
        "\n",
        "# Verificar as regras do sistema de controle difuso\n",
        "print(sistema_controle.rules)\n",
        "\n",
        "\n",
        "# Verificar as regras do sistema de controle difuso\n",
        "print(sistema_controle.rules)\n",
        "\n",
        "\n",
        "sistema_controle.addrule(regra1)\n",
        "print(\"Regra 1 adicionada com sucesso!\")\n",
        "\n",
        "sistema_controle.addrule(regra2)\n",
        "print(\"Regra 2 adicionada com sucesso!\")\n",
        "\n",
        "sistema_controle.addrule(regra3)\n",
        "print(\"Regra 3 adicionada com sucesso!\")\n",
        "\n",
        "sistema_controle.addrule(regra4)\n",
        "print(\"Regra 4 adicionada com sucesso!\")\n",
        "\n",
        "#sistema_controle.addrule(regra5)\n",
        "#print(\"Regra 5 adicionada com sucesso!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mbH5jo7HJWIW",
        "outputId": "d3d0b318-2435-452a-919f-cbb75daefe8f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<skfuzzy.control.controlsystem.RuleOrderGenerator object at 0x7af37fac7070>\n",
            "<skfuzzy.control.controlsystem.RuleOrderGenerator object at 0x7af37fac7070>\n",
            "Regra 1 adicionada com sucesso!\n",
            "Regra 2 adicionada com sucesso!\n",
            "Regra 3 adicionada com sucesso!\n",
            "Regra 4 adicionada com sucesso!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#print(simulacao.rules)\n",
        "\n",
        "# Imprimir as regras\n",
        "print(\"Regra 1:\", regra1)\n",
        "print(\"Regra 2:\", regra2)\n",
        "print(\"Regra 3:\", regra3)\n",
        "print(\"Regra 4:\", regra4)\n",
        "print(\"Regra 5:\", regra5)\n",
        "print(\"Regra 6:\", regra6)\n",
        "print(\"Regra 7:\", regra7)\n",
        "print(\"Regra 8:\", regra8)\n",
        "print(\"Regra 9:\", regra9)"
      ],
      "metadata": {
        "id": "1Pzf0aFlG0mA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Criar o sistema de controle difuso com as regras\n",
        "#sistema_controle = ctrl.ControlSystem([regra1, regra2, regra3, regra4, regra5, regra6, regra7, regra8, regra9])\n",
        "\n",
        "# Verificar se todas as variáveis estão definidas corretamente\n",
        "print(idade.terms)\n",
        "print(gravidade.terms)\n",
        "print(distancia.terms)\n",
        "print(renda.terms)\n",
        "print(frequencia.terms)\n",
        "print(risco.terms)\n",
        "\n",
        "#sistema_controle = ctrl.ControlSystem([regra1, regra2, regra3, regra4, regra5])\n",
        "\n",
        "# sistema_controle.addrule(regra9)\n",
        "\n",
        "# Criar a simulação do sistema difuso\n",
        "simulacao = ctrl.ControlSystemSimulation(sistema_controle)\n",
        "sistema_controle.view()"
      ],
      "metadata": {
        "id": "Uhm1aJNc80Xc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 510
        },
        "outputId": "eeca2eae-00fe-40a1-b25e-e792cd5c3b50"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OrderedDict([('Jovem', Idade[Jovem]), ('Meia-idade', Idade[Meia-idade]), ('Idoso', Idade[Idoso])])\n",
            "OrderedDict([('Leve', Gravidade[Leve]), ('Moderada', Gravidade[Moderada]), ('Grave', Gravidade[Grave])])\n",
            "OrderedDict([('Perto', Distancia[Perto]), ('Media', Distancia[Media]), ('Longe', Distancia[Longe])])\n",
            "OrderedDict([('Baixa', Renda[Baixa]), ('Media', Renda[Media]), ('Alta', Renda[Alta])])\n",
            "OrderedDict([('Boa', Frequencia[Boa]), ('Regular', Frequencia[Regular]), ('Ruim', Frequencia[Ruim])])\n",
            "OrderedDict([('Baixo', Risco[Baixo]), ('Medio', Risco[Medio]), ('Alto', Risco[Alto])])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(simulacao.output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q8E8UGn7Gx1N",
        "outputId": "e590322f-7933-40d0-cdff-e04e231ac44e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OrderedDict()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Dividir os dados em conjuntos de treinamento e teste\n",
        "X = dados[['Idade', 'Gravidade', 'Renda', 'Distancia', 'Frequencia']]\n",
        "y = dados['Risco']\n",
        "print(X.shape)\n",
        "print(y.shape)\n",
        "\n",
        "print(X.head())\n",
        "print(y.head())\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-gb9-D2SAhC6",
        "outputId": "714ecce7-8bce-4344-9d6e-534fd56bc822"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(20, 5)\n",
            "(20,)\n",
            "   Idade  Gravidade  Renda  Distancia  Frequencia\n",
            "0     32          1  45000   0.333333          95\n",
            "1     68          3  18000   0.820513          60\n",
            "2     25          2  32000   0.134615          85\n",
            "3     54          2  28000   0.570513          70\n",
            "4     42          1  56000   0.237179          90\n",
            "0    Baixo\n",
            "1     Alto\n",
            "2    Baixo\n",
            "3    Medio\n",
            "4    Baixo\n",
            "Name: Risco, dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Pré-processamento dos dados\n",
        "Realize a normalização ou o escalonamento dos dados de entrada para garantir que estejam na mesma escala e evitar a dominância de certas variáveis.\n",
        "Lide com outliers e valores discrepantes que possam afetar o desempenho do modelo."
      ],
      "metadata": {
        "id": "jIhNNTYC9ySl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo de normalização dos dados\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "\n",
        "scaler = MinMaxScaler()\n",
        "X_scaled = scaler.fit_transform(X)"
      ],
      "metadata": {
        "id": "utA4BjQ-9sSO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Treinamento\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
      ],
      "metadata": {
        "id": "Hsj40cGgHv7r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Seleção de variáveis:\n",
        "Avalie a relevância de cada variável de entrada e considere remover variáveis que possam não contribuir significativamente para a previsão.\n",
        "Utilize técnicas de seleção de variáveis, como a análise de correlação ou a importância das variáveis em modelos de aprendizado de máquina, para identificar as variáveis mais informativas."
      ],
      "metadata": {
        "id": "QevAwwFiTnm8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exemplo de seleção de variáveis usando a importância das variáveis em um modelo de Random Forest\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "rf = RandomForestClassifier()\n",
        "rf.fit(X_train, y_train)\n",
        "importancias = rf.feature_importances_\n",
        "# Selecionar as variáveis mais importantes com base em um limiar\n",
        "limiar_importancia = 0.1\n",
        "variaveis_selecionadas = X.columns[importancias >= limiar_importancia]"
      ],
      "metadata": {
        "id": "LdPN5IB3TmY2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "variaveis_selecionadas"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xWSE3-dOT31D",
        "outputId": "b73caaa0-2935-4d5d-833d-06f57cc12bc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['Idade', 'Renda', 'Distancia', 'Frequencia'], dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Validação cruzada:\n",
        "Utilize a validação cruzada para avaliar o desempenho do modelo de forma mais robusta e evitar o overfitting.\n",
        "A validação cruzada permite obter uma estimativa mais confiável da acurácia do modelo, treinando e testando em diferentes subconjuntos dos dados.\n",
        "\n",
        "Lembremos de verificar se as variáveis de entrada (Idade, Gravidade, Renda, Distancia, Frequencia) estão definidas corretamente no seu sistema de controle difuso e se correspondem aos nomes usados na simulação.\n",
        "\n",
        "Após fazer essas alterações, a validação cruzada deve ser executada sem erros e poderemos obter a acurácia média do seu modelo de sistema de controle difuso."
      ],
      "metadata": {
        "id": "XNJkeifHT-4l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import cross_val_score\n",
        "# Criar uma instância do wrapper do sistema de controle difuso\n",
        "fuzzy_system_wrapper = FuzzyControlSystemWrapper(sistema_controle)\n",
        "\n",
        "# Realizar a validação cruzada\n",
        "scores = cross_val_score(fuzzy_system_wrapper, X, y, cv=5, scoring='accuracy')\n",
        "acuracia_media = scores.mean()\n",
        "print(f\"Acurácia média na validação cruzada: {acuracia_media:.2f}\")\n"
      ],
      "metadata": {
        "id": "PvdczYdQWPcB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Ajuste de hiperparâmetros:\n",
        "Realize uma busca de hiperparâmetros para encontrar a melhor combinação de parâmetros para o seu modelo.\n",
        "Utilize técnicas como a busca em grade (grid search) ou a busca aleatória (random search) para explorar diferentes configurações de hiperparâmetros."
      ],
      "metadata": {
        "id": "UEpR59ZbU0RD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "\n",
        "param_grid = {\n",
        "    'idade_jovem_mean': [10, 20, 30],\n",
        "    'idade_jovem_std': [5, 10],\n",
        "    'idade_meia_idade_mean': [40, 50],\n",
        "    'idade_meia_idade_std': [5, 10],\n",
        "    # Adicionar outros parâmetros\n",
        "}\n",
        "\n",
        "fuzzy_system_wrapper = FuzzyControlSystemWrapper(sistema_controle)\n",
        "grid_search = GridSearchCV(fuzzy_system_wrapper, param_grid, cv=5, scoring='accuracy')\n",
        "grid_search.fit(X, y)\n",
        "melhores_parametros = grid_search.best_params_\n",
        "\n",
        "print(\"Melhores parâmetros encontrados:\", melhores_parametros)"
      ],
      "metadata": {
        "id": "QpFhrjOha4gR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Treinando o modelo difuso"
      ],
      "metadata": {
        "id": "stgFtU3NTvEH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Treinar o modelo difuso\n",
        "previsoes_treino = []\n",
        "for _, row in X_train.iterrows():\n",
        "    simulacao.input['Idade'] = row['Idade']\n",
        "    simulacao.input['Gravidade'] = row['Gravidade']\n",
        "    simulacao.input['Renda'] = row['Renda']\n",
        "    simulacao.input['Distancia'] = row['Distancia']\n",
        "    simulacao.input['Frequencia'] = row['Frequencia']\n",
        "    try:\n",
        "        simulacao.compute()\n",
        "        previsoes_treino.append(simulacao.output['Risco'])\n",
        "    except ValueError:\n",
        "        previsoes_treino.append(0)  # Atribuir um valor padrão quando a saída é vazia\n"
      ],
      "metadata": {
        "id": "84IESnkd82Y4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Avaliar o modelo difuso no conjunto de teste\n",
        "previsoes_teste = []\n",
        "for _, row in X_test.iterrows():\n",
        "    simulacao.input['Idade'] = row['Idade']\n",
        "    simulacao.input['Gravidade'] = row['Gravidade']\n",
        "    simulacao.input['Renda'] = row['Renda']\n",
        "    simulacao.input['Distancia'] = row['Distancia']\n",
        "    simulacao.input['Frequencia'] = row['Frequencia']\n",
        "    try:\n",
        "        simulacao.compute()\n",
        "        previsoes_teste.append(simulacao.output['Risco'])\n",
        "    except ValueError:\n",
        "        previsoes_teste.append(0)  # Atribuir um valor padrão quando a saída é vazia\n",
        "\n"
      ],
      "metadata": {
        "id": "Lz_QhgLR84Hy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Os rótulos discretos\n",
        "\n",
        " São um tipo de representação em que os valores são divididos em categorias ou classes distintas e não contínuas. Neste caso, os rótulos discretos são usados para converter as previsões numéricas contínuas em categorias discretas com base em um limite (threshold) específico.\n",
        "\n",
        "##Utilidade e casos de uso dos rotulos\n",
        " Os rótulos discretos são úteis em várias situações:\n",
        "\n",
        "- Interpretabilidade: Converter previsões numéricas em rótulos discretos pode tornar os resultados mais interpretáveis e compreensíveis para os usuários finais. Em vez de lidar com números contínuos, os rótulos discretos fornecem uma categorização mais clara e significativa.\n",
        "- Tomada de decisão: Os rótulos discretos podem ser usados diretamente para tomar decisões com base nas previsões. Por exemplo, se o rótulo previsto for 'Alto', pode acionar uma ação específica, como enviar um alerta ou tomar uma medida preventiva.\n",
        "- Avaliação do modelo: Os rótulos discretos permitem calcular métricas de avaliação, como acurácia, precisão, recall e F1-score, que são comumente usadas para avaliar o desempenho de modelos de classificação.\n",
        "\n"
      ],
      "metadata": {
        "id": "7nQMVVB6PzR5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Previsões numéricas\n",
        "\n",
        "\n",
        "As previsões numéricas (previsoes_treino e previsoes_teste) são convertidas em rótulos discretos ('Alto' ou 'Baixo')\n",
        "com base no valor do limite. Se a previsão numérica for maior ou igual ao limite, o rótulo atribuído será 'Alto';\n",
        "caso contrário, será 'Baixo'.\n",
        "\n",
        "Quanto ao ajuste do limite, ele depende do problema específico e dos requisitos do seu sistema.\n",
        "O valor do limite determina a fronteira entre as classes discretas. Ajustar o limite permite controlar a sensibilidade\n",
        "do modelo em relação à classificação das previsões.\n",
        "Por exemplo, se você quiser que o modelo seja mais sensível em classificar as previsões como 'Alto',\n",
        "pode diminuir o valor do limite. Isso fará com que mais previsões sejam classificadas como 'Alto'.\n",
        "Por outro lado, se você quiser que o modelo seja mais restritivo ao classificar as previsões como 'Alto',\n",
        "pode aumentar o valor do limite.\n",
        "\n",
        "```python:\n",
        "\n",
        "# Exemplo 1: Aumentar o limite para tornar o modelo mais restritivo\n",
        "limite = 7\n",
        "previsoes_treino_rotulos = ['Alto' if x >= limite else 'Baixo' for x in previsoes_treino]\n",
        "previsoes_teste_rotulos = ['Alto' if x >= limite else 'Baixo' for x in previsoes_teste]\n",
        "\n",
        "# Exemplo 3: Usar múltiplos limites para criar mais categorias discretas\n",
        "limites = [3, 6, 8]\n",
        "labels = ['Baixo', 'Médio', 'Alto', 'Muito Alto']\n",
        "previsoes_treino_rotulos = [labels[sum(x >= limite for limite in limites)] for x in previsoes_treino]\n",
        "previsoes_teste_rotulos = [labels[sum(x >= limite for limite in limites)] for x in previsoes_teste]\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "ZLuui27BRSc7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Converter as previsões para rótulos discretos\n",
        "limite = 7  # Ajustar conforme necessário\n",
        "previsoes_treino_rotulos = ['Alto' if x >= limite else 'Baixo' for x in previsoes_treino]\n",
        "previsoes_teste_rotulos = ['Alto' if x >= limite else 'Baixo' for x in previsoes_teste]\n",
        "\n"
      ],
      "metadata": {
        "id": "kWyrP7Jm86XE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Calcular a acurácia do modelo difuso\n",
        "acuracia_treino = accuracy_score(y_train, previsoes_treino_rotulos)\n",
        "acuracia_teste = accuracy_score(y_test, previsoes_teste_rotulos)\n",
        "\n",
        "print(f\"Acurácia no conjunto de treinamento: {acuracia_treino:.2f}\")\n",
        "print(f\"Acurácia no conjunto de teste: {acuracia_teste:.2f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wSrccgcP87nU",
        "outputId": "c0e1e626-1245-4642-87e9-ef778b7a0631"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Acurácia no conjunto de treinamento: 0.69\n",
            "Acurácia no conjunto de teste: 1.00\n"
          ]
        }
      ]
    }
  ]
}