<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Enzo Cardeal Neves on Medium]]></title>
        <description><![CDATA[Stories by Enzo Cardeal Neves on Medium]]></description>
        <link>https://medium.com/@enzocardeal?source=rss-f09787821377------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*CR3nWHVKLyIUC_WlbYpTAA.jpeg</url>
            <title>Stories by Enzo Cardeal Neves on Medium</title>
            <link>https://medium.com/@enzocardeal?source=rss-f09787821377------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 00:51:31 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@enzocardeal/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Construindo uma Rede Neural do zero | Pytorch]]></title>
            <link>https://medium.com/turing-talks/construindo-uma-rede-neural-do-zero-pytorch-671ee06fbbe1?source=rss-f09787821377------2</link>
            <guid isPermaLink="false">https://medium.com/p/671ee06fbbe1</guid>
            <category><![CDATA[pytorch]]></category>
            <category><![CDATA[mnist]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[redes-neurais]]></category>
            <category><![CDATA[grupo-turing]]></category>
            <dc:creator><![CDATA[Enzo Cardeal Neves]]></dc:creator>
            <pubDate>Mon, 13 Jul 2020 12:01:01 GMT</pubDate>
            <atom:updated>2020-07-13T12:01:01.418Z</atom:updated>
            <content:encoded><![CDATA[<h4>“Neurons that fire together, wire together”</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*qnKPo2eELpkucJpqkHF6qw.gif" /></figure><p>Bem-vindos à mais uma edição do <strong><em>Turing Talks</em></strong>! Nessa semana abordaremos <strong>como desenvolver um modelo de <em>Deep Learning</em> usando <em>Pytorch</em></strong>.</p><p>Para entender bem o post é esperado que o leitor tenha uma boa noção dos seguintes tópicos:</p><ul><li>Aspectos de programação orientada a objetos em Python</li><li>familiaridade com Numpy</li><li>Compreensão básica de como redes neurais funcionam</li></ul><p>Em relação a redes neurais, as seguintes fontes são suficiente para conseguir acompanhar o post:</p><ul><li><a href="https://medium.com/turing-talks/turing-talks-19-modelos-de-predi%C3%A7%C3%A3o-redes-neurais-1f165583a927">Redes Neurais | Teoria</a></li><li><a href="https://medium.com/turing-talks/turing-talks-21-modelos-de-predi%C3%A7%C3%A3o-redes-neurais-parte-2-b0c2c33ee339">Redes Neurais | Teoria #2</a></li><li><a href="https://medium.com/turing-talks/turing-talks-22-modelos-de-predi%C3%A7%C3%A3o-redes-neurais-parte-3-9c5d5d0c60e7">Redes Neurais | Teoria #3</a></li></ul><p>Ou para quem entende inglês, pode assistir a playlist a seguir que é bem didática:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FaircAruvnKk%3Flist%3DPLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DaircAruvnKk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FaircAruvnKk%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/3e32cfb5e76f5fbc1e6d1dbb7af9b713/href">https://medium.com/media/3e32cfb5e76f5fbc1e6d1dbb7af9b713/href</a></iframe><p>Com essas habilidades, vamos fazer um passo a passo do “<em>Hello World</em>” das redes neurais (RNs): a classificação de números escritos a mão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IuRwl2AJI1O8sPOCTXEe8w.png" /></figure><h3>O que é Pytorch?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*1mxhFmmWdh7dYlt5HA2UqQ.png" /></figure><p>Uma biblioteca open source para criar redes neurais que permite tanto o uso da CPU quanto da GPU para o treinamento do modelo. Por ser mais flexível que o TensorFlow e muito bem documentada, é ótima para se fazer pesquisas (na verdade, é o <em>framework</em> mais usado no meio acadêmico para construir RNs) e para montar a sua primeira rede neural :)</p><p>Algumas das suas principais características são:</p><ul><li>Grafos computacionais dinâmicos(será explicado melhor posteriormente no post)</li><li>Ecossistema robusto, se integrando muito bem com outros <em>frameworks</em> voltados para a construção de modelos <em>deep learning</em></li><li>Treinamento distribuído, sendo possível alocar várias GPUs para treinar o modelo</li><li>Estrutura “pythônica”, ou seja, a sintaxe é bem parecida com a do python</li></ul><h3>Fazendo e aprendendo</h3><p>Para cada etapa da construção, iremos mostrar a aplicação em código e explicar o que está sendo feito, dessa forma ficará mais fácil de acompanhar o que está acontecendo.</p><p>Antes de mais nada, você deve <a href="https://pytorch.org/get-started/locally/">instalar a biblioteca</a>, recomendamos que use o <a href="https://www.anaconda.com/products/individual">Anaconda</a> para isso. Como ambiente de trabalho, utilizaremos o Jupyter Notebook.</p><h3>Etapa 1 - Carregando as bibliotecas e o dataset</h3><p>Primeiramente importamos todas as bibliotecas necessárias.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1908161fd818803c2355342bafec4a45/href">https://medium.com/media/1908161fd818803c2355342bafec4a45/href</a></iframe><p>Por ser um dataset tão famoso, o <a href="http://yann.lecun.com/exdb/mnist/">MNIST</a> já vem incluso na biblioteca, então podemos baixá-lo diretamente a partir do import datasets.</p><p><strong>Tensor</strong></p><p>Um tensor é como se fosse uma matriz, a diferença é que suas dimensões não estão limitadas a 2. Ele pode tanto ter dimensão 0 (<strong>escalar</strong>) quanto dimensão n.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pGIeFIxvpY8dpzivKZwwrA.jpeg" /><figcaption>Uma boa analogia rs</figcaption></figure><p>Precisamos converter os dados para tensor, pois é assim que a biblioteca trabalha com as informações.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cc55a94134262e8dfdc24e1abfa8a0c8/href">https://medium.com/media/cc55a94134262e8dfdc24e1abfa8a0c8/href</a></iframe><ul><li>a partir da transforms.ToTensor() definimos a variável transform como a conversão dos dados do dataset para tensor.</li><li>carregamos o set de treino na variável trainset. o primeiro argumento é o local onde será salvado o dataset, train=true<strong> </strong>determina que você quer carregar a parte reservada para treino (85,7% dos dados) e no último argumento, passamos a transformação definida anteriormente.</li><li>por ser um dataset muito grande(70.000 imagens), devemos criar um buffer para otimizar a tarefa e acessá-lo em subgrupos menores. Para isso, definimos a variável trainloader que é um objeto iterável que nos fornece lotes(batchs) de itens até que o set seja todo percorrido. Passamos como argumento o trainset, batch_size=64 para que os subgrupos sejam de 64 itens e shuffle=true que determina que iremos tomar os itens de forma aleatória, ou seja, um mesmo item pode estar presente em mais de um subgrupo.</li><li>repetimos o mesmo processo para o set de validação</li></ul><h3>Etapa 2 - Conferindo a estrutura dos dados</h3><p>Vamos abrir um dos itens do dataset para termos uma ideia de seu formato. Cada item possui uma imagem e uma etiqueta, este ultimo é o digito que a imagem representa.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/240d8741b7eb220a486a8bd35bb56a33/href">https://medium.com/media/240d8741b7eb220a486a8bd35bb56a33/href</a></iframe><p>Analisando a dimensão do tensor imagem e do tensor etiqueta(um número de 0 a 9):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e82dd09adce82ec3d122e453406825b6/href">https://medium.com/media/e82dd09adce82ec3d122e453406825b6/href</a></iframe><p>O tensor etiqueta não possui dimensão nenhuma por ser um escalar.</p><p>Já o tensor imagem possui 3 dimensões. Por quê?</p><p>A primeira dimensão é o número de canais da nossa imagem. Como é uma imagem preto e branco, possui apenas um, que diz respeito a intensidade do preto em cada pixel. Imagens coloridas costumam ter 3 canais (vermelho, azul e verde).</p><p>As duas ultimas dimensões representam a quantidade de pixels, nesse caso 28 x 28 = 784 pixels.</p><p>Sendo assim, para o Pytorch, cada imagem é uma “matriz” (na verdade é um tensor, nunca se esqueça) 28 x 28 com valores para cada elemento variando de 0 a 1 de forma continua.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/98f5273cdb41365c7e575e334649c5b9/href">https://medium.com/media/98f5273cdb41365c7e575e334649c5b9/href</a></iframe><h3>Etapa 3 - Construindo os elementos da Rede Neural</h3><p>Uma boa prática é construir uma classe para conter a estrutura da nossa RN. Essa modularizarão facilita adaptações futuras no nosso modelo. Por sorte, o Pytorch possui uma superclasse que auxilia nessa tarefa, a <a href="https://pytorch.org/docs/stable/nn.html?highlight=module#torch.nn.Module">nn.Module</a>.</p><p>A rede que queremos montar é a seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/787/1*PKszxCuNRCUzy1GA8aMoww.png" /></figure><p>Na camada entrada temos 28 x 28 = 784 neurônios, um para cada pixel da imagem. Esses neurônios irão receber o valor entre 0 e 1 de acordo com a intensidade do preto no pixel correspondente. Nas camadas internas 1 e 2, temos 128 e 64 neurônios, respectivamente. Essa escolha foi arbitrária e, ao final do post, veremos que foi boa o suficiente para conseguirmos um resultado satisfatório.</p><p>Utilizaremos a <a href="https://en.wikipedia.org/wiki/Rectifier_(neural_networks)"><strong>ReLU</strong></a> como função de ativação das camadas: entrada → interna 1 e interna 1 → interna 2. Essa é uma função do seguinte formato: f(y) = y, se y&gt;0, caso contrário, f(y) = 0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/272/1*q-gLDg2kNX2qqW6VeWhwLQ.jpeg" /></figure><p>Por ser um problema de classificação, no tensor devolvido pela camada saída(10 valores entre 0 e 1, cada um correspondendo a chance, segundo o modelo, de a imagem fornecida ser o número do índice correspondente, como exemplificado na imagem abaixo), aplicaremos a função <a href="https://pytorch.org/docs/stable/nn.html?highlight=logsoftmax#torch.nn.LogSoftmax"><strong>LogSoftmax</strong></a>, que devolve um tensor com as mesmas dimensões da saída.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HzJ4UYXvOHq-hLRRRgWe8A.png" /><figcaption>Representação de um modelo bem treinado</figcaption></figure><p>A partir deste tensor e do target(nesse caso é a etiquete pois ela define qual o digito que a imagem sendo analisada representa), aplicamos a função <a href="https://pytorch.org/docs/stable/nn.html#nllloss"><strong>negative log-likelihood loss(NLLLoss)</strong></a><strong> </strong>e<strong> </strong>calculamos a <strong>perda</strong>. A lógica é a mesma do erro quadrático médio(MSE), quanto mais próximo de zero, melhor.</p><p>Definimos então a classe Modelo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b1b7eadc4b18f22aed881bd804d21ea8/href">https://medium.com/media/b1b7eadc4b18f22aed881bd804d21ea8/href</a></iframe><p>A função<strong> </strong>forward(self, X) nos retorna o tensor que será utilizado para calcular a perda. <strong>Isso é o que o modelo retorna</strong>.</p><p>Repare aqui que todas as funções que utilizamos são do import torch.nn.functional as F<strong>, </strong>funções especiais para trabalhar com tensores, e o tipo das camadas foram definidos a partir do import nn. Utilizamos camadas lineares por simplicidade. Para classificação de imagens, o ideal seria também utilizarmos camadas de convolução 2D.</p><p>Vamos agora definir a estrutura de treino do modelo. As principais etapas são:</p><ul><li>Calcular a perda a partir da comparação entre as predições e as etiquetas(target) do subgrupo sendo analisado</li><li>Com a perda, calcular o gradiente em relação aos pesos e as bias</li><li>a partir do gradiente e de uma politica de otimização, atualizar os pesos e as bias</li></ul><p>Graças ao Pytorch, para defini-las será um passeio no parque.</p><h4>Autograd</h4><p>A partir dos <a href="https://blog.paperspace.com/pytorch-101-understanding-graphs-and-automatic-differentiation/">grafos computacionais dinâmicos</a>, por padrão o Pytorch armazena uma espécie de histórico das operações realizadas. No exemplo a seguir isso fica mais claro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*8EQE6cnhWvSNCfyB1ev78A.png" /><figcaption><a href="https://towardsdatascience.com/understanding-pytorch-with-an-example-a-step-by-step-tutorial-81fc5f8c4e8e#3806">https://towardsdatascience.com/understanding-pytorch-with-an-example-a-step-by-step-tutorial-81fc5f8c4e8e#3806</a></figcaption></figure><p>É possível calcular as derivadas parciais da <strong>loss = ((y-(a+b*x))**2).mean() </strong>em relação a <strong>a </strong>e <strong>b</strong>(caixas azuis) já que foi armazenado a “história” dessas variáveis.</p><p>Assim, calculamos o gradiente facilmente, pela regra da cadeia, da perda em relação aos pesos e bias. CALMA! a biblioteca fará todo esse processo para você.</p><h4>Otimizador</h4><p>A primeira vista você pode pensar em atualizar os pesos e as bias a partir de um loop, calculando cada elemento da seguinte forma: <strong>a = a - lr*grad </strong>(onde <strong>lr </strong>é a taxa de aprendizado e <strong>grad</strong> é a derivada parcial da <strong>perda </strong>em relação a <strong>a</strong>). Isso não é necessário. A partir do import optim, podemos escolher qual otimizador usar para fazer essas atualizações. Nesse caso vamos usar o SGD (<em>Stochastic Gradient Descent</em>). Seus parâmetros principais são:</p><ul><li>params<strong>: </strong>iterável de parâmetros para serem otimizados(no nosso caso, pesos e bias)</li><li>lr<strong>: </strong>taxa de aprendizado</li><li>momentum<strong>: </strong>valor entre 0 e 1, serve para evitar que o modelo encontre um falso mínimo global. Para uma boa RN, quanto maior a lr, menor deve ser o momentum.</li></ul><p>Definimos então a função treino<strong>:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/aaf86d22917470c07c1f9a187643eab3/href">https://medium.com/media/aaf86d22917470c07c1f9a187643eab3/href</a></iframe><p>Explicando sucintamente o que está sendo feito:</p><ol><li>inicializamos o otimizador</li><li>a partir de modelo.train()colocamos o modelo no modo treino</li><li>definimos quantas epochs queremos para treinar o modelo</li><li>em cada epoch, iteramos pelo trainloader(lembrando que este é um objeto iterável) até que todo o set de treino seja percorrido</li><li>em cada iteração do trainloadercalculamos a perda instantânea, que representa a perda calculada apenas em relação aos 64 itens atuais. Para calcular a perda da epoch, deve-se tomar a média das perdas instantâneas.</li><li>a partir de perda_instantanea.backward()calculamos o gradiente da perda instantânea</li><li>com as derivadas parciais e chamando otimizador.step() , atualizamos os pesos e bias</li><li>Os passos 5, 6 e 7 são repetidos até que todo o trainset<strong> </strong>seja percorrido</li><li>Volta ao passo 4 até chegar a ultima epoch</li></ol><p>Vamos agora definir a função validacao<strong>. </strong>Como esse não é o foco principal do post, deixaremos as explicações apenas nos comentários do código.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9763981a31b3fe6af5080b5cde662dd/href">https://medium.com/media/b9763981a31b3fe6af5080b5cde662dd/href</a></iframe><h3>Etapa 4 - Rodando a rede neural</h3><p>Primeiro vamos inicializar o modelo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b732ba1b150c5d9dd0a956625e0a1a6a/href">https://medium.com/media/b732ba1b150c5d9dd0a956625e0a1a6a/href</a></iframe><p>Colocamos para rodar na GPU(se possível) para demonstrar essa funcionalidade.</p><h4>Treinando o modelo</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1d31d88ee94a1e21633f9ada46cebfad/href">https://medium.com/media/1d31d88ee94a1e21633f9ada46cebfad/href</a></iframe><h4>Validando o Modelo</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5a43bcb2346f89493d3077e4001022a0/href">https://medium.com/media/5a43bcb2346f89493d3077e4001022a0/href</a></iframe><h3>5 - Salvando o modelo</h3><p>Claro que depois de todo esse trabalho, queremos guardar a evolução da RN.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ceedefcaeb469016095a9cde3008bdbd/href">https://medium.com/media/ceedefcaeb469016095a9cde3008bdbd/href</a></iframe><h3>Bônus</h3><p>Para visualizar a uma predição aleatória do set de validação, você pode executar a célula a seguir no seu notebook:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c3c0403e42c4e78d50f2ed5dbe20d6b7/href">https://medium.com/media/c3c0403e42c4e78d50f2ed5dbe20d6b7/href</a></iframe><h3>Considerações finais</h3><p>Com esse post, construímos uma base boa para conseguirmos treinar Redes Neurais mais complexas utilizando o Pytorch sem grandes dificuldades. Apresentamos as principais características da biblioteca mas sem entrar muito nos detalhes já que nosso foco foi montar a rede em si.</p><p>Existem diversos pacotes para facilitar o trabalho com os diferentes tipos de dados, sendo eles:</p><ul><li><strong>Pillow</strong> e <strong>OpenCV</strong> para imagens</li><li><strong>scipy</strong> e <strong>libroso</strong> para áudio</li><li><strong>Cython</strong>, <strong>NLTK</strong> ou <strong>SpaCy</strong> para texto</li></ul><p>Independente do tipo dos dados, depois de carregados e convertidos para tensores, o processo para montar a RN é bem similar (usando as camadas, otimizadores e função perda mais adequados) com o que fizemos aqui.</p><p>Outra ferramenta interessante e bem integrada com Pytorch é o <a href="https://www.tensorflow.org/tensorboard?hl=pt-br"><strong>TensorBoard</strong></a>, que permite visualizar, a partir de gráficos, como o modelo está evoluindo. Caso tenha interesse em conhecê-la, suas funcionalidades foram demonstradas em um Turing Talks <a href="https://medium.com/turing-talks/turing-talks-25-redes-neurais-com-keras-e-tensorflow-2-0-44fc0974c7fb">passado</a>.</p><p>Por fim, esperamos ter tirado um pouco desse misticismo que existe em volta da “buzzword” <em>Machine Learning </em>e mostrar que, com as ferramentas que temos a nosso dispor, qualquer um pode montar uma rede neural do zero.</p><p>Numa abordagem quase que de tentativa e erro para determinar a estrutura do nosso modelo, conseguimos um preditor com uma taxa de acerto de 97% (o estado da arte para esse problema é 99,79%). Claro que apenas reproduzimos técnicas existente há décadas e, se você quiser se aventurar de verdade por esse mundo, montando modelos com alto grau de complexidade, há uma longa jornada de aprendizado a ser percorrida.</p><p>Código completo: <a href="https://github.com/enzocardeal/clasificacao-de-digito">https://github.com/enzocardeal/clasificacao-de-digito</a></p><p>Nossas redes: <a href="https://www.facebook.com/grupoturing.usp/">Facebook</a>, <a href="https://www.linkedin.com/company/grupo-turing/">LinkedIn</a>, <a href="https://www.instagram.com/grupoturing.usp/">Instagram</a></p><p>Até a próxima!</p><h3>Referências</h3><p>[1] <a href="https://pytorch.org/docs/stable/index.html">Pytorch documentation</a></p><p>[2] <a href="https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py">Pytorch - Training a classifier</a></p><p>[3] <a href="https://www.kaggle.com/sdelecourt/cnn-with-pytorch-for-mnist">CNN with Pytorch for MNIST</a></p><p>[4] <a href="https://github.com/pytorch/examples/blob/master/mnist/main.py">Pytorch git examples</a></p><p>[5] <a href="https://towardsdatascience.com/pytorch-for-deep-learning-a-quick-guide-for-starters-5b60d2dbb564">PyTorch for Deep Learning: A Quick Guide for Starters</a></p><p>[6] <a href="https://towardsdatascience.com/understanding-pytorch-with-an-example-a-step-by-step-tutorial-81fc5f8c4e8e">Understanding PyTorch with an example: a step-by-step tutorial</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=671ee06fbbe1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/turing-talks/construindo-uma-rede-neural-do-zero-pytorch-671ee06fbbe1">Construindo uma Rede Neural do zero | Pytorch</a> was originally published in <a href="https://medium.com/turing-talks">Turing Talks</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aprendizado por Reforço #4 — Gym]]></title>
            <link>https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-4-gym-d18ac1280628?source=rss-f09787821377------2</link>
            <guid isPermaLink="false">https://medium.com/p/d18ac1280628</guid>
            <category><![CDATA[grupo-turing]]></category>
            <category><![CDATA[openai-gym]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[reinforcement-learning]]></category>
            <dc:creator><![CDATA[Enzo Cardeal Neves]]></dc:creator>
            <pubDate>Sun, 22 Mar 2020 06:35:37 GMT</pubDate>
            <atom:updated>2020-06-09T13:07:59.652Z</atom:updated>
            <content:encoded><![CDATA[<h3>Aprendizado por Reforço #4— Gym</h3><h4>A caixa de areia da Inteligência Artificial</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AiPOaTzia_MbY6mGNkbpMg.gif" /></figure><p>Bem-vindos à mais uma edição do <strong><em>Turing Talks</em></strong>! Nessa semana abordaremos a primeira ferramenta que irá auxiliá-lo a montar um modelo de <em>Reinforcement Learning</em>.</p><p>Um dos empecilhos iniciais para se aplicar ou desenvolver um algoritmo de RL é a necessidade de um ambiente (virtual ou real) para a atuação do agente. A tarefa de construir esse espaço de trabalho é dispendiosa, muitas vezes sendo a etapa mais difícil do projeto, o que pode acabar desmotivando entusiastas a aprender mais a fundo sobre o tema. A biblioteca Gym se propõem a sanar exatamente esse problema, fornecendo vários ambientes diferentes para o treinamento de um agente.</p><h3>Introdução</h3><p>A <a href="https://openai.com/">OpenAI</a> é uma instituição sem fins lucrativos, fundada em 2015 pelo Elon Musk, Sam Altman e outros investidores, que tem como missão pesquisar e desenvolver novas tecnologias na área de IA e disponibilizar esses novos conhecimentos de forma gratuita para o uso de todos. Um de seus primeiros projetos foi a criação da <a href="https://gym.openai.com/">Gym</a>, uma biblioteca de Python feita para encurtar o caminho entre a ideia de algum modelo de Aprendizado por Reforço e a sua implementação. Ela fornece diversos ambientes diferentes para você testar um agente, sendo necessário apenas o desenvolvimento da lógica do algoritmo em questão.</p><p>Imagine um boneco de ação articulado em vários pontos diferentes. Essas articulações permitem uma infinidade de posições para o brinquedo. A criança que brinca com ele é quem irá ditar os estados atingidos. O boneco, portanto, apresenta um comportamento diferente para cada brincadeira da criança. Podemos então, estabelecer uma analogia entre o boneco e a Gym e entre a criança e o algoritmo de RL que se deseja implementar.</p><h3>Quais ambientes a biblioteca oferece?</h3><p>Além de ser possível adicionar ambientes feitos por terceiros (inclusive feito por você!), os oferecidos nativamente são divididos em categorias, sendo as principais: <strong>Atari, controle clássico, MuJoCo, robóticos , jogos de texto e Box2D</strong>. Vamos ver a seguir um exemplo de cada uma delas.</p><h4>Atari</h4><p>Jogos clássicos convertidos para um formato que é possível treinar o agente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/160/1*9M3APqQ7J1XykhV2PHZ0NA.gif" /><figcaption>MsPacman-v0</figcaption></figure><h4>Controle clássico</h4><p>Problemas clássicos de mecânica que estão presentes na literatura de RL há bastante tempo. Uma das vantagens de usar Gym para esses problemas é que, como há uma consistência do meio utilizado, fica mais fácil comparar os resultados de estudos diferentes desenvolvidos no mesmo ambiente.</p><p>No exemplo a seguir, tem-se um veículo com um motor que não é forte o suficiente para subir o morro maior sem um auxílio externo. O agente deve, portanto, aprender a aumentar sua energia potencial subindo o morro menor para assim ter energia mecânica suficiente para subir o morro maior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*JaXyJ3wSeS-v4L_at6YQDg.gif" /><figcaption>MountainCar-v0</figcaption></figure><h4>Box2D</h4><p>Ambientes feitos com base no simulador de física bidimensional Box2D. As tarefas em questão são contínuas, ou seja, não possuem um fim bem definido.</p><p>No exemplo a seguir, ensinamos um robô bípede a andar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*J3i79Sk6fYbXd6J6JDaFBw.gif" /><figcaption>BipedalWalker-v2</figcaption></figure><p><strong>MuJoCo</strong></p><p>baseados em uma engine física com foco em simulações de biomecânica, articulações, gráficas e animação. Aqui também temos tarefas contínuas.</p><p>No exemplo a seguir, temos um ambiente tridimensional no qual ensinamos um robô de 4 patas a andar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*IvFDIPmL0c5fozUnFF7Hwg.gif" /><figcaption>Ant-v2</figcaption></figure><h4>Robóticos</h4><p>Ambiente que simula membros robóticos (uma mão ou uma garra) motivados por tarefas com metas bem definidas.</p><p>No exemplo a seguir, uma mão robô manipula um bloco de madeira.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*sKLeBABGbgy3rRxZl-XijA.gif" /><figcaption>HandManipulateBlock-v0</figcaption></figure><h4>Jogos de texto</h4><p>Jogos simples com gráficos feito a partir de texto apenas.</p><p>Aqui temos o jogo do táxi. O objetivo é recolher um passageiro num determinado ponto e deixá-lo em outro. Caso o passageiro for deixado em um local errado, o jogador é penalizado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/122/1*vJQIsLL2R5S84owOB6Z4lw.gif" /><figcaption>Taxi-v3</figcaption></figure><h3>Botando a mão na massa</h3><p>Para nosso exemplo prático, vamos ensiná-lo a aplicar <strong><em>Q-learning</em></strong> no jogo do táxi. Caso você não saiba do que estamos falando, recomendamos o post anterior que introduz o tópico:</p><p><a href="https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-1-introdu%C3%A7%C3%A3o-7382ebb641ab">Aprendizado por Reforço #1- Introdução</a></p><p>Escolhemos esse algoritmo pois, além de já ter sido explicado anteriormente, é o mais básico de RL, o que facilitará o entendimento e a aplicação. Utilizaremos o jogo do táxi pois conseguimos mapear todos os estados possíveis, característica essencial para a aplicação de <strong><em>Q-learning</em></strong>.</p><h4>Regras do jogo</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/1*Lb9hpyffWp7Gv7tfG-yReA.png" /></figure><p><em>“Há 4 localizações (nomeadas por letras diferentes), e nosso trabalho é pegar um passageiro em um local e deixá-lo em outro. Nós recebemos +20 pontos por destino correto e -1 ponto para cada passo tomado. Há também -10 pontos de penalidade para tentativas de embarque e desembarque erradas.”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*vJQIsLL2R5S84owOB6Z4lw.gif" /><figcaption>Taxi-v3</figcaption></figure><ul><li>Na representação do ambiente, o retângulo colorido é o táxi, <strong>amarelo</strong> quando estiver vazio e <strong>verde</strong> quando estiver com passageiro.</li><li>As barras <strong>(“|”)</strong> representam paredes as quais o táxi não pode atravessar.</li><li><strong>R, G, B </strong>e<strong> Y</strong> representam os pontos de embarque e desembarque. A letra <strong>azul </strong>representa a origem do passageiro e a letra <strong>roxa</strong> representa o destino.</li></ul><h4>Espaço de estados</h4><p>Definimos aqui o universo de todos os estados (situação atual e imediata do jogo) possíveis do agente no ambiente. Como foi dito anteriormente, esse número é finito, então vamos calculá-lo. O tabuleiro é uma malha 5x5, o que permite 25 posições diferentes para o veículo. Há 4 locais (R, G, B e Y) de embarque e ainda o próprio carro como localização disponível para o passageiro habitar, o que contabiliza 5 lugares possíveis. Para finalizar a viagem, há 4 destinos diferentes (R, G, B e Y), portanto, vem:</p><p>5 x 5 x 5 x 4 = 500 estados possíveis!</p><p>Podemos representar qualquer sequência de eventos imaginável com esses 500 estados. Surpreso com o resultado?</p><h4>Espaço de ações</h4><p>As ações que podem ser tomadas em cada estado são:</p><ul><li>0 = sul</li><li>1 = norte</li><li>2 = leste</li><li>3 = oeste</li><li>4 = embarcar</li><li>5 = desembarcar</li></ul><p>Note que sempre que o carro tentar atravessar uma parede o agente receberá uma penalidade de -1 e continuará no mesmo estado que estava anteriormente.</p><h4>Implementando com a biblioteca</h4><p>Para começar nosso projeto vamos precisar de um ambiente de trabalho. Recomendamos o <a href="https://jupyter.org/install.html">Jupyter Notebook</a>, mas você pode usar o de sua preferência.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/98ee8c4591e415453ef5254b9fa49a54/href">https://medium.com/media/98ee8c4591e415453ef5254b9fa49a54/href</a></iframe><p>Posteriormente, fazemos as importações necessárias.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a63243b1f03dc9b1cd647b6d38076fd/href">https://medium.com/media/4a63243b1f03dc9b1cd647b6d38076fd/href</a></iframe><p>Pronto, temos nosso espaço de trabalho configurado e pronto para uso. Mas antes de continuarmos, vamos entender melhor alguns dos métodos e objetos principais da Gym.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6496ea5c9c3ac230dacd4b01b61d5f08/href">https://medium.com/media/6496ea5c9c3ac230dacd4b01b61d5f08/href</a></iframe><p>A primeira linha do código carrega o ambiente que vamos usar, no nosso caso “Taxi-v3”. Ele fica salvo na variável <strong>env</strong>.</p><p>Com o método <strong>.render(), </strong>renderizamos o estado atual do ambiente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/204/1*NHj87VMdYk42JlwiizKzXw.png" /><figcaption>Primeiro estado renderizado</figcaption></figure><p>Outros métodos também muito importantes são:</p><ul><li><strong>env.reset: </strong>Reseta o ambiente e retorna um estado inicial aleatório.</li><li><strong>env.step (action): </strong>Executa uma ação (passo). Retorna:</li></ul><p>* <strong>observation: </strong>observações do ambiente.</p><p>* <strong>reward: </strong>recompensa recebida após a ação tomada.</p><p>* <strong>done: </strong>indica se foi o fim de um episódio. Acontece quando um passageiro embarca no táxi e desembarca no local correto.</p><p>* <strong>info: </strong>informação adicional para debbuging. O agente não tem acesso a elas.</p><p>Podemos também conferir as dimensões do <strong>espaço de ações</strong> e <strong>espaço de estados</strong>, como segue:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/227d2bf699c8de45d5cd6ca4fafc6ada/href">https://medium.com/media/227d2bf699c8de45d5cd6ca4fafc6ada/href</a></iframe><p>O que condiz com o que calculamos anteriormente.</p><h4>Q-learning</h4><p>Vamos agora recordar das recompensas para cada ação. Elas já estão pré-definidas na biblioteca da seguinte maneira:</p><ul><li>+20 para um desembarque correto.</li><li>-10 para um embarque ou desembarque incorreto.</li><li>-1 para ações que não sejam as duas anteriores.</li></ul><p>A recompensa de -1 é importante pois garante que o carro evite paredes (caso fique tentando entrar em uma, irá receber -1 indefinidamente) e que o agente busque se otimizar de forma a performar o menor caminho possível até o ponto de desembarque.</p><p>Como dito antes, caso não saiba o que é <strong><em>Q-learning</em></strong>, <a href="https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-1-introdu%C3%A7%C3%A3o-7382ebb641ab">leia o nosso post anterior</a>. Precisamos determinar os <strong><em>q-values</em></strong> para cada tupla (estado, ação), que irão orientar a política do nosso agente, ou seja 500 x 6 = 3.000 valores. A partir da <a href="https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-3-processo-de-decis%C3%A3o-de-markov-parte-2-15fe4e2a4950">equação de Bellman</a>, determinamos os <strong><em>q-values</em></strong> como segue:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0AeB7wyr8ZdS1jmzCg0dRA.png" /></figure><p>Onde:</p><ul><li><strong>α</strong> é a taxa de aprendizado (0 &lt; α ≤ 1), que representa o quanto nosso <strong><em>q-value</em></strong> está sendo atualizado em cada iteração.</li><li><strong>γ</strong> é o fator de desconto (0 &lt; γ ≤ 1), que representa a importância que damos para recompensas futuras. γ próximo de 1 favorece as recompensas mais distantes enquanto gama perto de 0 praticamente às desconsidera.</li></ul><p>O que estamos fazendo é atualizar o <strong><em>q-value</em></strong> da ação tomada no estado atual. Tomamos o valor antigo com um peso de (1- α) e adicionamos o novo valor aprendido, que é a combinação da recompensa por realizar a ação tomada no estado atual, com recompensa máxima, descontada (γ), do próximo estado que estaremos assim que tomarmos a ação.</p><p>Essa política fará com que o agente tome a rota que fornecerá a maior soma de recompensas possível.</p><p><strong>Tabela-Q</strong></p><p>Para guardar esses valores vamos criar uma tabela <strong>Estados</strong> x <strong>Ações</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*Wld5XiGcXnCROZNCDtnoHw.png" /></figure><p>Iniciamos a tabela preenchida com zeros e a cada iteração atualizamos os valores.</p><p>Passo-a-passo, fica:</p><ul><li>Inicializar a tabela-Q preenchida com zeros.</li><li>Para as ações seguintes, há uma chance do agente tomá-las de forma aleatória ou seguir a política da tabela Estados x Ações.</li><li>Após episódios suficientes, é esperado que o agente atinja uma política ótima e a tabela Estados x Ações esteja com os valores o mais próximo do ideal possível.</li></ul><p><strong>Implementação em código</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a8fdd0adceaaee5073771c00e97d90ee/href">https://medium.com/media/a8fdd0adceaaee5073771c00e97d90ee/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/38f7b67c8548ec3d4865567042e5104c/href">https://medium.com/media/38f7b67c8548ec3d4865567042e5104c/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/224/1*pfDXnfJbmjZGRh602MRKBw.gif" /></figure><p>Vamos então testar o nosso agente. Será que ele atingiu uma política ótima?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0144f824c5aa438bd4a4603b182b197e/href">https://medium.com/media/0144f824c5aa438bd4a4603b182b197e/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/192/1*LEKJ3a056p1QA3Bd_JQnEw.gif" /></figure><p>Dos 100 episódios testados, nosso agente não recebeu nenhuma penalidade, o que é um ótimo parâmetro para medirmos o sucesso de seu treinamento. Em relação a média de passos, também obtemos um bom valor (metade das casas do tabuleiro percorridas) tendo em vista a existência dos obstáculos.</p><h3>Conclusão</h3><p>Neste post apresentamos a Gym, uma ferramenta poderosa que facilita muito a vida de quem quer iniciar os estudos em <em>Reinforcement Learning</em>. Apresentamos aqui seus diferentes tipos de ambientes e suas principais funcionalidades fazendo a aplicação em um exemplo prático.</p><p>Além de ser essa ótima ferramenta para iniciantes, ela também é de grande valor no meio acadêmico. Isso porque, ao normalizar o espaço de trabalho que as pesquisas são desenvolvidas, ou seja estudos diferentes desenvolvidos no mesmo ambiente, torna-se mais fácil e de maior confiabilidade se comparar os resultados obtidos.</p><p>Trabalhamos para implementar o <em>Q-learning</em>, um dos algoritmos mais simples de RL, ideal para os propósitos didáticos do post. Sua aplicação se limita a cenários com um número de estados finito e suficientemente pequeno. Caso esse valor se torne muito grande ou indefinido, devemos procurar outros métodos mais complexos de implementação de RL.</p><p>Atualmente, para resolver os problemas mais abstratos costuma-se usar as<em> Deep Neural Networks </em>que recebem na camada de entradas informações do estado e ações para poder aproximar um valor bom o suficiente para o <strong><em>q-value</em></strong>, mesmo sem levar em consideração todos os estados posteriores possíveis (até porque podem existir infinitos), aprendendo a retornar as ações corretas após treinamento suficiente.</p><p>Esse é o tipo de abordagem que se usa para treinar braços robóticos, jogos sem finais definidos como Flappy Bird, decidir preços praticados por uma empresa de acordo com as flutuações do mercado, gerenciamento de estoques ou realizar previsões no mercado financeiro. Note, portanto, que apesar da maior complexidade, a ideia central é a mesma apresentada em <strong><em>Q-learning</em></strong>.</p><p>Por fim, vamos voltar nossa atenção aos hiperparâmetros(α, γ e ε). Para decidi-los, tomamos uma abordagem de tentativa e erro. O ideal seria os ajustarmos de forma a diminuí-los com o passar do tempo, porém, por termos um espaço de estados tão pequeno, conseguimos atingir uma política ótima com valores estáticos. A justificativa para a diminuição de cada um é:</p><ul><li><strong>α</strong>: quanto mais próximo do fim do treino, com uma base de conhecimento sobre o ambiente já consolidada, uma alta taxa de aprendizado torna-se menos relevante.</li><li><strong>γ</strong>: Quanto mais próximo do final do treinamento, o comportamento do agente para os finais dos episódios já estão bem definido e, se estiver aprendendo de forma correta, estará de acordo com o esperado. É interessante então melhorar o comportamento para as situações mais iniciais.</li><li><strong>ε</strong>: Quanto mais atualizada a tabela-q, menos o agente precisa explorar ações aleatórias.</li></ul><p>Para os aficionados em RL que chegaram até aqui, nossos mais profundos agradecimentos. Não se esqueçam de conferir nossas redes: <a href="https://medium.com/turing-talks">Medium</a>, <a href="https://www.facebook.com/grupoturing.usp/">Facebook</a>, <a href="https://www.instagram.com/grupoturing.usp/">Instagram</a> e <a href="https://www.linkedin.com/company/grupo-turing/">LinkedIn</a>. Caso tenha interesse, você pode encontrar o notebook completo do post <a href="https://github.com/enzodeal/taxi-v3/blob/master/taxis-v3.ipynb">aqui</a>.</p><p>Até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d18ac1280628" width="1" height="1" alt=""><hr><p><a href="https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-4-gym-d18ac1280628">Aprendizado por Reforço #4 — Gym</a> was originally published in <a href="https://medium.com/turing-talks">Turing Talks</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aprendizado por Reforço #1- Introdução]]></title>
            <link>https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-1-introdu%C3%A7%C3%A3o-7382ebb641ab?source=rss-f09787821377------2</link>
            <guid isPermaLink="false">https://medium.com/p/7382ebb641ab</guid>
            <category><![CDATA[grupo-turing]]></category>
            <category><![CDATA[aprendizado-por-reforço]]></category>
            <category><![CDATA[reinforcement-learning]]></category>
            <dc:creator><![CDATA[Enzo Cardeal Neves]]></dc:creator>
            <pubDate>Sun, 23 Feb 2020 11:56:01 GMT</pubDate>
            <atom:updated>2020-06-09T13:04:32.123Z</atom:updated>
            <content:encoded><![CDATA[<h3>Aprendizado por Reforço #1— Introdução</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iG4kh-qmLMABg5Aq.gif" /></figure><p>Bem-vindos a mais uma edição do <strong><em>Turing Talks</em></strong>! Nessa semana daremos início a nossa série de aprendizado por reforço, uma técnica de <strong><em>Machine Learning</em></strong> um tanto quanto diferente das abordadas nos posts anteriores. Nesta publicação trataremos de conceitos básicos e daremos uma visão geral sobre o tópico. Então, caso você já tenha alguma familiaridade com o assunto, recomendamos que acompanhe os próximos posts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*MerNVyy5mFbO5ja9BwTGlw.gif" /><figcaption>Exemplo de recompensa negativa rs</figcaption></figure><h3>Introdução</h3><p>A ideia básica é que um <strong>agente </strong>(explicaremos melhor este conceito a seguir) procura cumprir uma determinada tarefa, inicialmente com um abordagem de tentativa e erro. Posteriormente, os resultados de cada tentativa, independente de seu sucesso, são utilizados para treinar o agente por meio de um sistema de <strong>recompensa/punição </strong>e determinar se as ações tomadas são válidas ou não. Daí a ideia de aprendizado por reforço. O agente aprende tanto com os erros quanto com os acertos, e no final é esperado que ele execute a tarefa com maestria.</p><p>Suponha agora que você nunca tenha jogado <em>Pong, </em>o famoso jogo de Atari. Você irá jogá-lo pela primeira vez, mas ninguém te passou as regras e as únicas informações sabidas sobre o funcionamento do jogo é que é possível mover a barra direita para cima ou para baixo e que a tela “<em>Game Over</em>” é o pior resultado possível. O jogo se inicia e, reparando na bola vindo em sua direção, você decide tomar a seguinte abordagem: desviar toda vez que a bola chegar perto de você. O jogo segue, até que o placar atinge 11:0 e a tela “<em>Game Over” </em>é exibida<em>. </em>Para próxima partida, com base em sua experiência anterior, você resolve mover a barra na direção da bola toda vez que ela se aproxima. Com essa nova estratégia você conseguiu vencer o jogo e evitar a tela de “<em>Game Over”.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TcOWlA2MtFazxB91jU4M5Q.gif" /><figcaption>Uma partida de <em>Pong</em></figcaption></figure><p>Esse exemplo, apesar de um pouco absurdo na perspectiva de um modelo de <em>Reinforcement Learning, </em>pois a evolução do agente geralmente requer muito mais do que apenas um episódio (nesse caso, partida jogada) para aprender a tarefa desejada, ilustra como funciona a lógica do aprendizado por reforço.</p><h3>Qual a diferença em relação a outros métodos de Machine Learning?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*aBoIm7kwgbeDCbOg447U_w.jpeg" /></figure><ul><li><strong>Aprendizado supervisionado</strong>: É necessário um <em>dataset</em> de treino, no qual é sabido os valores corretos de saída para as entradas correspondentes. A partir dele, é treinado o algoritmo que aprende a predizer resultados, com certo grau de acurácia, previamente desconhecidos.</li><li><strong>Aprendizado não supervisionado</strong>: o algoritmo procura separar os dados em grupos com características similares. Não há <em>dataset</em> para treino, ou seja, não há informação prévia sobre em qual grupo pertence uma determinada entrada.</li></ul><p>Comparando com os anteriores, <em>Reinforcement Learning</em> se assemelha com o primeiro no sentido de aprender com as experiências anteriores e com o segundo no sentido de aprender de uma forma não supervisionada, porém essas experiências geralmente são simuladas, como veremos a seguir, e o aprendizado se dá tanto com os acertos quanto com os erros.</p><h3>Conceitos importantes</h3><p>Antes de nos aprofundarmos no assunto é importante entender alguns conceitos-chave:</p><ul><li><strong>Agente: </strong>Entidade, podendo ser tanto um <a href="https://www.youtube.com/watch?v=L4KBBAwF_bE"><em>software</em></a><em> </em>quanto a <a href="https://www.youtube.com/watch?v=W_gxLKSsSIE">sua combinação com <em>hardware</em></a>, que tomará decisões no ambiente, interagindo com ele tomando determinadas ações e recebendo as recompensas correspondentes. Essa é a entidade que aprende no <em>Reinforcement Learning.</em></li><li><strong>Ambiente: </strong>É a materialização (ou simulação) do problema a ser resolvido. Podendo ser real ou virtual, este será o espaço no qual o agente realizará suas ações.</li><li><strong>Estado (s): </strong>É como o sistema, agente e ambiente, se encontra em um determinado instante. Sempre que o agente realiza uma ação, o ambiente fornece um novo estado e uma recompensa correspondente.</li><li><strong>Política (π): </strong>Estratégia aplicada pelo agente para decidir a próxima ação com base no estado atual. A política é sempre atualizada para se atingir um comportamento ideal.</li><li><strong>Recompensa (r):</strong> Norteia as ações do agente, sendo a política ideal determinada a partir dela. Se a ação tomada pelo agente em um determinado estado for desejada, a recompensa é positiva, caso contrário, ela é negativa ou nula.</li></ul><h3>Markov Decision Process (MDP)</h3><p>A lógica do aprendizado por reforço é fácil de entender e visualizar pois se assemelha bastante com a forma como nós aprendemos. O desafio, então, é traduzir essa lógica para uma forma que a máquina possa executá-la. Para isso, é utilizado um modelo matemático conhecido como <strong><em>Markov Decision Process</em></strong><em>.</em></p><p>O processo se dá da seguinte maneira: no instante inicial (t), o <strong>agente</strong> seleciona uma <strong>ação, </strong>muda para um novo <strong>estado, </strong>recebe uma <strong>recompensa</strong> e então o ciclo é reiniciado para o próximo instante (t+1).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*Z1X0fHfrtKT8FLNVsa20sw.png" /><figcaption>Estrutura de um MDP</figcaption></figure><h4>Probabilidade de transição</h4><p>Para <a href="https://medium.com/turing-talks/turing-talks-15-fundamentos-de-probabilidade-para-machine-learning-73dd3202e4c5#3db1">entender esse comportamento de forma probabilística</a>, iremos trabalhar com a probabilidade de uma transição de estado. Essa probabilidade será função do estado e ação imediatamente anteriores, não importando todo o resto.</p><p>Imagine um indivíduo hipotético que só pense em três coisas: dormir, correr ou tomar sorvete. Caso ele esteja correndo, há 60% de chance dele continuar, 30% de chance dele ir tomar sorvete ou 10% de chance dele ir dormir. Para cada um dos estados que esse indivíduo consegue almejar e atingir, existem as chances correspondentes de migração para outro pertencente a esse grupo. Essa é uma ilustração das probabilidades de transição.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/1*ZLftzKAhB4CNOgt5OfRR5g.png" /><figcaption>Pessoa simples com poucas ambições</figcaption></figure><p>Formalmente, definimos a probabilidade de transição para o estado <strong><em>s’, </em></strong>com recompensa <strong><em>r</em></strong> por tomar a ação <strong><em>a</em></strong>, como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*zgXxX5yxhqV6s9pv66KjNw.png" /></figure><h4>Retorno (G)</h4><p>O retorno é um conceito importante pois ele representa o sucesso do agente. Ele é definido como a soma das recompensas futuras (repare que o que acompanha o primeiro termo é <strong><em>t+1 </em></strong>e não <strong><em>t</em></strong>), sendo o objetivo do agente maximizá-lo. É equacionado como segue:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/394/1*OQI1euosR8ew2cvpVz-cRw.png" /></figure><p>Mas e no caso de uma tarefa que não possui um final bem definido? Por exemplo, o jogo <em>Flappy Bird, </em>caso o jogador jogue de maneira perfeita (situação esperada de um agente bem treinado), o jogo segue indefinidamente. Nesse caso, o valor do retorno tenderá para o infinito, o que não é muito conveniente pois precisamos que ele convirja para um valor fixo.</p><p>Para contornar esse fato utilizamos o <strong>retorno com desconto (discounted return). </strong>É definido um fator de desconto γ, entre 0 e 1, que vai determinar a importância dada as recompensas mais futuras. Matematicamente, escrevemos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/372/1*_fGY77W22zk_RDYSiYelQg.png" /></figure><p>Quanto menor o γ, mais relevante são as recompensas mais imediatas.</p><h4>Política (<strong>π</strong>)</h4><p>A política é a função que mapeia um dado estado em probabilidades de se selecionar cada ação possível nele. A política é atualizada até atingir uma <strong>configuração ótima </strong>(quando o agente executa sua função corretamente).</p><p>Então, se um agente segue uma política <strong>π </strong>em um determinado momento <strong><em>t</em></strong>, então <strong>π(<em>a|s) </em></strong>é<strong> </strong>a probabilidade da ação <strong><em>a </em></strong>ser executada caso o estado correspondente seja <strong><em>s</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*-SIF28D8Yxx9J1Sy4u506Q.png" /></figure><h4>Função state-value</h4><p>Definida em função do estado, determina quão bom ele é caso o agente siga uma política <strong>π </strong>pelo resto do processo. O resultado dessa função é o <strong>retorno médio </strong>seguindo essas condições. É equacionado como segue:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*LrmYeB7g3NdyZ8Af6sg5MA.png" /></figure><h4>Função state-action</h4><p>Definida em função do estado e da ação, determina quão bom é para o agente tomar esta ação específica, nesse estado, caso ele siga a política <strong>π </strong>pelo resto do processo. O resultado dessa função é o <strong>retorno médio </strong>seguindo essas condições. Equacionando:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/368/1*I2gXh3dYh7bXH_SxFdxxWQ.png" /></figure><p>Repare que para as duas funções acima, como as ações tomadas pelo agente são influenciadas pela política, elas também são definidas em relação a essa política.</p><h4>Política ótima</h4><p>Quando o agente executa sua função da forma esperada é dito que a política ótima foi atingida. Isso ocorre quando para todo estado possível a função <em>state-value</em> atinge seu valor máximo. Em outras palavras:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/1*vWCJtlt0v8_viwphXhdCvQ.png" /></figure><p>Atrelado a política ótima há também a <em>Q-function </em>ótima, que é quando a função <em>state-action </em>atinge seu valor máximo para todo estado e ação possíveis. Expressando formalmente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/566/1*Co6Um9K0s206XMzPOMEjOQ.png" /></figure><h4>Equação de Bellman</h4><p>Esse tópico é um tanto quanto complexo e será melhor elucidado em um <em>Turing Talks</em> futuro totalmente dedicado a ele. Por hora, iremos aceitar o seguinte fato: <strong>uma propriedade fundamental da <em>Q-function</em> ótima é que ela deve satisfazer a seguinte equação:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/403/1*9Eh3ziYW2yRjvjHdjdwnqA.png" /></figure><p>conhecida como equação de Bellman, onde<strong><em> s’</em></strong> e <strong><em>a’</em></strong> representam o estado e a ação no instante <strong><em>t+1</em></strong>, respectivamente. Ela é útil pois, uma vez determinada a <em>Q-function</em> ótima, podemos determinar a política ótima porque, com <strong><em>q∗</em></strong>, para qualquer estado <strong><em>s</em></strong>, o algoritmo de <em>reinforcement learning</em> consegue encontrar a ação a que maximiza <strong><em>q∗(s, a)</em></strong>.</p><h3>Q-learning</h3><p>E como a gente aplica tudo isso pra poder chegar no nosso modelo esperado? Há vários algoritmos para fazer isso(<strong><em>SARSA, Deep Q-network, Deep Deterministic Policy Gradient</em></strong> etc), mas vamos nos ater a explicar como funciona o <em>Q-learning</em>.</p><p>O objetivo do Q-learning é gerar a política que maximize o total de recompensa recebida depois de todos os estados sucessivos. O algoritmo atualizará iterativamente os valores de <strong><em>q </em></strong>para cada par <strong>estado/ação</strong> <strong><em>(s, a)</em></strong> usando a equação de Bellman até que o valor da função convirja para <strong><em>q∗. </em></strong>Para entender melhor, vejamos no exemplo.</p><h3>Exemplo prático: novo Jogo da Cobrinha</h3><p>Suponha o seguinte jogo: há 9 posições possíveis, sendo que em cada uma pode haver maçãs ou armadilhas. O jogador é a cobrinha que pode se mover para cima, para baixo, direita ou esquerda. O objetivo é coletar o maior número de maçãs com no máximo 5 movimentos. Caso a cobrinha passe por uma armadilha, o jogador é derrotado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*8arVSLJobAq887Oiqjtu-w.jpeg" /></figure><p>A cobrinha será nosso <strong>agente</strong> e o tabuleiro será o <strong>ambiente</strong>. Vamos então montar nossa estrutura de recompensas para treinar o agente:</p><ul><li>5 maçãs recompensam 10 pontos</li><li>3 maçãs recompensam 6 pontos</li><li>2 maçãs recompensam 4 pontos</li><li>Armadilha recompensa -10 pontos e recebe derrota</li><li>Casa vazia recompensa -1 ponto</li></ul><p>De início, o agente sabe apenas para quais direções pode se mover, porém, não tem noção alguma de como esse sistema de pontuação funciona e todo o tabuleiro é uma grande incógnita.</p><p>Para saber mais sobre o jogo, a cobrinha deve explorar o tabuleiro. Sendo assim, o valor de <strong><em>q</em></strong> para cada par <strong><em>(s, a)</em></strong> é inicializado com 0 e após cada partida esses valores são atualizados.</p><p>Podemos montar uma tabela com todas as ações possíveis(movimento da cobrinha) em cada estado(casas do tabuleiro) para armazenar os valores de <strong><em>q</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mRWMbwXDrr5DhnVwLj7S5g.png" /></figure><p>Após cada partida, os valores de <strong><em>q</em></strong> na tabela se aproximam cada vez mais do valor ideal, possibilitando que o agente os use de referência para tomar as decisões adequadas e vencer o jogo.</p><h4>Exploração x Aplicação</h4><p>Se a política determina que o agente deve tomar as ações que maximizem o retorno, como a cobrinha irá tomar uma decisão na primeira partida se o valor inicial da função <em>state-action </em>é o mesmo para todo par <strong><em>(s, a)</em></strong>?</p><p>Inicialmente o agente deve tomar ações aleatórias, sem buscar aumentar o retorno, para melhor entender o ambiente e ajustar os valores de <strong><em>q. </em></strong>Esse processo é conhecido como <strong>exploração (<em>exploration</em>)</strong><em>.</em></p><p>Com base nos conhecimentos adquiridos, a cobrinha passa a tomar decisões mais lógicas para cumprir seu objetivo (vencer o jogo). Essa abordagem fica conhecida como <strong>aplicação </strong>(note que aqui fizemos uma tradução livre do conceito que é visto nas literaturas em inglês, <strong><em>exploitation</em></strong>, para ficar de mais fácil entendimento para o leitor).</p><p>De início, o comportamento predominante é o de exploração e posteriormente, passa a ser o de aplicação. Essa mudança gradual é importante pois se o agente apenas explorar, ele continuará a agir de maneira desmotivada, no sentido de nunca tentar cumprir a tarefa proposta. Se ele apenas aplicar, antes de ter explorado por completo o ambiente, ele poderá cair numa política pseudo-ótima.</p><p>Imagine a seguinte situação: Antes de explorar todo tabuleiro a cobrinha encontra primeiro o par de maçãs. Para encontrá-las foram necessários 2 movimentos. Os outros 3 movimentos restantes não são suficientes para atingir outras maçãs e claramente esta não é a situação que a cobrinha mais comeu. Porém, como o tabuleiro não foi totalmente explorado, o agente acredita estar seguindo um política ótima, quando na verdade não está. Daí a importância tanto da exploração quanto da aplicação.</p><h4>Estratégia Epsilon greedy</h4><p>Para conseguir esses pesos diferenciados para <strong><em>exploração/aplicação</em></strong> utilizamos um fator de exploração <strong><em>ϵ </em></strong>iniciado em 1. Esse fator representa a probabilidade de o agente tomar uma ação que fuja da política, ou seja, uma exploração. Com o passar do episódios, o fator decai e o agente toma uma abordagem mais “gananciosa” (<em>greedy</em>), buscando aplicar cada vez mais o que foi aprendido anteriormente.</p><h3>Tá bom, mas isso daí só serve pra joguinho?</h3><p>No decorrer do post nos restringimos em demonstrar o funcionamento do <em>Reinforcement Learning</em> apenas com sua utilidade em treinar agentes para jogos. Mas não se deixe enganar em achar que essa é a sua única aplicação (ufa!). Ela foi exaustivamente usada pois é a mais tangível para a maioria dos leitores. Vamos ver a seguir algumas outras.</p><h4>Robótica</h4><p>Robôs que aprendem sozinhos a realizarem tarefas complexas já fazem parte de algumas fábricas pelo mundo, como a <a href="https://www.technologyreview.com/s/601045/this-factory-robot-learns-a-new-job-overnight/">Fanuc</a>, fabricante japonesa de robôs.</p><h4>Preços dinâmicos</h4><p>Ajustes de preços de acordo com a oferta e demanda podem fazer uso de técnicas como Q-learning, sendo utilizada durante as interações com os clientes.</p><h4>Tratamento de cânceres</h4><p>O tratamento de regime dinâmico (<a href="https://arxiv.org/abs/1801.09271">DTR</a>) é tópico de várias pesquisas médicas da atualidade. Algoritmos de RL ajudam a processar dados clínicos para se chegar em um estratégia de tratamento, usando-se indicadores recolhidos de pacientes.</p><h4>Mercado financeiro</h4><p>A <a href="https://pit.ai/">Pit.ai</a> é pioneira em utilizar as técnicas de reinforcement learning para avaliar estratégias de investimentos, e tem se mostrado uma ferramenta bastante robusta.</p><h4>Personalização de sugestões no e-Commerce</h4><p>Reconhecer o perfil de cada cliente e sugerir preços e ofertas que terão mais chances de gerarem uma venda bem-sucedida.</p><h3>Conclusão</h3><p>É importante que tenha ficado claro o seguinte: a partir do mapeamento de cada estado do ambiente, por meio do que é aprendido com as experiências anteriores, tanto favoráveis quanto desfavoráveis, é possível atingir uma política ótima que permitirá que o agente execute a tarefa proposta. Os episódios iniciais são majoritariamente para exploração enquanto os finais são focados em aplicação.</p><p>Construímos aqui a fundação para que você possa acompanhar sem grandes dificuldades as próximas publicações dessa série. Caso não tenha entendido as minúcias da matemática, não se preocupe, o mais importante é entender a ideia geral do que cada função representa.</p><p>Para os guerreiros que chegaram até aqui, nossos mais profundos agradecimentos. Claramente, assim como nós, apaixonados por Machine Learning! Não se esqueçam de conferir nossas redes: <a href="https://medium.com/turing-talks">Medium</a>, <a href="https://www.facebook.com/grupoturing.usp/">Facebook</a>, <a href="https://www.instagram.com/grupoturing.usp/">Instagram</a> e <a href="https://www.linkedin.com/company/grupo-turing/">LinkedIn</a>.</p><p>Até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7382ebb641ab" width="1" height="1" alt=""><hr><p><a href="https://medium.com/turing-talks/aprendizado-por-refor%C3%A7o-1-introdu%C3%A7%C3%A3o-7382ebb641ab">Aprendizado por Reforço #1- Introdução</a> was originally published in <a href="https://medium.com/turing-talks">Turing Talks</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modelos de Predição | Ensemble Learning]]></title>
            <link>https://medium.com/turing-talks/turing-talks-24-modelos-de-predi%C3%A7%C3%A3o-ensemble-learning-aa02ce01afda?source=rss-f09787821377------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa02ce01afda</guid>
            <category><![CDATA[ensemble-learning]]></category>
            <category><![CDATA[grupo-turing]]></category>
            <category><![CDATA[aprendizado-de-maquina]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[modelos-de-predição]]></category>
            <dc:creator><![CDATA[Enzo Cardeal Neves]]></dc:creator>
            <pubDate>Sun, 10 Nov 2019 15:04:09 GMT</pubDate>
            <atom:updated>2020-06-09T12:56:13.428Z</atom:updated>
            <content:encoded><![CDATA[<h4>“Apes together strong!”</h4><p>Escrito por <a href="https://medium.com/@enzocardeal">Enzo Cardeal</a> e <a href="https://medium.com/@bernardo.rcoutinho">Bernardo Coutinho</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fa21eKCaQa1CIuDR7rMEOw.jpeg" /></figure><p>Bem-vindos a mais uma edição do <strong><em>Turing Talks</em></strong>! Nessa semana falaremos sobre os métodos de <strong>Ensemble Learning</strong>, que consiste na união de diversos modelos de predição mais simples para obter um modelo geral mais consistente e menos suscetível a ruídos.</p><p>Sem mais delongas, vamos direto à explicação!</p><h3><strong>O que é Ensemble Learning?</strong></h3><p>O conceito de <strong>Ensemble Learning</strong>, também chamado de aprendizado por agrupamento, se baseia na ideia de combinar diversos modelos de predição mais simples (<strong>weak learner</strong>), treiná-los para uma mesma tarefa, e produzir a partir desses um modelo agrupado mais complexo (<strong>strong learner</strong>) que é a soma de suas partes.</p><p>Esse agrupamento objetiva, ao juntar múltiplos modelos mais fracos, diminuir a suscetibilidade geral deles a <a href="https://medium.com/turing-talks/turing-talks-10-introdu%C3%A7%C3%A3o-%C3%A0-predi%C3%A7%C3%A3o-a75cd61c268d"><strong>bias</strong></a> e a <a href="https://medium.com/turing-talks/turing-talks-10-introdu%C3%A7%C3%A3o-%C3%A0-predi%C3%A7%C3%A3o-a75cd61c268d"><strong>variance</strong></a>, tornando-os mais robustos. Portanto, os métodos de Ensemble devem levar em conta a maneira com a qual eles agrupam os modelos, associando os algoritmos de forma a minimizar suas desvantagens individuais no modelo final.</p><p>Geralmente é escolhido apenas um modelo base para ser treinado em sets diferentes e posteriormente é feita a combinação, formando assim um modelo homogêneo. Se o Ensemble final for formado por modelos diferentes dizemos que é um preditor heterogêneo.</p><p>Por exemplo, se quisermos criar um modelo Ensemble baseado no agrupamento de diversas <a href="https://medium.com/turing-talks/turing-talks-17-modelos-de-predi%C3%A7%C3%A3o-decision-tree-610aa484cb05">árvores de decisão</a>, que são modelos simples de alta variância, precisamos agregá-las de modo a aumentar sua resistência a variações nos dados. Logo, faria sentido treinar as árvores separadamente de forma a adaptar cada uma a partes diferentes da base de dados, assim, o conjunto delas saberia lidar com todas as variações dos dados. Esse é um dos principais pilares das <a href="https://medium.com/turing-talks/turing-talks-18-modelos-de-predi%C3%A7%C3%A3o-random-forest-cfc91cd8e524"><strong>Random Forests</strong></a>, o modelo mais popular de Ensemble.</p><p>Existem variados métodos de Ensemble Learning, mas neste texto focaremos principalmente em <strong>Bagging</strong>, <strong>Boosting </strong>e <strong>Stacking</strong>, os tipos mais utilizados em Data Science. Suas principais características são:</p><p>· <strong>Bagging: </strong>geralmente é feito com preditores homogêneos, cada um de forma independente em relação ao outro, de forma paralela. O algoritmo final é então feito a partir de algum tipo de resultado médio do que foi obtido a partir dos modelos bases.</p><p>· <strong>Boosting: </strong>geralmente é feito com preditores homogêneos, que são aplicados de forma sequencial (o posterior depende do antecessor) e depois combinados no modelo final.</p><p>· <strong>Stacking: </strong>geralmente é feito com preditores heterogêneos, treinando-os em paralelo. É então aplicado um modelo no <em>output </em>dos <em>weak learners </em>(podendo incluir ou não as <em>features </em>utilizadas para treiná-los).</p><h3>Bagging</h3><p>Antes de entendermos <strong>Bagging</strong> precisamos primeiro entender o que é <strong>Bootstrapping. </strong>Essa técnica consiste em subdividir nosso dataset em grupos menores, tomando elementos de forma aleatória e com reposição. Isso nos permite entender melhor o comportamento da média e do desvio padrão dos dados que estão além do dataset. Com isso, é possível fazer as pesquisas de opinião por exemplo.</p><p>Aplicamos então o mesmo modelo de predição em cada um dos subgrupos e tomamos a média dos resultados como a predição do nosso modelo final. Essa abordagem gera um preditor com menos<em> overfitting </em>(por outro lado, esse método pode aumentar um pouco a bias)<em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/481/1*nv7NX0YT4fSIymarECSuwg.png" /><figcaption>Infográfico de como Bagging funciona</figcaption></figure><p>Como<em> </em><strong>Bagging</strong> já foi abordado no <a href="https://medium.com/turing-talks/turing-talks-18-modelos-de-predi%C3%A7%C3%A3o-random-forest-cfc91cd8e524">Turing Talks #18</a><em> </em>não iremos nos estender muito nessa parte.</p><h3>Boosting</h3><p>Os métodos de<strong> Boosting</strong> compõem uma outra categoria de algoritmo de Ensemble Learning, focada principalmente em reduzir a bias dos modelos iniciais. Esse tipo de aprendizado se tornou muito popular no meio da Ciência de Dados nos últimos anos por obter ótimas performances em competições de Machine Learning, devido a sua grande adaptabilidade. Mas qual a teoria por trás desse algoritmo?</p><p>Assim como Bagging, os métodos de Boosting se baseiam em treinar diversos modelos mais simples a fim de produzir um modelo final mais robusto. Entretanto, nos algoritmos de Boosting os modelos não são mais treinados de forma independente entre si, mas de forma sequencial, a partir de uma análise dos modelos treinados previamente.</p><p>De modo a maximizar o desempenho do preditor final, o Boosting treina iterativamente novos modelos sempre com um enfoque nas observações que os modelos anteriores tiveram mais dificuldade, tornando a predição mais resistente a bias. Em sequência, atualizamos o modelo para priorizar as predições com maior acurácia nas observações da base de teste. A maneira como ocorre esse treinamento e essa atualização é onde diferem os diferentes algoritmos de Boosting.</p><p>Como o principal objetivo dos métodos de Boosting é de reduzir a bias dos preditores mais simples, é ideal escolher como base para a agregação um modelo simples com alto bias e baixa variância. Decorrente disso, geralmente escolhemos árvores de decisão de baixa profundidade para compor o preditor final.</p><h4>Adaboost</h4><p><strong><em>Adaptive Boosting</em></strong><em>, </em>ou simplesmente <strong><em>Adaboost</em></strong>, é um algoritmo consiste em combinar de forma sequencial vários modelos mais fracos, sendo assim o <em>weak learner</em> subsequente leva em consideração as predições do anterior, para formar um preditor mais conciso.</p><p>O diferencial desse algorítimo é que as predições mais difíceis (aquelas em que o <em>weak learner </em>da iteração atual mal previu) recebem um peso maior no preditor seguinte, buscando assim uma maior otimização do algoritmo final.</p><p>Noutros termos, cada modelo é inicializado com um peso padrão, que define seu poder de decisão no modelo final. A partir disso, conforme vamos treinando esses modelos simples, cada <em>weak learner</em> ganha um peso maior para as observações que ele prevê corretamente, e um peso menor para as observações em que ele possui um alto índice de erro.</p><p>Dessa forma, os <em>weak learners</em> com maior precisão terão maior poder de decisão no modelo final, produzindo um Ensemble extremamente robusto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/908/1*wE9Onlt9H4MQTVZB9Mu6DQ@2x.png" /><figcaption>Infográfico de como Adaboost funciona</figcaption></figure><h4>Gradient Boosting</h4><p>O<strong><em> Gradient Boosting</em></strong> é um outro tipo de algoritmo de Boosting, que difere do <strong><em>Adaboost</em></strong> quanto à maneira com a qual os modelos são treinados com relação aos anteriores.</p><p>Ao invés de estabelecer pesos para os <em>weak learners</em>, o <strong><em>Gradient Boosting</em></strong><em> </em>treina novos modelos diretamente no erro dos modelos anteriores. Ou seja, os novos modelos tentam prever o erro dos modelos anteriores em vez de prever independentemente o target. Dessa forma, obtemos a predição final somando a predição de todos os <em>weak learners.</em></p><p>O algoritmo do Gradient Boosting funciona assim: O primeiro modelo faz uma aproximação bem simples da predição, e obtemos os nossos erros residuais:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UCU0LVQULclL5zkk.png" /><figcaption>Predição e Erro do primeiro modelo</figcaption></figure><p>Depois, treinamos mais modelos nesses erros residuais, para tentar predizer o erro do primeiro modelo. Dessa forma, quando somamos as predições de cada modelo para obter a predição final, obtemos uma versão mais corrigida da primeira predição:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ckHhfb4LZMLt5ER1.png" /><figcaption>Soma das predições e erro do modelo final depois de 3 iterações</figcaption></figure><p>Repetimos esse processo por várias iterações, obtendo erros residuais cada vez menores.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5cTy3baGp5FGshp4.png" /><figcaption>Fonte: <a href="https://medium.com/hackernoon/gradient-boosting-and-xgboost-90862daa6c77">https://medium.com/hackernoon/gradient-boosting-and-xgboost-90862daa6c77</a></figcaption></figure><h3>Stacking</h3><p>Esse modelo é criado a partir das predições de <em>weak learners</em>, que são usadas como features . Essas novas features permitem que nosso modelo final agregue onde nossos modelos iniciais melhor performaram e descredite onde performaram mal.</p><h4><strong>Como isso é feito?</strong></h4><p>Na realidade, isso pode ser feito de diversas maneiras então vamos explicar aqui uma forma que será de mais fácil entendimento :)</p><ol><li>Separe o set de treino em 10 partes:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*ucynkDQPdlmGs0yQfJ9Ytg.png" /></figure><p>2. Um modelo base (<em>decision tree</em> por exemplo) é fitado (treinado) em 9 partes e a predição é feita na parte restante. Isso é feito para cada parte do set de treino.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*On_TexdunrdeT081j_s1SQ.png" /></figure><p>3. O modelo é então fitado em todo o set de treino.</p><p>4. As predições são então feitas no set de teste.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*ElCqbfJHd3-hsfZ0weEuNQ.png" /></figure><p>5. Os passos 2 e 4 são repetidos utilizando outro modelo base (KNN por exemplo), gerando outro set de predições tanto no set de teste quanto no set de treino.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*52EgW46kQamObkRyS81AsQ.png" /></figure><p>6. As predições do set de treino são usadas como <em>features </em>para construir o modelo final (modelo <em>stacking, </em>nesse caso utilizamos <em>logistic regression</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*Adb0KB0pFrRkFNG4pvYMiA.png" /></figure><p>Note que para construir o modelo final você pode também utilizar as outras <em>features do dataset.</em></p><h3>Exemplo Prático</h3><p>Agora que você já sabe a teoria por trás dos métodos de Ensemble Learning, podemos ir direto para a prática! Vamos mostrar como fazer predições com um modelo de <strong>Boosting</strong>, e um modelo de <strong>Bagging</strong>.</p><p>Mas primeiro, precisamos preparar a nossa área de trabalho! Primeiramente, vamos importar a biblioteca pandas, para poder lidar melhor com nossos dados. Se você não está familiarizado com a biblioteca, recomendamos ler o nosso <a href="https://medium.com/turing-talks/turing-talks-6-data-science-libraries-6c2599838b3e">Turing Talks sobre Bibliotecas de Data Science</a>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/da7d8bd6be5227f5241bed940c9610ea/href">https://medium.com/media/da7d8bd6be5227f5241bed940c9610ea/href</a></iframe><p>Agora, precisamos de uma base de dados. Para esse exercício, escolhemos o Boston Housing, um dataset bem simples com dados de casas na área de Boston, cujo objetivo é prever o preço de cada uma.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0691da7d82b8d7009f1ec79d532e672b/href">https://medium.com/media/0691da7d82b8d7009f1ec79d532e672b/href</a></iframe><p>Como essa base requer pouca limpeza de dados, vamos direto à aplicação dos modelos. Se você quiser aprofundar mais em Data Cleaning, <a href="https://medium.com/turing-talks/turing-talks-7-data-cleaning-c770969dd935">recomendamos nosso Turing Talks sobre esse assunto.</a></p><h4>Boosting</h4><p>Para exemplificar Boosting, vamos aplicar um modelo de Gradient Boosting no dataset de Boston, usando a biblioteca do Sci-Kit Learn.</p><p>Depois de importar o modelo, precisamos configurá-lo e escolher seus hiperparâmetros. No caso, definimos o número de estimadores, a taxa de aprendizado, e a profundidade de cada árvore de decisão. Os valores ideais para cada parâmetro vão variar bastante dependendo de sua aplicação, então é recomendável ficar mexendo nessas grandezas para ver qual combinação funcionará melhor.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/be0564b3954731b7617485480d06174c/href">https://medium.com/media/be0564b3954731b7617485480d06174c/href</a></iframe><h4>Bagging</h4><p>Vamos mostrar também um exemplo de como aplicar um modelo de Bagging: o Random Forest. Porém, como já abordamos o tema mais aprofundado em <a href="https://medium.com/turing-talks/turing-talks-18-modelos-de-predi%C3%A7%C3%A3o-random-forest-cfc91cd8e524">um Turing Talks anterior</a>, não vamos delongar muito na explicação.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/315a3d9148eed7103258fcb5b0e55774/href">https://medium.com/media/315a3d9148eed7103258fcb5b0e55774/href</a></iframe><p>Se quiser rodar o notebook você mesmo, disponibilizamos ele no<a href="https://colab.research.google.com/drive/1aVQW1E5PWATfvy7rr7Svj3M05YA4uHCq?usp=sharing"> Google Colaboratory</a>!</p><h3>Conclusão</h3><p>Nesse post abordamos vários conceitos-chave (<em>bootstrapping, boosting, bagging, stacking e random forest</em>) para se entender <em>Ensemble Learning</em>. Um modelo mais complexo que não tratamos é o <a href="https://www.datacamp.com/community/tutorials/xgboost-in-python"><em>XGBoost</em></a><em> (eXtreme Gadrient Boosting), </em>que consiste na aplicação do <em>Gradient Boosting </em>juntamente com outras técnicas para fazer o algoritmo aprender de maneira mais eficiente.</p><p>Por fim, gostaríamos de salientar que os métodos de <em>Ensemble Learning </em>não são nada engessados, o que permite muitas variações que vão depender de cada problema abordado<em>. </em>Portanto, lembre-se: entenda bem a situação que você está lidando e… abuse de sua criatividade!</p><p>Para os amantes de IA que nos acompanharam até aqui, nossos mais profundos agradecimentos! Não se esqueçam de conferir nossas redes: <a href="https://medium.com/turing-talks">Medium</a>, <a href="https://www.facebook.com/grupoturing.usp/">Facebook</a>, <a href="https://www.instagram.com/grupoturing.usp/">Instagram</a> e <a href="https://www.linkedin.com/company/grupo-turing/">LinkedIn</a>.</p><p>Até a próxima pessoal!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa02ce01afda" width="1" height="1" alt=""><hr><p><a href="https://medium.com/turing-talks/turing-talks-24-modelos-de-predi%C3%A7%C3%A3o-ensemble-learning-aa02ce01afda">Modelos de Predição | Ensemble Learning</a> was originally published in <a href="https://medium.com/turing-talks">Turing Talks</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>