<?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 Vivian Mayumi Yamassaki on Medium]]></title>
        <description><![CDATA[Stories by Vivian Mayumi Yamassaki on Medium]]></description>
        <link>https://medium.com/@vivianyamassaki?source=rss-e4ac86a38a49------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dVlQGxanGOg6tW1wMRQXTQ.png</url>
            <title>Stories by Vivian Mayumi Yamassaki on Medium</title>
            <link>https://medium.com/@vivianyamassaki?source=rss-e4ac86a38a49------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 10:36:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vivianyamassaki/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[Terminei a modelagem, e agora? — Parte I]]></title>
            <link>https://medium.com/creditas-tech/terminei-a-modelagem-e-agora-parte-i-604232bb5114?source=rss-e4ac86a38a49------2</link>
            <guid isPermaLink="false">https://medium.com/p/604232bb5114</guid>
            <category><![CDATA[creditasbr]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[feature-engineering]]></category>
            <category><![CDATA[deploy]]></category>
            <dc:creator><![CDATA[Vivian Mayumi Yamassaki]]></dc:creator>
            <pubDate>Thu, 18 Nov 2021 19:27:33 GMT</pubDate>
            <atom:updated>2021-11-24T19:52:46.690Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/923/1*vvaTdHLczgrAIpax9B0Dkg.png" /></figure><h3>Terminei a modelagem, e agora? — Parte I</h3><p>Com o <a href="https://g1.globo.com/economia/concursos-e-emprego/noticia/2021/07/05/demanda-por-profissionais-da-area-de-dados-cresce-quase-500percent-salarios-chegam-a-r-22-mil.ghtml">aumento do número de vagas</a> para profissionais nas áreas de Ciência e Engenharia de Dados, ocorreu também um aumento da quantidade de cursos de Data Science e Machine Learning disponíveis no mercado.</p><p>No entanto, muitos cursos da área não abordam todas as etapas de um fluxo de Data Science; focando na análise exploratória, feature engineering, modelagem e vão até a avaliação do modelo. Assim, fica faltando uma etapa muito importante: <strong>como colocar o modelo em produção e que cuidados devemos ter para que essa etapa seja feita de maneira mais fácil e da melhor forma possível</strong>.</p><p>Por conta disso, antes de entrar na Creditas, eu tinha muitas dúvidas sobre o que deveria fazer para “tirar” o modelo e todo o pré-processamento de dados que eu tinha feito em um notebook para que ele ficasse disponível e pudesse fazer predições em tempo real para dados ainda não vistos e que pudesse, de fato, ser utilizado e gerar valor.</p><p>Como é uma dúvida que pode surgir para outras pessoas, eu e o <a href="https://medium.com/@andre.oliveira_17523">André Oliveira</a>, respectivamente dos times de Data Science (DS) e Machine Learning Engineering (MLE) da Creditas, resolvemos palestrar sobre isso na <a href="https://youtu.be/faXgMxy6NUw">Python Brasil 2021</a>. Aqui na Creditas, os times de DS e MLE trabalham juntos para que possamos colocar nossos modelos em produção, de modo que eles possam ser utilizados nas tomadas de decisões.</p><p>Além dessa palestra, nós decidimos escrever este artigo também para compartilhar, com mais detalhes, algumas das práticas que temos nos nossos times para colocar os modelos de Data Science em produção e também algumas ideias de como você pode fazer o mesmo com os seus modelos.</p><p>Para podermos explicar essas ideias e práticas, optamos por utilizar o famoso conjunto de dados da <a href="https://www.kaggle.com/c/titanic/">competição do Titanic</a> presente no Kaggle. Para simplificar, decidimos construir um modelo utilizando somente as variáveis: <em>Pclass</em>, <em>Age</em>, <em>Fare</em> e <em>Sex</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zJHiaXs5eLHlaJyC" /><figcaption>Exemplos iniciais do conjunto de treinamento do Titanic, retirado do Kaggle</figcaption></figure><p>Com esse conjunto de dados disponível no Kaggle, eu e o André treinamos um modelo bem simples utilizando uma Regressão Logística para podermos exemplificar a questão da implantação/deploy de um modelo com algum exemplo prático. Nós disponibilizamos todos os códigos que mostraremos ao longo do artigo <a href="https://github.com/vivianyamassaki/kaggle_titanic_deploy">neste repositório</a> do Github.</p><p>Agora que já demos essa introdução e temos nossos dados, vamos começar!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/242/0*dvSYhsEDGM_FNfLb" /><figcaption>Gif do João Kléber escrito “Paraê! Paraê!” retirado <a href="https://tenor.com/view/jo%C3%A3o-kleber-stop-thats-enough-gif-11732101">daqui</a></figcaption></figure><p>Mas…Antes de começarmos a implantação em si, é interessante mencionarmos alguns cuidados prévios que precisamos ter nas etapas de Feature Engineering e Modelagem! Isso porque ao tomarmos esses cuidados, a etapa de implantação do modelo acaba sendo facilitada.</p><p>Antes de focarmos na modelagem e a produtização de modelos em si, nas próximas seções vamos falar sobre como podemos fazer a feature engineering de modo que funcione tanto durante a pesquisa, quando estamos treinando e construindo um modelo, quanto na etapa de produção, quando o modelo será utilizado para gerar predições para dados ainda não vistos.</p><h3>Cuidados com a Feature Engineering</h3><p>Com relação à etapa de Feature Engineering, uma coisa que me fazia ficar muito em dúvida era sobre as transformações dos dados que havíamos feito em pesquisa e como as faríamos em produção. Imagine as três situações abaixo:</p><ul><li><em>One-hot encoding</em>: suponha que, no conjunto de treinamento, a categoria “escolaridade” só tinha os valores “Ensino Médio” e “Ensino Superior”, então seu modelo só aprendeu sobre eles. O que aconteceria se, em produção, seu modelo recebesse como exemplo um caso em que a escolaridade é “Ensino Fundamental”?</li><li><em>Tratamento de valores faltantes</em>: imagine que você fez um tratamento de valores faltantes para a variável “idade” e que vai usar a mediana para isso. No seu conjunto de treinamento você calculou que a mediana é de 35 anos. Como você faria para utilizar esse valor em produção caso você tenha que fazer uma predição para um exemplo que não tenha a idade?</li><li><em>Normalização de dados</em>: por fim, suponha que você aplicou algumas técnicas de transformação de variáveis numéricas como o <a href="https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html">StandardScaler</a> e <a href="https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html">MinMaxScaler</a> para fazer a normalização de dados. Como você faria para que essas normalizações também fossem realizadas em produção?</li></ul><p>Abaixo, vamos explorar cada um desses tratamentos e como poderíamos fazê-los para que funcionem em produção também.</p><h4>One-hot encoding</h4><p>Para a utilização de variáveis categóricas, às vezes precisamos aplicar técnicas como o <a href="https://towardsdatascience.com/categorical-encoding-using-label-encoding-and-one-hot-encoder-911ef77fb5bd">one-hot encoding</a> para que elas possam ser utilizadas pelos modelos (principalmente para os algoritmos já existentes no <a href="https://scikit-learn.org/stable/">Scikit-learn</a> que não trabalham com tipos categóricos de maneira direta).</p><p>Para que essa transformação também possa ser utilizada em produção, precisamos definir o que queremos que aconteça quando o modelo for requisitado para fazer uma predição para um exemplo que tem um valor diferente do que ele viu quando foi treinado, como no exemplo que demos anteriormente. No caso de um novo valor de escolaridade, vamos querer que o modelo retorne um erro ou que ele retorne uma predição?</p><p>Considerando a segunda opção, podemos usar o <a href="https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html">OneHotEncoder</a> presente no Scikit-learn para aplicar a técnica e fazer um tratamento que lide com esse problema de um valor novo em produção, conforme podemos ver no trecho de código abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/34d030a11f76ae8e087d131f117739fa/href">https://medium.com/media/34d030a11f76ae8e087d131f117739fa/href</a></iframe><p>Para os casos em que não queremos que o modelo retorne um erro quando recebe um valor categórico novo em produção, devemos deixar o parâmetro <em>handle_unknown</em> como “ignore”. Quando o deixamos assim, se recebermos um valor não visto pelo modelo quando ele foi treinado para uma determinada variável categórica, todos os campos nas colunas originadas pelo one-hot encoding a partir dessa variável ficarão como 0.</p><p><strong>Uma outra coisa muito importante de se fazer pensando que o modelo irá para produção e precisará das transformações feitas na feature engineering é salvá-las de alguma forma!</strong> Por exemplo, poderíamos salvar o OneHotEncoder que criamos com base nos dados do conjunto de treinamento como um objeto <a href="https://docs.python.org/pt-br/3/library/pickle.html">Pickle</a> para que possamos utilizá-lo em produção também. Abaixo, temos um trecho de código mostrando como o salvamos:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a855e82e88c2a18e2ce345c180f3a428/href">https://medium.com/media/a855e82e88c2a18e2ce345c180f3a428/href</a></iframe><p>No código acima, estamos salvando o OneHotEncoder criado no pré-processamento dos dados na pasta <em>models</em> e com o nome “ohe.pkl”. Não se esqueça disso porque daqui a pouco vamos voltar a falar desse arquivo 😉</p><h4>Tratamento de valores faltantes</h4><p>Para os casos de tratamento de valores faltantes em produção, não podemos simplesmente fazer algo como o preenchimento de valores faltantes abaixo:</p><pre>median_age = df[&#39;Age&#39;].median()</pre><pre>df[&#39;Age&#39;] = df[&#39;Age&#39;].fillna(median_age)</pre><p>Para o conjunto de treinamento, esse tratamento irá funcionar e fará sentido, uma vez ele calculará a mediana com base nos dados que, de fato, serão utilizados pelo modelo para aprender e generalizar um padrão. Mas, em produção, você terá apenas um exemplo com valor faltante ou, mesmo que você esteja fazendo predições em lote, não deveria calcular a mediana com base em valores não vistos pelo seu modelo, visto que possivelmente não terão a mesma mediana do seu conjunto de treinamento.</p><p>Assim, quando queremos fazer o preenchimento de valores faltantes, devemos salvar esses valores de alguma forma. No exemplo abaixo, salvamos uma lista contendo tuplas com o nome da variável e o valor que deve ser utilizado em casos de valores faltantes, para que esses mesmos valores sejam utilizados tanto em pesquisa quanto em produção:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1800a94972b4573983d1730cb9ab79fc/href">https://medium.com/media/1800a94972b4573983d1730cb9ab79fc/href</a></iframe><p>Uma outra alternativa seria criar um <a href="https://scikit-learn.org/stable/modules/classes.html#module-sklearn.impute">Imputer</a> e utilizá-lo para fazer essas transformações. Com ele, você pode indicar qual estratégia usará para preencher os valores faltantes (substituindo pela média, mediana ou moda). Nesse caso, assim como fizemos com o one-hot encoding, você precisa salvá-lo para que possamos utilizá-lo em produção! Um exemplo da utilização do <a href="https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer">SimpleImputer</a> é dado abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b81e6b0e67559922c2f3066b8f55f3a5/href">https://medium.com/media/b81e6b0e67559922c2f3066b8f55f3a5/href</a></iframe><p>No código acima, estamos salvando o SimpleImputer criado na pasta “models” e com o nome “imputer.pkl”. É interessante notar que, quando o criamos, passamos o valor “median” para o parâmetro “strategy”. Isso foi necessário porque queríamos que a variável <em>Age</em> tivesse os valores faltantes preenchidos com a mediana e, caso não passássemos nada, o padrão é que o SimpleImputer preencha os valores faltantes com média.</p><h4>Normalização de dados</h4><p>Para os casos em que precisamos ou queremos aplicar a normalização de dados, também precisamos fazer algo parecido com o que fizemos com o one-hot encoding e o imputer: salvar o scaler para que ele possa posteriormente ser utilizado também em produção. Abaixo, temos um exemplo de utilização do <a href="https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html">MinMaxScaler</a> para fazer a normalização dos dados numéricos:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/97ef836bbd1d28d90bdc1bd9188cdef2/href">https://medium.com/media/97ef836bbd1d28d90bdc1bd9188cdef2/href</a></iframe><p>Acima, nós também salvamos o <em>scaler </em>que geramos para fazer a normalização dos dados das variáveis numéricas existentes no conjunto de dados. Aqui também é necessário salvar o <em>scaler </em>porque ele utilizou os valores mínimos e máximos de cada variável numérica do conjunto de treinamento para as reescalar.</p><p>Em produção, assim como ocorreu com o preenchimento de valores faltantes, não podemos utilizar as informações para exemplos ainda não vistos pelo modelo, uma vez que não necessariamente eles terão os mesmos valores mínimos e máximos que existiam no conjunto de treinamento e que foi utilizado para fazer a normalização dos dados que foram fornecidos para o modelo ser treinado.</p><h4>Utilizando um pipeline para a feature engineering</h4><p>Agora que já sabemos como tratar nossos dados na feature engineering para que isso funcione em produção também, temos mais uma coisa sobre a feature engineering que pode facilitar ainda mais a produtização de nossos modelos: a utilização de <a href="https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html">pipelines</a>.</p><p>Para este artigo não ficar muito grande, deixamos o <a href="https://medium.com/data-hackers/como-usar-pipelines-no-scikit-learn-1398a4cc6ae9">link</a> de outro artigo que contém uma explicação um pouco mais aprofundada sobre o uso de pipelines caso você queira conferir depois. Mas basicamente o Pipeline é uma classe do Scikit-learn que permite que as transformações da feature engineering sejam feitas na sequência uma das outras. Para isso, cada uma das transformações é feita em scripts separados e terá métodos de <em>fit</em> e <em>transform</em>.</p><p>Abaixo, temos um exemplo de como poderia ser um pipeline para a feature engineering que exemplificamos ao longo deste artigo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/539e6ea49dc66a35a8f850ec92786c0d/href">https://medium.com/media/539e6ea49dc66a35a8f850ec92786c0d/href</a></iframe><p>No exemplo acima, o pipeline executa as transformações na seguinte ordem: primeiro faz a transformação das variáveis categóricas (linha 15 do código), depois a transformações de valores faltantes (linha 16) e, por último, faz a normalização dos dados numéricos (linha 17).</p><p>Como o pipeline executa as transformações na sequência em que foram passadas para ele, é importante tomar muito cuidado com a ordem em que passamos as transformações!</p><p>Imagine o seguinte caso: ao invés de pedir que ele faça a transformação das variáveis categóricas, você primeiro deixou que ele fizesse a normalização dos dados numéricos. Com isso, se estivéssemos utilizando o MinMaxScaler, todos seus dados numéricos ficariam entre 0 e 1 assim que essa transformação fosse feita. Só que, logo em seguida, você faz o preenchimento de valores faltantes (vamos supor que sempre que a variável “Age” for nula, você preenche com a mediana que é 35). Assim, todas as suas variáveis estarão com a escala de 0 e 1, mas o valor faltante agora está com 35, o que pode acabar prejudicando as predições geradas pelo seu modelo. Portanto, revise e tome muito cuidado com as transformações e a sequência delas no seu pipeline!</p><p>Como dissemos anteriormente, cada uma das transformações ficam em scripts separados e são chamados pelo pipeline. Abaixo, deixamos o exemplo de um dos scripts criados para esse pipeline, que faz a transformação das variáveis categóricas aplicando o one-hot encoding:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/576941051b7e34a8e0863c8be2fc9760/href">https://medium.com/media/576941051b7e34a8e0863c8be2fc9760/href</a></iframe><p>Tal como no exemplo acima, cada transformer terá 2 métodos principais: o <strong><em>fit </em></strong>e o <strong><em>transform</em></strong>. O <em>fit </em>será utilizado quando estamos ensinando qual tipo de transformação deve ser feita para o pré-processamento dos dados e salvamos essa transformação para ser utilizada posteriormente (que é basicamente os trechos de código que mostramos anteriormente quando estávamos explicando as transformações), enquanto que o método <em>transform </em>é utilizada para aplicar as transformações que foram “aprendidas” quando foi feito o <em>fit</em>.</p><p><strong>E como posso utilizar esse pipeline?</strong></p><p>Para utilizar o pipeline, basta chamar o método <em>get_pipeline </em>que criamos e utilizar os métodos <em>fit</em>, <em>transform </em>ou <em>fit_transform</em> (no qual ele já faz o <em>fit </em>e o <em>transform </em>para um mesmo conjunto de dados), tal como no trecho abaixo:</p><pre>feature_engineering_pipeline = FeatureEngineering().get_pipeline()</pre><pre>X_train = feature_engineering_pipeline.fit_transform(X_train)</pre><pre>X_test = feature_engineering_pipeline.transform(X_test)</pre><p>Acima, nós chamamos o pipeline e o instanciamos na variável <em>feature_engineering_pipeline</em>. Após isso, utilizamos o método <em>fit_transform </em>quando utilizamos o conjunto de treinamento para que a feature engineering “aprenda” como as transformações devem ser feitas de acordo com os dados do conjunto de treinamento e então retorne os dados do conjunto de treinamento com as transformações necessárias.</p><p>Já quando vamos fazer as transformações para o conjunto de teste e para exemplos em produção, devemos usar apenas o método <em>transform</em>, visto que não podemos fazer o <em>fit</em>, uma vez que as transformações da feature engineering não devem “aprender” com esses dados, apenas transformá-los de acordo com o que foi observado no conjunto de treinamento.</p><p>Abaixo, temos um exemplo de como os dados sairão do pipeline quando utilizamos o método <em>transform</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/0*p_LiQpq8YZrSdzkB" /><figcaption>Exemplo de saída do pipeline após a feature engineering</figcaption></figure><p><strong>Mas quais são as vantagens de fazermos a feature engineering utilizando um pipeline?</strong></p><ul><li>A etapa de feature engineering fica muito mais organizada! Como o pipeline segue uma sequência e criamos os transformers seguindo um padrão, fica muito mais fácil para entender o que está acontecendo e, consequentemente, facilita o entendimento do código por outras pessoas e por você no futuro.</li><li>Por conta da separação das transformações em arquivos diferentes, quando ocorre algum erro ou alguma transformação incorreta, é mais fácil saber qual script devemos olhar e, com isso, podemos corrigir o problema mais rapidamente.</li><li>A utilização de pipelines também facilita quando formos colocar o modelo em produção. Às vezes, algumas transformações da feature engineering feitas para o treinamento do modelo não serão exatamente as mesmas que você fará em produção. Por exemplo, vamos supor que as variáveis que você utilizou no modelo foram extraídas de um banco de dados de forma estruturada, mas em produção você receberá os dados no formato JSON. Utilizando o pipeline, você só precisaria adaptar o pipeline de pesquisa para incluir uma transformação inicial que iria transformar os dados no formato JSON para o formato tabular e, após essa transformação, poderia executar as demais transformações normalmente.</li></ul><h3>Não deixe de salvar o seu modelo!</h3><p>Pronto, agora que já terminamos a feature engineering, chegamos na etapa da modelagem! <strong>Nessa etapa, o que precisamos fazer, pensando que depois vamos disponibilizar o modelo em produção, é salvá-lo!</strong> Isso é feito da mesma forma como salvamos os scalers da feature engineering:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c4721c8beb102d75340f529e1bc97a2a/href">https://medium.com/media/c4721c8beb102d75340f529e1bc97a2a/href</a></iframe><p>Considerando que já temos separado um conjunto de treinamento com as variáveis e target a serem utilizados, basta treinarmos o modelo com esse conjunto. No exemplo acima, o modelo treinado fica armazenado na variável “model” e nas linhas 8 e 9, salvamos esse modelo em um objeto “model.pkl”.</p><p>Dessa forma, nosso modelo ficará encapsulado nesse arquivo e poderá ser utilizado em produção pela nossa aplicação para fazer predições para novos dados. Bastará fornecer para ele o exemplo com as <em>features </em>necessárias (e já transformadas) para que ele possa fazer essas predições 😊</p><p>Mas e os notebooks?</p><p>Nós criamos vários notebooks aqui no time de Data Science da Creditas! O que acontece é que esses notebooks são focados nas etapas de análise exploratória e avaliação dos modelos, no qual fazemos uso de diversos gráficos (dentre eles os que estão no <a href="https://medium.com/creditas-tech/galeritas-uma-biblioteca-para-visualiza%C3%A7%C3%A3o-de-dados-ef5ab0652268">Galeritas</a>, nossa biblioteca <em>open-source</em> para visualização de dados), testes estatísticas e diversas outras análises que podem ser feitas e visualizadas mais facilmente por meio dos notebooks. Assim, a utilização de scripts e notebooks em nosso fluxo de trabalho fica mais ou menos da seguinte forma:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/443/0*nLCAhmlAe-W8PGXU" /><figcaption>Tabela descrevendo o uso de notebooks e scripts em Python no fluxo de projetos de Data Science</figcaption></figure><p>Inclusive, as grandes vantagens de não termos notebooks contendo a modelagem é que não necessitamos ficar executando um notebook toda hora sempre que quisermos gerar predições com um modelo que treinamos e não deixamos esse modelo parado sem auxiliar nas tomadas de decisão e gerar valor para a Creditas.</p><p>Ao salvarmos o modelo como um objeto Pickle, por exemplo, não só facilitamos a implantação do modelo, como continuamos permitindo a utilização desse modelo em notebooks para fazermos nossas avaliações. Abaixo, deixamos um exemplo de um notebook no qual importamos o modelo que treinamos anteriormente para um notebook:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/649/0*Ga9Xnkrq3R3FAelg" /><figcaption>Notebook para exemplificar a utilização de um modelo treinado</figcaption></figure><p>No exemplo acima, importamos o conjunto de teste após passar pelo pipeline da feature engineering para a variável <em>test</em> e o modelo para a variável <em>model</em>. Após isso, geramos as predições para esse conjunto de dados com o modelo treinado e salvamos essas predições na coluna “prediction”, de modo que agora podemos fazer uma série de análises com essa informação ao longo do notebook 😊</p><h3>Conclusões sobre os cuidados antes da implantação</h3><p>Para sintetizar, as dicas que demos até agora com relação às etapas de feature engineering e modelagem são:</p><ul><li>Salve todas as transformações que você fizer na feature engineering e salve também o seu modelo, porque isso permitirá que eles sejam utilizados tanto durante o treino e teste do modelo quanto quando for fazer as predições em produção. Não necessariamente você precisa salvar o modelo e as transformações como objetos Pickle como mostramos ao longo do artigo, mas é interessante que você os salve de alguma forma para que possam ser consumidos mais facilmente quando desejável.</li><li>Pode ser interessante fazer o uso de pipelines na etapa de feature engineering, uma vez que eles facilitam o entendimento do código e deixam as transformações de uma forma organizada (o que pode ajudar na identificação de erros), o que facilita no entendimento das adaptações que serão necessárias para se fazer quando precisamos colocar o modelo em produção.</li></ul><p><strong>Pronto! Agora sim podemos começar a implantação do modelo! 🥳</strong></p><p>Para o artigo não ficar muito grande, nós o quebramos em duas partes. Para conferir a segunda parte do artigo, em que o André explica e dá dicas para a implantação de um modelo de Data Science, é só clicar <a href="https://medium.com/@andre.oliveira_17523/terminei-a-modelagem-e-agora-parte-ii-8fb75280bdc6"><strong>aqui</strong></a>!</p><p><strong>Tem interesse em trabalhar conosco?</strong><em> Nós estamos sempre procurando por pessoas apaixonadas por tecnologia para fazer parte da nossa Tripulação! Você pode conferir nossas vagas</em><a href="https://careers.creditas.com/en?utm_source=Medium%20Tech&amp;utm_medium=home&amp;utm_content=cta_post_blogs"><em> aqui</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=604232bb5114" width="1" height="1" alt=""><hr><p><a href="https://medium.com/creditas-tech/terminei-a-modelagem-e-agora-parte-i-604232bb5114">Terminei a modelagem, e agora? — Parte I</a> was originally published in <a href="https://medium.com/creditas-tech">Creditas Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Galeritas: uma biblioteca para visualização de dados]]></title>
            <link>https://medium.com/creditas-tech/galeritas-uma-biblioteca-para-visualiza%C3%A7%C3%A3o-de-dados-ef5ab0652268?source=rss-e4ac86a38a49------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef5ab0652268</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[creditasbr]]></category>
            <dc:creator><![CDATA[Vivian Mayumi Yamassaki]]></dc:creator>
            <pubDate>Thu, 30 Sep 2021 16:01:43 GMT</pubDate>
            <atom:updated>2021-09-30T23:43:34.067Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/923/1*FVHnYHrmqpPCgVvuzmAaeA.png" /></figure><blockquote>Este artigo foi escrito em conjunto com <a href="https://medium.com/u/cea9b9f8764">Bruno Belluomini</a></blockquote><p>Geralmente, temos códigos e funções que podem ser reutilizados em diversos projetos. Aqui no time de Data Science da Creditas isso também acontece e, por isso, nós criamos uma biblioteca interna que possui diversas funções que utilizamos nos mais variados projetos que temos: desde as que usamos para fazer testes estatísticos com as variáveis dos nossos conjuntos de dados até funções para gerar gráficos para nossas análises exploratórias.</p><p>O problema de se ter essa biblioteca única é que ao longo dos anos ela começou a ficar cada vez maior e isso também fez com que ela ficasse um pouco bagunçada, visto que várias pessoas do time foram acrescentando seus códigos ao longo do tempo e não tínhamos uma categorização do que havia nela e nem um padrão definido para que as pessoas pudessem seguir.</p><p>Assim, sentimos a necessidade de organizá-la e compartimentalizar algumas de suas partes que, por si só, poderiam gerar bibliotecas mais específicas e serem utilizadas somente para os projetos em que fossem necessárias.</p><p>Além disso, nosso time também tinha um grande desejo de contribuir com a comunidade de Data Science de alguma forma, mas como essa biblioteca única possui várias funções específicas para o contexto da Creditas, não faria sentido deixá-la aberta a todas as pessoas.</p><p>Foi assim que surgiu a ideia de criarmos o <em>Galeritas</em>.</p><h3><strong>O que é o Galeritas?</strong></h3><p>O <a href="https://github.com/Creditas/galeritas">Galeritas</a> é uma <strong>biblioteca open source voltada para visualização de dados em Python</strong>. Ele contém uma série de gráficos que podem ser utilizados para (mas não se limitando à) análise exploratória de dados e avaliação de modelos criados em projetos de Data Science.</p><p>Optamos por criar uma biblioteca contendo gráficos porque eles podem ser utilizados para os mais diversos dados e contextos e, desse modo, achamos que essa seria uma ótima forma de fazer a contribuição para a comunidade que tanto desejávamos, visto que há diversos gráficos mais trabalhosos de serem feitos com o <a href="https://seaborn.pydata.org/">Seaborn</a> ou o <a href="https://matplotlib.org/">Matplotlib</a>. Bastaria então utilizar as funções já disponíveis na biblioteca ao invés de ter que descobrir como criá-las e desenvolvê-las.</p><p>Além disso, ela ajuda no dia a dia do nosso time, uma vez que não precisamos ficar procurando em diversos notebooks até conseguirmos encontrar um gráfico que outra pessoa do time utilizou uma vez e que queremos reutilizar no projeto que estamos trabalhando atualmente.</p><h3><strong>Que gráficos já existem na biblioteca?</strong></h3><p>No momento em que escrevemos este artigo, o Galeritas conta com 4 gráficos. Nós já criamos uma documentação para a biblioteca (você pode encontrá-la <a href="https://galeritas.readthedocs.io/en/latest/">aqui</a>) na qual descrevemos esses gráficos e seus parâmetros, mas abaixo também vamos descrever brevemente as funções que podem gerá-los e dar exemplos de como eles são para facilitar a sua compreensão.</p><p><strong>Bar plot with population proportion</strong></p><p>Essa função tem como principal objetivo produzir um gráfico de barras com uma informação adicional do tamanho da população presente nas categorias representadas por cada uma das barras presente no gráfico.</p><p>Abaixo, temos um exemplo de código utilizando essa função, no qual precisamos fornecer três parâmetros obrigatórios:</p><ul><li><strong>df</strong>: o conjunto de dados;</li><li><strong>x</strong>: o nome da coluna que contém as categorias que serão descritas pelas barras;</li><li><strong>y</strong>: o nome da coluna contendo os valores que serão descritos no eixo Y.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/08bba40f43c0b8672c8608b87413c92d/href">https://medium.com/media/08bba40f43c0b8672c8608b87413c92d/href</a></iframe><p>Com o código acima, geramos o gráfico abaixo, no qual podemos visualizar 3 barras mostrando a <strong>mediana</strong> (que é a métrica default para esse gráfico, mas outras podem ser utilizadas) para as respectivas categorias e a quantidade e proporção da população do conjunto de dados presente em cada uma delas. Por exemplo, a categoria <em>Gentoo</em> tem uma mediana de cerca de 5.000 e 124 exemplos do conjunto de dados é dessa categoria (que representa 36,05% do total de exemplos):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xrRqbOk8ZelHjQy2jPbKig.png" /><figcaption>Exemplo gerado com a função bar_plot_with_population_proportion. Em vermelho, deixamos algumas explicações sobre partes do gráfico</figcaption></figure><p>Essa função também contém vários outros parâmetros opcionais (como o título do gráfico e seu tamanho que usamos no exemplo acima) caso se deseje tornar o gráfico mais customizado. Por exemplo, com essa função também é possível dividir a barra de uma mesma categoria mostrando as métricas para os valores positivos e negativos que ela possui.</p><p><strong>Plot ECDF curve</strong></p><p>Essa função foi criada para gerar uma função de distribuição empírica<strong>.</strong> Caso você queira saber mais sobre ela, pode conferir <a href="https://towardsdatascience.com/what-why-and-how-to-read-empirical-cdf-123e2b922480">este</a> artigo aqui.</p><p>O Seaborn agora conta com uma <a href="https://seaborn.pydata.org/generated/seaborn.ecdfplot.html">versão</a> para esse gráfico, mas<strong> </strong>sentíamos falta de algumas coisas nessa implementação, como indicações sobre percentis, o que nos motivou a criar uma versão no Galeritas.</p><p>Novamente, temos um exemplo de código abaixo. Para essa função, apenas 2 parâmetros são obrigatórios:</p><ul><li><strong>df</strong>: o conjunto de dados;</li><li><strong>column_to_plot</strong>: o nome da coluna que contém os valores que utilizaremos para gerar a distribuição.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7dc2439dc0dd90a91bc77e7fdf0e4fc3/href">https://medium.com/media/7dc2439dc0dd90a91bc77e7fdf0e4fc3/href</a></iframe><p>Com o código acima, produzimos o gráfico abaixo, no qual temos as distribuições para as mesmas categorias que havíamos observado no gráfico anterior. É possível observar que 25% dos exemplos na categoria <em>Gentoo</em> possuem um valor para a variável <em>body_mass_g </em>de até cerca de 4.700. Além disso, conseguimos notar que as distribuições das categorias <em>Adelie</em> e <em>Chinstrap</em> são mais similares do que a distribuição de <em>Gentoo</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nSfm9CFMOZIsie4-GM4UdQ.png" /><figcaption>Exemplo gerado com a função plot_ecdf_curve. Em vermelho, deixamos algumas explicações sobre partes do gráfico</figcaption></figure><p>Como dissemos anteriormente, esse gráfico só possui dois parâmetros obrigatórios, mas também possui alguns opcionais como o <em>hue</em>, que usamos no exemplo acima para gerar distribuições para cada uma das categorias presente na coluna <em>species</em> do conjunto de dados utilizado.</p><p><strong>Precision and recall by probability threshold</strong></p><p>Essa função gera um gráfico mostrando as métricas de precisão, recall (ou revocação/sensibilidade) e suporte para diferentes limiares de predições de um modelo. O código dessa função foi adaptado <a href="https://blog.insightdatascience.com/visualizing-machine-learning-thresholds-to-make-better-business-decisions-4ab07f823415">daqui</a>.</p><p>Ela exige três parâmetros obrigatórios:</p><ul><li><strong>df</strong>: o conjunto de dados;</li><li><strong>prediction_column_name</strong>: o nome da coluna que contém as predições feitas pelo modelo;</li><li><strong>target_name</strong>: o nome da coluna o target do modelo.</li></ul><p>Apesar dessa função ter somente três parâmetros obrigatórios, é importante ter atenção ao parâmetro opcional <strong>target</strong>, visto que ela indica a classe que será utilizada para gerar as métricas. No exemplo abaixo, usamos o valor do parâmetro <em>target</em> igual a 1 (classe <em>survived</em> = 1), que é o valor <em>default</em>. No entanto, caso quiséssemos ver o gráfico considerando a classe <em>survived </em>= 0, precisaríamos passar este valor para o parâmetro <em>target</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f716c2e68ded0dab926198815378723/href">https://medium.com/media/4f716c2e68ded0dab926198815378723/href</a></iframe><p>Com o código acima, conseguimos gerar o gráfico abaixo, no qual podemos observar os valores de precisão, recall e suporte para cada limiar de valores preditos pelo modelo. Além disso, como fazemos uma amostragem para ver o desempenho das predições para cada uma das métricas, também é possível notar o intervalo de confiança que temos para cada uma delas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VExSw0hXFwfV6m50wUVvbg.png" /><figcaption>Exemplo gerado com a função precision_and_recall_by_probability_threshold. Em vermelho, deixamos algumas explicações sobre partes do gráfico</figcaption></figure><p>Assim, para o exemplo acima, se definíssemos um limiar das predições em 0,3, temos, aproximadamente, uma precisão entre 0,66 e 0,81, um recall entre 0,75 e 0,89 e um suporte entre 0,40 e 0,52 .</p><p><strong>Stacked percentage bar plot</strong></p><p>Por fim, temos a função <em>stacked_percentage_bar_plot</em>, que foi criada para gerar um gráfico de barras empilhadas, de modo a exibir barras para uma determinada categoria e, dentro de cada uma delas, ter barras empilhadas mostrando a proporção de exemplos dela considerando uma segunda categoria.</p><p>Abaixo, temos um exemplo de código utilizando essa função, no qual precisamos fornecer três parâmetros obrigatórios:</p><ul><li><strong>df</strong>: o conjunto de dados;</li><li><strong>categorical_feature</strong>: o nome da coluna que contém as categorias que serão descritas pelas barras;</li><li><strong>hue</strong>: o nome da coluna contendo a segunda categoria que será empilhada em cada uma das barras do gráfico.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/89b3e68d310b2a3d065bd996cabfd591/href">https://medium.com/media/89b3e68d310b2a3d065bd996cabfd591/href</a></iframe><p>Com o código acima, geramos o gráfico abaixo no qual podemos observar que, considerando a variável <em>island</em>, quando ela é igual a <em>Biscoe</em>, temos cerca de 25% de exemplos <em>Adelie</em> e 75% <em>Gentoo</em>. Por outro lado, todos os exemplos da categoria <em>Torgersen</em> são <em>Adelie</em> para a variável <em>species</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4EljFiZ9K28TyzDpGKx0CA.png" /><figcaption>Exemplo gerado com a função stacked_percentage_bar_plot. Em vermelho, deixamos algumas explicações sobre partes do gráfico</figcaption></figure><p>Todas as funções que acabamos de descrever possuem uma série de parâmetros opcionais que podem ser utilizados para customizar os gráficos (cores, labels, títulos, exibição de nulos, posição da legenda, etc.). Então, caso tenha ficado com curiosidade, não deixe de conferir a documentação para aprender a explorar os gráficos do Galeritas com todo seu potencial!</p><h3>Como posso utilizar o Galeritas?</h3><p>A instalação e utilização do Galeritas é bem simples! A biblioteca já consta no <a href="https://pypi.org/project/galeritas/">Pypi</a>, então para instalá-la basta utilizar o comando abaixo:</p><pre>pip install galeritas</pre><p>Após isso, basta importar a biblioteca inteira:</p><pre>import galeritas</pre><p>Também é possível importar só as funções dos gráficos que você gostaria de utilizar em seus notebooks, por exemplo:</p><pre>from galeritas import plot_ecdf_curve</pre><h3><strong>Como posso contribuir com o projeto?</strong></h3><p>Primeiramente, caso queira fazer parte da comunidade do projeto, deixamos aqui o convite para você entrar no nosso servidor do Discord por <a href="https://discord.gg/u8G9ME2jq3">este</a> link! O servidor conta com alguns canais para interação e contribuições:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6HT5Tet5DfL1jaWO" /><figcaption>Canal de boas-vindas no servidor do Galeritas no Discord</figcaption></figure><p>Abaixo, deixamos listadas as diversas maneiras de contribuir com o Galeritas:</p><ol><li>Nos ajudando a resolver <a href="https://github.com/Creditas/galeritas/issues">issues</a> do projeto;</li><li>Nos ajudando a revisar <a href="https://github.com/Creditas/galeritas/pulls">pull requests</a> (PR);</li><li>Nos ajudando a desenvolver algumas sugestões de gráficos mais votados pela comunidade;</li><li>Criar e reportar uma issue quando encontrar algum bug ou problema;</li><li>Compartilhar ideias de melhorias ou sugestões de novos gráficos;</li><li>Ajudar a divulgar o projeto para pessoas que conhece e que poderiam usá-lo! <strong>💚</strong></li></ol><p>Para mais detalhes sobre como essas contribuições podem ser feitas, veja os canais no servidor do Discord ou o <a href="https://github.com/Creditas/galeritas">repositório do Galeritas</a> no Github.</p><p>Por fim, também é importante salientar que quem quiser contribuir com o desenvolvimento e melhoria de códigos, precisa se atentar ao fato de que a biblioteca segue o padrão <a href="https://www.python.org/dev/peps/pep-0008/">PEP8</a> do Python e todos os gráficos devem possuir testes unitários (como referências sobre isso, deixamos <a href="https://medium.com/data-hackers/testes-unit%C3%A1rios-para-profissionais-de-dados-com-pytest-o-guia-definitivo-5ac05f4ef866">um artigo</a> que fala sobre testes unitários para profissionais de dados e também <a href="https://towardsdatascience.com/unit-testing-python-data-visualizations-18e0250430">um artigo</a> sobre testes unitários em Python para visualização de dados) para mantermos o padrão e a qualidade do Galeritas 😉</p><h3><strong>Conclusão e próximos passos</strong></h3><p>O Galeritas já tem facilitado bastante o fluxo de trabalho do nosso time de Data Science, pois basta instalar a biblioteca no ambiente do projeto, importá-la no notebook e gerar os gráficos desejados!</p><p>Como próximos passos, já estamos trabalhando em adicionar mais uma série de gráficos que já usamos ou que achamos interessantes para o nosso time (dando alguns <em>spoilers</em>, podemos citar o gráfico do teste de Kolmogorov-Smirnov (KS) e um <em>scatterplot</em> com quadrantes e informações sobre densidade). Também queremos melhorar a documentação do Galeritas, descrevendo-a melhor e adicionando alguns exemplos de saída das funções para facilitar o seu entendimento.</p><p>Esperamos que você tenha se animado para testar a biblioteca e também contribuir para que ela cresça cada vez mais e facilite o trabalho de diversas pessoas (inclusive o seu)! <strong>💚</strong></p><p><strong>Tem interesse em trabalhar conosco?</strong><em> Nós estamos sempre procurando por pessoas apaixonadas por tecnologia para fazer parte da nossa Tripulação! Você pode conferir nossas vagas</em><a href="https://careers.creditas.com/en?utm_source=Medium%20Tech&amp;utm_medium=home&amp;utm_content=cta_post_blogs"><em> aqui</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef5ab0652268" width="1" height="1" alt=""><hr><p><a href="https://medium.com/creditas-tech/galeritas-uma-biblioteca-para-visualiza%C3%A7%C3%A3o-de-dados-ef5ab0652268">Galeritas: uma biblioteca para visualização de dados</a> was originally published in <a href="https://medium.com/creditas-tech">Creditas Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Combinando modelos de Machine Learning com Lógica Fuzzy — Parte 2]]></title>
            <link>https://medium.com/creditas-tech/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-2-2f75699987c0?source=rss-e4ac86a38a49------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f75699987c0</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[fuzzy-logic]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[creditasbr]]></category>
            <dc:creator><![CDATA[Vivian Mayumi Yamassaki]]></dc:creator>
            <pubDate>Tue, 24 Nov 2020 17:55:57 GMT</pubDate>
            <atom:updated>2020-11-25T12:09:58.918Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/669/1*DCPiTSMU69HEvStMbgvvvQ.png" /></figure><h3>Combinando modelos de Machine Learning com Lógica Fuzzy — Parte 2</h3><blockquote>Esta é a segunda e última parte do artigo sobre combinação de modelos de Machine Learning com Lógica Fuzzy. Na primeira parte, falei sobre a nossa motivação em utilizar lógica fuzzy, seus conceitos e como construir um sistema de controle fuzzy. Ela é essencial para o entendimento desta segunda parte; portanto, não deixe de conferi-la <a href="https://medium.com/@vivian.yamassaki/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-1-b5a9f0761a5d">aqui</a>.</blockquote><p>Para fazer a combinação dos modelos por meio de lógica fuzzy com Python, nós utilizamos o pacote <a href="https://github.com/scikit-fuzzy/scikit-fuzzy">scikit-fuzzy</a>. Na documentação, temos um exemplo de sua aplicação para um <a href="https://pythonhosted.org/scikit-fuzzy/auto_examples/plot_tipping_problem_newapi.html">problema de se dar uma gorjeta</a> (em que, dada a qualidade do serviço e do prato pedido, deseja-se saber quanto de gorjeta deve ser dada). Como esse exemplo já está bem explicado, vamos imaginar um outro caso aqui para ilustrar e vermos a aplicação da lógica fuzzy em outro cenário 🙂</p><p>Imagine então que temos dois modelos: um modelo de regressão que prediz o valor de um imóvel (como dessa <a href="https://www.kaggle.com/c/house-prices-advanced-regression-techniques">competição famosa do Kaggle</a>) e um modelo de classificação que prediz a chance de um imóvel ser vendido. Poderíamos então combinar esses dois modelos para dizer o quão bom um imóvel é:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/584/1*1vf5dDZis2hfKqhi853jVQ.png" /><figcaption>Exemplo de utilização da lógica fuzzy para o caso de imóveis: combinando a chance do imóvel ser vendido e seu preço, queremos determinar a qualidade deste imóvel (ícones criados por <a href="http://www.freepik.com/">Freepik</a> e <a href="https://www.flaticon.com/authors/smashicons">Smashicons</a> do <a href="http://www.flaticon.com/">www.flaticon.com</a>).</figcaption></figure><p>Agora que já conhecemos os conceitos de um sistema de controle fuzzy, vamos aplicar o passo a passo no caso acima para criarmos um sistema que retorne a qualidade de um imóvel. Primeiramente, vamos definir as entradas e a saída do nosso sistema:</p><p><strong>Entradas</strong></p><p><em>Valor</em></p><ul><li>Universo (intervalo de valores crisp): o quão alto é o preço do imóvel, considerando uma escala entre R$ 100.000 a R$ 1.000.000?</li><li>Conjunto fuzzy (intervalo de valores fuzzy): baixo, médio e alto</li></ul><p><em>Venda</em></p><ul><li>Universo: considerando um valor entre 0 e 1, qual a chance do imóvel ser vendido?</li><li>Conjunto fuzzy: baixa, média e alta</li></ul><p><strong>Saída</strong></p><p><em>Qualidade</em></p><ul><li>Universo: qual a qualidade do imóvel, numa escala entre 0 e 100?</li><li>Conjunto fuzzy: ruim, mediana e boa</li></ul><p>Vamos agora passar todas essas definições para o Python utilizando o scikit-fuzzy:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bba52cbddcd30d2f60583f5b3ddc30cc/href">https://medium.com/media/bba52cbddcd30d2f60583f5b3ddc30cc/href</a></iframe><p>Acima, utilizamos o módulo <em>control</em> que tem as classes <em>Antecedent</em> e <em>Consequent</em> para definir as variáveis de entrada e saída, respectivamente. Essas classes recebem como parâmetros o universo e a label com o nome da variável.</p><p>O universo deve ser um array com os possíveis valores (não só os valores mínimo e máximo). Por isso, utilizamos a função arange do numpy para gerar esse array. Nessa função fornecemos 3 parâmetros: o valor inicial, o valor final e o passo, mas é importante dizer que o valor final <strong>não</strong> estará incluído no array (por isso no código os valores finais para cada variável estão maiores do que definimos no universo).</p><p>Após essa definição inicial, vamos definir as funções de pertinência para os antecedentes e o consequente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/82a0ffcc948b877d0f4e4a01cd28a6fe/href">https://medium.com/media/82a0ffcc948b877d0f4e4a01cd28a6fe/href</a></iframe><p>No código acima, arbitrariamente escolhemos as funções de pertinência das variáveis. Para a venda e o preço, optamos pela função triangular (definida com a função <em>trimf</em>), enquanto que a qualidade foi definida com a função trapezoidal (com a função <em>trapmf</em>). Ambas receberam dois argumentos: o universo das variáveis que definimos no código anterior e um array para definir o formato dos triângulos e trapézios (para a função triangular, o array deve ter 3 elementos, enquanto que para a trapezoidal precisa ter 4). Os valores desses arrays que definem os formatos também foram escolhidos empiricamente.</p><p>No código acima também utilizamos a função <em>view</em>, com a qual conseguimos visualizar as funções de pertinência definidas para cada antecedente e consequente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3R0P6J2QQjWYxiI74ECI8w.png" /><figcaption>Funções de pertinência para as variáveis venda, preço e qualidade.</figcaption></figure><p>Em seguida, vamos criar as regras para esse sistema:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f8c2c7091ac6447a17e2de8d3f40e6d7/href">https://medium.com/media/f8c2c7091ac6447a17e2de8d3f40e6d7/href</a></iframe><p>Podemos observar que foram definidas 5 regras para esse sistema utilizando a classe Rule, para o qual foram passados dois parâmetros para ela: o antecedente (em que para algumas regras foram utilizados os operadores <strong>E</strong> ou <strong>OU</strong> para relacionar duas variáveis de entrada) e o consequente. Novamente, essas regras foram escolhidas empiricamente.</p><p>Após a definição das regras, temos as linhas 16 e 17 do código acima, em que passamos as regras para o sistema de controle definido pela classe <em>ControlSystem</em> e, para simular esse sistema, criamos o <em>ControlSystemSimulation</em>. Agora que temos o sistema pronto, podemos fornecer dois valores de entrada como exemplo para verificar qual será a saída do sistema:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ca4dedd2fec17dc8b1cc3d0332c8dfab/href">https://medium.com/media/ca4dedd2fec17dc8b1cc3d0332c8dfab/href</a></iframe><p>No exemplo acima, fornecemos como entrada uma predição do modelo de classificação que retornou que esse imóvel tem 80% de probabilidade de ser vendido, enquanto que a predição do modelo de regressão foi de que o valor do imóvel é de R$ 150.000,00.</p><p>Utilizamos então a função <strong>compute</strong> para calcular qual a saída do sistema fuzzy. Importante notar que estamos utilizando os parâmetros default da biblioteca para fazer as etapas de inferência fuzzy e a defuzzificação. Você pode checar a <a href="https://pythonhosted.org/scikit-fuzzy/api/api.html">documentação</a> caso queira utilizar outros métodos para essas etapas.</p><p>Como retorno para o exemplo acima, o print informa que a saída é igual a 60 e também temos o seguinte gráfico retornado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/0*ECkuChFGVjCDnI3X" /><figcaption>Saída resultante quando temos como entrada um valor de 150.000 reais e uma probabilidade de venda de 0.8.</figcaption></figure><p>Agora vamos supor que os modelos fizeram predições para um outro imóvel e retornaram uma predição de venda igual a 0.78 e um valor de imóvel de R$ 680.000,00. Para esse caso, o sistema retorna uma saída de 79.37 e o seguinte gráfico abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*TItvYCJco9uiV5II" /><figcaption>Saída resultante quando temos como entrada um valor de 680.000 reais e uma probabilidade de venda de 0.78.</figcaption></figure><p>Ótimo, agora temos saídas para dois imóveis! O que podemos fazer com elas? Com as saídas do sistema de controle fuzzy, sabemos que o segundo imóvel tem uma qualidade maior do que o primeiro. Poderíamos dar mais destaque para esse segundo imóvel, visto que sabemos que ele é melhor e deve vender mais rápido ou poderíamos dar um desconto para o primeiro imóvel, visto que sua qualidade é inferior. Enfim, são muitas as possibilidades de utilização das saídas do sistema de controle utilizando lógica fuzzy!</p><h4>Vantagens e desvantagens de se utilizar lógica fuzzy</h4><p>Dentre as vantagens que podemos citar sobre a utilização de lógica fuzzy para combinar modelos de Machine Learning é de que definições das variáveis e das regras podem ser facilmente entendidas e podem (e deveriam) ser definidas em conjunto com pessoas de outras áreas.</p><p>Uma outra grande vantagem de utilizar a lógica fuzzy como mostramos no artigo é que conseguimos escolher a forma como a saída do sistema de controle será, de modo que ela faça sentido para o negócio e que seja facilmente entendida pelas pessoas. Pegando o exemplo de se definir a qualidade do imóvel novamente: se utilizássemos a abordagem que citei na <a href="https://medium.com/@vivian.yamassaki/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-1-b5a9f0761a5d">primeira parte do artigo</a> e fizéssemos simplesmente uma multiplicação das predições dos dois modelos de Machine Learning que retornam o preço e a vendabilidade dos imóveis, o resultado dessa multiplicação por si só não quer dizer nada (por exemplo, para um imóvel que tem 50% de probabilidade de ser vendido e cuja estimativa de preço é de R$ 100.000,00, uma saída de 50.000 não quer dizer que o imóvel será vendido por esse valor). Já com a lógica fuzzy, podemos criar um score (com o intervalo que acharmos que faça sentido) assim como fizemos acima, em que o imóvel pode ter valores entre 0 e 100 e que quanto maior, maior é a qualidade do imóvel. Com isso, sua saída fica muito mais intuitiva.</p><p>Por fim, uma outra vantagem é de que, com as regras da lógica fuzzy, não teríamos mais o dilema de escolher, pensando no exemplo do imóvel, se seria melhor focar em um imóvel mais barato, mas com mais chances de ser vendido, ou em um imóvel mais caro, mas com menores chances de ser vendido. Com o sistema de controle, podemos definir as regras que achamos que fazem sentido e as testamos para verificar se as premissas assumidas de fato estão coerentes.</p><p>Já uma das grandes desvantagens de utilizar lógica fuzzy é que muitas coisas precisam ser definidas: as variáveis de entrada e saída; seus universos e termos que serão assumidos no conjunto fuzzy; funções de pertinência e regras. Essas duas últimas em especial são bem complicadas de serem definidas e, como foi possível ver no último exemplo, geralmente são escolhidas empiricamente (ou necessitam de uma pessoa super especialista que nos ajude com todas essas definições).</p><p>Além disso, como essas definições comumente são feitas dessa maneira empírica, são necessárias muitas validações e testes para verificar se as saídas do sistema de controle fuzzy realmente estão fazendo sentido. Para isso, poderíamos aplicar um teste A/B (ou quem sabe usar o Multi-Armed Bandit que o Bruno explicou muito bem neste artigo <a href="https://medium.com/creditas-tech/quando-o-teste-a-b-n%C3%A3o-%C3%A9-o-suficiente-melhorando-suas-escolhas-com-multi-armed-bandit-aa232f4c8e61">aqui</a>) para testar se as definições escolhidas para o sistema de controle fuzzy estão resolvendo nosso problema ou se é necessário mudá-las e tentar de novo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*Qe9vRRYiwAnmtaAg" /><figcaption>Não desista que uma hora o sistema de controle com lógica fuzzy vai funcionar! (gif retirado <a href="https://giphy.com/gifs/just-keep-swimming-1sSWWMNnaZLlm">daqui</a>).</figcaption></figure><h4><strong>Conclusão</strong></h4><p>A Lógica Fuzzy, apesar de necessitar de várias definições, é de fácil entendimento e pode trazer diversas vantagens para o negócio. No caso do projeto que mencionei na primeira parte do artigo, quando combinamos os dois modelos por meio da multiplicação, só tivemos o melhor resultado em uma das métricas que analisamos, enquanto que utilizar só o modelo de classificação era melhor nas demais métricas. Já ao utilizar lógica fuzzy para fazer essa combinação, obtivemos os melhores resultados para todas as métricas analisadas, o que nos mostrou que sua utilização poderia trazer um potencial ganho para a Creditas.</p><p>Espero que esse artigo tenha ajudado no entendimento da lógica fuzzy e de como ela pode ser utilizada caso se deseje fazer a combinação de predições de modelos de Machine Learning 😃</p><h4>Referências</h4><p>Durante a pesquisa por referências, não foi encontrado um único material explicando sobre todas as etapas da lógica fuzzy com detalhes e dando um exemplo de aplicação (principalmente em português), mas deixarei alguns materiais que li para escrever este artigo.</p><p>Primeiro, temos como referências os sites de professores da USP e da UFPR com links e materiais mais teóricos:</p><ul><li><a href="https://docs.ufpr.br/~volmir/TP034_TPO.html">Optativa - Tópicos Especiais em PO</a></li><li><a href="https://www.ime.usp.br/~tonelli/verao-fuzzy/links.php">Lógica Fuzzy</a></li></ul><p>Indico novamente a documentação do scikit-fuzzy, visto que lá tem alguns exemplos que ajudam no entendimento de como a biblioteca funciona, assim como a explicação dos métodos existentes na biblioteca:</p><p><a href="https://pythonhosted.org/scikit-fuzzy/">skfuzzy 0.2 docs - skfuzzy v0.2 docs</a></p><p>Por fim, deixo o link para um dos pouquíssimos artigos no Towards Data Science sobre lógica fuzzy:</p><p><a href="https://towardsdatascience.com/a-very-brief-introduction-to-fuzzy-logic-and-fuzzy-systems-d68d14b3a3b8">A very brief introduction to Fuzzy Logic and Fuzzy Systems</a></p><p><strong>Tem interesse em trabalhar conosco?<em> </em></strong>Nós estamos sempre procurando por pessoas apaixonadas por tecnologia para fazer parte da nossa Tripulação! Você pode conferir nossas vagas <a href="https://careers.creditas.com/en?utm_source=Medium%20Tech&amp;utm_medium=home&amp;utm_content=cta_post_blogs">aqui</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f75699987c0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/creditas-tech/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-2-2f75699987c0">Combinando modelos de Machine Learning com Lógica Fuzzy — Parte 2</a> was originally published in <a href="https://medium.com/creditas-tech">Creditas Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Combinando modelos de Machine Learning com Lógica Fuzzy — Parte 1]]></title>
            <link>https://medium.com/creditas-tech/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-1-b5a9f0761a5d?source=rss-e4ac86a38a49------2</link>
            <guid isPermaLink="false">https://medium.com/p/b5a9f0761a5d</guid>
            <category><![CDATA[creditasbr]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[fuzzy-logic]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Vivian Mayumi Yamassaki]]></dc:creator>
            <pubDate>Tue, 24 Nov 2020 17:53:26 GMT</pubDate>
            <atom:updated>2021-03-04T19:34:15.105Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/669/1*DCPiTSMU69HEvStMbgvvvQ.png" /></figure><h3>Combinando modelos de Machine Learning com Lógica Fuzzy — Parte 1</h3><p>No mês de setembro, tivemos nosso<a href="https://www.linkedin.com/posts/creditasbr_learnfast-activity-6712785759017021440-Ekzl"> primeiro Hackday</a> aqui na Creditas, no qual tripulantes de Produto e Tecnologia tiveram o dia livre para inovar e colocar diversas ideias em prática. Aproveitamos a oportunidade e formamos um time composto por mim, de Data Science, e a Larissa Farabello e o André Oliveira de Machine Learning Engineering (aliás, o André publicou <a href="https://medium.com/creditas-tech/nossos-primeiros-passos-para-escalar-a-produ%C3%A7%C3%A3o-de-modelos-de-data-science-b43ba330e935">este artigo aqui</a> sobre esse time na Creditas. Confere lá 😀) para fazer alguns experimentos em um dos nossos projetos.</p><p>Esse projeto, em linhas gerais, consiste na utilização de dois modelos de Machine Learning desenvolvidos pelo time de Data Science: um modelo de classificação e outro, de regressão. Para combinar esses dois modelos, nós pegavámos as saídas de ambos e as multiplicávamos. Abaixo, temos um exemplo da saída dessa combinação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/687/1*2f78zSz4y6r_rqNyYSOS0g.png" /><figcaption>Exemplo da saída dada pela multiplicação das predições do modelo de classificação e de regressão. Nesse caso, a predição do modelo de classificação foi 0,75 e a do modelo de regressão, 30.000. Ao multiplicarmos as predições dos dois modelos, obtemos como saída o valor 22.500 (ícones criados por <a href="https://www.flaticon.com/authors/becris">Becris</a> do <a href="http://www.flaticon.com/">www.flaticon.com</a>).</figcaption></figure><p>Nós tínhamos a hipótese de que simplesmente multiplicar os dois valores poderia não ser a melhor forma de combinar os dois modelos, então foi aí que surgiu a ideia de utilizarmos<strong> lógica fuzzy </strong>para fazer essa combinação.</p><h3>Mas o que é lógica fuzzy?</h3><p>A lógica fuzzy (em português também pode ser chamada de <em>lógica difusa</em>) já é um conceito bem antigo, que surgiu na década de 60 e é aplicada em diversas áreas, desde engenharia até inteligência artificial. Basicamente, ela consiste em modelar um problema de modo aproximado ao invés de preciso, assim como é o raciocínio humano em diversas situações.</p><p>Uma analogia que eu achei interessante fazer quando estudava sobre lógica fuzzy foi de associá-la a uma escala likert, visto que, diferente de uma pesquisa binária, nessa escala as respostas variam conforme o grau de concordância da pessoa respondendo a uma determinada pergunta. A figura abaixo ilustra essa diferença entre a lógica clássica (binária) e a lógica fuzzy caso fizéssemos uma pesquisa sobre uma mesma pergunta utilizando essas duas abordagens distintas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/469/1*Ia05RO8MTeJf0royjZv7UA.png" /><figcaption>Analogia para diferenciar a lógica fuzzy da clássica (booleana).</figcaption></figure><p>Desse modo, enquanto que na lógica binária nós só temos uma resposta que pode assumir apenas dois valores (no caso do exemplo acima, sim ou não), na lógica fuzzy nós podemos obter uma resposta que está entre esses dois valores (no exemplo acima, você poderia não concordar 100% com a pergunta feita, então poderia escolher a opção de <em>concordar parcialmente</em>).</p><p>Assim, na lógica fuzzy é possível trabalhar com informações incertas que nós comumente usamos em nosso dia a dia (como responder questionamentos com <em>talvez</em>, <em>mais ou menos</em>, <em>às vezes</em>, <em>depende</em>, etc.).</p><p><strong>E como podemos utilizar a lógica fuzzy para combinar os nossos modelos de Machine Learning?</strong></p><p>Para utilizar a lógica fuzzy nessa combinação, precisamos construir um chamado <strong>Fuzzy Control System</strong>, que basicamente consiste em um sistema que utiliza a lógica difusa. Na imagem abaixo temos um resumo dos componentes que fazem parte de um sistema de controle difuso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*mn_Zm1vE1ePyeTQyZQgazw.png" /><figcaption>Imagem ilustrando os componentes de um sistema de controle fuzzy. Ele foi baseado nestes diagramas <a href="https://www.researchgate.net/figure/Architecture-of-a-fuzzy-logic-system_fig2_309452475">aqui</a> e <a href="https://www.jvejournals.com/article/16699">aqui</a>.</figcaption></figure><p>Abaixo será detalhado o que significa cada um desses componentes e como eles são definidos:</p><h4>1) Entrada e saída crisp</h4><p>Cada variável fuzzy possui um valor chamado de <strong>valor crisp</strong>, que nada mais é do que um número dentro de um domínio pré-determinado (na lógica fuzzy, esse domínio é chamado de <strong>universo</strong>). O universo então é a definição do intervalo dos valores no qual se encontra a variável e, por isso, precisamos definir quais são seus valores mínimo e máximo.</p><p>Para deixar esse conceito um pouco mais claro, imagine que temos um sistema que tem uma variável fuzzy referente à altura de uma pessoa. Assim, começamos definindo que o <strong>universo</strong> para essa variável terá o intervalo de 1,20 a 2 metros. Agora, vamos supor que eu fornecerei a minha altura para esse sistema; nesse caso, a entrada terá um <strong>valor crisp</strong> de 1,54 m.</p><p>Desse modo, as entradas para o sistema de controle fuzzy serão os valores crisp de cada variável. No nosso caso, como iremos aplicar a lógica fuzzy para combinar dois modelos de Machine Learning, o sistema receberá um valor crisp referente a predição de cada modelo e, portanto, para cada variável fuzzy. Além disso, a saída do sistema de controle também será um valor crisp (daqui a pouco falamos mais sobre isso).</p><h4>2) Fuzzificação</h4><p>A primeira etapa do sistema de controle fuzzy será aplicar a fuzzificação nas entradas crisp que foram recebidas. Essa etapa então consiste em transformar o valor crisp da entrada para um valor fuzzy e, para isso, precisamos definir os<strong> termos</strong> e <strong>funções de pertinência</strong> para esse sistema:</p><p><strong>Termo</strong></p><p>Uma variável fuzzy pode ter diversos <strong>termos</strong> que podem ser utilizados para descrevê-la. Todos esses termos compõem o chamado <strong>conjunto fuzzy</strong> e são utilizados para definir qual será o <strong>valor fuzzy</strong> dessa variável fuzzy. Exemplos de termos usados para qualificar a variável fuzzy são: bom, mediano, alto, aceitável, às vezes, etc. Voltando no nosso exemplo da altura, o conjunto fuzzy da nossa variável poderia ter os seguintes termos: baixa, mediana e alta para caracterizar a estatura de uma pessoa.</p><p><strong>Função de Pertinência</strong></p><p>Cada termo terá uma<strong> função de pertinência </strong>que definirá como o valor crisp será mapeado considerando uma escala (que varia entre 0 e 1) que reflete o grau de pertinência do valor para aquele termo. A função então define o pertencimento de um determinado elemento a um conjunto.</p><p>Essas funções podem ter diferentes formatos. Na imagem abaixo podemos ver algumas funções que podem ser utilizadas como função de pertinência:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7faBUEDzH3yXSFLKk_gDSA.png" /><figcaption>Exemplos de funções de pertinência.</figcaption></figure><p>Para exemplificar, vamos usar novamente o exemplo da altura. Supondo que tenhamos uma função de pertinência trapezoidal para cada um dos termos <em>baixa</em>, <em>mediana</em> e <em>alta</em>, que caracterizam a estatura de uma pessoa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*hXOx-8hQcwOe4Ty325C3Rw.png" /><figcaption>Exemplo das funções de pertinência considerando a variável altura.</figcaption></figure><p>Na imagem acima, podemos notar que no eixo X do gráfico temos os valores crisp da variável altura (e que vão de 1,20 a 2 m, visto que foi esse o universo que definimos) e no eixo Y temos o grau de pertinência, que vai de 0 a 1. Dependendo da altura da pessoa, ela terá um determinado grau de pertinência para cada termo. Por exemplo, considerando o conjunto de pessoas de estatura baixa, pessoas <em>completamente baixas</em> (ou seja, que tenham um grau de pertinência igual a 1 para esse conjunto) seriam aquelas que tivessem uma altura entre 1,20 e 1,45 m aproximadamente, enquanto que pessoas que tivessem uma altura de 1,56 m seriam consideradas <em>um pouco baixas</em>, visto que o grau de pertinência para esse conjunto seria mais baixo e menor do que 1.</p><p>Também é interessante notar que há sobreposições entre as funções de pertinência que descrevem diferentes termos. Isso acontece justamente por conta da incerteza que é intrínseca ao conceito de lógica fuzzy (ou seja, uma pessoa com 2 m de altura claramente se encontra no conjunto de pessoas altas, mas uma pessoa com 1,70 m pertence tanto ao conjunto de pessoas altas quanto de pessoas de estatura mediana, de modo que seu grau de pertinência pode ser diferente para cada um desses conjuntos), sendo assim possível fazer uma transição gradual de um conjunto para o outro.</p><p>Exemplificando com a minha altura, vamos verificar qual é o meu grau de pertinência para o conjunto de pessoas baixas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*Tgles1s2rrJ1_f-pJxnTCA.png" /><figcaption>Pertinência para o conjunto de pessoas baixas considerando uma pessoa com 1,54 m.</figcaption></figure><p>Nesse caso, se eu fornecesse minha altura, veríamos que, por eu ter 1,54 m, meu grau de pertinência para o conjunto de pessoas baixas é de 0,7. Abaixo, os gráficos demonstram o meu grau de pertinência para os dois conjuntos restantes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M5nKXjYOC8KD0ntGqt3ltA.png" /><figcaption>Pertinência para o conjunto de pessoas com estaturas mediana e alta considerando uma pessoa com 1,54 m.</figcaption></figure><p>Acima, podemos notar que com 1,54 m, meu grau de pertinência para o conjunto de pessoas com estatura mediana já é bem menor do que o que eu obtive para o conjunto de pessoas baixas, visto que agora ele é de apenas 0,2. Já para o conjunto de pessoas altas, a triste realidade é que meu grau de pertinência para ele é igual a 0 😢.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/363/0*9gflPi6WKVuJE7FD" /><figcaption>Problemas de pessoas baixas (gif retirado <a href="https://giphy.com/gifs/images-the-big-short-9SVhWZRItejW8">daqui</a>).</figcaption></figure><p><strong>3) Regras Fuzzy</strong></p><p>Um outro componente importante para o sistema de controle são as <strong>regras fuzzy</strong>. Elas são utilizadas para ligar diferentes variáveis fuzzy, de modo que elas descrevem como uma ou mais variáveis fuzzy estão relacionadas umas com as outras.</p><p>Cada uma das regras que compõem o conjunto de regras fuzzy são expressas por meio de declaração de IF/THEN (ou, em português, SE/ENTÃO). A parte do SE é chamada de <strong>antecedente</strong>, enquanto que a parte do ENTÃO é chamada de <strong>consequente</strong>.</p><p>Vamos supor que queremos relacionar a altura e o peso de uma pessoa para determinar o tamanho de sua roupa (obviamente essa abordagem é extremamente simplista e que não faz tanto sentido assim, visto que o ideal seria pegar outras medidas do corpo como da cintura, busto, quadril, etc., mas vamos utilizá-lo como exemplo apenas por ser mais simples de entender 😉). Assim, poderíamos ter a seguinte regra fuzzy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*Ypp_n1aKBs6bur1FLI5wDA.png" /><figcaption>Exemplo de uma regra fuzzy.</figcaption></figure><p>Na regra acima, é interessante notar que temos duas variáveis como antecedentes, conectadas por um <em>E</em>. Também poderíamos ter regras ligando essas variáveis com um <em>OU</em> ou <em>NÃO</em>. Por exemplo, poderíamos ter regras como:</p><ul><li><strong>SE</strong> altura é média <strong>OU</strong> peso é médio <strong>ENTÃO</strong> tamanho é médio;</li><li><strong>SE</strong> altura<strong> NÃO</strong> é baixa <strong>ENTÃO</strong> tamanho é médio.</li></ul><p><strong>4) Inferência Fuzzy</strong></p><p>Agora que já temos as definições iniciais do nosso sistema, chegou a hora de juntar tudo e fazer a inferência fuzzy. Nessa etapa, temos a análise das regras definidas na etapa anterior com as entradas fuzzy de acordo com as funções de pertinência da etapa de fuzzificação para encontrarmos a região resultante do consequente.</p><p>Existem diversas técnicas de inferência fuzzy, mas a mais utilizada é o método <strong>Mamdani</strong>. Para explicar como esse método funciona, vamos usar novamente o exemplo da altura e peso para definir o tamanho da roupa e calcularmos qual será a região resultante para esse consequente (tamanho). Vamos supor que tenhamos as seguintes definições para esse sistema:</p><p><strong>Entradas</strong> (que já vimos que podem ser chamadas também de <em>antecedentes</em>):</p><p><em>Altura</em></p><ul><li>Universo (intervalo de valores crisp): o quão alta é a pessoa, considerando uma escala entre 1,20 m a 2 m?</li><li>Conjunto fuzzy (intervalo de valores fuzzy): baixa, mediana e alta.</li><li>Função de pertinência:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*hXOx-8hQcwOe4Ty325C3Rw.png" /><figcaption>Função de pertinência para a altura</figcaption></figure><p><em>Peso</em></p><ul><li>Universo: considerando um valor entre 20 e 120 kg, o quão pesada é a pessoa?</li><li>Conjunto fuzzy: baixo, médio e alto.</li><li>Função de pertinência:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*S51t9LNamazaEHy6QWL1yg.png" /><figcaption>Função de pertinência para o peso</figcaption></figure><p><strong>Saída</strong> (também chamada de <em>consequente</em>):</p><p><em>Tamanho</em></p><ul><li>Universo: quão grande é o tamanho da roupa, numa escala entre 0 e 1?</li><li>Conjunto fuzzy: pequeno, médio e grande.</li><li>Função de pertinência:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/648/1*-nuWOjK12xW-0DRcKLfvfw.png" /><figcaption>Função de pertinência para o tamanho</figcaption></figure><p><strong>Regras</strong></p><ol><li>SE peso é baixo ENTÃO tamanho é pequeno;</li><li>SE altura é mediana OU peso é médio ENTÃO tamanho é médio;</li><li>SE altura é alta E peso é alto ENTÃO tamanho é grande.</li></ol><p>Dado o sistema definido acima, vamos fazer a inferência fuzzy ao fornecermos como entrada uma altura de 1,75 m e um peso de 75 kg.</p><p>O primeiro passo na inferência fuzzy utilizando o método Mamdami é fornecer os graus de pertinência de cada variável (de acordo com os conjuntos fuzzy) para as regras que compõem o sistema e, assim, encontrarmos a região resultante para o consequente (que no nosso caso é o tamanho da roupa). Vamos começar analisando a regra 1 definida acima:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AMoDGriVqiYCK7tkS3xbmQ.png" /><figcaption>Região resultante considerando a primeira regra (gráfico à direita).</figcaption></figure><p>Acima, podemos ver que a região resultante para a primeira regra é 0 (gráfico à direita). Isso porque a regra diz que se o peso é baixo, então o tamanho será pequeno. Conforme podemos ver no gráfico à esquerda, o peso de 75 kg não está na área do triângulo verde, que compreende o conjunto de pesos baixos; logo, o grau de pertinência para esse conjunto será 0.</p><p>Portanto, precisamos verificar o grau de pertinência da variável no conjunto fuzzy descrito na regra para verificarmos qual será o grau de pertinência para o consequente. Vamos agora observar a regra 2:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NH-8BIXAi7myo9KEbyE9-A.png" /><figcaption>Região resultante considerando a segunda regra (terceiro gráfico).</figcaption></figure><p>Para a segunda regra, vemos que a altura fornecida tem um grau de pertinência de 0,25 para o conjunto de estatura mediana (trapézio azul no primeiro gráfico), enquanto que o peso tem um grau de pertinência de 0,8 para o conjunto de peso médio (triângulo azul no segundo gráfico). Por que então o grau de pertinência do tamanho está como 0,8? Isso porque os dois antecedentes presentes nessa regra estão ligados pelo operador <strong>OU</strong>. Quando temos esse operador, o grau de pertinência do consequente será igual ao grau de pertinência máximo obtido pelos antecedentes (nesse caso, como os graus obtidos foram 0,25 e 0,8, o valor máximo foi 0,8). Como o grau de pertinência foi de 0,8 e estávamos avaliando o consequente com relação ao conjunto de tamanho médio, a região resultante compreenderá somente a área desse conjunto até chegar ao grau de pertinência de 0,8, que no terceiro gráfico da imagem acima está ilustrada como a região demarcada em vermelho claro.</p><p>Por fim, vamos observar o resultado com relação à regra 3:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i8YPPt33EkDHqYUCaiaWaQ.png" /><figcaption>Região resultante considerando a terceira regra (terceiro gráfico).</figcaption></figure><p>Para a terceira regra, podemos notar que a altura fornecida tem um grau de pertinência de 0,75 para o conjunto de estatura alta (trapézio cinza no primeiro gráfico), enquanto que o peso tem um grau de pertinência de 0,2 para o conjunto de peso alto (triângulo cinza no segundo gráfico). Por que o grau de pertinência do tamanho está como 0,2? Não deveria ser 0,75 como vimos na regra anterior?</p><p>Acontece que agora os dois antecedentes presentes nessa regra estão ligados pelo operador <strong>E</strong>. Quando temos esse operador, diferentemente do operador OU, o grau de pertinência do consequente será igual ao grau de pertinência mínimo obtido pelos antecedentes (nesse caso, como os graus obtidos foram 0,75 e 0,2, o valor mínimo foi 0,2). Como o grau de pertinência foi de 0,2 e estávamos avaliando o consequente com relação ao conjunto de tamanho grande, a região resultante compreenderá somente a área desse conjunto até chegar ao grau de pertinência de 0,2, que no terceiro gráfico da imagem acima também está ilustrada como a região demarcada em vermelho claro.</p><p>Após analisarmos as 3 regras do sistema, precisamos unir as 3 regiões obtidas para o consequente. Isso é feito na etapa de agregação das regras, em que as regiões obtidas para cada termo são combinadas em um único conjunto difuso para cada consequente. Abaixo temos essa unificação das saídas das regras para formar a região resultante destacada em vermelho no gráfico à direita:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S5pGH8t1qKdYaWVe0btQ4A.png" /><figcaption>Região resultante para o consequente tamanho.</figcaption></figure><p><strong>4) Defuzzificação</strong></p><p>Finalmente, chegamos no componente final do nosso sistema de controle fuzzy que é chamado de <strong>defuzzificação</strong>. Ela é necessária quando se espera que o sistema retorne um número e não o conjunto fuzzy criado para cada consequente, como ocorre na maioria das vezes.</p><p>Nessa etapa, precisamos converter a saída da inferência fuzzy (que é a região resultante do consequente), feita com base nas funções de pertinência e nas regras, para um valor crisp. Diversos métodos podem ser utilizados para fazer essa conversão; abaixo estão listados alguns deles:</p><ul><li>Centroide</li><li>Média dos máximos</li><li>Mínimo dos máximos</li><li>Máximo dos máximos</li></ul><p>Como o método mais utilizado é o centroide, vamos utilizá-lo para explicar essa etapa. O seu cálculo varia dependendo se o consequente pode assumir valores discretos ou contínuos. Se as possibilidades forem discretas, calculamos uma média ponderada de acordo com o grau de pertinência para a distribuição de possibilidades de saída do modelo. Já se as possibilidades de valores são contínuas, aí precisaríamos aplicar integrais nesse cálculo que é feito para valores discretos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/582/1*8X5LVVK5P7V6ACJmOXUpzQ.png" /><figcaption>Cálculo do método centroide para defuzzificação considerando valores discretos e contínuos.</figcaption></figure><p>Vamos fingir que os valores possíveis do consequente do nosso exemplo são discretos apenas para simplificar. Assim, para o exemplo que usamos na etapa anterior com as entradas sendo uma altura de 1,75 m e um peso de 75 kg, temos o seguinte valor crisp de saída do sistema:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IMZ09JZa9qLazywvbSJDRg.png" /><figcaption>Exemplo de cálculo da saída crisp utilizando o método centroide para defuzzificação.</figcaption></figure><p>Na imagem acima, é possível observar que usamos 9 pontos diferentes no nosso conjunto fuzzy para calcular o valor crisp de saída do sistema (de 0,1 a 0,9, representados no eixo X do gráfico). Para o ponto 0,1, vemos que seu grau de pertinência para o termo pequeno é 0, por isso ele é multiplicado por 0 assim como os pontos 0,2 e 0,3. Já no ponto 0,4 temos um grau de pertinência de 0,8 para o termo médio, por isso ele é multiplicado por 0,8, assim como os pontos 0,5 e 0,6. Fazemos essas multiplicações pelos graus de pertinência para todos os pontos observados e depois dividimos pela soma dos graus de pertinência (que são somados de acordo com a quantidade de pontos que foram multiplicados por eles no numerador da divisão) para fazer a média ponderada e, assim, obter o valor crisp de saída do sistema.</p><p>Portanto, fornecendo uma altura de 1,75 m e um peso de 75 kg para o sistema que criamos de exemplo, a saída desse sistema seria <strong>0,6029</strong>. Nesse caso em específico do tamanho da roupa não faz muito sentido olhar a saída crisp, visto que é muito mais informativo saber se é pequeno, médio ou grande, mas para casos reais, obter a saída do sistema fuzzy como um valor numérico pode ser muito útil para tomadas de decisões, priorizações e análises, por exemplo.</p><p>Caso quiséssemos utilizar os conceitos de pequeno, médio e grande com base na saída crisp, o que poderíamos fazer nesse exemplo é considerar o intervalo do tamanho (que, conforme definimos no universo é: <em>quão grande é o tamanho da roupa, numa escala entre 0 e 1?</em>) e dividi-lo em 3 partes de modo que as saídas crisp entre 0 e 0,33 serão consideradas um tamanho pequeno; saídas entre 0,33 e 0,66 serão tamanho médio; e saídas acima disso serão de tamanho grande. Assim, para esse exemplo em que a saída foi de 0,6029, poderíamos considerar que o tamanho seria médio.</p><p><strong>Pronto, terminamos de ver todos os componentes de um sistema de controle fuzzy!</strong></p><p>Resumindo então o passo a passo do que precisamos fazer para usar esse sistema:</p><ol><li>Identificar as variáveis (tanto as de entrada quanto de saída);</li><li>Definir os universos e termos de cada uma das variáveis;</li><li>Definir as funções de pertinência para cada subconjunto fuzzy;</li><li>Criar as regras fuzzy relacionando os antecedentes e consequentes (lembrando dos operadores E, OU e NÃO que podem ser utilizados para defini-las);</li><li>Fazer a fuzzificação de acordo com o método escolhido (aqui usamos o Mamdami, mas há outros como um chamado Sugeno);</li><li>Agregar as saídas obtidas após a fuzzificação para cada regra de forma a se obter um único conjunto fuzzy para cada consequente;</li><li>Fazer a defuzzificação para se obter um número que represente o consequente no “mundo real” (lembrando que há diversos métodos existentes que podem ser utilizados para fazer essa defuzzificação);</li><li>Volte para o começo e refaça as definições do sistema caso veja que as saídas não estão fazendo muito sentido (falaremos mais sobre isso na parte sobre vantagens e desvantagens).</li></ol><h4>Legal! E como eu faço isso para combinar os meus modelos de Machine Learning usando Lógica Fuzzy em Python?</h4><p>Isso você pode conferir na segunda parte do artigo <a href="https://medium.com/@vivian.yamassaki/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-2-2f75699987c0">aqui</a>, em que além do código em Python, também há uma parte sobre as vantagens e desvantagens de se utilizar lógica fuzzy para fazer essa combinação. Não deixe de conferir 😉</p><p><strong>Tem interesse em trabalhar conosco?<em> </em></strong>Nós estamos sempre procurando por pessoas apaixonadas por tecnologia para fazer parte da nossa Tripulação! Você pode conferir nossas vagas <a href="https://careers.creditas.com/en?utm_source=Medium%20Tech&amp;utm_medium=home&amp;utm_content=cta_post_blogs">aqui</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b5a9f0761a5d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/creditas-tech/combinando-modelos-de-machine-learning-com-l%C3%B3gica-fuzzy-parte-1-b5a9f0761a5d">Combinando modelos de Machine Learning com Lógica Fuzzy — Parte 1</a> was originally published in <a href="https://medium.com/creditas-tech">Creditas Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>