IEx09_Rede_Neural_PACIENTES_One_Rule.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.2"
    },
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ms-daniel/Exercicio-IA-Rede-Neural/blob/main/IEx09_Rede_Neural_PACIENTES_One_Rule.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m5tVff4dgKyg"
      },
      "source": [
        "\n",
        "# Treinamento - One Role"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P8xB4G8ogKym"
      },
      "source": [
        "### Carregando Arquivo de Treinamento (.csv)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a5MRh5ZfgKyn",
        "outputId": "64a386eb-252e-463e-f5d4-36928ef20b7b"
      },
      "source": [
        "import pandas as pd\n",
        "# Carregando dados do arquivo CSV\n",
        "url = 'https://raw.githubusercontent.com/ms-daniel/Exercicio-IA-Rede-Neural/main/dados_pacientes_treinamento.csv'\n",
        "base_Treinamento = pd.read_csv(url,sep=';', encoding = 'latin1').values\n",
        "print(\"---------------------------------\")\n",
        "print(\"Dados dos Pacientes - TREINAMENTO\")\n",
        "print(\"---------------------------------\")\n",
        "print(base_Treinamento)\n",
        "print(\"---------------------------------\")\n",
        "\n",
        "# Extração dos Atributos a serem utilizadas pela rede\n",
        "print(\"Atributos de Entrada\")\n",
        "print(\"---------------------------------\")\n",
        "print(base_Treinamento[:, 1:5])\n",
        "\n",
        "print(\"----------------------------\")\n",
        "print(\"Classificação Supervisionada\")\n",
        "print(\"----------------------------\")\n",
        "print(base_Treinamento[:, 5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------------------------------\n",
            "Dados dos Pacientes - TREINAMENTO\n",
            "---------------------------------\n",
            "[['João' 'sim' 'sim' 'pequenas' 'sim' 'doente']\n",
            " ['Pedro' 'não' 'não' 'grandes' 'não' 'saudável']\n",
            " ['Maria' 'sim' 'sim' 'pequenas' 'não' 'saudável']\n",
            " ['José' 'sim' 'não' 'grandes' 'sim' 'doente']\n",
            " ['Ana' 'sim' 'não' 'pequenas' 'sim' 'saudável']\n",
            " ['Leila' 'não' 'não' 'grandes' 'sim' 'doente']]\n",
            "---------------------------------\n",
            "Atributos de Entrada\n",
            "---------------------------------\n",
            "[['sim' 'sim' 'pequenas' 'sim']\n",
            " ['não' 'não' 'grandes' 'não']\n",
            " ['sim' 'sim' 'pequenas' 'não']\n",
            " ['sim' 'não' 'grandes' 'sim']\n",
            " ['sim' 'não' 'pequenas' 'sim']\n",
            " ['não' 'não' 'grandes' 'sim']]\n",
            "----------------------------\n",
            "Classificação Supervisionada\n",
            "----------------------------\n",
            "['doente' 'saudável' 'saudável' 'doente' 'saudável' 'doente']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPpDXy7cgKyp"
      },
      "source": [
        "### Pré-processamento de Dados"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L4nvyQJegKyq",
        "outputId": "311b52ea-f601-42d0-92e5-0317392eb3ea"
      },
      "source": [
        "import numpy as np \n",
        "from sklearn import preprocessing\n",
        "\n",
        "# Binarizador de rótulo\n",
        "lb = preprocessing.LabelBinarizer()\n",
        "\n",
        "#A saída da transformação é também conhecido como codificação 1-de-n\n",
        "#Transforma valores categóricos equidistantes em valores binários equidistantes.\n",
        "#Atributos categóricos com valores sim e não\n",
        "lb.fit(['sim', 'não'])\n",
        "febre = lb.transform(base_Treinamento[:,1])  \n",
        "enjoo = lb.transform(base_Treinamento[:,2])\n",
        "dores = lb.transform(base_Treinamento[:,4])\n",
        "\n",
        "#Atributos categóricos com valores pequenas e grandes\n",
        "lb.fit(['grandes', 'pequenas'])\n",
        "manchas = lb.transform(base_Treinamento[:,3])\n",
        "\n",
        "#Atributos categóricos com valores saudável e doente\n",
        "lb.fit(['saudável', 'doente'])\n",
        "classes = lb.transform(base_Treinamento[:,5])\n",
        "\n",
        "#Concatenação de Atributos (Colunas) \n",
        "atributos_norm = np.column_stack((febre,enjoo,manchas,dores))\n",
        "print(\"--------------------------------\")\n",
        "print(\"Atributos de Entrada - Numéricos\")\n",
        "print(\"--------------------------------\")\n",
        "print(atributos_norm)\n",
        "\n",
        "print(\"----------------------------------------\")\n",
        "print(\"Classificação Supervisionada - Numéricos\")\n",
        "print(\"----------------------------------------\")\n",
        "diagnostico_norm = np.hstack((classes))\n",
        "print(diagnostico_norm)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--------------------------------\n",
            "Atributos de Entrada - Numéricos\n",
            "--------------------------------\n",
            "[[1 1 1 1]\n",
            " [0 0 0 0]\n",
            " [1 1 1 0]\n",
            " [1 0 0 1]\n",
            " [1 0 1 1]\n",
            " [0 0 0 1]]\n",
            "----------------------------------------\n",
            "Classificação Supervisionada - Numéricos\n",
            "----------------------------------------\n",
            "[0 1 1 0 1 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GC4FUfD5gKyr"
      },
      "source": [
        "### Treinamento do Neurônio\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kDmPLB5FgKys",
        "outputId": "dda97962-1ee2-4222-f0e0-3f90d39d9a49"
      },
      "source": [
        "from sklearn.multiclass import OneVsOneClassifier\n",
        "from sklearn.svm import LinearSVC\n",
        "\n",
        "#from sklearn.linear_model import Perceptron\n",
        "# Treinamento do Perceptron a partir dos atributos de entrada e classificações\n",
        "modelo = OneVsOneClassifier(LinearSVC(random_state=0))\n",
        "modelo.fit(atributos_norm, diagnostico_norm)\n",
        "\n",
        "# Acurácia do modelo, que é : 1 - (predições erradas / total de predições)\n",
        "# Acurácia do modelo: indica uma performance geral do modelo. \n",
        "# Dentre todas as classificações, quantas o modelo classificou corretamente;\n",
        "# (VP+VN)/N\n",
        "print('Acurácia: %.3f' % modelo.score(atributos_norm, diagnostico_norm))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Acurácia: 1.000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HMwrAoNwgKyt"
      },
      "source": [
        "### ----------------------------------------------------------------------------"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6UKPw4jagKyu"
      },
      "source": [
        "# Validação do Aprendizado "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0tUmMoPHgKyv"
      },
      "source": [
        "### Predição Simples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W4MRpx9PgKyw",
        "outputId": "9a7366c6-a7c8-48ca-ec06-6b8823c26631"
      },
      "source": [
        "Luiz = [[0,0,1,1]]\n",
        "print(\"Luiz\", modelo.predict(Luiz))\n",
        "Laura = [[1,1,0,1]]\n",
        "print(\"Laura\", modelo.predict(Laura))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Luiz [1]\n",
            "Laura [0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VweXD-8_gKyx"
      },
      "source": [
        "### Predição a partir de base de dados de teste (.csv)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ceg0-DfVgKyx",
        "outputId": "765cdaea-465d-4d21-c530-12207b5fcf8d"
      },
      "source": [
        "import pandas as pd\n",
        "# Carregando dados do arquivo CSV\n",
        "url = 'https://raw.githubusercontent.com/ms-daniel/Exercicio-IA-Rede-Neural/main/dados_pacientes_treinamento.csv'\n",
        "base_Testes = pd.read_csv(url,sep=';', encoding = 'latin1').values\n",
        "print(\"----------------------------\")\n",
        "print(\"Dados dos Pacientes - TESTES\")\n",
        "print(\"----------------------------\")\n",
        "print(base_Testes)\n",
        "print(\"---------------------------------\")\n",
        "\n",
        "# Extração dos Atributos a serem utilizadas pela rede\n",
        "print(\"Atributos de Entrada\")\n",
        "print(\"---------------------------------\")\n",
        "print(base_Testes[:, 1:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------------------------\n",
            "Dados dos Pacientes - TESTES\n",
            "----------------------------\n",
            "[['João' 'sim' 'sim' 'pequenas' 'sim' 'doente']\n",
            " ['Pedro' 'não' 'não' 'grandes' 'não' 'saudável']\n",
            " ['Maria' 'sim' 'sim' 'pequenas' 'não' 'saudável']\n",
            " ['José' 'sim' 'não' 'grandes' 'sim' 'doente']\n",
            " ['Ana' 'sim' 'não' 'pequenas' 'sim' 'saudável']\n",
            " ['Leila' 'não' 'não' 'grandes' 'sim' 'doente']]\n",
            "---------------------------------\n",
            "Atributos de Entrada\n",
            "---------------------------------\n",
            "[['sim' 'sim' 'pequenas' 'sim']\n",
            " ['não' 'não' 'grandes' 'não']\n",
            " ['sim' 'sim' 'pequenas' 'não']\n",
            " ['sim' 'não' 'grandes' 'sim']\n",
            " ['sim' 'não' 'pequenas' 'sim']\n",
            " ['não' 'não' 'grandes' 'sim']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g6JQnLaEgKyx"
      },
      "source": [
        "### Pré-processamento de Dados"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SJM8C3IDgKyy",
        "outputId": "c0df8a80-0bd3-418d-881a-8036f9630c46"
      },
      "source": [
        "import numpy as np \n",
        "from sklearn import preprocessing\n",
        "\n",
        "# Binarizador de rótulo\n",
        "lb = preprocessing.LabelBinarizer()\n",
        "\n",
        "#A saída da transformação é também conhecido como codificação 1-de-n\n",
        "#Transforma valores categóricos equidistantes em valores binários equidistantes.\n",
        "#Atributos categóricos com valores sim e não\n",
        "lb.fit(['sim', 'não'])\n",
        "febre = lb.transform(base_Testes[:,1])  \n",
        "enjoo = lb.transform(base_Testes[:,2])\n",
        "dores = lb.transform(base_Testes[:,4])\n",
        "\n",
        "#Atributos categóricos com valores pequenas e grandes\n",
        "lb.fit(['grandes', 'pequenas'])\n",
        "manchas = lb.transform(base_Testes[:,3])\n",
        "\n",
        "#Concatenação de Atributos (Colunas) \n",
        "atributos_norm = np.column_stack((febre,enjoo,manchas,dores))\n",
        "print(\"--------------------------------\")\n",
        "print(\"Atributos de Entrada - Numéricos\")\n",
        "print(\"--------------------------------\")\n",
        "print(atributos_norm)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--------------------------------\n",
            "Atributos de Entrada - Numéricos\n",
            "--------------------------------\n",
            "[[1 1 1 1]\n",
            " [0 0 0 0]\n",
            " [1 1 1 0]\n",
            " [1 0 0 1]\n",
            " [1 0 1 1]\n",
            " [0 0 0 1]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3QO3B6S3gKyy"
      },
      "source": [
        "### Predição da Base"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3ZovGGdmgKyz",
        "outputId": "ff2e84fb-19eb-4f0e-ca4f-fc4ce48cb7cb"
      },
      "source": [
        "base_Predicao = modelo.predict((atributos_norm))\n",
        "print(\"Classificações: \", base_Predicao)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Classificações:  [0 1 1 0 1 0]\n"
          ]
        }
      ]
    }
  ]
}