<?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 Willian Bogler on Medium]]></title>
        <description><![CDATA[Stories by Willian Bogler on Medium]]></description>
        <link>https://medium.com/@willian.bogler?source=rss-25cb2867be40------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*gZHCHuCx21BzJWyh.jpg</url>
            <title>Stories by Willian Bogler on Medium</title>
            <link>https://medium.com/@willian.bogler?source=rss-25cb2867be40------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 22:56:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@willian.bogler/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[RANDOM FOREST]]></title>
            <link>https://medium.com/@willian.bogler/random-forest-a9556c9f2fb8?source=rss-25cb2867be40------2</link>
            <guid isPermaLink="false">https://medium.com/p/a9556c9f2fb8</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[random-forest]]></category>
            <dc:creator><![CDATA[Willian Bogler]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 19:01:32 GMT</pubDate>
            <atom:updated>2026-11-11T19:01:32.171Z</atom:updated>
            <content:encoded><![CDATA[<p>Em meu último texto exploramos o conceito de árvores de decisão, abordando o que são, como podem ser implementadas em Python e como a qualidade dos dados influencia diretamente os resultados obtidos pelos algoritmos. Durante aquela leitura, talvez você tenha se feito a mesma pergunta que eu fiz quando conheci o tema:</p><blockquote><em>“E se, em vez de utilizar apenas uma árvore de decisão, eu utilizasse várias delas ao mesmo tempo?”</em></blockquote><p>A resposta é sim. Essa abordagem existe, é amplamente utilizada no mercado e recebe o nome de <strong>Random Forest</strong>. Neste artigo vamos entender seus principais conceitos, suas vantagens em relação às árvores de decisão tradicionais e, assim como no texto anterior, construiremos uma implementação prática utilizando Python.</p><h3>O problema das Árvores de Decisão</h3><p>Quando estudamos árvores de decisão, nos deparamos rapidamente com um dos problemas mais comuns em Machine Learning: o <strong>overfitting</strong>.</p><p>O overfitting ocorre quando um modelo aprende excessivamente os dados utilizados durante o treinamento. Em vez de capturar apenas os padrões relevantes do problema, ele passa a memorizar características específicas daquela amostra, incluindo ruídos, inconsistências e casos excepcionais.</p><p>O resultado é um modelo que apresenta excelente desempenho sobre os dados utilizados no treinamento, mas que possui dificuldades para generalizar suas previsões quando recebe dados novos. Para reduzir essa limitação, surgiu o <strong>Random Forest</strong>, uma das técnicas mais populares e eficientes do Machine Learning clássico.</p><h3>A ideia do Random Forest</h3><p>O Random Forest parte de um princípio extremamente simples:</p><blockquote><em>Em vez de confiar na decisão de uma única árvore, por que não consultar dezenas ou até centenas delas?</em></blockquote><p>O nome Random Forest pode ser traduzido como <strong>Floresta Aleatória</strong>, já que o algoritmo constrói um conjunto de árvores de decisão que trabalham em conjunto. Cada árvore realiza sua própria análise do problema e gera uma previsão independente. Ao final do processo, todas as respostas são combinadas para produzir uma decisão única.</p><p>Essa abordagem pertence à categoria de técnicas conhecidas como <strong>Ensemble Learning</strong>, ou aprendizado por conjunto, em que múltiplos modelos colaboram para produzir um resultado mais robusto do que aquele obtido por um único algoritmo.</p><blockquote>Quando utilizamos apenas uma árvore de decisão, todo o resultado depende da estrutura construída durante o treinamento.</blockquote><p>Já no Random Forest, cada árvore é treinada utilizando subconjuntos diferentes dos dados e diferentes combinações de atributos. Isso cria uma diversidade de interpretações sobre o mesmo problema.</p><p>Na prática:</p><ul><li>Uma árvore pode cometer um erro.</li><li>Outra árvore pode acertar.</li><li>Uma terceira pode identificar um padrão que as demais não perceberam.</li></ul><p>Ao combinar todas essas análises, os erros individuais tendem a ser reduzidos, enquanto os padrões realmente relevantes ganham mais força.</p><p>Como resultado, temos:</p><ul><li>Melhor capacidade de generalização;</li><li>Menor risco de overfitting;</li><li>Maior resistência a ruídos nos dados;</li><li>Melhor desempenho preditivo em diversos cenários.</li></ul><p>Não é por acaso que o Random Forest continua sendo uma das primeiras opções em muitos projetos de Ciência de Dados, mesmo diante de algoritmos mais modernos como XGBoost, LightGBM e redes neurais profundas.</p><h3>Como o Random Forest funciona?</h3><p>Seguindo o mesmo padrão adotado no artigo anterior, não vou me aprofundar nos cálculos matemáticos envolvidos no algoritmo. Entretanto, caso você tenha interesse em compreender os fundamentos teóricos do Random Forest, recomendo a leitura do artigo original publicado por <strong>Leo Breiman</strong> em 2001, intitulado <em>Random Forests</em>, disponível em: <a href="https://www.stat.berkeley.edu/~breiman/randomforest2001.pdf">Random Forests — Leo Breiman (2001)</a></p><h3>Entendendo as Amostras</h3><p>Para manter a continuidade do conteúdo e facilitar a comparação entre os algoritmos, utilizaremos as mesmas bases de dados fictícias apresentadas no texto anterior.</p><p>Essas bases simulam informações financeiras de clientes que solicitaram empréstimos, contendo características como estado civil, renda e existência de empréstimos anteriores.</p><p>Foram criados dois cenários distintos:</p><ul><li><strong>Base 1:</strong> clientes com rendimentos de até R$ 8.000;</li><li><strong>Base 2:</strong> clientes com rendimentos de até R$ 15.000.</li></ul><p>A utilização das mesmas bases permitirá observar com mais clareza as diferenças de comportamento entre uma única árvore de decisão e uma floresta composta por múltiplas árvores, evidenciando como o Random Forest consegue produzir previsões mais consistentes e menos suscetíveis ao overfitting. A tabela 1 abaixo é a tabela padrão para esse texto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/487/1*U6glB690wI87k5XOHksZww.png" /><figcaption>Tabela 1: Dados originais e tratados</figcaption></figure><p>A tabela 1 será processada em várias outras tabelas e a seleção dos seus dados ocorre por meio de uma técnica chamada <strong>Bootstrap Sampling</strong>, responsável por criar amostras aleatórias a partir do conjunto de dados original. Um aspecto importante dessa abordagem é que a seleção é realizada <strong>com reposição</strong>, ou seja, após um registro ser escolhido, ele retorna ao conjunto e pode ser selecionado novamente.</p><p>Na prática, isso significa que um mesmo registro pode aparecer várias vezes na amostra utilizada para treinar uma árvore específica, enquanto outros registros podem não ser selecionados naquela amostra. Dessa forma, cada árvore da floresta é treinada com uma visão ligeiramente diferente dos dados, aumentando a diversidade das decisões tomadas pelo conjunto.</p><p>Utilizando os dados da Tabela 1 como exemplo, poderíamos gerar diferentes amostras aleatórias para o treinamento das árvores que compõem a floresta. Em uma dessas amostras, determinados registros poderiam aparecer mais de uma vez, enquanto outros poderiam sequer ser selecionados, conforme ilustrado na tabela a seguir, veja um exemplo de tabelas processadas nas tabelas 2 e 3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/485/1*_KZ-UuAkzd7ciBYEN6YqqQ.png" /><figcaption>Tabela 2: Valores aleatório para uma novo nó.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/486/1*aduSve6kXlfoi0EjjcKsFA.png" /><figcaption>Tabela 3: Valores aleatórios para um novo nó.</figcaption></figure><p>Esse processo de geração de amostras se repete até atingir a quantidade de árvores definida para a floresta. Observe que, conforme mencionado anteriormente, um mesmo registro pode ser selecionado diversas vezes dentro de uma amostra, enquanto outros podem simplesmente não aparecer. Essa característica é fundamental para que cada árvore seja treinada com uma visão ligeiramente diferente do conjunto de dados original.</p><p>Entretanto, a aleatoriedade do Random Forest não se limita apenas à seleção dos registros. Existe um segundo mecanismo responsável por aumentar a diversidade entre as árvores: a seleção aleatória dos atributos.</p><p>Durante a construção de cada árvore, nem todas as variáveis disponíveis são consideradas em cada divisão. Em vez disso, o algoritmo seleciona aleatoriamente apenas uma parcela dos atributos para participar do processo de decisão. Uma abordagem bastante comum para problemas de classificação consiste em utilizar a raiz quadrada da quantidade total de atributos como referência para determinar esse número.</p><p>Em nosso exemplo, possuímos três atributos de entrada. Aplicando essa regra, temos: <strong>√3 ≈ 1,73</strong></p><p>Como não é possível utilizar uma fração de atributo, o valor é arredondado para <strong>2 atributos por árvore</strong>. Dessa forma, cada árvore será construída utilizando combinações aleatórias de duas variáveis dentre as três disponíveis.</p><p>Essa estratégia reduz a influência excessiva de um único atributo sobre todo o modelo e impede que todas as árvores sigam exatamente o mesmo caminho de decisão. Como consequência, aumenta-se a diversidade da floresta, tornando as previsões mais robustas e menos suscetíveis ao overfitting.</p><p>Considerando a aplicação simultânea do <em>Bootstrap Sampling</em> e da seleção aleatória de atributos, poderíamos obter uma distribuição semelhante à apresentada a seguir para o treinamento de cada árvore da floresta (tabela 4 e 5).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/1*paINKATKHVSSmpQWEhLoHg.png" /><figcaption>Tabela 4: Nova tabela com redução de atributos para um nó.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/390/1*JEpWMWtNv4Gt6GYwTKtQMw.png" /><figcaption>Tabela 5: Nova tabela com redução de atributos para um nó.</figcaption></figure><p>Agora que já entendemos como os dados são selecionados de forma aleatória, surge uma nova pergunta: <strong>o que fazemos com esse conjunto de dados gerado para cada árvore?</strong></p><p>É nesse momento que entra o principal mecanismo do Random Forest, conhecido como <strong>Bagging</strong>. O termo é a combinação das palavras <em>Bootstrap</em> e <em>Aggregating</em>, representando as duas etapas fundamentais do algoritmo.</p><p>O <strong>Bootstrap</strong> é responsável pela criação de múltiplas amostras aleatórias com reposição a partir da base de dados original, conforme discutido anteriormente. Já o <strong>Aggregating</strong> consiste na consolidação das previsões produzidas por todas as árvores da floresta, permitindo a obtenção de uma resposta final mais estável e confiável.</p><p>Em problemas de classificação, essa agregação normalmente ocorre por meio de votação, em que a classe mais escolhida pelas árvores é definida como resultado do modelo. Já em problemas de regressão, o valor final corresponde à média das previsões realizadas por cada árvore.</p><p>É justamente essa combinação entre diversidade e agregação que torna o Random Forest tão eficiente. Enquanto árvores individuais podem cometer erros ou se especializar demais em determinados padrões, a floresta tende a compensar essas falhas ao considerar o conhecimento coletivo de todas as árvores.</p><h3>Montando o Script</h3><p>Agora que compreendemos os principais conceitos do algoritmo e a forma como as árvores são construídas, vamos partir para a implementação prática em Python e analisar os resultados obtidos.</p><p>Inicialmente, utilizaremos a mesma base contendo <strong>oito registros</strong>, que foi armazenada em um arquivo CSV. Para manipular os dados, utilizaremos a biblioteca <strong>Pandas</strong>, amplamente empregada em projetos de Ciência de Dados e Machine Learning.</p><p>O primeiro passo consiste em carregar o arquivo, remover o atributo <strong>ID</strong> (que não possui relevância para o processo de aprendizado), definir quais colunas serão utilizadas como variáveis de entrada (<strong>X</strong>) e qual será a variável de saída (<strong>y</strong>). Por fim, exibiremos os registros para verificar se os dados foram carregados corretamente.</p><p>O código a seguir realiza essa preparação inicial da base:</p><pre>import pandas as pd<br><br>#leitura e tratamento dos dados<br><br>#leitura do arquivo csv com os dados<br>df = pd.read_csv(&#39;./data/11registros.csv&#39;, sep=&#39;;&#39;)<br><br>#Exibi as colunas e seus informação<br>print(df.head())<br>print(df.info())<br><br>#exclui o id, pois não tem necessidade dessa informação<br>df = df.drop(&#39;id&#39;, axis=1)<br><br><br>#separamos quem é variável (X) e quem é a resposta (y)<br>X = df.drop(&#39;emprestar&#39;, axis=1)<br>y = df[&#39;emprestar&#39;]<br><br>#exibimos como ficou nosso conjunto de dados<br>print(df.head())</pre><p>O resultado do processamento podemos ver no terminal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/1*Z7VbHC76KbmtXu5kxGfsnw.png" /></figure><p>A próxima etapa consiste em importar a biblioteca <strong>Scikit-Learn</strong>, utilizando o módulo ensemble, que reúne algoritmos baseados em conjuntos de modelos (<em>Ensemble Learning</em>). Nesse caso, utilizaremos especificamente o <strong>RandomForestClassifier</strong>, responsável por implementar o algoritmo Random Forest para problemas de classificação.</p><p>Na criação do modelo, definimos o parâmetro n_estimators=100, que representa a quantidade de árvores que compõem a floresta. Esse valor é amplamente utilizado como padrão porque oferece um bom equilíbrio entre desempenho e custo computacional. Em geral, quanto maior o número de árvores, mais estável tende a ser a previsão do modelo, já que o impacto de erros individuais é reduzido. Entretanto, após determinado ponto, o aumento da quantidade de árvores gera ganhos cada vez menores, enquanto o tempo de processamento continua crescendo. Por esse motivo, 100 árvores costuma ser um excelente ponto de partida para a maioria dos cenários.</p><p>Também mantivemos o parâmetro criterion= &#39;gini&#39;, utilizando o mesmo critério de divisão empregado anteriormente na árvore de decisão. Dessa forma, conseguimos comparar os resultados entre os dois modelos sem alterar a métrica utilizada para avaliar a qualidade das separações realizadas em cada nó.</p><p>Outro parâmetro importante é o random_state=42. Como o Random Forest utiliza diversos processos aleatórios durante sua construção, diferentes execuções podem produzir resultados ligeiramente diferentes. O objetivo do random_state é fixar a &quot;semente&quot; desses processos aleatórios, garantindo que qualquer pessoa que execute o código obtenha exatamente os mesmos resultados. O valor 42 não possui nenhum significado matemático especial para o algoritmo; trata-se apenas de uma convenção amplamente adotada pela comunidade de tecnologia e ciência de dados, popularizada por referências da cultura geek e frequentemente utilizada em exemplos, tutoriais e documentações.</p><p>Após a criação do objeto, realizamos o treinamento do modelo por meio do método fit(), permitindo que a floresta aprenda os padrões presentes na base de dados. Em seguida, utilizamos o método predict() para realizar previsões.</p><p>Em um cenário real, o ideal seria dividir os dados entre conjuntos de treinamento e teste, permitindo avaliar a capacidade de generalização do modelo em registros que ele nunca viu anteriormente. No entanto, como estamos trabalhando com uma base fictícia extremamente pequena, contendo apenas oito registros, a separação comprometeria ainda mais a quantidade de dados disponível para treinamento. Por essa razão, utilizaremos toda a base para fins didáticos, focando na compreensão do funcionamento do algoritmo.</p><p>Por fim, exportamos o modelo treinado para um arquivo utilizando a biblioteca joblib. Essa prática é bastante comum em ambientes de produção, pois evita a necessidade de realizar um novo treinamento sempre que o sistema for executado. Além disso, ela nos permitirá demonstrar, na próxima etapa, como carregar um modelo previamente treinado e utilizá-lo para realizar previsões em outra aplicação ou script Python.</p><p>O código a seguir apresenta a criação, treinamento, utilização e persistência do modelo Random Forest:</p><pre>from sklearn.ensemble import RandomForestClassifier<br><br>#cria o modelo Random Forest<br>modelo_rf = RandomForestClassifier(<br>    n_estimators=100,     # quantidade de árvores<br>    criterion=&#39;gini&#39;,     # metrica que usamos no texto 1 para arvore de decisao<br>    random_state=42<br>)<br><br>#treinamento<br>modelo_rf.fit(X, y)<br><br>#previsão de exemplo<br>predicoes = modelo_rf.predict(X)<br><br>print(predicoes)<br><br>import joblib<br><br>joblib.dump(modelo_rf, &#39;emprestimo2.pkl&#39;)</pre><p>Agora que o modelo foi treinado e exportado para o arquivo emprestimo1.pkl, podemos utilizá-lo para avaliar novos pedidos de empréstimo sem a necessidade de realizar todo o processo de treinamento novamente. Essa é uma prática bastante comum em aplicações reais, nas quais o treinamento ocorre uma única vez e o modelo resultante é disponibilizado para ser consumido por diferentes sistemas.</p><p>Para demonstrar esse processo, desenvolvemos um segundo script responsável por carregar o modelo previamente treinado e solicitar ao usuário algumas informações que serão utilizadas na análise de crédito. Nesse exemplo, serão coletados três atributos: <strong>estado civil</strong>, <strong>renda total</strong> e a informação sobre a existência de empréstimos ativos.</p><p>Após o preenchimento desses dados, o script organiza as informações no mesmo formato utilizado durante o treinamento do modelo. Essa etapa é fundamental, pois o Random Forest espera receber os dados exatamente na mesma estrutura com a qual foi treinado.</p><p>Em seguida, o arquivo emprestimo1.pkl é carregado utilizando a biblioteca joblib, permitindo que o método predict() seja executado sobre os novos dados informados pelo usuário.</p><p>Com base nos padrões aprendidos durante o treinamento, o modelo realiza sua previsão e retorna uma resposta indicando se o empréstimo foi <strong>aprovado</strong> ou <strong>negado</strong>. Embora este seja um exemplo simplificado e construído sobre uma base fictícia, ele reproduz o mesmo fluxo utilizado em sistemas reais de análise de crédito, recomendação de produtos, detecção de fraudes e diversas outras aplicações de Machine Learning.</p><p>O código a seguir demonstra como carregar o modelo treinado, receber os dados do usuário e realizar uma nova previsão:</p><pre>import joblib<br>import pandas as pd<br><br>#carrega o modelo já treinado<br>modelo_producao = joblib.load(&#39;emprestimo1.pkl&#39;)<br><br>print(&quot;modelo de esprestimo&quot;)<br><br>estado_civil = int(input(&quot;Digite 0 para solteiro e 1 para casado: &quot;))<br>renda_total = float(input(&quot;Digite a renda total: &quot;))<br>emprestimo = int(input(&quot;Digite 0 para não tem emprestimo e 1 para caso tenha emprestimo: &quot;))<br><br>#dados de cliente salvos<br>dados_cliente = [[estado_civil, renda_total, emprestimo]]<br><br>#delimitacao das colunas<br>colunas = [&#39;estado_civil&#39;, &#39;renda_total&#39;, &#39;tem_emprestimo&#39;]<br>#Estruturação dos nossos dados em coluna e seus valores<br>dados_formatados = pd.DataFrame(dados_cliente, columns=colunas)<br><br>#chamamos o modelo<br>resultado = modelo_producao.predict(dados_formatados)<br><br>if resultado[0] == 1:<br>    print(&quot;Emprestimo aprovado&quot;)<br>else:<br>    print(&quot;Emprestimo negado&quot;)<br><br>print (modelo_producao.predict_proba(dados_formatados))</pre><p>Ao executar o script e informar os dados solicitados, obtemos o resultado apresentado a seguir. Para manter a consistência com os testes realizados no texto sobre árvores de decisão e facilitar a comparação entre os modelos, utilizaremos exatamente os mesmos cenários avaliados anteriormente.</p><p>Na primeira simulação, apresentada na imagem abaixo, o Random Forest produziu o mesmo resultado obtido pela árvore de decisão. Esse comportamento era esperado, já que estamos diante de um caso relativamente simples e cujos padrões estão bem representados na base de treinamento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/859/1*pBOtDI_PhBJ3LdVeoavQ9g.png" /></figure><p>Entretanto, o verdadeiro diferencial do Random Forest aparece quando avaliamos cenários em que a árvore de decisão apresentou dificuldades. Ao repetir esses mesmos testes (imagem abaixo), observamos que já na primeira tentativa o modelo conseguiu chegar a uma conclusão diferente da árvore isolada, produzindo justamente o resultado esperado para aquele contexto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*jfd9AOW2FlTfbXi8FajLbQ.png" /></figure><p>Ao expandirmos os testes para os demais cenários, a Rando Forest demonstrou uma capacidade superior de generalização, apresentando uma taxa de acerto maior do que a obtida pela árvore de decisão. Os resultados dos outros dois testes podem ser observados nas imagens apresentadas a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*2lnPKURZAjOuqu-lLsVbnA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/859/1*gME0weSi_XnHx4-CtHATYA.png" /></figure><p>De maneira geral, os resultados foram bastante positivos, especialmente para situações envolvendo valores de renda acima dos limites observados durante o treinamento. Nesses casos, o Random Forest demonstrou maior capacidade de extrapolar padrões e produzir respostas coerentes.</p><p>Por outro lado, alguns cenários continuaram apresentando previsões questionáveis. Um exemplo é o caso de um indivíduo casado, com renda de apenas R$ 1.500,00 e que já possui um empréstimo ativo. Intuitivamente, esse perfil poderia representar um risco maior para concessão de crédito, mas o modelo ainda indicou aprovação, conforme demonstrado na imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*2lnPKURZAjOuqu-lLsVbnA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/859/1*gME0weSi_XnHx4-CtHATYA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/874/1*RL4UhxFuun2NPIL1pTW0sQ.png" /></figure><p>Esse comportamento evidencia uma limitação importante do experimento: a quantidade reduzida de registros disponíveis para treinamento. Como a floresta foi construída a partir de apenas oito exemplos, sua capacidade de identificar padrões mais complexos é naturalmente limitada. Em projetos reais, seria necessário um volume significativamente maior de dados para que o algoritmo pudesse aprender de forma mais consistente as características associadas à aprovação ou reprovação de empréstimos.</p><p>Ainda assim, quando fornecemos ao modelo uma combinação de atributos que já estava presente na base de treinamento, o comportamento foi exatamente o esperado. No exemplo do requerente com renda de R$ 10.000,00 e empréstimo ativo, registro utilizado durante o treinamento, o Random Forest corretamente classificou a solicitação como <strong>não aprovada</strong>, conforme apresentado na imagem a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/855/1*adxeGsk5WF7qL5kxL3U0xQ.png" /></figure><p>Esse resultado reforça um ponto importante sobre Machine Learning: a qualidade e a quantidade dos dados normalmente exercem mais influência nos resultados finais do que a escolha do algoritmo em si. Embora o Random Forest tenha demonstrado desempenho superior ao da árvore de decisão em diversos cenários, ambos os modelos continuam limitados pelas informações que receberam durante o treinamento. Quanto mais representativa for a base de dados, maiores serão as chances de o algoritmo produzir previsões consistentes e confiáveis.</p><p>Mas esse comportamento era esperado. Como o cenário utilizado fazia parte do conjunto de treinamento, o modelo deveria ser capaz de reproduzir corretamente a resposta observada durante o aprendizado. Ao analisar o resultado, minha primeira impressão foi de que poderia existir algum problema na implementação ou na configuração do algoritmo. Entretanto, após uma avaliação mais cuidadosa, ficou evidente que a origem desses resultados inconsistentes estava na própria base de dados utilizada.</p><p>A primeira base apresenta uma distribuição bastante desequilibrada, contendo uma quantidade significativamente maior de casos aprovados do que reprovados. Como consequência, o modelo tende a aprender que aprovar empréstimos é a resposta mais frequente e, portanto, mais provável. Em bases pequenas como esta, esse desequilíbrio influencia fortemente o comportamento do algoritmo e pode levá-lo a aprovar solicitações que, do ponto de vista do negócio, talvez devessem ser rejeitadas.</p><p>Isso não significa que o Random Forest falhou. Na verdade, ele está tomando decisões com base exatamente nas informações que recebeu durante o treinamento. O problema está na qualidade e representatividade dos dados disponíveis, que não fornecem exemplos suficientes de situações de reprovação para que o modelo consiga identificar esses padrões com maior precisão.</p><p>Para validar essa hipótese, vamos realizar um novo treinamento utilizando uma base mais ampla, contendo <strong>11 registros</strong>. O objetivo não é alterar os dados utilizados anteriormente nem modificar as regras de negócio implícitas no primeiro modelo, mas sim aumentar a quantidade de exemplos disponíveis para aprendizado, oferecendo à floresta uma visão mais equilibrada dos cenários de aprovação e reprovação.</p><p>Dessa forma, poderemos comparar os resultados obtidos pelos dois modelos e verificar se o aumento da quantidade de dados contribui para melhorar a capacidade de generalização das previsões. A nova base utilizada para o treinamento é apresentada a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*-Ao6UjhgkREQNijI1MjQIA.png" /></figure><p>Modelo treinado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/703/1*ELfTqTtl-EwayJXWI_bVjA.png" /></figure><p>Com a ampliação da base de treinamento para 11 registros, já foi possível observar uma melhora significativa nos resultados obtidos pelo modelo. As previsões passaram a refletir cenários mais próximos do esperado, demonstrando que mesmo um pequeno aumento na quantidade de exemplos pode impactar positivamente a capacidade de generalização do Random Forest.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/845/1*IoBhCGh_EYZ9WOJlhW_NeQ.png" /></figure><p>Para tornar a análise mais interessante, optei também por exibir as probabilidades retornadas pelo algoritmo por meio do método predict_proba(). Dessa forma, além da decisão final, podemos visualizar o nível de confiança do modelo em cada previsão.</p><p>Nos exemplos apresentados neste artigo, o primeiro valor corresponde à probabilidade de empréstimo negado, enquanto o segundo representa a probabilidade de empréstimo aprovado. Essa informação nos permite compreender melhor o raciocínio do modelo e identificar situações em que a decisão foi tomada com maior ou menor confiança.</p><p>Embora os resultados tenham evoluído em relação ao modelo anterior, ainda estamos longe de um cenário ideal. A principal limitação continua sendo a qualidade da base de dados utilizada no treinamento. Mesmo com o aumento para 11 registros, a distribuição dos dados permanece bastante inclinada para casos de aprovação de crédito.</p><p>Em outras palavras, o modelo continua sendo exposto a uma quantidade muito maior de exemplos positivos do que negativos. Consequentemente, ele tende a associar mais padrões ao perfil de aprovação, reduzindo sua capacidade de identificar situações que deveriam resultar em reprovação.</p><p>Esse comportamento fica evidente ao analisarmos as imagens a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/839/1*Lu1HztzlhTniYUgK8I6XoQ.png" /></figure><p>Observe que, em diversos cenários, o modelo apresenta probabilidades relativamente altas para aprovação, mesmo quando os dados sugerem um perfil mais arriscado. Isso ocorre porque a floresta está aprendendo a partir de uma base que ainda não representa adequadamente os casos de negativa.</p><p>Para corrigir esse viés, vamos realizar um novo ajuste na base de treinamento. Desta vez, além de aumentar a quantidade de registros, incluiremos mais exemplos de solicitações reprovadas. O objetivo é fornecer ao algoritmo uma amostra mais equilibrada entre aprovações e reprovações, permitindo que ele aprenda melhor as características associadas a cada decisão.</p><p>Esse tipo de intervenção é bastante comum em projetos reais de Machine Learning. Muitas vezes, melhorar a qualidade dos dados e balancear as classes produz ganhos mais significativos do que simplesmente trocar de algoritmo ou ajustar hiperparâmetros.</p><p>A seguir é apresentada a nova versão da base de dados, contendo registros adicionais e alguns cenários ajustados para representar melhor situações de reprovação de crédito:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*UBXe0DysGQkwo4reDT_1hg.png" /></figure><p>Após incluir os novos registros e treinar novamente o modelo, repetimos os testes utilizando os mesmos cenários anteriores.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/1*je4f4tE3p9XL4tl4zi-ChA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/853/1*xK25io5j3wUFMjWlRvDMWg.png" /></figure><p>Os resultados mostraram probabilidades diferentes das obtidas anteriormente, mesmo sem alterar o algoritmo. Isso reforça uma das principais lições do Machine Learning:</p><blockquote><strong>A qualidade dos dados influencia diretamente a qualidade das previsões</strong>.</blockquote><p>Também foi possível observar diferenças entre as respostas da Árvore de Decisão e do Random Forest. Enquanto a árvore toma suas decisões com base em uma única estrutura, o Random Forest combina a análise de várias árvores, tornando as previsões mais robustas.</p><p>Mesmo utilizando uma base pequena, com apenas oito registros, o Random Forest já demonstrou sua principal vantagem: reduzir os efeitos do overfitting observados na árvore de decisão isolada. Ao considerar múltiplas árvores e agregar seus resultados, a floresta conseguiu produzir respostas mais equilibradas e com maior capacidade de generalização.</p><p>Embora este experimento utilize uma base simplificada e fictícia, ele evidencia dois conceitos fundamentais: a importância de dados bem distribuídos e o poder do Random Forest como evolução natural das árvores de decisão para problemas de classificação.</p><h3>Para Fechar</h3><p>O Random Forest é um algoritmo versátil que pode ser utilizado tanto em problemas de <strong>classificação</strong> quanto de <strong>regressão</strong>. Em problemas de classificação, seu objetivo é determinar a qual categoria um novo registro pertence. Alguns exemplos são a identificação de spam, a aprovação de crédito ou a previsão de cancelamento de assinaturas.</p><p>Nesse cenário, cada árvore da floresta realiza sua própria previsão e a resposta final é definida pela opção mais votada. Por exemplo, se um cliente casado, com renda de R$ 15.000 e sem empréstimos ativos receber aprovação em cinco árvores e reprovação em duas, o resultado final será a aprovação do crédito.</p><p>Já nos problemas de regressão, o objetivo é prever valores numéricos contínuos, como preços de imóveis, consumo de energia ou faturamento futuro. Nesse caso não existe votação: cada árvore produz um valor e o resultado final corresponde à média das previsões geradas pela floresta.</p><p>Um ponto importante é que cada árvore do Random Forest não representa apenas uma regra simples. Cada uma delas é uma árvore de decisão completa, contendo diversos níveis, divisões e nós internos. A floresta nada mais é do que um conjunto dessas árvores trabalhando em paralelo, tornando o modelo mais robusto e menos suscetível ao overfitting.</p><p>Como todo algoritmo, o Random Forest também possui algumas limitações:</p><ul><li>Menor interpretabilidade quando comparado a uma única árvore de decisão;</li><li>Maior consumo de memória;</li><li>Tempo de treinamento mais elevado;</li><li>Possível perda de desempenho em bases extremamente esparsas ou de alta dimensionalidade quando comparado a algoritmos especializados.</li></ul><p>Ainda assim, seu sucesso está baseado em uma ideia simples: <strong>várias opiniões independentes tendem a produzir decisões mais confiáveis do que uma única opinião</strong>.</p><p>Ao longo deste artigo vimos que a combinação de <strong>Bootstrap Sampling</strong>, <strong>seleção aleatória de atributos</strong> e <strong>agregação das respostas das árvores</strong> permite construir modelos mais estáveis e com maior capacidade de generalização. Também observamos, por meio dos experimentos realizados, que a qualidade dos dados possui impacto direto nos resultados obtidos, muitas vezes sendo mais importante do que a própria escolha do algoritmo.</p><p>Por esse motivo, o Random Forest continua sendo uma das técnicas mais utilizadas em projetos de Ciência de Dados e Machine Learning. Ele oferece um excelente equilíbrio entre simplicidade, desempenho e robustez, servindo tanto como solução final para muitos problemas quanto como ponto de partida para a construção de modelos mais sofisticados.</p><p>Mais importante do que decorar conceitos ou parâmetros é compreender a principal lição deste experimento: <strong>bons modelos começam com bons dados</strong>. Afinal, mesmo a floresta mais inteligente não consegue encontrar caminhos que não existem nos dados que recebeu para aprender.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a9556c9f2fb8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[UM POUCO SOBRE ÁRVORE DE DECISÃO]]></title>
            <link>https://medium.com/@willian.bogler/um-pouco-sobre-%C3%A1rvore-de-decis%C3%A3o-8c0b15a43e7d?source=rss-25cb2867be40------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c0b15a43e7d</guid>
            <dc:creator><![CDATA[Willian Bogler]]></dc:creator>
            <pubDate>Sat, 07 Nov 2026 20:46:35 GMT</pubDate>
            <atom:updated>2026-11-07T20:46:35.147Z</atom:updated>
            <content:encoded><![CDATA[<p>Recentemente, precisei rever alguns conceitos fundamentais para a minha pesquisa de doutorado, e um deles foi a Árvore de Decisão. Como a ideia aqui é compartilhar conhecimento de forma prática e rápida, não vou encher este texto de cálculos ou detalhamentos matemáticos exaustivos, pois isso seria um artigo muito longo e esse não é meu objetivo.</p><blockquote><strong>Pare e pense: como você toma uma decisão no seu dia a dia?</strong></blockquote><p>Às vezes, agimos por puro impulso ou sentimentalismo. Outras vezes, fazemos uma análise rápida do tipo “se eu fizer isso, recebo aquilo”. Porém, existem aquelas decisões mais elaboradas, nas quais precisamos avaliar diferentes cenários, descartar alternativas ao longo do caminho e, só então, chegar a uma conclusão ou ação.</p><p>É exatamente aí que uma Árvore de Decisão brilha. O papel dela é pegar um problema complexo e fatiá-lo em várias perguntas menores. Conforme essas pequenas perguntas são respondidas, o caminho vai se afunilando até chegarmos ao resultado esperado.</p><p><strong>Vamos explorar um exemplo bem prático: decidir se vamos ou não a um show.</strong></p><p>É claro que cada pessoa tem seus próprios critérios, mas a minha lógica de decisão (minha árvore particular) funcionaria mais ou menos assim:</p><ul><li><strong>Tem show a menos de 500km de onde eu moro?</strong></li></ul><p><em>Sim:</em> Passo para a próxima pergunta.<br><em>Não:</em> Não vou.</p><ul><li><strong>O show é de rock?</strong></li></ul><p><em>Sim:</em> Passo para a próxima pergunta.<br><em>Não:</em> Não vou.</p><ul><li><strong>O ingresso custa menos de 100 reais?</strong></li></ul><p><em>Sim:</em> Partiu show!<br><em>Não:</em> Não vou.</p><p>Esse é um exemplo simples (e que poderia ter inúmeras variações), mas com ele já dá para compreender a essência de como o algoritmo funciona. Temos um desafio inicial que é quebrado em perguntas menores; elas reduzem as possibilidades passo a passo até o veredito final.</p><p>Visualmente, o que teríamos nessa situação é a seguinte estrutura:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/1*8ub8vFHGMZS2NDx8rScLYw.png" /></figure><h3><strong>A Anatomia da Árvore: Raiz, Nós e Folhas</strong></h3><p>Agora, vamos entender como essa estrutura é montada na prática.</p><p>Aquela nossa primeira pergunta (<em>“Tem show a menos de 500km?”</em>) é o que chamamos de <strong>Nó Raiz</strong>. É o ponto de partida de onde tudo se ramifica. As perguntas que vêm na sequência (<em>“O show é de rock?”</em>, <em>“Custa menos de R$ 100?”</em>) são os <strong>Nós Internos</strong>. Já as extremidades da árvore, ou seja, as decisões finais (<em>“Vou”</em> ou <em>“Não vou”</em>), recebem o nome de <strong>Folhas</strong>.</p><p>Resumindo o nosso cenário: temos 3 nós de decisão (contando com a raiz) e 4 folhas (os destinos finais).</p><p>Dependendo da complexidade do problema, essas árvores podem crescer bastante. Por isso, usamos três métricas principais para medir o tamanho delas:</p><ul><li><strong>Profundidade (ou Altura):</strong> É o número máximo de “passos” (níveis) da raiz até a folha mais distante. No nosso exemplo, o caminho mais longo te obriga a passar por 3 perguntas (Distância ➔ Gênero ➔ Preço) para chegar ao veredito. Logo, a nossa profundidade máxima é <strong>3</strong>.</li><li><strong>Tamanho Absoluto (Total de Nós):</strong> É a soma de todos os “bloquinhos” da estrutura, sem exceção. Somando 1 raiz + 2 nós internos + 4 folhas, a árvore tem um tamanho absoluto de <strong>7</strong>.</li><li><strong>Largura (Total de Folhas):</strong> Indica a quantidade de desfechos finais possíveis. Aqui, nossa largura é <strong>4</strong>.</li></ul><p><strong>Mas como o modelo toma essas decisões na vida real?</strong></p><p>Talvez, neste exato momento, você tenha pensado: <em>“Ah, em programação é só fazer um monte de comandos IF e pronto&quot;</em>. Ou então: <em>&quot;Precisamos de dados!&quot;</em>.</p><p>Se você pensou nos famosos IFs, acertou em partes. Para um problema simples como o do show, escrever regras na mão resolveria perfeitamente. Porém, conforme o nível de complexidade aumenta, mapear manualmente todas as possibilidades se torna humanamente inviável.</p><p>É por isso que recorremos à segunda opção: <strong>os dados</strong>. Em vez de programarmos as regras na mão, nós fornecemos um conjunto de dados históricos para que o próprio modelo aprenda e crie a árvore sozinho.</p><p>Para o nosso exemplo do show, esse histórico de dados poderia ter uma estrutura parecida com esta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*TItb0_ZpVY79tCa_F8g6MQ.png" /></figure><p>Se você olhar com atenção para a tabela acima, vai notar que temos as nossas variáveis de análise e o resultado final. Mas temos também um clássico problema do mundo real: <strong>a falta de padronização e o uso de textos soltos (dados qualitativos).</strong></p><p>Repare que temos “Rock” com letra maiúscula, “rock” minúsculo, “sAmba” com erro de digitação, além de respostas como “ir”, “não” e “não ir”. Para nós, humanos, é fácil entender o contexto, mas para uma máquina, isso é uma verdadeira bagunça.</p><p>A regra de ouro em Machine Learning é: <strong>um bom modelo precisa de bons dados</strong>. E como os algoritmos lidam muito melhor com números do que com palavras, precisamos fazer um tratamento nessa base.</p><p>No nosso cenário, a solução é simples: podemos substituir tudo o que for “Rock” por <strong>1</strong> e qualquer outro gênero por <strong>0</strong>. O mesmo princípio se aplica à coluna de decisão, onde respostas positivas (“ir”) viram <strong>1</strong> e as negativas (“não”, “não ir”) viram <strong>0</strong>.</p><p>Após aplicar essa padronização matemática, nossa base de dados enxuta e pronta para treinar o modelo ficaria com esta cara:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/797/1*6B4-zGNdIKLLdFJIJTr33w.png" /></figure><p>É claro que, no nosso exemplo, simplificamos as coisas focando em apenas um gênero musical (Rock = 1, Resto = 0). No mundo real, se tivéssemos vários estilos diferentes na jogada, precisaríamos transformar todas essas categorias em representações numéricas mais abrangentes.</p><p>E para que a gente (meros humanos) não nos percamos no meio de tanto número, seria indispensável criar um dicionário de dados (ou glossário) para traduzir o que cada código significa.</p><p>Mas calma! Mergulhar fundo nas técnicas avançadas de análise e tratamento de dados renderia um artigo inteiro só para isso, e não é o nosso foco neste texto.</p><p>O grande ponto de toda essa etapa de preparação é um só: <strong>é somente em posse de uma base de dados limpa, padronizada e bem estruturada que finalmente damos a largada para construir a nossa Árvore de Decisão.</strong></p><h3>Colocando a Mão na Massa: Montando a Árvore de Decisão</h3><p>Até é possível calcular as probabilidades de cada nó manualmente, mas a ideia aqui é descomplicar. Por isso, vamos explorar ferramentas prontas que fazem o trabalho pesado por nós. Para isso vamos utilizar a linguagem de programação Python.</p><p>Para facilitar o entendimento, vamos criar um novo cenário fictício: um modelo de <strong>aprovação de crédito</strong>. O objetivo é prever se um empréstimo deve ser liberado (ou não) para uma pessoa, baseando-se no seu estado civil, renda total e se ela já possui algum empréstimo ativo.</p><p>Nossa base de dados inicial tem a seguinte estrutura:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/695/1*hyRiObBkGAbYPM59yK0LYA.png" /></figure><p>Para dar vida a essa árvore e deixar o algoritmo redondinho para uso, vamos importar quatro bibliotecas clássicas do ecossistema Python:</p><ul><li><strong>Pandas:</strong> É o nosso “Excel” do Python. Ele é essencial para ler, estruturar e manipular a nossa base de dados.</li><li><strong>Scikit-Learn (Sklearn):</strong> A verdadeira estrela do show. É a principal biblioteca de Machine Learning, onde o algoritmo de Árvore de Decisão já está pronto para ser treinado.</li><li><strong>Matplotlib:</strong> A nossa ferramenta gráfica. Com ela, vamos “desenhar” a árvore de decisão para visualizarmos exatamente o caminho que o modelo está fazendo.</li><li><strong>Joblib:</strong> Serve para exportar e salvar o nosso modelo treinado. Afinal, ninguém quer ter o retrabalho de treinar o algoritmo do zero toda vez que for usá-lo.</li></ul><p>Como vimos nos exemplos anteriores, a primeira ação obrigatória é sempre o <strong>tratamento dos dados</strong>.</p><p>Repare que na nossa tabela atual, a coluna estado_civil ainda possui valores qualitativos (&quot;solteiro&quot; e &quot;casado&quot;). O computador precisa de números, então vamos aplicar aquela mesma lógica de conversão: <strong>casado vira 1</strong> e <strong>solteiro vira 0</strong>.</p><p>Para carregar os dados e fazer essa substituição, utilizamos o primeiro bloco de código do nosso script:</p><pre>import pandas as pd<br><br>#leitura e tratamento dos dados<br><br>#leitura do arquivo csv com os dados<br>df = pd.read_csv(&#39;./dados.csv, sep=&#39;;&#39;)<br><br>#Exibi as colunas e seus informação<br>print(df.head())<br>print(df.info())<br><br>#exclui o id, pois não tem necessidade dessa informação<br>df = df.drop(&#39;id&#39;, axis=1)<br><br>#convertendo o estado_civil para número<br>df[&#39;estado_civil&#39;] = df[&#39;estado_civil&#39;].map({&#39;solteiro&#39;: 0, &#39;casado&#39;: 1})<br><br>#agora sim, separamos quem é variável (X) e quem é a resposta (y)<br>X = df.drop(&#39;emprestar&#39;, axis=1)<br>y = df[&#39;emprestar&#39;]<br><br>#exibimos como ficou nosso conjunto de dados<br>print(df.head())</pre><p>Na imagem abaixo temos o resultado da nossa nova tabela, a qual está com os dados estruturados e prontos para o processamento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/659/1*tWpieYEV0SuQbS9_YBOuog.png" /></figure><p>O próximo bloco de código é um exemplo de como usamos as ferramentas para a construção da árvore de decisão bem como exibição de sua estrutura.</p><pre># Processamento na arvore de decisão<br><br>from sklearn.tree import DecisionTreeClassifier, plot_tree<br>import matplotlib.pyplot as plt<br><br>#escolhemos o método de classificação denominado Gini<br>modelo_arvore = DecisionTreeClassifier(criterion=&#39;gini&#39;)<br>modelo_arvore.fit(X, y)<br><br>plt.figure(figsize=(10, 8))<br><br>#a função plot_tree desenha os nós, mostrando o Gini e a regra de quebra<br>plot_tree(<br>    modelo_arvore, <br>    feature_names=X.columns,              <br>    class_names=[&#39;Não Emprestar&#39;, &#39;Emprestar&#39;], <br>    filled=True,                          <br>    rounded=True                          <br>)<br><br>#mostra o gráfico na tela<br>plt.show()</pre><p>Executando esse código, a mágica acontece e temos a nossa Árvore de Decisão desenhada na tela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*dPMiIKGgLK4xnrppvbuAuA.png" /></figure><p>Não é olhando para essa imagem que o sistema vai tomar decisões no dia a dia. Essa representação visual serve apenas para nós, humanos, auditarmos a estrutura e entendermos a matemática que o algoritmo fez por trás dos panos.</p><p>Um dos pontos mais importantes de se observar nessa imagem é o valor chamado de <strong>Gini</strong> (ou Impureza de Gini). De forma bem simples, o Gini mede o grau de “dúvida” ou “mistura” das informações naquela etapa.</p><p>Repare na imagem: toda vez que o valor do Gini for igual a <strong>zero</strong>, significa que o modelo tem 100% de certeza sobre o resultado daquela ramificação, ou seja, chegamos a uma <strong>Folha</strong>. Por outro lado, se o valor do Gini for maior que zero, significa que ainda há incerteza misturada, indicando que estamos diante de um <strong>Nó</strong> que precisará ser recalculado e ramificado novamente.</p><p>Agora que já desvendamos a estrutura visual da nossa Árvore de Decisão, chegou a hora de colocá-la para trabalhar no mundo real.</p><p>Aqui vai uma regra de ouro de Machine Learning em produção: <strong>nós não retreinamos o algoritmo do zero a cada nova requisição.</strong> Fazer isso a cada pedido de empréstimo seria um desperdício absurdo de tempo e processamento.</p><p>O que fazemos na prática é “congelar” esse aprendizado. Nós <strong>salvamos o modelo já treinado</strong> (geralmente exportando em um arquivo com a extensão .pkl) e, posteriormente, embarcamos esse arquivo no sistema principal da aplicação. Assim, o sistema em produção só terá o trabalho de receber os dados do novo cliente, passá-los pelas regras da árvore que já está pronta e cuspir a decisão final.</p><p>Para exportar o nosso modelo e transformá-lo nesse arquivo portátil, utilizamos o comando dump da biblioteca joblib.</p><p>Esse é o nosso terceiro bloco de código:</p><pre>#exportando o modelo<br><br>import joblib<br><br>joblib.dump(modelo_arvore, &#39;emprestimo1.pkl&#39;)</pre><p>Com o nosso modelo devidamente treinado e salvo, chegou a hora da verdade: colocá-lo para rodar na prática.</p><p>Vamos simular um sistema simples fazendo o papel da nossa aplicação final. A missão desse script é bem direta: ele vai coletar as informações de um novo cliente, estruturar os dados no formato exato que a máquina entende e enviar tudo para o algoritmo bater o martelo, afinal, esse empréstimo será aprovado ou reprovado?</p><pre>import joblib<br>import pandas as pd<br><br>#carrega o modelo já treinado<br>modelo_producao = joblib.load(&#39;emprestimo1.pkl&#39;)<br><br>print(&quot;modelo de esprestimo&quot;)<br><br>estado_civil = input(&quot;Digite 0 para solteiro e 1 para casado: &quot;)<br>renda_total = input(&quot;Digite a renda total: &quot;)<br>emprestimo = input(&quot;Digite 0 para não tem emprestimo e 1 para caso tenha emprestimo: &quot;)<br><br>#dados de cliente salvos<br>dados_cliente = [[estado_civil, renda_total, emprestimo]]<br><br>#delimitacao das colunas<br>colunas = [&#39;estado_civil&#39;, &#39;renda_total&#39;, &#39;tem_emprestimo&#39;]<br>#Estruturação dos nossos dados em coluna e seus valores<br>dados_formatados = pd.DataFrame(dados_cliente, columns=colunas)<br><br>#chamamos o modelo<br>resultado = modelo_producao.predict(dados_formatados)<br><br>if resultado[0] == 1:<br>    print(&quot;Emprestimo aprovado&quot;)<br>else:<br>    print(&quot;Emprestimo negado&quot;)</pre><p>Rodando o script e inserindo os dados solicitados o nosso modelo conseguiu atender às especificações e determinar se o pedido de emprestimo foi aprovado ou não.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*xv_4pcAi88ED1PM-Vs809g.png" /></figure><p>Porém, ao testar mais o algoritmo, esbarrei em um detalhe interessante. Me deparei com um comportamento que é super comum em árvores de decisão quando são treinadas com um volume de dados tão pequeno e limitado como esse nosso exemplo.</p><p>Para você entender exatamente o que aconteceu, dá uma olhada nos parâmetros que enviei para o modelo e no resultado inesperado que ele me devolveu:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*dj_Y1cVuM6SIV10N8mYbOg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*28jvW5rd0XscLN1InLZnRA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*BMpYITQ8UzusFZvoaPFixw.png" /></figure><p>Pela nossa lógica, esse novo empréstimo deveria ser aprovado. Porém, devido ao tamanho minúsculo da nossa base de dados, acabamos de esbarrar em um problema clássico de Machine Learning: <strong>o viés de dados</strong>, que gerou o que podemos chamar de uma generalização “burra”.</p><p>O modelo é, por natureza, cego para o mundo real; ele só sabe aquilo que ensinamos a ele naquelas 8 linhas. Se você analisar a nossa tabela original, vai notar que a única pessoa com uma renda alta (R$ 10.000) teve o empréstimo negado. O que a Árvore de Decisão fez? Ela calculou o melhor ponto de corte e cravou a primeiríssima regra do nosso Nó Raiz como: renda_total &lt;=8750.0.</p><p>Como não havia absolutamente nenhum exemplo na base com alguém ganhando mais de R$ 8.750 que tivesse sido aprovado, a árvore assumiu uma verdade absoluta e perigosa: <strong>renda alta = calote.</strong></p><p>A partir daí, qualquer valor acima de 8.750 cai no lado “Falso” da regra e vai direto para a folha de negação. Para a matemática do Gini, o cliente que ganha 14k é estatisticamente idêntico àquele que ganha 10k e foi negado. O modelo simplesmente não tem o contexto do mundo real para saber que 14k é um salário excelente.</p><p><strong>Diante disso, uma pergunta natural surge: como resolvemos essa situação?</strong></p><blockquote><strong>O algoritmo não está errado, os dados é que são insuficientes.</strong></blockquote><p>Para a árvore “aprender” que pessoas que ganham 14k podem, sim, ser ótimos pagadores, precisamos alimentar nossa tabela adicionando linhas com perfis de alta renda sendo aprovados.</p><p>Assim, ao treinarmos o modelo novamente, o cálculo do Gini vai perceber que uma renda_total &gt; 8750 já não leva a uma certeza absoluta (Gini 0.0). Isso forçará a árvore a se adaptar, criando um novo Nó para fazer perguntas mais sofisticadas, como por exemplo: <em>&quot;Ok, a renda é alta, mas ele já tem outros empréstimos ativos?&quot;</em>, para só então tomar a decisão final.</p><p>Ajustei o quadro dos dados, o qual ficou estruturado como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*MEfemsmyladru9sTLP0Flg.png" /></figure><p>A estrutura da árvore mudou também:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*RiziIdVLx4jnIM8ykEKcow.png" /></figure><p>E esse foi o resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*82JZH6w7oUlLFTrFe6P4rg.png" /></figure><h3><strong>O algoritmo é um espelho dos dados</strong></h3><p>Para fechar o raciocínio, a Árvore de Decisão é uma ferramenta fantástica justamente por ser muito intuitiva. Ela imita a forma como nós mesmos pensamos, fatiando um problema complexo em pequenas perguntas simples de resolver, até chegar a uma resposta final.</p><p>Mas, como vimos no nosso teste do empréstimo, a tecnologia não faz milagres sozinha. A grande lição que fica não é sobre qual biblioteca do Python você deve usar, mas sim entender a regra número um do aprendizado de máquina: <strong>o coração de qualquer modelo de Machine Learning está na qualidade e na diversidade dos dados</strong>.</p><p>Um algoritmo de ponta treinado com dados limitados ou enviesados só vai tomar decisões brilhantemente erradas. Ele não tem “bom senso” ou intuição do mundo real; ele é apenas um reflexo exato daquilo que você o ensinou.</p><p>Revisitar esses conceitos básicos tem sido um passo fundamental na minha pesquisa de doutorado, nesta atividade eu reforcei em minha mente a necessidade de olhar com muito mais rigor para a base de dados, pois só terei uma resposta coerente e boa se a minha base seguir os mesmos princípios.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c0b15a43e7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>