{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [], "include_colab_link": true }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "source": [ "# CIAG 2024 - Introdução ao Aprendizado de Máquina\n", "\n", "> Indented block\n", "\n", "\n", "\n", "- Neste notebook, iremos rever conceitos importantes referentes à Aprendizagem de Máquina, como problemas de regressão vs. classificação, divisão dos dados em conjuntos de treino, validação e teste e avaliação dos modelos utilizados (métricas de precisão e revocação, por exemplo). Iremos utilizar basicamente dois *toy-datasets* que podem ser encontrados na documentação da biblioteca `scikit-learn`, sendo eles a base de dados [Iris](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html#sklearn.datasets.load_iris), para classificação, e de [Diabetes](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html#sklearn.datasets.load_diabetes), para regressão." ], "metadata": { "id": "JiZ_scQLKx46" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "e7-9mfYyNJds", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "b1bcdd5c-822c-4e34-aa10-5a484fbf6e0c" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Python 3.9.16\n" ] } ], "source": [ "# Caso queira saber a versão do Python que está sendo executada neste notebook, basta executar esta célula\n", "!python --version" ] }, { "cell_type": "markdown", "source": [ "## 1. Conjunto de Exercícios - Carregamento das bases de dados\n", "\n", "- Para começarmos a revisão de aprendizagem de máquina, primeiro devemos ser capazes de carregar as bases de dados em memória. Iremos definir em detalhes um *pipeline* de processamento completo, ou seja, desde o carregamento dos dados até o treinamento dos modelos, para a base de dados Iris, e a sua tarefa, posteriormente, será de replicar as mesmas ideias para a base de dados de Diabetes.\n", "\n" ], "metadata": { "id": "1r-7o-i9L_-m" } }, { "cell_type": "code", "source": [ "# Importando as funções para carregar os dados em memória\n", "from sklearn.datasets import load_iris, load_diabetes" ], "metadata": { "id": "styHLg22L4Wq" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# Podemos brincar com alguns parâmetros presentes na documentação.\n", "# Aqui, iremos carregar os dados como tabelas Pandas, apenas para uma visualização mais limpa.\n", "\n", "X, y = load_iris(return_X_y=True, as_frame=True)" ], "metadata": { "id": "_2u-shnwMh1B" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "X.head()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 206 }, "id": "e8Z2DMn1MvE5", "outputId": "e93a8947-6005-4ba9-c92e-7893f7a88ce5" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "0 5.1 3.5 1.4 0.2\n", "1 4.9 3.0 1.4 0.2\n", "2 4.7 3.2 1.3 0.2\n", "3 4.6 3.1 1.5 0.2\n", "4 5.0 3.6 1.4 0.2" ], "text/html": [ "\n", "
\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
05.13.51.40.2
14.93.01.40.2
24.73.21.30.2
34.63.11.50.2
45.03.61.40.2
\n", "
\n", " \n", " \n", " \n", "\n", " \n", "
\n", "
\n", " " ] }, "metadata": {}, "execution_count": 5 } ] }, { "cell_type": "code", "source": [ "y.head()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YFrB2mSUMwcx", "outputId": "fcf93e45-3834-4538-dbc9-af31c464e78f" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0 0\n", "1 0\n", "2 0\n", "3 0\n", "4 0\n", "Name: target, dtype: int64" ] }, "metadata": {}, "execution_count": 6 } ] }, { "cell_type": "markdown", "source": [ "## 2. Conjunto de Exercícios - Divisão entre treino/validação/teste\n", "\n", "- Como visto em sala de aula, tipicamente separamos os dados em 3 conjuntos: Treino, Validação e Teste, onde cada um deles possuem um propósito específico, como podemos ver a seguir:\n", " - **Treino:** Como o nome diz, esse conjunto dos dados serve para treinarmos os nossos modelos. Em outras palavras, encontrar os pesos dos nossos modelos que minimizam um certo erro;\n", "\n", " - **Validação:** Como o nome diz, esse conjunto dos dados serve para validarmos os nossos modelos. Tipicamente, quando trabalhamos com aprendizagem de máquina, temos diversos modelos com hiperparâmetros que devemos otimizar de acordo com os nossos dados, como por exemplo: a profundidade de uma árvore, o número de vizinhos de um KNN, entre outros. Para isso, utilizamos o conjunto de validação para verificar qual variação dos hiperparâmetros do nosso modelo é a mais promissora;\n", " \n", " - **Teste:** O conjunto de teste é o conjunto que não iremos utilizar nem durante o treinamento nem durante a a validação do nosso modelo. O intuito desse conjunto de dados é representar dados novos, que o nosso modelo não viu ainda, a fim de mensurar a qualidade das nossas predições em dados reais." ], "metadata": { "id": "a59dZr4ONLMq" } }, { "cell_type": "markdown", "source": [ "1. Utilizando a função [`train_test_split`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html), divida os dados carregados anteriormente em dois conjunos: treino e teste. Posteriormente, iremos definir o conjunto de validação utilizando validação cruzada em N-Folds, durante o treinamento dos nossos modelo.\n", "\n", "**Dica:** Após implementar o treinamento dos modelos, volte nessa célula e brinque com a porcentagem dos dados que serão destinados para o conjunto de treino e teste. Além disso, para fins de reprodutibilidade, sugerimos que você defina um `random_state`, para evitar eventuais dores de cabeça com resultados inconsistentes.\n", "- Uma outra dica útil é realizar um `shuffle` durante a divisão dos dados, já que as *labels* nessa base de dados estão agrupadas, introduzindo assim um potencial desbalanceamento de classes nos conjuntos. Leia a documentação da função para obter mais informações sobre como realizar esse `shuffle`." ], "metadata": { "id": "bJaB_KlVOpdb" } }, { "cell_type": "code", "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "# Convertendo os valores para matrizes e vetores numpy\n", "X = X.values\n", "y = y.values\n", "\n", "# Implemente aqui a sua solução\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)\n", "\n", "print('Tamanho do conjunto de treino:', X_train.shape)\n", "print('Tamanho do conjunto de teste:', X_test.shape)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "FNzU8dm9NIsv", "outputId": "d7482cec-a973-4ec4-d916-44bf5ffd301a" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Tamanho do conjunto de treino: (100, 4)\n", "Tamanho do conjunto de teste: (50, 4)\n" ] } ] }, { "cell_type": "markdown", "source": [ "2. Implemente também uma visualização da distribuição das classes nos dois conjuntos de dados através de gráficos de barra, utilizando a biblioteca `matplotlib`.\n", "\n", "**Dica:** Utilize a classe `Counter` do módulo `collections`, nativo do Python, para contar quantas classes temos nas anotações de cada conjunto." ], "metadata": { "id": "bLELeN30QnTX" } }, { "cell_type": "code", "source": [ "import matplotlib.pyplot as plt\n", "from collections import Counter\n", "\n", "# Função auxiliar para ordenar um dicionário baseado nas chaves (caso precise)\n", "def sort_dict(d):\n", " return {key: d[key] for key in sorted(d)}\n", "\n", "# Implemente aqui a sua solução\n", "train_labels = sort_dict(Counter(y_train))\n", "test_labels = sort_dict(Counter(y_test))\n", "\n", "fig, axs = plt.subplots(1, 2, figsize=(8, 4))\n", "\n", "axs[0].set_title('Conjunto de treino')\n", "axs[0].bar(train_labels.keys(), train_labels.values())\n", "axs[0].set_xticks(list(train_labels.keys()))\n", "\n", "axs[1].set_title('Conjunto de teste')\n", "axs[1].bar(test_labels.keys(), test_labels.values())\n", "axs[1].set_xticks(list(test_labels.keys()))\n", "\n", "fig.supxlabel('Classes')\n", "fig.supylabel('Quantidade')\n", "\n", "fig.tight_layout()\n", "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 305 }, "id": "A5EjhqeeQeQh", "outputId": "124e11ad-c60b-4ed1-be05-09f8b32eb311" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "## 3. Conjunto de Exercícios - Treinamento dos modelos\n", "\n", "- Como mencionado anteriormente, durante o treinamento dos modelos iremos utilizar uma validação cruzada com N-Folds. Além disso, iremos explorar 3 modelos clássicos durante os nossos exercícios, sendo eles: (i) Naive Bayes, que servirá como *baseline* para comparações futuras; (ii) árvores de decisão, podendo ficar livre para explorar \"variantes\" *ensemble* como no caso de modelos de *bagging* e *boosting*; e finalmente (iii) K-Nearest Neighbors." ], "metadata": { "id": "MAa-8EcgQVIL" } }, { "cell_type": "code", "source": [ "# Definindo todos os imports necessários para esse conjunto de exercícios\n", "# Caso necessário, inclua outros imports (principalmente se quiserem trabalhar com outros modelos)\n", "from sklearn.model_selection import KFold\n", "\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.neighbors import KNeighborsClassifier" ], "metadata": { "id": "UZNIpAQiUvD9" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "1. Instancie um objeto da classe `KFold`, passando o número de *folds* que deseja utilizar durante o processo de validação cruzada (sugerimos um valor de 5 *folds*, mas fique a vontade para testar outros valores).\n", "\n", "**Dica:** A mesma dica de definir um `random_state` se aplica também durante a definição do seu objeto da classe `KFold` se desejar habilitar a opção de `shuffle` da classe." ], "metadata": { "id": "rV9DTN9yVOCA" } }, { "cell_type": "code", "source": [ "# Implemente a sua solução aqui\n", "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n", "print('Número de splits:', kf.get_n_splits(X_train))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "NnsyoSbbVM9z", "outputId": "96d79155-09a6-4052-87c1-b0d7f1f4397d" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Número de splits: 5\n" ] } ] }, { "cell_type": "markdown", "source": [ "2. Treine o modelo Naive Bayes utilizando os dados de treino para realizar o loop de validação cruzada. Como o modelo a ser utilizado não possui hiperparâmetros, ele servirá como um ótimo *baseline* para o nosso problema.\n", "\n", "**Dica:** Para mensurar a qualidade do seu modelo, utilize as métricas: acurácia, revocação e precisão. A biblioteca `sklearn` implementa tais funções, mas, caso queira, sinta-se a vontade para implementar as suas próprias funções para tais métricas." ], "metadata": { "id": "27nhWNiyWGQ6" } }, { "cell_type": "code", "source": [ "# Caso queira utilizar as implementações padrões da biblioteca para as métricas\n", "# Caso for utilizar precision e recall_score, lembre-se de definir o parâmetro 'average' para None. Dessa forma,\n", "# as métricas serão calculadas para cada classe, ao invés de realizarmos algum tipo de sumarização.\n", "from sklearn.metrics import recall_score\n", "from sklearn.metrics import accuracy_score\n", "from sklearn.metrics import precision_score" ], "metadata": { "id": "D9AAyBuxWFbP" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "- Utilize o seguinte trecho de código para implementar a validação cruzada utilizando N-Folds. Você pode utilizar `train_index` e `validation_index` para indexar as variáveis `X_train` e `y_train` para obter os conjuntos de treino e validação, respectivamente, da sua validação cruzada!\n", "\n", "```python\n", "# kf é um objeto da classe KFold\n", "for i, (train_index, validation_index) in enumerate(kf.split(X_train)):\n", " print(f\"Fold {i}:\")\n", " print(f\" Train: index={train_index}\")\n", " print(f\" Validation: index={validation_index}\")\n", "```\n", "\n" ], "metadata": { "id": "jqXk9FsyXYwF" } }, { "cell_type": "code", "source": [ "# Implemente aqui a sua solução\n", "for i, (train_index, val_index) in enumerate(kf.split(X_train)):\n", " gnb = GaussianNB()\n", " gnb.fit(X_train[train_index], y_train[train_index])\n", "\n", " preds = gnb.predict(X_train[val_index])\n", " print(f'\\nResultados para o Fold-{i+1}:')\n", " print(f' - Acurácia:', accuracy_score(y_train[val_index], preds))\n", " print(f' - Precisão:', precision_score(y_train[val_index], preds, average=None))\n", " print(f' - Revocação:', recall_score(y_train[val_index], preds, average=None))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uhvnvGkhXWcS", "outputId": "6c4fcfe8-605b-4056-a464-aca3d898dc9a" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "Resultados para o Fold-1:\n", " - Acurácia: 0.95\n", " - Precisão: [1. 1. 0.9]\n", " - Revocação: [1. 0.875 1. ]\n", "\n", "Resultados para o Fold-2:\n", " - Acurácia: 0.9\n", " - Precisão: [1. 0.9 0.75]\n", " - Revocação: [1. 0.9 0.75]\n", "\n", "Resultados para o Fold-3:\n", " - Acurácia: 0.9\n", " - Precisão: [1. 1. 0.71428571]\n", " - Revocação: [1. 0.71428571 1. ]\n", "\n", "Resultados para o Fold-4:\n", " - Acurácia: 0.9\n", " - Precisão: [1. 0.71428571 1. ]\n", " - Revocação: [1. 1. 0.77777778]\n", "\n", "Resultados para o Fold-5:\n", " - Acurácia: 1.0\n", " - Precisão: [1. 1. 1.]\n", " - Revocação: [1. 1. 1.]\n" ] } ] }, { "cell_type": "markdown", "source": [ "3. Utilizando o mesmo *pipeline* de treinamento, treine agora um modelo baseado em Árvore de Decisão de K-Nearest Neighbors. Como hiperparâmetros, experimente variar a profundidade da sua árvore de decisão e o número de vizinhos mais próximos que o algoritmo de KNN deve considerar para as estimações.\n", "\n", "**Dica:** Após cada loop por todos os *folds* da validação cruzada, tire a média das métricas para obter uma sumarização da qualidade do seu modelo ao utilizar um valor de hiperparâmetro específico. É recomendado você fazer um plot para aumentar a interpretação dos resultados, onde o eixo-x pode ser, por exemplo, o valor do hiperparâmetro e o eixo-y a acurácia tanto nos dados de treino quanto nos dados de validação." ], "metadata": { "id": "xTsVDUqAaHCI" } }, { "cell_type": "code", "source": [ "# Implemente a sua solução aqui\n", "import numpy as np\n", "\n", "heights = [1, 2, 4, 8, 16, 32, 64]\n", "mean_accuracy = {\n", " 'train': [],\n", " 'validation': []\n", "}\n", "\n", "for height in heights:\n", " accuracy = {\n", " 'train': [],\n", " 'validation': []\n", " }\n", "\n", " for i, (train_index, val_index) in enumerate(kf.split(X_train)):\n", " dt = DecisionTreeClassifier(max_depth=height)\n", " dt.fit(X_train[train_index], y_train[train_index])\n", "\n", " preds = dt.predict(X_train[train_index])\n", " accuracy['train'].append(accuracy_score(y_train[train_index], preds))\n", "\n", " preds = dt.predict(X_train[val_index])\n", " accuracy['validation'].append(accuracy_score(y_train[val_index], preds))\n", "\n", " mean_accuracy['train'].append(np.mean(accuracy['train']))\n", " mean_accuracy['validation'].append(np.mean(accuracy['validation']))\n", "\n", "plt.title('Performance da Árvore de Decisão')\n", "plt.ylabel('Acurácia')\n", "plt.xlabel('Profundidade da Árvore')\n", "\n", "plt.plot(heights, mean_accuracy['train'], label='treino')\n", "plt.plot(heights, mean_accuracy['validation'], label='validação')\n", "\n", "plt.legend()\n", "plt.show()" ], "metadata": { "id": "9CxOxFWhaEtv" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# Implemente a sua solução aqui\n", "import numpy as np\n", "neighbors = [1, 2, 4, 8, 16, 32, 64]\n", "mean_accuracy = {\n", " 'train': [],\n", " 'validation': []\n", "}\n", "\n", "for neighbor in neighbors:\n", " accuracy = {\n", " 'train': [],\n", " 'validation': []\n", " }\n", "\n", " for i, (train_index, val_index) in enumerate(kf.split(X_train)):\n", " nn = KNeighborsClassifier(n_neighbors=neighbor)\n", " nn.fit(X_train[train_index], y_train[train_index])\n", "\n", " preds = nn.predict(X_train[train_index])\n", " accuracy['train'].append(accuracy_score(y_train[train_index], preds))\n", "\n", " preds = nn.predict(X_train[val_index])\n", " accuracy['validation'].append(accuracy_score(y_train[val_index], preds))\n", "\n", " mean_accuracy['train'].append(np.mean(accuracy['train']))\n", " mean_accuracy['validation'].append(np.mean(accuracy['validation']))\n", "\n", "plt.title('Performance do KNN')\n", "plt.ylabel('Acurácia')\n", "plt.xlabel('Número de Vizinhos')\n", "\n", "plt.plot(neighbors, mean_accuracy['train'], label='treino')\n", "plt.plot(neighbors, mean_accuracy['validation'], label='validação')\n", "\n", "plt.legend()\n", "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "id": "qsWVJ6bYgqyZ", "outputId": "4de3594f-f605-4208-e9a7-8539c04766ec" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "4. Sumarize os seus resultados. Qual modelo que você utilizou obteve o melhor resultado? Para isso, escolha os melhores modelos obtidos através da validação cruzada e avalie eles utilizando o conjunto de teste. O resultado condiz com as suas expectativas?" ], "metadata": { "id": "07D-x5ImaumL" } }, { "cell_type": "code", "source": [ "# Implemente a sua solução aqui\n", "gnb = GaussianNB()\n", "dt = DecisionTreeClassifier(max_depth=8)\n", "nn = KNeighborsClassifier(n_neighbors=8)\n", "\n", "gnb_preds = gnb.fit(X_train, y_train).predict(X_test)\n", "dt_preds = dt.fit(X_train, y_train).predict(X_test)\n", "nn_preds = nn.fit(X_train, y_train).predict(X_test)\n", "\n", "print(f'Resultados para o Naive Bayes:')\n", "print(f' - Acurácia:', accuracy_score(y_test, gnb_preds))\n", "print(f' - Precisão:', precision_score(y_test, gnb_preds, average=None))\n", "print(f' - Revocação:', recall_score(y_test, gnb_preds, average=None))\n", "\n", "print(f'\\nResultados para a Árvore de Decisão:')\n", "print(f' - Acurácia:', accuracy_score(y_test, dt_preds))\n", "print(f' - Precisão:', precision_score(y_test, dt_preds, average=None))\n", "print(f' - Revocação:', recall_score(y_test, dt_preds, average=None))\n", "\n", "print(f'\\nResultados para o KNN:')\n", "print(f' - Acurácia:', accuracy_score(y_test, nn_preds))\n", "print(f' - Precisão:', precision_score(y_test, nn_preds, average=None))\n", "print(f' - Revocação:', recall_score(y_test, nn_preds, average=None))" ], "metadata": { "id": "SuIEgdO9auLn" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "5. **Extra:** Ainda utilizando o conjunto de teste, para enriquecer os seus resultados, plote uma matriz de confusão para cada modelo." ], "metadata": { "id": "r1Bjq14kbIRy" } }, { "cell_type": "code", "source": [ "import seaborn as sns # para visualização da matriz de confusão\n", "from sklearn.metrics import confusion_matrix # para geração da matriz de confusão\n", "\n", "# Implemente a sua solução aqui\n", "cf_matrix = confusion_matrix(y_test, gnb_preds)\n", "sns.heatmap(cf_matrix/np.sum(cf_matrix), annot=True, fmt='.2%', cmap='Blues').set(title='Matriz de confusão para Naive Bayes')\n", "plt.show()" ], "metadata": { "id": "aB_zwGxBbi_8" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "cf_matrix = confusion_matrix(y_test, dt_preds)\n", "sns.heatmap(cf_matrix/np.sum(cf_matrix), annot=True, fmt='.2%', cmap='Blues').set(title='Matriz de confusão para Árvore de Decisão')\n", "plt.show()" ], "metadata": { "id": "J0zAF5Vokqvf" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "cf_matrix = confusion_matrix(y_test, nn_preds)\n", "sns.heatmap(cf_matrix/np.sum(cf_matrix), annot=True, fmt='.2%', cmap='Blues').set(title='Matriz de confusão para KNN')\n", "plt.show()" ], "metadata": { "id": "8hAPETJwkwBW" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "## 4. Conjunto de Exercícios - Tarefa de Regressão (desafio)\n", "\n", "- Agora é com você! Repita os mesmos passos definidos para a tarefa de classificação sobre os dados da tarefa de regressão (base de dados de diabetes). Fique atento às nuâncias que existem entre os dois tipos de problemas, principalmente aos modelos que irá utilizar e as métricas! Sinta-se livre para explorar outros *pipelines*, preprocessamentos, e até mesmo uma outra base de dados! A ideia deste exercício é fazer com que você coloque a mão na massa por conta própria, enfrentando os problemas que encontrar ao longo do caminho." ], "metadata": { "id": "hNykUxuibmvL" } }, { "cell_type": "code", "source": [], "metadata": { "id": "T6H9JFa4cNMZ" }, "execution_count": null, "outputs": [] } ] }