├── data.zip ├── README.md ├── LICENSE ├── Aula7-Regressao-Linear-Simples.ipynb └── Aula4-Classificacao-Naive Bayes.ipynb /data.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/prof-francisco-rodrigues/ciencia-de-dados/HEAD/data.zip -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Ciência de Dados 2 | Francisco Aparecido Rodrigues, francisco@icmc.usp.br.
3 | Universidade de São Paulo, São Carlos, Brasil.
4 | https://sites.icmc.usp.br/francisco
5 | Copyright: Creative Commons 6 |
7 | 8 | Neste repositório incluímos diversos notebooks em Python que descrevem os principais conceitos relacionados à Ciência de Dados. 9 | 10 | O notebooks são os seguintes: 11 | 12 | **Aula 0: Introdução à Programação em Python** 13 | 14 | **Aula 1 - Preparação e transformação dos dados**: Apresentamos exemplos de como limpar e adequar os dados para serem tratados por algoritmos de Ciência de Dados. Também consideramos métodos básicos de pré-processamento e transformação de dados.
15 | Aula no Youtube: https://bit.ly/3em6BA0 16 | 17 | **Aula 2 - Análise Exploratória de dados**: inclui medidas resumo e de correlação (Pearson e Spearman).
18 | Aulas no youtube:
19 | Medidas resumo: https://bit.ly/37HwebF
20 | Correlação: https://bit.ly/2UXDhIe
21 | 22 | **Aula 3 - Teoria da Decisão Bayesiana e o Classificador Bayesiano**.
23 | Aulas no youtube:
24 | Teoria da Decisão Bayesiana: https://www.youtube.com/watch?v=8zAKWEOdGsg
25 | Classificador Bayesiano: https://www.youtube.com/watch?v=Rq_hXHrdkbc
26 | 27 | **Aula 4 - Classificador Naive Bayes**.
28 | Aula no youtube:
29 | https://www.youtube.com/watch?v=Bk2mSIMw_XE&list=PLSc7xcwCGNh1PJrPfLaH4MMjfDl48tmGM&index=11&ab_channel=FranciscoRodrigues 30 | 31 | **Aula 5 – Algoritmo k-vizinhos mais próximos**.
32 | Aula no youtube:
33 | https://www.youtube.com/watch?v=7WySJWL2o_4&list=PLSc7xcwCGNh1PJrPfLaH4MMjfDl48tmGM&index=12&ab_channel=FranciscoRodrigues 34 | 35 | **Aula 6 – Regressão Logística**.
36 | Aula no youtube:
37 | https://www.youtube.com/watch?v=EoP2wN0yuHA&list=PLSc7xcwCGNh1PJrPfLaH4MMjfDl48tmGM&index=13&ab_channel=FranciscoRodrigues 38 | 39 | **Aula 7 – Regressão Liner Simples**.
40 | Aula no youtube:
41 | https://www.youtube.com/watch?v=xRIc81AeLOg&t=44s&ab_channel=FranciscoRodrigues 42 | 43 | Se for usar em suas aulas, cite a fonte: https://github.com/franciscoicmc 44 | 45 | Novos notebooks serão incluídos periodicamente. 46 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Creative Commons Legal Code 2 | 3 | CC0 1.0 Universal 4 | 5 | CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE 6 | LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN 7 | ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS 8 | INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES 9 | REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS 10 | PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM 11 | THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED 12 | HEREUNDER. 13 | 14 | Statement of Purpose 15 | 16 | The laws of most jurisdictions throughout the world automatically confer 17 | exclusive Copyright and Related Rights (defined below) upon the creator 18 | and subsequent owner(s) (each and all, an "owner") of an original work of 19 | authorship and/or a database (each, a "Work"). 20 | 21 | Certain owners wish to permanently relinquish those rights to a Work for 22 | the purpose of contributing to a commons of creative, cultural and 23 | scientific works ("Commons") that the public can reliably and without fear 24 | of later claims of infringement build upon, modify, incorporate in other 25 | works, reuse and redistribute as freely as possible in any form whatsoever 26 | and for any purposes, including without limitation commercial purposes. 27 | These owners may contribute to the Commons to promote the ideal of a free 28 | culture and the further production of creative, cultural and scientific 29 | works, or to gain reputation or greater distribution for their Work in 30 | part through the use and efforts of others. 31 | 32 | For these and/or other purposes and motivations, and without any 33 | expectation of additional consideration or compensation, the person 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she 35 | is an owner of Copyright and Related Rights in the Work, voluntarily 36 | elects to apply CC0 to the Work and publicly distribute the Work under its 37 | terms, with knowledge of his or her Copyright and Related Rights in the 38 | Work and the meaning and intended legal effect of CC0 on those rights. 39 | 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be 41 | protected by copyright and related or neighboring rights ("Copyright and 42 | Related Rights"). Copyright and Related Rights include, but are not 43 | limited to, the following: 44 | 45 | i. the right to reproduce, adapt, distribute, perform, display, 46 | communicate, and translate a Work; 47 | ii. moral rights retained by the original author(s) and/or performer(s); 48 | iii. publicity and privacy rights pertaining to a person's image or 49 | likeness depicted in a Work; 50 | iv. rights protecting against unfair competition in regards to a Work, 51 | subject to the limitations in paragraph 4(a), below; 52 | v. rights protecting the extraction, dissemination, use and reuse of data 53 | in a Work; 54 | vi. database rights (such as those arising under Directive 96/9/EC of the 55 | European Parliament and of the Council of 11 March 1996 on the legal 56 | protection of databases, and under any national implementation 57 | thereof, including any amended or successor version of such 58 | directive); and 59 | vii. other similar, equivalent or corresponding rights throughout the 60 | world based on applicable law or treaty, and any national 61 | implementations thereof. 62 | 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention 64 | of, applicable law, Affirmer hereby overtly, fully, permanently, 65 | irrevocably and unconditionally waives, abandons, and surrenders all of 66 | Affirmer's Copyright and Related Rights and associated claims and causes 67 | of action, whether now known or unknown (including existing as well as 68 | future claims and causes of action), in the Work (i) in all territories 69 | worldwide, (ii) for the maximum duration provided by applicable law or 70 | treaty (including future time extensions), (iii) in any current or future 71 | medium and for any number of copies, and (iv) for any purpose whatsoever, 72 | including without limitation commercial, advertising or promotional 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each 74 | member of the public at large and to the detriment of Affirmer's heirs and 75 | successors, fully intending that such Waiver shall not be subject to 76 | revocation, rescission, cancellation, termination, or any other legal or 77 | equitable action to disrupt the quiet enjoyment of the Work by the public 78 | as contemplated by Affirmer's express Statement of Purpose. 79 | 80 | 3. Public License Fallback. Should any part of the Waiver for any reason 81 | be judged legally invalid or ineffective under applicable law, then the 82 | Waiver shall be preserved to the maximum extent permitted taking into 83 | account Affirmer's express Statement of Purpose. In addition, to the 84 | extent the Waiver is so judged Affirmer hereby grants to each affected 85 | person a royalty-free, non transferable, non sublicensable, non exclusive, 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the 88 | maximum duration provided by applicable law or treaty (including future 89 | time extensions), (iii) in any current or future medium and for any number 90 | of copies, and (iv) for any purpose whatsoever, including without 91 | limitation commercial, advertising or promotional purposes (the 92 | "License"). The License shall be deemed effective as of the date CC0 was 93 | applied by Affirmer to the Work. Should any part of the License for any 94 | reason be judged legally invalid or ineffective under applicable law, such 95 | partial invalidity or ineffectiveness shall not invalidate the remainder 96 | of the License, and in such case Affirmer hereby affirms that he or she 97 | will not (i) exercise any of his or her remaining Copyright and Related 98 | Rights in the Work or (ii) assert any associated claims and causes of 99 | action with respect to the Work, in either case contrary to Affirmer's 100 | express Statement of Purpose. 101 | 102 | 4. Limitations and Disclaimers. 103 | 104 | a. No trademark or patent rights held by Affirmer are waived, abandoned, 105 | surrendered, licensed or otherwise affected by this document. 106 | b. Affirmer offers the Work as-is and makes no representations or 107 | warranties of any kind concerning the Work, express, implied, 108 | statutory or otherwise, including without limitation warranties of 109 | title, merchantability, fitness for a particular purpose, non 110 | infringement, or the absence of latent or other defects, accuracy, or 111 | the present or absence of errors, whether or not discoverable, all to 112 | the greatest extent permissible under applicable law. 113 | c. Affirmer disclaims responsibility for clearing rights of other persons 114 | that may apply to the Work or any use thereof, including without 115 | limitation any person's Copyright and Related Rights in the Work. 116 | Further, Affirmer disclaims responsibility for obtaining any necessary 117 | consents, permissions or other rights required for any use of the 118 | Work. 119 | d. Affirmer understands and acknowledges that Creative Commons is not a 120 | party to this document and has no duty or obligation with respect to 121 | this CC0 or use of the Work. 122 | -------------------------------------------------------------------------------- /Aula7-Regressao-Linear-Simples.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Regressão linear simples" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Francisco Aparecido Rodrigues, francisco@icmc.usp.br.
\n", 15 | "Universidade de São Paulo, São Carlos, Brasil.
\n", 16 | "https://sites.icmc.usp.br/francisco
\n", 17 | "Copyright: Creative Commons" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "
" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Vamos supor que temos o conjunto de dados abaixo." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 2, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "data": { 41 | "image/png": "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\n", 42 | "text/plain": [ 43 | "
" 44 | ] 45 | }, 46 | "metadata": { 47 | "needs_background": "light" 48 | }, 49 | "output_type": "display_data" 50 | } 51 | ], 52 | "source": [ 53 | "import matplotlib.pyplot as plt\n", 54 | "%matplotlib inline \n", 55 | "import numpy as np\n", 56 | "\n", 57 | "# define os dados\n", 58 | "x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) \n", 59 | "y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12]) \n", 60 | "plt.plot(x, y, 'bo')\n", 61 | "plt.xlabel(\"x\", fontsize = 15)\n", 62 | "plt.ylabel(\"y\", fontsize = 15)\n", 63 | "plt.show(True) " 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "Vemos que é uma relação entre as variáveis $X$ e $Y$. Queremos determinar um modelo que melhor descreva essa relação. Podemos supor um modelo de regressão linear simples, como:\n", 71 | "$$\n", 72 | "y_i \\approx \\beta_0 + \\beta_1x_i\n", 73 | "$$" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "Como há outros fatores, além de $x_i$ que afetam os valores de $y_i$, podemos escrever:\n", 81 | "$$\n", 82 | "y_i = \\beta_0 + \\beta_1 x_i + \\epsilon_i,\n", 83 | "$$\n", 84 | "onde $\\epsilon_i$ é uma variável aleatória que indica o erro na aproximação. O objetivo dos métodos de regressão é encontrar o melhor valor de $\\beta_0$ e $\\beta_1$ que minimizem o erro no ajuste. Ou seja, queremos encontrar a linha no plano $x-y$ que melhor se ajuste aos dados observados." 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "Estimando os coeficiente através do método dos momentos ou dos mínimos quadrados, obtemos:\n", 92 | " $$\n", 93 | " \\begin{cases}\n", 94 | " \\hat{\\beta}_1=\\frac{\\sum_{i=1}^n (x_i- \\bar{x})(y_i - \\bar{y})}{\\sum_{i=1}^n (x_i - \\bar{x})^2} = \\frac{S{xy}}{S{xx}}\\\\\n", 95 | " \\hat{\\beta}_0= \\bar{y}-\\hat{\\beta_1}\\bar{x}\n", 96 | " \\end{cases}\n", 97 | " $$" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Vamos implementar uma função para realizar a estimação." 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 3, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "from statistics import variance \n", 114 | "import math \n", 115 | "\n", 116 | "def estimate_coef(x, y): \n", 117 | " # número de observações/pontos\n", 118 | " n = np.size(x) \n", 119 | " \n", 120 | " # médias de x e y\n", 121 | " m_x, m_y = np.mean(x), np.mean(y) \n", 122 | " \n", 123 | " # calculating cross-deviation and deviation about x \n", 124 | " SS_xy = np.sum(y*x) - n*m_y*m_x \n", 125 | " SS_xx = np.sum(x*x) - n*m_x*m_x \n", 126 | " \n", 127 | " # calcula os coeficientes de regressão\n", 128 | " b_1 = SS_xy / SS_xx \n", 129 | " b_0 = m_y - b_1*m_x \n", 130 | " \n", 131 | " return(b_0, b_1) \n", 132 | "\n", 133 | "# função para mostrar os dados e o ajuste linear\n", 134 | "def plot_regression_line(x, y, b): \n", 135 | " # mostra os dados\n", 136 | " plt.scatter(x, y, color = \"b\", marker = \"o\", s = 50) \n", 137 | " \n", 138 | " # prediz os valores\n", 139 | " y_pred = b[0] + b[1]*x \n", 140 | " \n", 141 | " # mostra a reta de regressão\n", 142 | " plt.plot(x, y_pred, color = \"r\") \n", 143 | " \n", 144 | " plt.xlabel('x', fontsize = 15) \n", 145 | " plt.ylabel('y', fontsize = 15) \n", 146 | " plt.show(True) " 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "Assim, aplicando ao conjunto de dados:" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 4, 159 | "metadata": {}, 160 | "outputs": [ 161 | { 162 | "name": "stdout", 163 | "output_type": "stream", 164 | "text": [ 165 | "Estimated coefficients:\n", 166 | "b_0 = 1.2363636363636363 \n", 167 | "b_1 = 1.1696969696969697\n" 168 | ] 169 | }, 170 | { 171 | "data": { 172 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAELCAYAAAA7h+qnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAf+0lEQVR4nO3dd3SVVbrH8e8DWIFRRuN4xYKOjICoiBlFwK6jg6jYANu1MxaUsRcso14cB1FhRCkLFAsicxFEEZAiqCjFUASkCGIBRY0FCVFpee4fOxjMTTDAydlvzvl91nKFvCee86yz4Pyy9373fszdERGR7FYtdgEiIhKfwkBERBQGIiKiMBARERQGIiIC1IhdwJbaddddvV69erHLEBGpUqZPn/6Nu+eUvl5lw6BevXrk5eXFLkNEpEoxs0/Luq5pIhERURiIiIjCQEREUBiIiAgKAxERIc13E5nZU0Br4Gt3b1x87WHgNGAN8BFwqbuvSGddIiJJV1AAgwfDokVQvz60awe1a6fu+dM9MhgAnFLq2ligsbsfDHwI3JHmmkREEm3SJKhbF/7+d+jaNXytWzdcT5W0hoG7vwV8V+raGHdfV/ztFGDPdNYkIpJkBQXQqlX4WlgYrhUWllxftSo1r5O0NYPLgFGxixARSYrBg6GoqOzHiorC46mQmDAws87AOmDgJn6mg5nlmVlefn5++ooTEYlk0aKSEUFphYWweHFqXicRYWBmFxMWli/wTbRec/e+7p7r7rk5Of/vaA0RkYxTvz7UrFn2YzVrwv77p+Z1ooeBmZ0C3Aac7u4/xq5HRCRJ2rWDar98Uju78M0vj1WrFh5PhbSGgZkNAiYDB5jZMjO7HOgJ1AbGmtksM+udzppERJKsdm0YORIa1fyUEdXPYArN2GXHn365XqtWal4nrfsM3P28Mi73T2cNIiJVytq1tJzcnbn+D9ZVhzFH30/X9tvQ9vzUBQFU4SOsRUQy3pQp8Le/wezZ2Omns83jj3Pq3ntXyktFXzMQEZFSVqyAq6+G5s3hu+9g2DAYPhwqKQhAYSAikhzuMGgQNGgAffuGrcbz5kGbNpX+0pomEhFJgsWL4ZprYOxY+POfYdQoOPTQtL28RgYiIjGtXg0PPACNG8PUqdCzJ0yenNYgAI0MRETiefNNuOoqWLAA2raFxx6DPfaIUopGBiIi6fbNN3DppXDssWFkMGpUOGQoUhCAwkBEJH3c4emnwwLx88/DHXfA3LlwSumT/dNP00QiIukwb164XfStt6BlS+jdGw48MHZVv9DIQESkMv30E3TuDE2awJw50K9fWCtIUBCARgYiIpXn9dfD7aJLlsBFF0G3brDbbrGrKpNGBiIiqfbll3DeeWEtoEYNeOMNePbZxAYBKAxERFKnqAh69QoLxMOGwX33wezZcNxxsSv7TZomEhFJhfffD4fKTZ0KJ5wQQqF+/dhVVZhGBiIiW2PVKrj5ZjjsMPj443DL6NixVSoIQCMDEZEtN3w4XHcdLF0KHTrAQw9BnTqxq9oiGhmIiGyupUvDSaJt2sBOO8GkSdCnT5UNAlAYiIhU3Lp14fyghg1hzJgwEpgxA1q0iF3ZVtM0kYhIRUybFhaIZ82CVq3C6aL77hu7qpTRyEBEZFN++AE6doRmzeDrr2HIEBgxIqOCABQGIiJlcw8niTZoEG4T7dgR5s+Hs88Gs9jVpZymiURESluyBK69FkaPhqZN4dVXITc3dlWVSiMDEZEN1qyBBx8Mh8hNmgTdu4dNZBkeBKCRgYhIMGlSWCCeNw/OOgt69IA994xdVdpoZCAi2e3bb+GKK+Coo8Ju4ldfhZdeyqogAIWBiGQr93CSaIMGMGAA3HJLGBW0bh27sig0TSQi2WfhwtB1bMKEcMtonz5w8MFl/mhBQbipaNGicNxQu3ZQu3aa602DtIaBmT0FtAa+dvfGxdd+DwwG6gGfAG3d/ft01iUiWeLnn8MC8b/+BTvuGFpPXnklVCt7kmTSpLC/rKgICguhZk248UYYOTJ0rswk6Z4mGgCU7vx8OzDe3esD44u/FxFJrXHj4KCD4IEH4JxzYMGCsGBcThAUFIQgKCgIQQDh64brq1alsfY0SGsYuPtbwHelLp8BPFP852eANumsSUQy3FdfwYUXwkknhe/HjIGBA+EPf9jk/zZ4cBgRlKWoKDyeSZKwgPwHd18OUPy13L5wZtbBzPLMLC8/Pz9tBYpIFVRUBH37hgXi//wH7r47dB3bEAq/YdGikhFBaYWFsHhxCmtNgCSEQYW5e193z3X33JycnNjliEhSzZkTbhX929/gkENCF7L774cddqjwU9SvH9YIylKzJuy/f4pqTYgkhMFXZvZfAMVfv45cj4hUVYWFcNtt4QiJhQvh6afDHUMNG272U7VrV+5yAtWqhcczSRLC4BXg4uI/XwwMj1iLiFRVr70WjpHo2hX++7/DAvEll2zxoXK1a4e7hmrXLhkh1KxZcr1WrdSVngTpvrV0EHAssKuZLQPuBR4C/mNmlwOfAeemsyYRqeI+/xw6dQq7hhs2hDffhKOPTslTt2wJX3wRFosXLw5TQ+3aZV4QQJrDwN3PK+ehE9JZh4hkgPXr4Ykn4K67YO1a6NIlNKbfdtuUvkytWnD55Sl9ykTSDmQRqXqmTw+Lw9Onw1/+Ak8+CX/8Y+yqqrQkrBmIiFTMypVhSujww2HZMhg0KPQcUBBsNY0MRCT53GHoULj+eli+HK66KhwrsfPOsSvLGBoZiEiyffIJnHZaOEIiJwcmTw7TQgqClFIYiEgyrV0bbhM98MCwV6BbN8jLgyOOiF1ZRtI0kYgkz+TJYYF4zhw4/XR4/HHYe+/YVWU0jQxEJDm+/z6EQPPm4c/DhsHw4QqCNFAYiEh87vDCC+FQuX794IYbQtexNjrEOF00TSQicS1eHLqOjRsHf/5zuFX00EOB7OkylgQKAxGJY/XqsEDcpQtstx307BluGa1eHciuLmNJoDAQkfSbODF88C9cCG3bwmOPwR57/PLwxl3GNtjQW6BVq3BeUCaeDxST1gxEJH3y8+Hii+G442DNGhg1KswDbRQEkH1dxpJAYSAila+oCPr3DwvEL7wAd9wBc+fCKaVbogfZ1mUsCTRNJCKVa968MCX09tthsr9377CRbBM2dBkrKxAysctYEmhkICKV46efoHNnaNIkjAL69Qu9Bn4jCCD7uowlgcJARFLv9dehceNwmFz79qHr2OWXl/8JX0q2dRlLAk0TiUjqLF8eNowNHgx/+hOMHw/HH79FT5VNXcaSQGEgIltv/Xro0ycsDK9eDffdFxrTb7fdVj1ttnQZSwKFgYhsnVmzwnlC06bBCSdAr15hBViqFK0ZiMiWWbUKbroJcnNDz4Hnn4exYxUEVZRGBiKy+YYPh+uug6VLoUMHeOghqFMndlWyFTQyEJGKW7o0nCTapg3stFM4QKhPHwVBBlAYiMhvW7cunB/UsCGMGRNGAjNmQIsWsSuTFNE0kYhs2rRpYYF41qxwSlzPnrDvvrGrkhTTyEBEyvbDD9CxIzRrBl9/Df/7vzBihIIgQykMROTX3OE//wlTQr16hUCYPx/OOQfMYlcnlUTTRCIJEr2z15IlcO21MHo03+zdlBcueIUdD86lnYEajGU2c/fYNQBgZjcAVwAOzAEudfefy/v53Nxcz8vLS1d5IpWurM5e1aqlqbPXmjXQrRs88ADrrAadi/6H3tWvZeWPNdJbh1Q6M5vu7rmlrydimsjM6gLXA7nu3hioDrSPW5VI+mzc2WvDsc2FhSXXV62qxBefNCn0HO7cmbV/aUXjavPpuroTK3+skd46JKpEhEGxGsAOZlYD2BH4InI9ImkTpbPXt9/CFVfAUUeFT/lXX+WZ015iGXumtw5JhESEgbt/DnQDPgOWAz+4+5jSP2dmHcwsz8zy8vPz012mSKVJa2cvd3j22dB1bMAAuOWW0ICmdWt1GMtiiQgDM6sDnAHsC+wB1DSzC0v/nLv3dfdcd8/NyclJd5kilWZDZ6+ypLSz18KF4TC5iy8OTzpjBnTt+suLp60OSZxEhAFwIvCxu+e7+1pgKNA8ck0iaVPpnb1+/hnuvRcOPhhmzgytJ995J3yfzjoksZISBp8BzcxsRzMz4ARgfuSaRNKmUjt7jR8fPvTvvz/sFViwIOwoLuNTXx3Gslci9hm4+1QzGwLMANYBM4G+casSSa+Ud/b66qtwxPTAgeHJxoyBk05Kfx1SJSRmn8Hm0j4DkXIUFYXm87fdFlZ9b78d7rwTtt8+dmWSAOXtM0jEyEBEUmTOHLjqKnj3XTjmmLA20KBB7KqkCkjKmoGIbI3CwjASaNo03DE0YABMmKAgkArTyECkqnvttXCe0KefwmWXhVtFd9kldlVSxWhkIFJVff55uDuodWvYcUd4803o319BIFtEYSBS1axfD//+dzhi+rXXoEuX0Hjm6KNjVyZVmKaJRKqS6dPDHoHp0+Hkk+GJJ+CPf4xdlWQAjQxEqoKVK6FTJzj88DA99OKLMGqUgkBSRiMDkSRzh6FD4frrYflyuPrqMC20886xK5MMozAQIQEdxsryySeh5eRrr8Ehh4RQOOKIyEVJplIYSNYrq8PYjTdG7Oy1di107w7/+EfoOfzII2FkUEP/XKXy6G+XZLWNO4xtsOE8/1atwhk9aT2TZ/LksEA8Zw6ccUa4a2jvvdNYgGQrLSBLVovSYaws338fQqB58/DnYcPg5ZcVBJI2CgPJatE7e7nDCy+EYyP69w/zU/PnQ5s2lfzCIr+maSLJahs6e5UVCJXe2WvRIrjmGhg3Ltwy+vrr0KRJJb6gSPk0MpCsFqWz1+rVodHMQQfBtGlh49i77yoIJCqFgWS1tHf2mjgx3CZ6771hKmjBgjA6qF49xS8ksnk0TSRZLy2dvfLz4eab4dlnYd99w+7hU05J4QuIbB2FgQjhg//yyyvhiYuK4Omn4dZbw/2rd94JnTuHU0ZFEqTC00Rm1trMNK0kUlHz5sGxx8IVV8CBB4aTRbt0URBIIm3Oh/tw4HMz+5eZNaysgkSqvJ9+Cr/9N2kCH3wQbhmdOBEaNYpdmUi5NicM/gj0BdoCc81sspldaWa/q5zSRKqg11+Hxo3hwQfh/PPDAvFll5V/y5JIQlT4b6i7f+Lu97r7vsBJwGLgMWC5mT1nZsdVVpEiibd8ObRvHxaFt9km9B8eMABycmJXJlIhW/Triru/4e4XAX8CpgMXAOPM7GMzu8HMtDAt2WH9+rBPoEGDcHzE/ffD+++HtQKRKmSLPrTN7BjgUuBsYC3wBPAycDJwH/Bn4PwU1SiSTLNmhfOEpk2DE0+EJ58MW5pFqqAKh4GZ7QNcXPxfPWAi0AEY6u6ri39svJlNBp5PbZkiCbJqVdg01qNHaD4/cCCcd144blqkitqckcES4AtgAPCUu39czs99AEzbyrpEkmn4cLjuOli6NIwK/vlPqFMndlUiW21zwuA0YLS7l3Pgb+DuHwJaTJbMsnRpCIHhw8OZQoMHw5FHxq5KJGU2526ikb8VBFvDzHY2syFmtsDM5puZ/qVJfOvWwaOPQsOGMHYsdO0K06crCCTjJOmunx6Ekcc5ZrYtoG2aEte0aWEqaNYsOPVU6NkT6tWLXZVIpUjETpjijWtHA/0B3H2Nu6+IW5VkrR9+gGuvhWbNwgFzL70Er76qIJCMlogwAPYD8oGnzWymmfUzs5qlf8jMOphZnpnl5efnp79KyWzuYS2gQQPo3Ts0oZ8/H846S3cKScZLShjUAJoCvdz9UKAQuL30D7l7X3fPdffcHO3slFRasgT++tewi7hu3TBF1L17aGwgkgWSEgbLgGXuPrX4+yGEcBCpXGvWhHOEDjwwdBvr0QOmToXDDotdmUhaJWIB2d2/NLOlZnaAuy8ETgDmxa5LMtzbb8NVV4Wjps85J4wE6taNXZVIFIkIg2LXAQOL7yRaQjjuQiT1vv02NJt56inYZx8YMSLcLSSSxRITBu4+C8iNXYdkMPfQdvLmm2HFCrjtNrj77pLmxyJZLDFhIFKpFiyAq68OTWaaNw93Cx10UOyqRBIjKQvIIpXj55/hnnvgkEPC5rG+fcNagYJA5Fc0MpDMNW5cGA0sXgwXXgiPPAK77Ra7KpFE0shAMs9XX8EFF8BJJ4XNYmPHwnPPKQhENkFhIJmjqAj69Ak7iIcMCdNDs2eHxjMiskmaJpLMMGdOOFRu8uTQcrJ3bzjggNhViVQZGhlI1VZYGPYMHHooLFoEzzwDb7yhIBDZTBoZSNU1YgR07AiffgpXXAEPPRTaUIrIZlMYSHQFBeGw0EWLQj/5du1+43y4ZcugUycYOjScKfT229CyZdrqFclECgOJatIkaNUqrP0WFobNwDfeCCNHlvH5vn59aDBz112hA9mDD8JNN8G220apXSSTKAwkmoKCEAQFBSXXCgvD11at4IsvoFat4gfy8sIC8YwZcMop8MQTsN9+aa9ZJFNpAVmiGTw4jAjKUlQUHmflytBk5ogjQjoMHhyGDQoCkZRSGEg0ixaVjARKKyx0th8xJDSi79kz7CResADatlXXMZFKoDCQaOrXL/vA0H34hFHVW3PBy+eGXcNTpoRA2Gmn9BcpkiUUBhJNu3ZQbaO/gTVYyy10ZR6NaLn+TVb/81F47z04/PB4RYpkCYWBRFO7dpj+r10bjt/+XaZzGF25jfE1TmbekPlsd/sNUEP3OIikg8JAomrZ6Du+PedvjP+5BXv/bgVjOw7nuO+HcfjZe8UuTSSr6NcuicMdBg6EG29km+++g5tuYud//IOTfrmXVETSSWEg6ffhh3DNNTB+fLhldOzY0HxGRKLRNJGkz+rVcP/9cPDBYRPZk0/CO+8oCEQSQCMDSY8JE8JegYULoX17eOwx2H332FWJSDGNDKRy5efDxRfD8cfD2rUwejQMGqQgEEkYhYFUjqIi6N8/dB0bNAg6d4a5c+Hkk2NXJiJl0DSRpN4HH8BVV4UjSY86KnQda9QodlUisgkaGUjq/Pgj3HEHNGkC8+aFkcHEiQoCkSpAIwNJjdGjw+2iH38c1ggefhhycmJXJSIVpJGBbJ3ly8MhQ3/9a2gyM2ECDBigIBCpYhIVBmZW3cxmmtmI2LXIb1i/PjSYadAAhg8P+wfefx+OPTZ2ZSKyBZI2TdQJmA/8LnYhsgkzZ4auY++9ByeeGDaP1a8fuyoR2QqJGRmY2Z7AqUC/2LVIOQoK4IYbIDcXPv00nC00ZoyCQCQDJCYMgO7ArUA5jRDBzDqYWZ6Z5eXn56evMoGXXw53BXXvDldeGbqOnX++uo6JZIhEhIGZtQa+dvfpm/o5d+/r7rnunpujBcr0+OwzOOMMOPNMqFMH3n037BuoUyd2ZSKSQokIA6AFcLqZfQK8CBxvZs/HLSnLrVsHjzwSRgPjxkHXrjB9Ohx5ZOzKRKQSJCIM3P0Od9/T3esB7YE33P3CyGVlrylTwrrAzTfDcceFDWS33ALbbBO7MhGpJIkIA0mIFSvCyaLNm8M338BLL8Err8A++8SuTEQqWdJuLcXdJwITI5eRXdzhxRfDnUL5+XD99fDAA6E5sYhkhcSFgaTZRx+FYyTGjIHDDoPXXgtfRSSraJooW61ZA126QOPGMHky/PvfMHWqgkAkS2lkkI3eeiscMT1/Ppx9NvToAXXrxq5KRCLSyCCbfPMNXHYZHHNMOG56xAgYMkRBICIKg6zgHk4SbdAAnnsObr01NKA59dTYlYlIQmiaKNMtWBCmhN58M2wY69MHDjoodlUikjAaGWSqn36Cu++Ggw8OR0v36RPaUCoIRKQMGhlkorFjw+axjz6CCy+Ebt3gD3+IXZWIJJjCIIKCAhg8GBYtCqc/t2uXov1dX34JN94IgwaFJx47NvQbEBH5DQqDNJs0CVq1gqIiKCyEmjXD5/fIkdCy5RY+aVER9O0Lt98epofuuSc0pt9++5TWLiKZS2GQRgUFIQgKCkquFRaGr61awRdfQK1am/mks2eHrmNTpoSWk717wwEHpKpkEckSWkBOo8GDwy/xZSkqCo9XWGFhOEm0aVNYvBieeQbeeENBICJbRCODNFq0qGQkUFphYfhMr5BXX4WOHUPjmcsvh3/9C3bZJWV1ikj20cggjerXD2sEZalZE/bf/zeeYNkyOOssOP30MJ/01lvQr5+CQES2msIgjdq1g2rlvOPVqoXHy7RuXeg93LAhjBoFDz4IM2fCUUdVWq0ikl0UBmlUu3a4a6h27ZIRQs2aJdfLXDzOy4Mjjgi9Blq2DMdI3HEHbLttWmsXkcymNYM0a9ky3DU0eHBYI9h//zAi+H9BsHIl3HUXPPEE7LZb+B/OPRfMotQtIplNYRBBrVph3bdM7qHdZKdOsHx5aDzTpQvstFNaaxSR7KJpoiT55BNo3TqMAHbbLewd6NlTQSAilU5hkARr14bbQxs1CqeLPvoovPceHH547MpEJEtomii2d98NO4jnzoU2bUL7yb32il2ViGQZjQxi+f576NABWrSAH36A4cNh2DAFgYhEoTBIN3d4/vlwbMRTT8FNN8G8eWEjmYhIJJomSqcPPwx3B40fH/YOjBkDTZrErkpERCODtFi9Gu67L3QZy8uDJ5+Ed95REIhIYmhkUNkmTAg9iD/8ENq3h8ceg913j12ViMivKAwqS35+WA947jnYbz8YPRpOPjl2Vb9SaR3XRKTKSUQYmNlewLPA7kAR0Nfde8StagsVFYWF4VtvhVWroHPn8N8OO8Su7FcqpeOaiFRZiQgDYB1wk7vPMLPawHQzG+vu82IXtlk++CBMCU2aBEcfDb16hY1kCVMpHddEpEpLxAKyuy939xnFfy4A5gN141a1GX78MZwk2qQJzJ8fRgYTJyYyCCDFHddEJCMkZWTwCzOrBxwKTC3jsQ5AB4C99947rXWVa9QouPZa+PhjuOQSePhh2HXX2FVtUso6rolIxkjEyGADM6sFvAT83d1Xln7c3fu6e6675+bk5KS/wI198QW0bRvmVbbbLowEnn468UEAKei4JiIZJzFhYGbbEIJgoLsPjV1PudavDyeJNmwIr7wCDzwAs2bBMcfErqzCtrjjmohkrESEgZkZ0B+Y7+6Pxq6nXDNnwpFHwnXXhR3Ec+eGBjTbbRe7ss2yRR3XRCSjJWXNoAVwETDHzGYVX7vT3UdGrKlEQQHcc084UTQnB154IWwgq8JdxyrccU1EskIiwsDdJwHJ/GR9+eUwEvj883DU9D//CTvvHLuqlNhkxzURySqJmCZKpM8+gzPOgDPPhN//PvQd6NUrY4JARGRjCoPS1q6Fbt3CAvG4ceFW0bw8aNYsdmUiIpUmEdNEiTFlSpgKmj0bTjsNHn8c9tkndlUiIpVOIwOAFSvg6quheXP49lsYOjR0HlMQiEiWyO4wcIdBg6BBA+jbFzp1CsdJnHlmlb5TSERkc2XvNNFHH4WuY2PGQG5uuMG+adPYVYmIRJF9I4M1a6BLF2jcGCZPDusCU6YoCEQkq2XfyOCtt8Ku4XPPhe7dYY89YlckIhJd1oVBwREnMu6uPKasOYz6I9XdS0QEsiwMSrp7HabuXiIiG8maNYONu3ttOMu/sLDk+qpVcesTEYkpa8JA3b1ERMqXNWGg7l4iIuXLmjBQdy8RkfJlTRiou5eISPmyJgzU3UtEpHxZdWupunuJiJQtq8IA1N1LRKQsWTNNJCIi5VMYiIiIwkBERBQGIiICmLvHrmGLmFk+8OlWPMWuwDcpKqeq03tRQu/Fr+n9KJEp78U+7p5T+mKVDYOtZWZ57p4bu44k0HtRQu/Fr+n9KJHp74WmiURERGEgIiLZHQZ9YxeQIHovSui9+DW9HyUy+r3I2jUDEREpkc0jAxERKaYwEBGR7AsDMzvFzBaa2WIzuz12PTGZ2V5mNsHM5pvZB2bWKXZNsZlZdTObaWYjYtcSm5ntbGZDzGxB8d+RI2PXFIuZ3VD8b2SumQ0ys+1j15RqWRUGZlYdeAL4K9AIOM/MGsWtKqp1wE3u3hBoBlyb5e8HQCdgfuwiEqIHMNrdGwCHkKXvi5nVBa4Hct29MVAdaB+3qtTLqjAADgcWu/sSd18DvAicEbmmaNx9ubvPKP5zAeEfe924VcVjZnsCpwL9YtcSm5n9Djga6A/g7mvcfUXcqqKqAexgZjWAHYEvIteTctkWBnWBpRt9v4ws/vDbmJnVAw4FpsatJKruwK1AUexCEmA/IB94unjarJ+ZldNFPLO5++dAN+AzYDnwg7uPiVtV6mVbGFgZ17L+3lozqwW8BPzd3VfGricGM2sNfO3u02PXkhA1gKZAL3c/FCgEsnKNzczqEGYQ9gX2AGqa2YVxq0q9bAuDZcBeG32/Jxk43NscZrYNIQgGuvvQ2PVE1AI43cw+IUwfHm9mz8ctKaplwDJ33zBSHEIIh2x0IvCxu+e7+1pgKNA8ck0pl21h8B5Q38z2NbNtCYtAr0SuKRozM8Kc8Hx3fzR2PTG5+x3uvqe71yP8vXjD3TPut7+KcvcvgaVmdkDxpROAeRFLiukzoJmZ7Vj8b+YEMnAxPat6ILv7OjPrCLxOuCPgKXf/IHJZMbUALgLmmNms4mt3uvvIiDVJclwHDCz+xWkJcGnkeqJw96lmNgSYQbgDbyYZeDSFjqMQEZGsmyYSEZEyKAxERERhICIiCgMREUFhICIiKAxERASFgYiIoDAQEREUBiJbrbgJzDIze7bU9VfM7EMz2zFWbSIVpTAQ2UrF5/xfDlxkZm0AzOxSQm+ES9z9x5j1iVSEjqMQSREz6wO0AU4BJgB93P22uFWJVIzCQCRFivtCzCaceb8YOMzdV8etSqRiNE0kkiLuvgoYAWwH9FcQSFWikYFIiphZLjAZmAPsAxxY3BdAJPEUBiIpYGbbE867XwK0Bd4nNA06PWphIhWkaSKR1PgfYHfgyuK7hy4GTjWzS6JWJVJBGhmIbCUzawG8BVzk7i9sdP1h4Eqgsbsvi1WfSEUoDERERNNEIiKiMBARERQGIiKCwkBERFAYiIgICgMREUFhICIiKAxERAT4PxhdJibXIZh7AAAAAElFTkSuQmCC\n", 173 | "text/plain": [ 174 | "
" 175 | ] 176 | }, 177 | "metadata": { 178 | "needs_background": "light" 179 | }, 180 | "output_type": "display_data" 181 | } 182 | ], 183 | "source": [ 184 | "import numpy as np\n", 185 | "\n", 186 | "# estima os coeficientes\n", 187 | "b = estimate_coef(x, y) \n", 188 | "print(\"Estimated coefficients:\\nb_0 = {} \\nb_1 = {}\".format(b[0], b[1])) \n", 189 | " \n", 190 | "# mostra o ajuste linear\n", 191 | "plot_regression_line(x, y, b) " 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "Para quantificar a acurácia do modelo, usamos o erro padrão residual (residual standard error):\n", 199 | "$$\n", 200 | "RSE = \\sqrt{\\frac{1}{n-2}\\sum_{i=1}^n (y_i-\\hat{y}_i)^2}\n", 201 | "$$" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 5, 207 | "metadata": {}, 208 | "outputs": [ 209 | { 210 | "name": "stdout", 211 | "output_type": "stream", 212 | "text": [ 213 | "RSE: 0.8384690232980003\n" 214 | ] 215 | } 216 | ], 217 | "source": [ 218 | "#funcao que calcula o RSE\n", 219 | "def RSE(x,y,b):\n", 220 | " n = len(y)\n", 221 | " RSE = 0\n", 222 | " for i in range(0,n):\n", 223 | " y_pred = b[0]+ x[i]*b[1] # valor predito\n", 224 | " RSE = RSE + (y[i]-y_pred)**2\n", 225 | " RSE = math.sqrt(RSE/(n-2))\n", 226 | " return RSE\n", 227 | "print('RSE:', RSE(x,y,b))" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "Outra medida importante é o coeficiente R2, que mede a proporção da variabilidade em Y que pode ser explicada a partir de X.\n", 235 | "$$\n", 236 | "R^2 = 1-\\frac{\\sum_{i=1}^n (y_i-\\hat{y}_i)^2}{\\sum_{i=1}^n(y_i-\\bar{y})^2}, \\quad 0\\leq R^2\\leq 1\n", 237 | "$$" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 6, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "name": "stdout", 247 | "output_type": "stream", 248 | "text": [ 249 | "R2: 0.952538038613988\n" 250 | ] 251 | } 252 | ], 253 | "source": [ 254 | "def R2(x,y,b):\n", 255 | " n = len(y)\n", 256 | " c1 = 0\n", 257 | " c2 = 0\n", 258 | " ym = np.mean(y)\n", 259 | " for i in range(0,n):\n", 260 | " y_pred = b[0]+ x[i]*b[1] # valor predito\n", 261 | " c1 = c1 + (y[i]-y_pred)**2\n", 262 | " c2 = c2 + (y[i]-ym)**2\n", 263 | " R2 = 1 - c1/c2\n", 264 | " return R2\n", 265 | "\n", 266 | "print('R2:', R2(x,y,b))" 267 | ] 268 | }, 269 | { 270 | "cell_type": "markdown", 271 | "metadata": {}, 272 | "source": [ 273 | "Quanto mais próximo de um, melhor é o ajuste da regressão linear." 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "O código completo:" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 19, 286 | "metadata": {}, 287 | "outputs": [ 288 | { 289 | "name": "stdout", 290 | "output_type": "stream", 291 | "text": [ 292 | "Coeficientes:\n", 293 | "b_0 = 1.2363636363636363 \n", 294 | "b_1 = 1.1696969696969697\n", 295 | "R2: 0.952538038613988\n" 296 | ] 297 | }, 298 | { 299 | "data": { 300 | "image/png": "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\n", 301 | "text/plain": [ 302 | "
" 303 | ] 304 | }, 305 | "metadata": { 306 | "needs_background": "light" 307 | }, 308 | "output_type": "display_data" 309 | } 310 | ], 311 | "source": [ 312 | "import matplotlib.pyplot as plt\n", 313 | "import numpy as np\n", 314 | "from statistics import variance \n", 315 | "import math \n", 316 | "\n", 317 | "# define os dados\n", 318 | "x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) \n", 319 | "y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12]) \n", 320 | "\n", 321 | "# funcao que estima os coeficientes\n", 322 | "def estimate_coef(x, y): \n", 323 | " # número de observações\n", 324 | " n = np.size(x) \n", 325 | " # estimadores\n", 326 | " m_x, m_y = np.mean(x), np.mean(y) \n", 327 | " SS_xy = np.sum(y*x) - n*m_y*m_x \n", 328 | " SS_xx = np.sum(x*x) - n*m_x*m_x \n", 329 | " # calcula os coeficientes de regressão\n", 330 | " b_1 = SS_xy / SS_xx \n", 331 | " b_0 = m_y - b_1*m_x \n", 332 | " return(b_0, b_1) \n", 333 | "\n", 334 | "# função para mostrar os dados e o ajuste linear\n", 335 | "def plot_regression_line(x, y, b): \n", 336 | " # mostra os dados\n", 337 | " plt.scatter(x, y, color = \"b\", marker = \"o\", s = 50) \n", 338 | " # prediz os valores\n", 339 | " y_pred = b[0] + b[1]*x \n", 340 | " # mostra a reta de regressão\n", 341 | " plt.plot(x, y_pred, color = \"r\") \n", 342 | " plt.xlabel('x', fontsize = 15) \n", 343 | " plt.ylabel('y', fontsize = 15) \n", 344 | " plt.show(True) \n", 345 | " \n", 346 | "def R2(x,y,b):\n", 347 | " n = len(y)\n", 348 | " c1 = 0\n", 349 | " c2 = 0\n", 350 | " ym = np.mean(y)\n", 351 | " for i in range(0,n):\n", 352 | " y_pred = b[0]+ x[i]*b[1] # valor predito\n", 353 | " c1 = c1 + (y[i]-y_pred)**2\n", 354 | " c2 = c2 + (y[i]-ym)**2\n", 355 | " R2 = 1 - c1/c2\n", 356 | " return R2\n", 357 | " \n", 358 | "# estima os coeficientes\n", 359 | "b = estimate_coef(x, y) \n", 360 | "print(\"Coeficientes:\\nb_0 = {} \\nb_1 = {}\".format(b[0], b[1])) \n", 361 | "print('R2:', R2(x,y,b))\n", 362 | "\n", 363 | "\n", 364 | "# mostra o ajuste linear\n", 365 | "plt.plot(x,y,'bo')\n", 366 | "plt.plot(x, b[0] + b[1]*x, 'r-')\n", 367 | "plt.savefig('plot.eps')" 368 | ] 369 | } 370 | ], 371 | "metadata": { 372 | "kernelspec": { 373 | "display_name": "Python 3", 374 | "language": "python", 375 | "name": "python3" 376 | }, 377 | "language_info": { 378 | "codemirror_mode": { 379 | "name": "ipython", 380 | "version": 3 381 | }, 382 | "file_extension": ".py", 383 | "mimetype": "text/x-python", 384 | "name": "python", 385 | "nbconvert_exporter": "python", 386 | "pygments_lexer": "ipython3", 387 | "version": "3.7.4" 388 | } 389 | }, 390 | "nbformat": 4, 391 | "nbformat_minor": 2 392 | } 393 | -------------------------------------------------------------------------------- /Aula4-Classificacao-Naive Bayes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Classificador Naive Bayes" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Francisco Aparecido Rodrigues, francisco@icmc.usp.br.
\n", 15 | "Universidade de São Paulo, São Carlos, Brasil.
\n", 16 | "https://sites.icmc.usp.br/francisco
\n", 17 | "Copyright: Creative Commons" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "
" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "No classificador Naive Bayes, podemos assumir que os atributos são normalmente distribuídos." 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 1, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "name": "stdout", 41 | "output_type": "stream", 42 | "text": [ 43 | "Número de linhas e colunas na matriz de atributos: (150, 5)\n" 44 | ] 45 | }, 46 | { 47 | "data": { 48 | "text/html": [ 49 | "
\n", 50 | "\n", 63 | "\n", 64 | " \n", 65 | " \n", 66 | " \n", 67 | " \n", 68 | " \n", 69 | " \n", 70 | " \n", 71 | " \n", 72 | " \n", 73 | " \n", 74 | " \n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | " \n", 87 | " \n", 88 | " \n", 89 | " \n", 90 | " \n", 91 | " \n", 92 | " \n", 93 | " \n", 94 | " \n", 95 | " \n", 96 | " \n", 97 | " \n", 98 | " \n", 99 | " \n", 100 | " \n", 101 | " \n", 102 | " \n", 103 | " \n", 104 | " \n", 105 | " \n", 106 | " \n", 107 | " \n", 108 | " \n", 109 | " \n", 110 | " \n", 111 | " \n", 112 | " \n", 113 | " \n", 114 | " \n", 115 | " \n", 116 | " \n", 117 | " \n", 118 | " \n", 119 | " \n", 120 | " \n", 121 | " \n", 122 | " \n", 123 | " \n", 124 | " \n", 125 | " \n", 126 | " \n", 127 | " \n", 128 | " \n", 129 | " \n", 130 | " \n", 131 | " \n", 132 | " \n", 133 | " \n", 134 | " \n", 135 | " \n", 136 | " \n", 137 | " \n", 138 | " \n", 139 | " \n", 140 | " \n", 141 | " \n", 142 | " \n", 143 | " \n", 144 | " \n", 145 | " \n", 146 | " \n", 147 | " \n", 148 | " \n", 149 | " \n", 150 | " \n", 151 | " \n", 152 | " \n", 153 | " \n", 154 | " \n", 155 | " \n", 156 | "
sepal_lengthsepal_widthpetal_lengthpetal_widthspecies
05.13.51.40.2setosa
14.93.01.40.2setosa
24.73.21.30.2setosa
34.63.11.50.2setosa
45.03.61.40.2setosa
55.43.91.70.4setosa
64.63.41.40.3setosa
75.03.41.50.2setosa
84.42.91.40.2setosa
94.93.11.50.1setosa
\n", 157 | "
" 158 | ], 159 | "text/plain": [ 160 | " sepal_length sepal_width petal_length petal_width species\n", 161 | "0 5.1 3.5 1.4 0.2 setosa\n", 162 | "1 4.9 3.0 1.4 0.2 setosa\n", 163 | "2 4.7 3.2 1.3 0.2 setosa\n", 164 | "3 4.6 3.1 1.5 0.2 setosa\n", 165 | "4 5.0 3.6 1.4 0.2 setosa\n", 166 | "5 5.4 3.9 1.7 0.4 setosa\n", 167 | "6 4.6 3.4 1.4 0.3 setosa\n", 168 | "7 5.0 3.4 1.5 0.2 setosa\n", 169 | "8 4.4 2.9 1.4 0.2 setosa\n", 170 | "9 4.9 3.1 1.5 0.1 setosa" 171 | ] 172 | }, 173 | "execution_count": 1, 174 | "metadata": {}, 175 | "output_type": "execute_result" 176 | } 177 | ], 178 | "source": [ 179 | "import random\n", 180 | "random.seed(42) # define the seed (important to reproduce the results)\n", 181 | "import pandas as pd\n", 182 | "import numpy as np\n", 183 | "import matplotlib.pyplot as plt\n", 184 | "\n", 185 | "#data = pd.read_csv('data/vertebralcolumn-3C.csv', header=(0))\n", 186 | "data = pd.read_csv('data/Iris.csv', header=(0))\n", 187 | "\n", 188 | "data = data.dropna(axis='rows') #remove NaN\n", 189 | "# armazena os nomes das classes\n", 190 | "classes = np.array(pd.unique(data[data.columns[-1]]), dtype=str) \n", 191 | "\n", 192 | "print(\"Número de linhas e colunas na matriz de atributos:\", data.shape)\n", 193 | "attributes = list(data.columns)\n", 194 | "data.head(10)" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": 2, 200 | "metadata": {}, 201 | "outputs": [], 202 | "source": [ 203 | "data = data.to_numpy()\n", 204 | "nrow,ncol = data.shape\n", 205 | "y = data[:,-1]\n", 206 | "X = data[:,0:ncol-1]" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "Selecionando os conjuntos de treinamento e teste." 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 3, 219 | "metadata": {}, 220 | "outputs": [], 221 | "source": [ 222 | "from sklearn.model_selection import train_test_split\n", 223 | "p = 0.7 # fracao de elementos no conjunto de treinamento\n", 224 | "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size = p, random_state = 42)" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": {}, 230 | "source": [ 231 | "### Classificação: implementação do método" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "Inicialmente, definimos uma função para calcular a densidade de probabilidade conjunta: $$p(\\vec{x}|C_i) = \\prod_{j=1}^d p(x_j|C_i), \\quad i=1,\\ldots, k$$ \n", 239 | "onde $C_i$ são as classes. Se a distribuição for normal, temos que cada atributo $X_j$ tem a seguinte função densidade de probabilidade associada, para cada classe:\n", 240 | "$$\n", 241 | "p(x_j|C_i) = \\frac{1}{\\sqrt{2\\pi\\sigma_{C_i}}}\\exp \\left[ -\\frac{1}{2}\\left( \\frac{x_j-\\mu_{C_i}}{\\sigma_{C_i}}\\right)^2 \\right], \\quad i=1,2,\\ldots, k.\n", 242 | "$$\n", 243 | "Assim, definimos uma função para calcular a função de verossimilhança." 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": 4, 249 | "metadata": {}, 250 | "outputs": [], 251 | "source": [ 252 | "def likelyhood(y, Z):\n", 253 | " def gaussian(x, mu, sig):\n", 254 | " return np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.)))\n", 255 | " prob = 1\n", 256 | " for j in np.arange(0, Z.shape[1]):\n", 257 | " m = np.mean(Z[:,j])\n", 258 | " s = np.std(Z[:,j]) \n", 259 | " prob = prob*gaussian(y[j], m, s)\n", 260 | " return prob" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": {}, 266 | "source": [ 267 | "A seguir, realizamos a estimação para cada classe:" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 5, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [ 276 | "P = pd.DataFrame(data=np.zeros((X_test.shape[0], len(classes))), columns = classes) \n", 277 | "for i in np.arange(0, len(classes)):\n", 278 | " elements = tuple(np.where(y_train == classes[i]))\n", 279 | " Z = X_train[elements,:][0]\n", 280 | " for j in np.arange(0,X_test.shape[0]):\n", 281 | " x = X_test[j,:]\n", 282 | " pj = likelyhood(x,Z)\n", 283 | " P[classes[i]][j] = pj*len(elements)/X_train.shape[0]" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": {}, 289 | "source": [ 290 | "Para as observações no conjunto de teste, a probabilidade pertencer a cada classe:" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": 6, 296 | "metadata": {}, 297 | "outputs": [ 298 | { 299 | "data": { 300 | "text/html": [ 301 | "
\n", 302 | "\n", 315 | "\n", 316 | " \n", 317 | " \n", 318 | " \n", 319 | " \n", 320 | " \n", 321 | " \n", 322 | " \n", 323 | " \n", 324 | " \n", 325 | " \n", 326 | " \n", 327 | " \n", 328 | " \n", 329 | " \n", 330 | " \n", 331 | " \n", 332 | " \n", 333 | " \n", 334 | " \n", 335 | " \n", 336 | " \n", 337 | " \n", 338 | " \n", 339 | " \n", 340 | " \n", 341 | " \n", 342 | " \n", 343 | " \n", 344 | " \n", 345 | " \n", 346 | " \n", 347 | " \n", 348 | " \n", 349 | " \n", 350 | " \n", 351 | " \n", 352 | " \n", 353 | " \n", 354 | " \n", 355 | " \n", 356 | " \n", 357 | " \n", 358 | " \n", 359 | " \n", 360 | " \n", 361 | " \n", 362 | " \n", 363 | " \n", 364 | " \n", 365 | " \n", 366 | " \n", 367 | " \n", 368 | " \n", 369 | " \n", 370 | " \n", 371 | " \n", 372 | " \n", 373 | " \n", 374 | " \n", 375 | " \n", 376 | " \n", 377 | " \n", 378 | " \n", 379 | " \n", 380 | " \n", 381 | " \n", 382 | " \n", 383 | " \n", 384 | " \n", 385 | " \n", 386 | "
setosaversicolorvirginica
01.824344e-904.440479e-034.107993e-05
11.652256e-041.196823e-164.171552e-23
26.741862e-2873.100666e-172.363765e-05
31.609452e-934.042876e-032.146958e-04
42.453031e-1068.057427e-043.352704e-04
51.491009e-035.335375e-151.159063e-22
61.585589e-533.230445e-032.400042e-07
75.666865e-1726.868359e-103.319537e-03
83.375351e-968.399067e-041.117962e-05
97.866680e-606.780257e-036.579053e-07
\n", 387 | "
" 388 | ], 389 | "text/plain": [ 390 | " setosa versicolor virginica\n", 391 | "0 1.824344e-90 4.440479e-03 4.107993e-05\n", 392 | "1 1.652256e-04 1.196823e-16 4.171552e-23\n", 393 | "2 6.741862e-287 3.100666e-17 2.363765e-05\n", 394 | "3 1.609452e-93 4.042876e-03 2.146958e-04\n", 395 | "4 2.453031e-106 8.057427e-04 3.352704e-04\n", 396 | "5 1.491009e-03 5.335375e-15 1.159063e-22\n", 397 | "6 1.585589e-53 3.230445e-03 2.400042e-07\n", 398 | "7 5.666865e-172 6.868359e-10 3.319537e-03\n", 399 | "8 3.375351e-96 8.399067e-04 1.117962e-05\n", 400 | "9 7.866680e-60 6.780257e-03 6.579053e-07" 401 | ] 402 | }, 403 | "execution_count": 6, 404 | "metadata": {}, 405 | "output_type": "execute_result" 406 | } 407 | ], 408 | "source": [ 409 | "P.head(10)" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": 7, 415 | "metadata": {}, 416 | "outputs": [ 417 | { 418 | "name": "stdout", 419 | "output_type": "stream", 420 | "text": [ 421 | "Accuracy: 0.9555555555555556\n" 422 | ] 423 | } 424 | ], 425 | "source": [ 426 | "from sklearn.metrics import accuracy_score\n", 427 | "\n", 428 | "y_pred = []\n", 429 | "for i in np.arange(0, P.shape[0]):\n", 430 | " c = np.argmax(np.array(P.iloc[[i]]))\n", 431 | " y_pred.append(P.columns[c])\n", 432 | "y_pred = np.array(y_pred, dtype=str)\n", 433 | "\n", 434 | "score = accuracy_score(y_pred, y_test)\n", 435 | "print('Accuracy:', score)" 436 | ] 437 | }, 438 | { 439 | "cell_type": "markdown", 440 | "metadata": {}, 441 | "source": [ 442 | "### Classificação: usando a biblioteca scikit-learn" 443 | ] 444 | }, 445 | { 446 | "cell_type": "markdown", 447 | "metadata": {}, 448 | "source": [ 449 | "Podemos realizar a classificação usando a função disponível na biblioteca scikit-learn." 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": 8, 455 | "metadata": {}, 456 | "outputs": [ 457 | { 458 | "name": "stdout", 459 | "output_type": "stream", 460 | "text": [ 461 | "Accuracy: 0.9777777777777777\n" 462 | ] 463 | } 464 | ], 465 | "source": [ 466 | "from sklearn.naive_bayes import GaussianNB\n", 467 | "from sklearn import metrics\n", 468 | "\n", 469 | "model = GaussianNB()\n", 470 | "model.fit(X_train, y_train)\n", 471 | "\n", 472 | "y_pred = model.predict(X_test)\n", 473 | "score = accuracy_score(y_pred, y_test)\n", 474 | "print('Accuracy:', score)" 475 | ] 476 | }, 477 | { 478 | "cell_type": "markdown", 479 | "metadata": {}, 480 | "source": [ 481 | "Outra maneira de efetuarmos a classificação é assumirmos que os atributos possuem distribuição diferente da normal. " 482 | ] 483 | }, 484 | { 485 | "cell_type": "markdown", 486 | "metadata": {}, 487 | "source": [ 488 | "Uma possibilidade é assumirmos que os dados possuem distribuição de Bernoulli. " 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": 9, 494 | "metadata": {}, 495 | "outputs": [ 496 | { 497 | "name": "stdout", 498 | "output_type": "stream", 499 | "text": [ 500 | "Accuracy: 0.28888888888888886\n" 501 | ] 502 | } 503 | ], 504 | "source": [ 505 | "from sklearn.naive_bayes import BernoulliNB\n", 506 | "\n", 507 | "model = BernoulliNB()\n", 508 | "model.fit(X_train, y_train)\n", 509 | "\n", 510 | "y_pred = model.predict(X_test)\n", 511 | "score = accuracy_score(y_pred, y_test)\n", 512 | "print('Accuracy:', score)" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": {}, 518 | "source": [ 519 | "Código completo." 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": 10, 525 | "metadata": {}, 526 | "outputs": [ 527 | { 528 | "name": "stdout", 529 | "output_type": "stream", 530 | "text": [ 531 | "Acuracia: 1.0\n" 532 | ] 533 | } 534 | ], 535 | "source": [ 536 | "import random\n", 537 | "import pandas as pd\n", 538 | "import numpy as np\n", 539 | "import matplotlib.pyplot as plt\n", 540 | "from sklearn.model_selection import train_test_split\n", 541 | "from sklearn.preprocessing import StandardScaler\n", 542 | "from sklearn.naive_bayes import GaussianNB\n", 543 | "from sklearn.metrics import accuracy_score\n", 544 | "\n", 545 | "random.seed(42) \n", 546 | "\n", 547 | "data = pd.read_csv('data/Iris.csv', header=(0))\n", 548 | "\n", 549 | "classes = np.array(pd.unique(data[data.columns[-1]]), dtype=str) \n", 550 | "\n", 551 | "# Converte para matriz e vetor do numpy\n", 552 | "data = data.to_numpy()\n", 553 | "nrow,ncol = data.shape\n", 554 | "y = data[:,-1]\n", 555 | "X = data[:,0:ncol-1]\n", 556 | "\n", 557 | "# Transforma os dados para terem media igual a zero e variancia igual a 1\n", 558 | "#scaler = StandardScaler().fit(X)\n", 559 | "#X = scaler.transform(X)\n", 560 | "\n", 561 | "# Seleciona os conjuntos de treinamento e teste\n", 562 | "p = 0.8 # fraction of elements in the test set\n", 563 | "X_train, X_test, y_train, y_test = train_test_split(X, y, \n", 564 | " train_size = p, random_state = 42)\n", 565 | "\n", 566 | "# ajusta o classificador Naive-Bayes de acordo com os dados\n", 567 | "model = GaussianNB()\n", 568 | "model.fit(X_train, y_train)\n", 569 | "# realiza a predicao\n", 570 | "y_pred = model.predict(X_test)\n", 571 | "# calcula a acuracia\n", 572 | "score = accuracy_score(y_pred, y_test)\n", 573 | "print('Acuracia:', score)" 574 | ] 575 | }, 576 | { 577 | "cell_type": "markdown", 578 | "metadata": {}, 579 | "source": [ 580 | "## Região de decisão" 581 | ] 582 | }, 583 | { 584 | "cell_type": "markdown", 585 | "metadata": {}, 586 | "source": [ 587 | "Selecionando dois atributos, podemos visualizar a região de decisão. Para graficar a região de separação, precisamos instalar a bibliteca mlxtend: http://rasbt.github.io/mlxtend/installation/
\n", 588 | "Pode ser usado: conda install -c conda-forge mlxtend" 589 | ] 590 | }, 591 | { 592 | "cell_type": "markdown", 593 | "metadata": {}, 594 | "source": [ 595 | "Para o classificador Naive Bayes:" 596 | ] 597 | }, 598 | { 599 | "cell_type": "code", 600 | "execution_count": 11, 601 | "metadata": {}, 602 | "outputs": [], 603 | "source": [ 604 | "from mlxtend.plotting import plot_decision_regions\n", 605 | "import numpy as np\n", 606 | "import matplotlib.pyplot as plt\n", 607 | "from sklearn import datasets\n", 608 | "from sklearn.neighbors import KNeighborsClassifier\n", 609 | "import sklearn.datasets as skdata\n", 610 | "from matplotlib import pyplot\n", 611 | "from pandas import DataFrame\n", 612 | "\n", 613 | "# Gera os dados em duas dimensões\n", 614 | "n_samples = 100 # número de observações\n", 615 | "# centro dos grupos\n", 616 | "centers = [(-4, 0), (0, 0), (3, 3)]\n", 617 | "X, y = skdata.make_blobs(n_samples=100, n_features=2, cluster_std=1.0, centers=centers, \n", 618 | " shuffle=False, random_state=42)\n", 619 | "\n", 620 | "# monta a matrix de atributos\n", 621 | "d = np.column_stack((X,np.transpose(y)))\n", 622 | "# converte para o formato dataframe do Pandas\n", 623 | "data = DataFrame(data = d, columns=['X1', 'X2', 'y'])\n", 624 | "features_names = ['X1', 'X2']\n", 625 | "class_labels = np.unique(y)" 626 | ] 627 | }, 628 | { 629 | "cell_type": "code", 630 | "execution_count": 12, 631 | "metadata": {}, 632 | "outputs": [ 633 | { 634 | "data": { 635 | "image/png": "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\n", 636 | "text/plain": [ 637 | "
" 638 | ] 639 | }, 640 | "metadata": { 641 | "needs_background": "light" 642 | }, 643 | "output_type": "display_data" 644 | }, 645 | { 646 | "data": { 647 | "image/png": "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\n", 648 | "text/plain": [ 649 | "
" 650 | ] 651 | }, 652 | "metadata": { 653 | "needs_background": "light" 654 | }, 655 | "output_type": "display_data" 656 | } 657 | ], 658 | "source": [ 659 | "from mlxtend.plotting import plot_decision_regions\n", 660 | "import matplotlib.pyplot as plt\n", 661 | "from sklearn import datasets\n", 662 | "from sklearn.naive_bayes import GaussianNB\n", 663 | "\n", 664 | "\n", 665 | "# mostra os dados e colori de acordo com as classes\n", 666 | "colors = ['red', 'blue', 'green', 'black']\n", 667 | "aux = 0\n", 668 | "for c in class_labels:\n", 669 | " ind = np.where(y == c)\n", 670 | " plt.scatter(X[ind,0][0], X[ind,1][0], color = colors[aux], label = c)\n", 671 | " aux = aux + 1\n", 672 | "plt.legend()\n", 673 | "plt.show()\n", 674 | "\n", 675 | "# Training a classifier\n", 676 | "model = GaussianNB()\n", 677 | "model.fit(X, y)\n", 678 | "\n", 679 | "# Plotting decision regions\n", 680 | "plot_decision_regions(X, y, clf=model, legend=2)\n", 681 | "\n", 682 | "plt.xlabel('X1')\n", 683 | "plt.ylabel('X2')\n", 684 | "plt.title('Decision Regions')\n", 685 | "plt.show()" 686 | ] 687 | }, 688 | { 689 | "cell_type": "markdown", 690 | "metadata": {}, 691 | "source": [ 692 | "### Exercícios de fixação" 693 | ] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": {}, 698 | "source": [ 699 | "1 - Repita todos os passos acima para a base de dados BreastCancer." 700 | ] 701 | }, 702 | { 703 | "cell_type": "markdown", 704 | "metadata": {}, 705 | "source": [ 706 | "2 - Considere a base vertebralcolumn-3C e compare o classificadores: Naive Bayes, Classificador Bayesiano paramétrico e o classiificador Bayesiano não-paramétrico." 707 | ] 708 | }, 709 | { 710 | "cell_type": "markdown", 711 | "metadata": {}, 712 | "source": [ 713 | "3 - Considerando a base de dados Vehicle, projete os dados em duas dimensões usando PCA e mostre as regiões de separação como feito acima." 714 | ] 715 | }, 716 | { 717 | "cell_type": "markdown", 718 | "metadata": {}, 719 | "source": [ 720 | "4 - Faça a classificação dos dados gerados artificialmente com o código abaixo. Compare os resultados para os métodos Naive Bayes, Classificador Bayesiano paramétrico e o classiificador Bayesiano não-paramétrico." 721 | ] 722 | }, 723 | { 724 | "cell_type": "code", 725 | "execution_count": 13, 726 | "metadata": {}, 727 | "outputs": [ 728 | { 729 | "data": { 730 | "image/png": "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\n", 731 | "text/plain": [ 732 | "
" 733 | ] 734 | }, 735 | "metadata": { 736 | "needs_background": "light" 737 | }, 738 | "output_type": "display_data" 739 | } 740 | ], 741 | "source": [ 742 | "from sklearn import datasets\n", 743 | "plt.figure(figsize=(6,4))\n", 744 | "\n", 745 | "n_samples = 1000\n", 746 | "\n", 747 | "data = datasets.make_moons(n_samples=n_samples, noise=.05)\n", 748 | "X = data[0]\n", 749 | "y = data[1]\n", 750 | "plt.scatter(X[:,0], X[:,1], c=y, cmap='viridis', s=50, alpha=0.7)\n", 751 | "plt.show(True)" 752 | ] 753 | }, 754 | { 755 | "cell_type": "markdown", 756 | "metadata": {}, 757 | "source": [ 758 | "5 - Encontre a região de separação dos dados do exercício anterior usando o método Naive Bayes." 759 | ] 760 | }, 761 | { 762 | "cell_type": "markdown", 763 | "metadata": {}, 764 | "source": [ 765 | "6 - (Facultativo) Escolha outras distribuições de probabilidade e implemente um algoritmo Naive Bayes geral. Ou seja, o algoritmo faz a classificação usando várias distribuições e obtém o melhor resultado, mostrando também qual a distribuição mais adequada." 766 | ] 767 | }, 768 | { 769 | "cell_type": "markdown", 770 | "metadata": {}, 771 | "source": [ 772 | "7 - (Para pensar) É possível implementar o Naive Bayes heterogêneo, ou seja, com diferentes distribuições para cada atributo?" 773 | ] 774 | }, 775 | { 776 | "cell_type": "markdown", 777 | "metadata": {}, 778 | "source": [ 779 | "8 - (Desafio) Gere dados com diferentes níveis de correlação entre as variáveis e verifique se a perfomance do algoritmo muda com a correlação." 780 | ] 781 | }, 782 | { 783 | "cell_type": "markdown", 784 | "metadata": {}, 785 | "source": [ 786 | "## Código completo" 787 | ] 788 | }, 789 | { 790 | "cell_type": "code", 791 | "execution_count": 14, 792 | "metadata": {}, 793 | "outputs": [ 794 | { 795 | "name": "stdout", 796 | "output_type": "stream", 797 | "text": [ 798 | "Accuracy: 1.0\n" 799 | ] 800 | } 801 | ], 802 | "source": [ 803 | "import random\n", 804 | "import pandas as pd\n", 805 | "import numpy as np\n", 806 | "from sklearn.model_selection import train_test_split\n", 807 | "from sklearn.metrics import accuracy_score\n", 808 | "\n", 809 | "random.seed(42) \n", 810 | "data = pd.read_csv('data/Iris.csv', header=(0))\n", 811 | "# classes: setosa, virginica e versicolor\n", 812 | "classes = pd.unique(data[data.columns[-1]])\n", 813 | "classes = np.array(classes, dtype=str) \n", 814 | "# converte para matrizes do numpy\n", 815 | "data = data.to_numpy()\n", 816 | "nrow,ncol = data.shape\n", 817 | "y = data[:,-1]\n", 818 | "X = data[:,0:ncol-1]\n", 819 | "# Seleciona o conjunto de teste e treinamento\n", 820 | "p = 0.7 \n", 821 | "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size = p)\n", 822 | "\n", 823 | "# funcao para calcular a verossimilhanca\n", 824 | "def likelyhood(y, Z):\n", 825 | " def gaussian(x, mu, sig):\n", 826 | " return np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.)))\n", 827 | " prob = 1\n", 828 | " for j in np.arange(0, Z.shape[1]):\n", 829 | " m = np.mean(Z[:,j])\n", 830 | " s = np.std(Z[:,j]) \n", 831 | " prob = prob*gaussian(y[j], m, s)\n", 832 | " return prob\n", 833 | "\n", 834 | "# matriz que armazena o produto da verossimilhanca pela priori\n", 835 | "P = pd.DataFrame(data=np.zeros((X_test.shape[0], len(classes))), columns = classes) \n", 836 | "for i in np.arange(0, len(classes)):\n", 837 | " elements = tuple(np.where(y_train == classes[i]))\n", 838 | " Z = X_train[elements,:][0]\n", 839 | " for j in np.arange(0,X_test.shape[0]):\n", 840 | " x = X_test[j,:]\n", 841 | " pj = likelyhood(x,Z) #verossimilhanca\n", 842 | " pc = len(elements)/X_train.shape[0] # priori\n", 843 | " P[classes[i]][j] = pj*pc\n", 844 | " \n", 845 | "# realiza a classificao seguindo a regra de Bayes\n", 846 | "y_pred = []\n", 847 | "for i in np.arange(0, P.shape[0]):\n", 848 | " c = np.argmax(np.array(P.iloc[[i]]))\n", 849 | " y_pred.append(P.columns[c])\n", 850 | "y_pred = np.array(y_pred, dtype=str)\n", 851 | "# calcula a acuracia na classificacao\n", 852 | "score = accuracy_score(y_pred, y_test)\n", 853 | "print('Accuracy:', score)" 854 | ] 855 | }, 856 | { 857 | "cell_type": "code", 858 | "execution_count": null, 859 | "metadata": {}, 860 | "outputs": [], 861 | "source": [] 862 | } 863 | ], 864 | "metadata": { 865 | "kernelspec": { 866 | "display_name": "Python 3", 867 | "language": "python", 868 | "name": "python3" 869 | }, 870 | "language_info": { 871 | "codemirror_mode": { 872 | "name": "ipython", 873 | "version": 3 874 | }, 875 | "file_extension": ".py", 876 | "mimetype": "text/x-python", 877 | "name": "python", 878 | "nbconvert_exporter": "python", 879 | "pygments_lexer": "ipython3", 880 | "version": "3.7.4" 881 | } 882 | }, 883 | "nbformat": 4, 884 | "nbformat_minor": 2 885 | } 886 | --------------------------------------------------------------------------------