livro_ESCD_projeto_de_sistemas.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/profkalinowski/livroescd/blob/main/livro_ESCD_projeto_de_sistemas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MDnXLbAXQbBn"
      },
      "source": [
        "# Livro Engenharia de Software para Ciência de Dados (Ed. Casa do Código)\n",
        "Marcos Kalinowski, Tatiana Escovedo, Hugo Villamizar e Hélio Lopes\n",
        "\n",
        "### Modelo de classificação simples usando POO"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LeUm9vsF0nmY"
      },
      "outputs": [],
      "source": [
        "# Imports necessários\n",
        "import pandas as pd\n",
        "from sklearn.datasets import load_iris # para importar o dataset iris\n",
        "from sklearn.model_selection import train_test_split # para particionar em bases de treino e teste\n",
        "from sklearn.metrics import confusion_matrix # para a exibição da matriz de confusão do modelo\n",
        "from sklearn.metrics import accuracy_score # para a exibição da acurácia do modelo\n",
        "from sklearn.svm import SVC # para utilizar o algoritmo SVM\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ibELgG7qoQpP"
      },
      "source": [
        "## Sem POO"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-870C7yUoQ0l",
        "outputId": "194d8491-fed2-4a9f-b461-0be4dbe42567"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8666666666666667\n"
          ]
        }
      ],
      "source": [
        "# Versão estruturada\n",
        "\n",
        "# Carga do dataset\n",
        "iris = load_iris()\n",
        "# conversão para dataframe\n",
        "dataset = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
        "dataset['target'] = iris.target  # adição da coluna target\n",
        "\n",
        "# Separação em bases de treino e teste\n",
        "array = dataset.values\n",
        "X = array[:, 0:4]\n",
        "Y = array[:, 4]\n",
        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.20,\n",
        "                                                    random_state=7)\n",
        "\n",
        "# Criação do modelo e predições\n",
        "model = SVC()  # cria o modelo\n",
        "model.fit(X_train, Y_train)  # treina o modelo com o dataset de treino\n",
        "predictions = model.predict(X_test)  # faz as predições com o dataset de teste\n",
        "\n",
        "# Avaliação das predições\n",
        "print(accuracy_score(Y_test, predictions))  # acurácia"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A5JdleHxMwdC"
      },
      "source": [
        "## Com POO"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YHn8HbDg0i5P",
        "outputId": "2f6018a6-9329-45f7-911c-45b747452e84"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.8666666666666667\n"
          ]
        }
      ],
      "source": [
        "# Em programas mais robustos, teríamos um arquivo .py para cada classe e\n",
        "# importaríamos as classes para executar o programa:\n",
        "# from <nome-do-arquivo> import <nome-da-classe>\n",
        "\n",
        "class Carregador:\n",
        "\n",
        "    def carregar_dados(self, url: str, atributos: list):\n",
        "        \"\"\" Carrega e retorna um DataFrame. Há diversos parâmetros \n",
        "        no read_csv que poderiam ser utilizados para dar opções \n",
        "        adicionais.\n",
        "        \"\"\"\n",
        "        return pd.read_csv(url, names=atributos)\n",
        "\n",
        "\n",
        "class PreProcessador:\n",
        "\n",
        "    def pre_processar(self, dataset, percentual_teste, seed=7):\n",
        "        \"\"\" Cuida de todo o pré-processamento. \"\"\"\n",
        "        # limpeza dos dados e eliminação de outliers\n",
        "\n",
        "        # feature selection\n",
        "\n",
        "        # divisão em treino e teste\n",
        "        X_train, X_test, Y_train, Y_test = self.__preparar_holdout(dataset,\n",
        "                                                                  percentual_teste,\n",
        "                                                                  seed)\n",
        "        # normalização/padronização\n",
        "        \n",
        "        return (X_train, X_test, Y_train, Y_test)\n",
        "\n",
        "    def __preparar_holdout(self, dataset, percentual_teste, seed):\n",
        "        \"\"\" Divide os dados em treino e teste usando o método holdout.\n",
        "        Assume que a variável target está na última coluna.\n",
        "        O parâmetro test_size é o percentual de dados de teste.\n",
        "        \"\"\"\n",
        "        dados = dataset.values\n",
        "        X = dados[:, 0:-1]\n",
        "        Y = dados[:, -1]\n",
        "        return train_test_split(X, Y, test_size=percentual_teste, random_state=seed)\n",
        "\n",
        "\n",
        "class Modelo:\n",
        "\n",
        "    def treinar_SVM(self, X_train, Y_train):\n",
        "        \"\"\" Cria e treina um modelo SVM. Poderia ter um Grid Search\n",
        "        com cross_validation para escolher os melhores hiperparâmetros, etc.\n",
        "        \"\"\"\n",
        "        modelo = SVC()\n",
        "        modelo.fit(X_train, Y_train)\n",
        "        return modelo\n",
        "\n",
        "\n",
        "class Avaliador:\n",
        "\n",
        "    def avaliar_acuracia(self, modelo, X_test, Y_test):\n",
        "        \"\"\" Faz uma predição e avalia o modelo. Poderia parametrizar o tipo de\n",
        "        avaliação, entre outros.\n",
        "        \"\"\"\n",
        "        predicoes = modelo.predict(X_test)\n",
        "        return accuracy_score(Y_test, predicoes)\n",
        "\n",
        "\n",
        "# Este código começaria daqui, logo após os imports\n",
        "# from carregador import Carregadpr\n",
        "# from preprocessador import PreProcessador\n",
        "# from modelo import Modelo\n",
        "# from avaliador import Avaliador\n",
        "\n",
        "# Instanciação das Classes\n",
        "carregador = Carregador()\n",
        "pre_processador = PreProcessador()\n",
        "modelo = Modelo()\n",
        "avaliador = Avaliador()\n",
        "\n",
        "# Parâmetros\n",
        "url_dados = ('https://archive.ics.uci.edu/'\n",
        "             'ml/machine-learning-databases/iris/iris.data')\n",
        "atributos = ['comprimento_sepala', 'largura_sepala',\n",
        "             'comprimento_petala', 'largura_petala',\n",
        "             'especie']\n",
        "percentual_teste = 0.2\n",
        "\n",
        "# Código\n",
        "\n",
        "# Carga\n",
        "dataset = carregador.carregar_dados(url_dados, atributos)\n",
        "# Pré-processamento\n",
        "X_train, X_test, Y_train, Y_test = pre_processador.pre_processar(dataset, \n",
        "                                                               percentual_teste)\n",
        "# Treinamento do modelo\n",
        "model = modelo.treinar_SVM(X_train, Y_train)\n",
        "# Impressão do resultado da avaliação\n",
        "print(avaliador.avaliar_acuracia(model, X_test, Y_test))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from abc import ABC, abstractmethod\n",
        "\n",
        "class RecomendadorPersonalizado(ABC):\n",
        "    @abstractmethod\n",
        "    def obterRecomendacoesPersonalizadas(self, user):\n",
        "        pass\n",
        "\n",
        "\n",
        "class RecomendadorDeItensProximos(ABC):\n",
        "    @abstractmethod\n",
        "    def obterItensProximos(self, item):\n",
        "        pass\n",
        "\n",
        "\n",
        "class RecomendadorFiltragemColaborativa(RecomendadorPersonalizado, RecomendadorDeItensProximos):\n",
        "\n",
        "    def obterRecomendacoesPersonalizadas(self, user):\n",
        "        print(\"Recomendações Personalizadas.\")\n",
        "\n",
        "    def obterItensProximos(self, item):\n",
        "        print(\"Recomendação de itens próximos.\")\n",
        "\n",
        "\n",
        "class RecomendadorFiltragemColaborativa(RecomendadorDeItensProximos):\n",
        "\n",
        "    def obterItensProximos(self, item):\n",
        "        print(\"Recomendação de itens próximos.\")"
      ],
      "metadata": {
        "id": "g9RzleD8mFUE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "\n",
        "model = Pipeline([('StandardScaler', StandardScaler()), \n",
        "                  ('KNN', KNeighborsClassifier())])\n",
        "\n",
        "model.fit(X_train, Y_train)\n",
        "accuracy_score(model.predict(X_test), Y_test)"
      ],
      "metadata": {
        "id": "EIqMnaL7mFYz"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}