Today I want to share how my first two ETHGlobal events in 2025 went (Prague in May and Cannes in July) — through the lens of someone who wasn’t into blockchain at all. If you’re in tech, great. If you’re not, that’s fine too — I’ll show you that you don’t need to be in tech to join. I’ll talk about the overall experience, the application, the venue, the food, the project, the sponsors, the swags, the scholarship… and did I already mention the food?! 🤤

But first: what’s a hackathon?

It’s basically an intensive sprint to build a project. In about 36 hours (depending on the event), you form a team, pick a problem, build an MVP, and present it. People come from all kinds of backgrounds: product, design, data, marketing, front-end/back-end dev, blockchain dev… The magic is in that mix — everyone brings their own expertise to turn an idea into something real in a very short time.

And what’s ETHGlobal?

ETHGlobal is a non-profit organization that, since 2016, has been connecting people from all over the world to build on top of Ethereum. It became known for hosting some of the biggest hackathons in the ecosystem — in-person, across multiple cities, and also ETHOnline. But it goes beyond just a weekend: they provide workshops, mentorship, and programs that bring builders, companies, and protocols closer together.

Their mission: helping ideas turn into products and pushing Web3 into real life.

Starting with the application…

First step: go to the ETHGlobal events page, pick a city (or the online edition), and hit Apply. The form will ask about your profile, links (GitHub/portfolio), and a short note on what you enjoy building.

Once you’re approved, you’ll get an email and need to secure your spot with a stake in ETH — basically a deposit to confirm attendance. It’s not a fee: as long as you participate and submit a project, you get it back (usually within ~3 weeks after the event). In my case, it was 0.02 ETH, but the amount can vary by edition, so always check the event info page.

To stake, you’ll need a wallet. I used Phantom (which is now multichain and supports Ethereum), but MetaMask and Coinbase Wallet work great too. The flow is simple:

1. Install the app/extension
2. Write down your seed phrase somewhere safe (offline!)
3. Add a bit of ETH to your wallet
4. Connect it to the Hacker Dashboard to complete the stake

💡 Tip: if you’ve never done this before, set up your wallet ahead of time and try a small test transaction first, just to get the hang of it.

Here’s a link where you can see how to buy crypto directly in Phantom.

About the event

ETHGlobal runs several hackathons throughout the year, each one in a different city or country. I joined Prague (May) and Cannes (July) in 2025. If traveling isn’t an option right now, there’s also ETHOnline, the 100% online — and massive — edition. This year it’ll take place from October 10 to 31, 2025, which means more time to bring an idea to life at your own pace.

For the in-person hackathons, the structure usually looks like this:

• Friday: workshops all day + opening ceremony in the evening; that’s when teams form and the hacking begins.
• Saturday: full-on building marathon.
• Sunday: submission in the morning, demos and finalists on stage in the afternoon.

In practice, it’s ~36 hours of hacking (from Friday around 9pm until Sunday around 9am). And you’re not alone: besides your team, there are mentors and sponsors around to brainstorm ideas, review architecture, suggest technologies, and help you define the MVP scope.

“But I don’t know anything about blockchain/Web3, won’t I get stuck?”
That was literally me. At my first event, I didn’t even know what a wallet was. The key was building a complementary team: the Web3 experts took care of the on-chain side, while I focused on product, frontend development, UX, and storytelling. In just 36 hours you learn a ton, push yourself out of your comfort zone, and still leave with an honest list of “next things to study.”

Sponsors and Prizes

At ETHGlobal, you’re competing on two fronts:

• 🏆 ETHGlobal Awards (the “Top 10”)
  The organization selects the 10 best projects of the edition. These teams become finalists and present a live demo to the entire audience and the judges. Beyond the visibility, finalists usually receive a Finalist Pack, which includes: access to ETHGlobal Plus for 12 months, 1000 USDC per team member, $500 in flight credits for the next hackathon, on-chain/NFT credentials proving you were a finalist, invitations sessions with founders, infrastructure credits to keep building.
• 💰 Sponsor Bounties
  These are challenge tracks set by each sponsor — for example, using their SDK, protocol, API, or building integrations. You pick the bounties you want to compete for, integrate their stack into your project, and submit to their track. Usually there are 1st/2nd/3rd places (sometimes special mentions), with prizes in cash, credits, and perks. You can win bounties without being a finalist — or be a finalist without winning a bounty (that was our case). And yes, it’s possible to take home multiple bounties if your project checks all the boxes.

In short: money and perks are great, but the biggest prize is visibility. Being in the Top 10 and/or winning bounties puts your project on the radar of communities, companies, and investors — and many things born over a single weekend end up becoming real products in the following months. (Our project, for example, is turning into a startup today — and it all started back at ETHGlobal Prague.)

💰 Scholarships & Opportunities

Keep an eye out — ETHGlobal and its partners/sponsors often provide travel scholarships and support. Sometimes it’s help with accommodation, flights, small grants, or even spots at a Hacker House. The best way not to miss anything is to follow ETHGlobal and the sponsors on X (Twitter), join the Discord, and turn on notifications for announcement channels.

At ETHGlobal Cannes, for example, they opened ~100 spots for the Hacker House. We managed to get one, and it was great: a hotel close to the venue, comfy, and zero stress with transportation. In other editions (like New York), partners such as Flow have also announced scholarships and specific support for builders.

How to increase your chances:

• Have a mini “press kit” ready: who you are, what you want to build, links (GitHub/portfolio), and why you want to join that edition.
• Apply as soon as applications open (the windows can be short).
• Show past participation or contributions (even small ones) — this helps a lot.
• If you got accepted but need support, write to the event team and explain your situation.
• Start networking early: connect with mentors, sponsors, and organizers on X/LinkedIn/Discord and send a message. It’s that classic story: you already have the “no” — many scholarships pop up because someone remembered you at the right time.

💌 Short message that works (adapt & send):

Hi! I got accepted to [ETHGlobal ___] and will be building [idea in 1 line]. I’m looking for support/a housing scholarship. Can I share a short deck/links with you? Thanks! 🙌

About the project

With Pomodoki, our strategy was simplicity with solid execution: a clear, straightforward idea, smooth UX, and an easy onboarding so anyone could start using it without friction. At a hackathon, winning isn’t about promising the world — it’s about showing quick value. Focus on one main flow you can demo in just a few clicks, and tell a story: problem → solution → why now.

General hack rules

• Everything is built from scratch during the event.
• No pre-existing personal projects: you can’t just bring something finished and polish it.
• Eligibility: only accepted and registered hackers are eligible for prizes.

Want to compete for the Top 10 (finalists)?
You’ll need to follow these steps:

• Auditable code: have a public repo (with a decent README, instructions, and license).
• Open source: keep the repo open so judges can review it.
• Complete submission on the Dashboard: include a clear description, stack used, links, video, and any extra instructions.
• Finalist Judging live: if selected, present at the scheduled time on Sunday.

As soon as the submission deadline closes, judging begins. For the finalist round, the format is usually ~4 minutes of demo followed by ~3 minutes of Q&A (this may vary by edition). To get there, make sure everything is polished on the dashboard: public repo, clear description, short video, and all the key info about your MVP.

On Sunday afternoon, if you’re selected as a finalist, you’ll get a confirmation email — that’s the signal to rush to the Finalists Room, do the tech check, align your pitch, and get your live presentation setup ready. Finalists go on stage first; only after the demos does the event announce the winners of the sponsor bounties.

About the space

Ah, the infrastructure! The venues are big and super comfortable: food available all day (and even late at night — long live the snacks!), unlimited water and coffee, well-equipped stations, and even a space to crash 😴.

Before experiencing it, my idea of a hackathon was: pizza and pressure. But not here. They strike a great balance with plenty of relaxation sessions, healthy food, and a cozy environment. All of that makes the hackathon feel lighter, healthier, and way more fun.

They serve breakfast, lunch, and dinner — almost always with local food. It’s amazing and also a chance to get a taste of the country beyond the event itself. On Saturday, there are usually city-inspired unwind activities: yoga, a little movie session, ice cream carts, local snacks… the perfect reset in the middle of a hackathon.

And there’s the bonus of getting to know the place. In Cannes, for example, the event was held at the Palais des Festivals, right in front of the beach (which meant we could enjoy the seaside at the end of the day). On Friday, there were even fireworks — absolutely beautiful. ✨

Another thing that really struck me: so many women. I honestly expected to see very few, since it’s historically such a male-dominated space — so it was truly beautiful to see so many women there. In Prague, for example, there was even a women-only chill space, super warm and welcoming. ✨

Swags

Ah, the swags… what can I even say?! Simply amazing! Always customized for each city and with really great quality. Think t-shirts you’ll actually wear, stickers, pins, tote bags, backpacks… In both Cannes and Prague, the items had the vibe of each place — and I still use them to this day.

🌟 ETHGlobal Spotlight

Beyond the hackathon itself, there’s also the Spotlight — a showcase of four early-stage projects that are already usable by the public. The idea is simple: put the products directly in the hands of builders and mentors to test live and collect feedback. Usually, these are projects that have either been finalists or already look “ready for the real world.”

In Cannes, at the very first Spotlight edition there, we presented Pomodoki. It was amazing: we got tons of qualified feedback, understood our target audience better, and walked away with a clearer roadmap. Alongside us were three other incredible projects:

• Decycle: smart recycling bins that reward users in $TRASH tokens based on the type and weight of the material.
• ZKPassport: identity verification with full privacy, powered by zero-knowledge proofs.
• Signals: a continuous prediction market where you can bet in real time on BTC price ranges.

The result? People testing the product all day long, asking exactly the right questions, and giving us tons of practical insights. It’s the kind of exposure that can speed up months of product development in just one weekend.

Why join?

For the visibility, the scale of the event, and the network you build. The numbers speak for themselves:

• Prague 2025: ~825 participants, 600+ builders, 217 submissions.
• Cannes 2025 (its very first edition): ~1,150 participants, 835 registered builders, people from 67 countries.

That’s a huge crowd watching demos, giving feedback, and reaching out to chat — the perfect environment to gain traction for your project. (That’s exactly what happened with Pomodoki.)

—

To wrap up, a few recommendations…

• Start connecting before the event: join the event’s Discord, introduce yourself in the right channels, look for people with skills that complement yours, and don’t be shy about sending DMs — remember, you already have the “no.”
• Follow ETHGlobal’s official accounts and the sponsors on X, and turn on notifications so you don’t miss announcements about housing, scholarships, or side activities.
• Take a look at the tech you plan to use; you don’t need to be an expert, but having some basic understanding will save you a lot of time.

Don’t be afraid to cut scope. Build around a simple idea, and focus on execution and user experience.

That’s it! Thanks for reading this far. And if this article helped you, drop a comment below — maybe we’ll see each other at the next ETHGlobal?! 🚀✨

E hoje quero te contar como foram meus primeiros dois eventos ETHGlobal em 2025 (Praga em maio, e Cannes em julho) pela minha lente de quem não era de blockchain. Se você é de tech, ótimo. Se não é, chega mais — eu te mostro, na prática, que não precisa ser de tech pra participar. Vou falar de experiência geral, aplicação, local, comida, projeto, sponsors, swags, scholarship, etc… já falei comida?!🤤

Mas, antes: o que é um hackathon?

É um intensivão de desenvolvimento de um projeto. Em cerca de 36 horas (varia conforme o evento), você forma um time, escolhe um problema, constrói um MVP e apresenta. Tem gente de tudo quanto é perfil: produto, design, dados, marketing, dev front/back, dev blockchain... O legal está justamente nessa combinação: cada pessoa contribui com sua experiência para transformar a ideia em algo concreto em pouco tempo.

E o que é a ETHGlobal?

O ETHGlobal é uma organização sem fins lucrativos que, desde 2016, conecta pessoas do mundo todo para construir em cima do Ethereum. Ficou conhecida por organizar alguns dos maiores hackathons do ecossistema — presenciais, em várias cidades, e também o ETHOnline — e vai além do fim de semana: oferece workshops, mentorias e programas que aproximam builders, empresas e protocolos.
A missão é: ajudar ideias a virarem produtos e impulsionar a Web3 para a vida real.

Começando com a inscrição…

Primeiro passo: entre na página de eventos da ETHGlobal, escolha a cidade ou edição online e clique em Apply. O formulário pede seu perfil, links (GitHub/portfolio) e um breve contexto do que você curte construir.

Depois da aprovação, você recebe um e-mail e precisa garantir sua vaga com uma stake em ETH, um depósito só para confirmar presença. Não é uma taxa: participando e submetendo um projeto, você recebe o reembolso (geralmente em ~3 semanas após o evento). No meu caso, foi 0.02 ETH; esse valor pode variar por edição, então sempre confira a página informativa do evento.

Para fazer a stake, você vai precisar de uma wallet. Eu usei Phantom (que hoje é multichain e suporta Ethereum), mas MetaMask e Coinbase Wallet também funcionam super bem. O fluxo é simples:

1. Instale o app/extensão,
2. Anote a seed phrase em um lugar seguro (offline!)
3. Adicione um pouco de ETH na sua wallet,
4. E então conecte-a ao Hacker Dashboard para concluir a stake.

Dica: se nunca mexeu com isso, cria a wallet antes do evento e faz um teste com um valor pequeno, só pra pegar o jeito.

Aqui nesse link você pode ver como comprar crypto no Phantom.

Sobre o evento

Acontecem vários ETHGlobal ao longo do ano, sempre em um país/cidade diferente. Eu fui a Praga (maio) e Cannes (julho) em 2025. Se viajar não rolar agora, tem o ETHOnline, a edição 100% online — e gigante. Este ano será de 10 a 31 de outubro de 2025, ou seja, mais tempo pra tirar uma ideia do papel e fazer com calma.

No presencial, o formato é o seguinte:

• Sexta: workshops o dia inteiro e abertura à noite; rola a formação de times e começa o “valendo!”.
• Sábado: maratona de desenvolvimento.
• Domingo: entrega pela manhã e, à tarde, demos e finalistas no palco.

Na prática, são ~36 horas de hacking (de sexta, ~21h, até domingo, ~9h). E você não está sozinho(a): além do seu time, tem mentores e patrocinadores disponíveis pra discutir ideias, revisar arquitetura, indicar tecnologias e ajudar a fechar o escopo do MVP.

“Mas eu não sei nada de blockchain/Web3, vou travar?”
Fui exatamente essa pessoa. No meu primeiro evento eu nem sabia o que era uma wallet. O segredo foi montar um time complementar: quem dominava Web3 puxou a parte on-chain; eu foquei em produto, marketing, UX e storytelling. Em 36 horas você aprende muito, se desafia e ainda volta pra casa com uma lista honesta de “próximos estudos”.

Patrocinadores e prêmios

No ETHGlobal você concorre em duas frentes:

1. Premiação do ETHGlobal (os “Top 10”) — a organização escolhe 10 melhores projetos da edição. Esses times viram finalistas e apresentam uma demo ao vivo para todo o público e jurados. Além da visibilidade, os finalistas costumam receber um Finalist Pack, com benefícios como: acesso ao ETHGlobal Plus por 12 meses, 1000 USDC por membro do time, $500 em crédito de voo para o próximo hackathon, credenciais on-chain/NFT comprovando que você foi finalista, convites/mentorias com founders e créditos de infraestrutura para continuar o build.
2. Bounties dos patrocinadores — são trilhas com desafios específicos de cada sponsor (usar um SDK, protocolo, API, compor integrações). Você escolhe as bounties que quer disputar, integra a stack no seu projeto e submete na trilha deles. Normalmente há 1º/2º/3º lugar (às vezes menções especiais), com prêmios em dinheiro, créditos e perks. Dá pra ganhar bounties mesmo sem ser finalista, ou vice -versa (nosso caso, a gente foi finalista mas não ganhou a bounty) — e dá pra levar mais de uma se o projeto cobrir bem os requisitos.

Resumo: grana e benefícios ajudam, mas o maior prêmio é a visibilidade. Estar entre os 10 e/ou ganhar bounties coloca seu projeto no radar de comunidades, empresas e investidores — e muita coisa que nasce no fim de semana vira produto de verdade nos meses seguintes (O nosso projeto por exemplo, está virando startup hoje, e ele começou lá no ETHGlobal em Praga).

💰 Scholarship (bolsas) e oportunidades

Fica de olho porque sempre pintam bolsas de viagem e apoios de parceiros/sponsors — às vezes é ajuda com hospedagem, passagem, grants pequenos ou Hacker House. O caminho mais certeiro pra não perder nada é seguir a ETHGlobal e os patrocinadores no X (Twitter), entrar no Discord e ativar as notificações dos canais de anúncios.

No ETHGlobal Cannes, por exemplo, abriram ~100 vagas para a Hacker House. A gente conseguiu uma dessas e foi ótimo: hotel pertinho do venue, confortável e zero estresse com deslocamento. Em outras edições (tipo Nova York), parceiros como a Flow também anunciam bolsas e apoios específicos pra builders.

Como aumentar suas chances:

• Tenha um mini “press kit” pronto: quem você é, o que quer construir, links (GitHub/portfolio) e por que participar daquela edição.
• Aplique assim que abrir (as janelas podem ser curtas).
• Mostre histórico de participação ou contribuições (mesmo pequenas) — isso ajuda muito.
• Se foi aceito(a) no hackathon mas precisa de ajuda, escreva pro time do evento explicando a situação.
• Ative o networking desde já: conecte-se com mentores, sponsors e organizadores no X/LinkedIn/Discord e mande mensagem. É aquela história: o “não” você já tem — muitas bolsas surgem justamente porque alguém lembrou de você na hora certa.

Mensagem curtinha que funciona (adaptar e colar):

Oi! Fui aceito(a) no [ETHGlobal ___] e vou construir [ideia em 1 linha]. Estou buscando apoio/bolsa de hospedagem. Posso te mandar um mini deck/links? Obrigado(a)! 🙌

Sobre o projeto

No nosso caso com o Pomodoki, a estratégia foi simplicidade com boa execução: uma ideia simples e clara, UX legal e onboarding acessível pra qualquer pessoa começar a usar sem fricção. Em hackathon, ganhar não é prometer o mundo — é mostrar valor rápido. Foque em 1 fluxo principal que você consegue demonstrar em poucos cliques e conte uma história: problema → solução → por que agora.

Regras gerais do hack

• Tudo do zero durante o evento: a construção acontece no fim de semana.
• Nada de projeto pessoal pré-existente: não vale levar algo pronto e só “dar uma polida”.
• Elegibilidade: só quem foi aceito(a) e está registrado(a) como hacker no evento concorre a prêmios.

Quer disputar os Top 10 (finalistas)?

Pra concorrer, precisa seguir o seguinte:

• Código auditável: tenha um repositório público (com README decente, instruções e licença).
• Open source: deixe o repo aberto para os jurados avaliarem.
• Submissão completa no Dashboard: descrição clara, stack usada, links, vídeo e qualquer instrução extra.
• Finalist Judging ao vivo: apresente no horário indicado se for selecionado(a) no domingo.

Assim que fecha o prazo de submissão, começa a avaliação. No julgamento de finalistas, o formato geralmente é ~4 minutos de demo seguidos de ~3 minutos de Q&A (pode variar por edição). Para chegar lá, deixe tudo redondo no dashboard: repositório público, descrição clara, vídeo curto e as infos essenciais do seu MVP.

No domingo à tarde, se você for selecionado(a) como finalista, chega um e-mail de confirmação — é o sinal para correr para a Finalists Room, fazer o tech check, alinhar o pitch e organizar o setup da apresentação ao vivo. Os finalistas apresentam primeiro; só depois das demos o evento anuncia os vencedores das bounties dos patrocinadores.

Sobre o espaço

Ah, a infraestrutura! Os venues são grandes e super confortáveis: comida o dia todo (e de madrugada — viva os snacks!), água e café à vontade, estações bem equipadas e até espaço pra dormir.

Antes de conhecer o evento, meu conceito de hackathon era: pizza e pressão. Mas ali não. Eles conseguem equilibrar tudo muito bem, com várias sessões de descompressão, comidas saudáveis e um ambiente confortável. E toda essa estrutura deixa o peso do hackathon bem mais leve, mais saudavel e divertido.

Eles servem café da manhã, almoço e jantar, quase sempre com comidas locais — incrível e uma chance de conhecer um pouco do país além do evento. No sábado, normalmente rolam atividades de descompressão ligadas à cidade: yoga, cineminha, carrinho de sorvete, snacks típicos… dá um reset ótimo no meio do hackathon.

E tem o bônus de conhecer o lugar. Em Cannes, por exemplo, o evento foi no Palais des Festivals, bem em frente à praia (ou seja, dava pra curtir no final do dia). Na sexta, ainda teve fogos de artifício; foi lindo demais.

Outra coisa que me marcou: muitas mulheres. Eu esperava ver poucas, por ser um ambiente historicamente masculino, então foi lindo demais ver tanta mulher. Em Praga, por exemplo, ainda havia um espaço de chill só para mulheres, super acolhedor.

Swags

Os swags… o que dizer dos swags?! simplesmente, incríveis! Sempre personalizados de acordo com a cidade e com uma qualidade ótima. Pense em camisetas que você realmente vai usar, adesivos, pins, tote bags, mochila, scarpe… Em Cannes e Praga vieram peças com a cara de cada lugar, e eu uso eles até hoje.

🌟 ETHGlobal Spotlight

Além do evento, agora também tem o Spotlight, que é uma vitrine com quatro projetos em estágio inicial já usáveis pelo público. A ideia é simples: colocar os produtos na mão de builders e mentores para testar ao vivo e coletar feedbacks. Geralmente entram projetos que já passaram por finais ou têm cara de “prontos para o mundo real”.

Em Cannes, na primeira edição por lá, levamos o Pomodoki. Foi incrível: recebemos muito feedback qualificado, entendemos melhor quem é nosso público-alvo e saímos com um roadmap mais claro. Ao nosso lado estavam outros três projetos incríveis:

• Decycle: reciclagem em lixeiras inteligentes com recompensa em $TRASH de acordo com tipo e peso do material.
• ZKPassport: verificação de identidade preservando a privacidade (zero-knowledge).
• Signals: mercado de previsão contínuo, onde dá pra apostar em faixas de preço do BTC em tempo real.

Resultado? Gente testando o dia todo, perguntas que pegam no ponto certo e um monte de insights práticos. É o tipo de exposição que acelera meses de produto em um fim de semana.

Por que participar?

Pela visibilidade, pelo tamanho do evento e pela rede de contatos que se cria. Os números falam por si: em Praga 2025 foram cerca de 825 participantes, mais de 600 pessoas construindo projetos e 217 submissões; em Cannes 2025, a primeira edição por lá, houve cerca de 1.150 participantes, 835 pessoas inscritas para construir e gente de 67 países. É muita gente assistindo apresentações, avaliando e chamando para conversar — o cenário perfeito para dar tração ao seu projeto (foi assim com o Pomodoki).

—

Para fechar, algumas recomendações…

Comece os contatos antes do evento: entre no servidor do evento, apresente-se nos canais corretos, procure pessoas com perfis que se complementem ao seu e mande mensagem sem vergonha — é aquela história, o “não” você já tem. Siga os perfis oficiais do ETHGlobal e dos patrocinadores na rede social X e ative as notificações para não perder avisos de alojamento, bolsas e atividades paralelas. Dê uma olhada nas tecnologias que pretende usar; não precisa virar especialista, mas chegar com noção do básico economiza muito tempo.

Não tenha medo de cortar escopo, construa em uma ideia simples, foque em execução e experiência do usuário.

É isso! Obrigada por ler até aqui. E se esse artigo te ajudou, conta nos comentários. Quem sabe a gente se encontra no próximo ETHGlobal?!

O que exatamente é um Algoritmo de pesquisa? É um tipo de algoritmo utilizado em inteligência artificial para encontrar a melhor solução para um problema explorando diferentes possibilidades no que chamamos de espaço de busca.

Imagine que você tem um monte de opções e deseja descobrir a melhor, considerando certas restrições. É aí que entram os algoritmos de busca.

Esses algoritmos passam por um grande número de possibilidades organizando-os em um tipo de gráfico, geralmente uma árvore. Eles então avaliam o melhor caminho, ou solução, com base em um determinado conjunto de regras. O objetivo é encontrar a solução ótima que atenda aos critérios do algoritmo.

Existem dois tipos principais de algoritmos de pesquisa:

Pesquisa Desinformada (Uninformed Search)

São algoritmos que não utilizam heurísticas específicas para orientar a busca. Eles exploram todas as ações possíveis de um estado, expandindo os nós uniformemente. Eles podem explorar muitos caminhos irrelevantes antes de encontrar uma solução. Alguns exemplos incluem:

• BFS — Pesquisa em amplitude
• DFS — Pesquisa em profundidade
• Uniform cost

Pesquisa informada (Informed Search)

São algoritmos que possuem informações sobre o objetivo durante a pesquisa, o que permite que a pesquisa priorize a expansão em direção ao estado final desejado, em vez de explorar caminhos que podem ter um custo favorável, mas não levam ao objetivo ou ao melhor solução geral. Em outras palavras, esses algoritmos utilizam regras (heurísticas) que ajudam a estimar onde está o objetivo. Exemplos incluem:

• Greedy Search
• A* Search

Esses algoritmos podem ser usados em diversas aplicações, como sistemas de navegação, como Google Maps, para calcular a rota mais eficiente entre dois pontos. Resolver puzzles, de forma a encontrar a melhor sequência de movimentos ou ações que conduza ao objetivo do jogo. Exploração do labirinto, encontrando um caminho para a saída.

Acesso ao Google Drive de resumos e exercícios

Agora estou disponibilizando exercícios relacionados a esses algoritmos e outros materiais de estudo em meu Google Drive. Durante minha jornada como estudante e criador de conteúdo, compartilharei continuamente resumos e conteúdos exclusivos com vocês.

Para apoiar esse projeto e continuar trazendo mais conteúdo, defini um valor simbólico. Se você tiver interesse em acessar esses materiais e quiser apoiar meu projeto, clique nesse link .

E antes de mais nada, agradeço por todo apoio de vocês sempre😍💖. Eu espero que esses recursos sejam úteis pra vocês assim como foram pra mim 😊✨

Vídeo no Youtube — versão em inglês

“Qualquer tolo consegue escrever código que um computador entenda. Bons programadores escrevem código que humanos possam entender.” Martin Fowler.

Terminei recentemente a leitura do livro “Código Limpo”, de Robert C. Martin e simplesmente explodiu minha mente! ✨Porque quem nunca se sentiu aliviado ao ver um código confuso funcionar?!

E a frase acima, escrita pelo autor do livro, Uncle Bob (tio Bob) descreve muito bem o que é abordado no livro, sobre valores para um profissional se tornar um programador melhor. Acho que deveria ser uma leitura obrigatória para todos desenvolvedores✨!

Em resumo, o autor mostra o que é um código ruim com exemplos reais e também a forma mais adequada para manter um código limpo, legível, simples, com clareza e consistência, de forma que qualquer humano consiga ler.

Mesmo um código ruim pode funcionar. Mas se ele não for limpo, pode acabar com uma empresa de desenvolvimento.

Você sabe quem escreveu código pensando em fazer o seu melhor, pensando em outras pessoas que lerão ele. Quantas vezes você se pegou lendo um código e gastando muitas horas apenas para entendê-lo? Quantas vezes você pressionou Ctrl + F para pesquisar uma variável no arquivo?

O autor tenta deixar bem claro que o objetivo não é vender seu padrão de desenvolvimento como uma verdade absoluta, ao invés disso, Robert tenta mostrar como trabalha e o que acha uma boa prática, além de mostrar o que não gosta e consultar programadores responsáveis por projetos e linguagens conhecidas para reforçar seu ponto de vista.

No livro, Robert também frisa um ponto com relação aos detalhes. Porque detalhes importam sim! Como diria o ditado dinamarquês “Honestidade nas pequenas coisas não é uma pequena coisa”. Ou seja, devemos prestar atenção as pequenas coisas e também ser honesto com elas. Ser honesto com nosso código, com nossos colegas e acima de tudo com nós mesmos sobre o estado do nosso código. Fizemos o melhor para deixar o mais limpo possível?

Um ponto importante que está no prefácio escrito por James O. Coplien e que vai de encontro com os princípios defendidos por Robert C. Martin é que 80% do que fazemos em desenvolvimento de software pode ser considerado como reparo. Sendo assim, o que podemos fazer para facilitar esta situação? Para isso, eles trazem uma filosofia japonesa de controle de qualidade chamada Total Productive Maintenance (TPM). O foco deste controle de qualidade está na manutenção e não na produção.

Em detalhes, a filosofia é composta por 5 conceitos:

1. Ordenação: nomear variáveis, funções e arquivos de forma apropriada para que você consiga encontrar o que está procurando.
2. Sistematizar: manter cada coisa em seu lugar. Um trecho de código deve estar onde você espera encontrar, caso não esteja, mova para o local certo.
3. Limpeza: manter o seu código limpo, indentar corretamente, remover blocos antigos de código e que foram comentados.
4. Padronização: seguir um padrão, em que todo o time faz as coisas da mesma forma, no mesmo estilo.
5. Disciplina: mantenha disciplina, siga as regras e esteja aberto a mudanças pessoais para se adaptar ao que foi combinado.

De forma resumida, construa programas que sejam mais fáceis de refatorar e fazer manutenção, pois escrever um código limpo e legível é tão importante quanto fazer ele funcionar.

Bom, mas daí você pode me perguntar: mas o que é um código sujo?? Pra entender um pouco mais sobre código limpo, é importante saber o conceito de código sujo e quais os seus impactos.

O que é código sujo e quais seus efeitos?

“Todos já nos sentimos aliviados ao vermos nosso programa confuso funcionar e decidimos que uma bagunça que funciona é melhor do que nada. Todos nós já dissemos que revisaríamos e limparíamos o código depois. É claro que naquela época não conhecíamos a lei de LeBlanc: Mais tarde é igual a nunca.”

Se você já teve alguma experiência com programação e códigos, vai perceber quando ver um código bom e um código ruim. No código ruim parece que você está andando em uma mata fechada, pois tem pouquíssima previsibilidade do que está por vir, além de andar em cima de uma areia movediça onde qualquer movimento brusco, você afunda ainda mais em diversos detalhes de implementação confusos e desnecessários.

Com um código ruim, a produtividade cai, fica muito mais difícil de fazer manutenção, continua gerando códigos ruins, novas funcionalidades são substituídas por correções de bugs, acaba-se criando um novo projeto pois o inicial gerou muitos problemas.

O que é Código limpo?

Como mencionado anteriormente, Código limpo é um código legível, simples e com clareza. Um código é dito limpo quando não é preciso se esforçar para entender o que o código está fazendo, dispensam-se comentários no código para poder explicá-lo.

Segundo Michael Feathers, código limpo é “[…] se importar. Um código limpo é um código que foi cuidado por alguém. Alguém que calmamente o manteve simples e organizado; alguém que prestou atenção necessária aos detalhes, alguém que se importou”.

Mas também não basta saber escrever um código limpo. É preciso manter o código limpo com o passar do tempo, porque se tem uma coisa que é bastante comum de acontecer é começar um projeto bonitinho do zero, mas com o passar do tempo ele virar uma completa bagunça.

Há uma regra do escotismo que diz:

“Deixe a área do acampamento mais limpa do que como você a encontrou”. Regra do escotismo.

Trazendo a regra para o mundo da programação, a regra significa deixar o código mais limpo do que estava antes de mexer nele.

E para complementar o conceito de Clean Code abordado até aqui, recomendo assistir ao vídeo da série Dicionário de programador do canal Código Fonte TV:

5 princípios para manter um código limpo

No livro, o autor mostra vários princípios e boas práticas pra manter o código limpo. Trouxe alguns desses princípios e passos mencionados pelo autor, para te ajudar a manter um código limpo, simples e legível:

1. Nomes significativos:

Escolher bons nomes leva tempo, mas economiza mais. A definição de nome é essencial para o bom entendimento de um código. Aqui, não importa o tipo de nome, seja ele: variável, função, parâmetro, classe, método.

Ao definir um nome, é preciso ter em mente 2 pontos principais:

1. Ele deve ser preciso e passar logo de cara sua ideia central. Ou seja, deve ir direto ao ponto;
2. Não se deve ter medo de nomes grandes. Se a sua função ou parâmetro precisa de um nome extenso para demonstrar o que realmente representa, é o que deve ser feito.

Além disso, é importante evitar informações erradas, fazer distinções de nomes significativas, usar nomes “buscáveis”, não utilizar abreviações. Em geral, classes devem ser representadas por substantivos (Cliente, Produto, NotaFiscal, etc.) e métodos devem ser representadas por verbos ou frases verbais (salvar, adicionar, enviarNotaFiscal).

Palavras comuns são redundantes. O nome de uma variável jamais deve conter a palavra “variável”. O nome de uma tabela jamais deve conter a palavra “tabela”. Imagine que você encontre uma classe Customer e outra CustomerObject. Qual seria a melhor para possuir o histórico de pagamento de um cliente?

Também é importante utilizar nomes pronunciáveis. Se não puder pronunciá-lo, não terá como discutir sobre tal nome sem parecer um idiota. “Bem, aqui no bê cê erre três cê ene tê, temos um pê esse zê quê int, viram?”

No exemplo abaixo, é possível ver uma variável criada chamada “genymdhms”. Mas o que ela significa?

Viu?! Eu não consigo entender o que ela está me dizendo, e também é difícil de pronunciar. A forma representada abaixo fica muito mais claro.

Por fim, usar números sequenciais em nomes (a1, a2, a3…) é o oposto da seleção de nomes expressivos. Eles não geram confusão, simplesmente não oferecem nenhuma informação.

2. Funções

Uma função deve fazer apenas uma coisa e devem ser pequenas. Basicamente se sua função está grande ou faz mais de uma coisa, refatore seu código, extraia funcionalidades diferentes de dentro da sua função e crie uma nova.

Não tenha medo de criar nomes extensos, pois eles são melhores que um pequeno e enigmático. Um nome longo e descritivo é melhor que um comentário extenso e descritivo. Use uma convenção de nomenclatura que possibilite uma fácil leitura de nomes de funções com várias palavras, e então, use estas para dar a função um nome que explique o que ela faz.

No livro, o autor fala que a quantidade ideal de parâmetros para uma função é zero(nulo). Depois vem um mônade, díade… Isso porque quando uma função retorna várias coisas, ficamos sem entender e faz com que leiamos novamente.

3. Comentários

“Não insira comentários num código ruim, reescreva-o.” Brian W. Kernighan

Comentário não é justificativa para ter um código sujo, bons códigos são auto documentados. Segundo o livro, não deve ser feito:

• Comentários longos: usado para descrever versões e modificações do código. Há casos onde é registrado no comentário a data de alteração do código, o que mudou e quem mudou, esse é trabalho para as ferramentas de controle de versão e não para um comentário.
• Comentários ruidosos: dizem o óbvio e não fornecem novas informações.

• Código comentado: código comentado para ser usado futuramente não existe, é um código que esta se depreciando.

Esse princípio afirma que comentários podem ser feitos, porém, se forem realmente necessários.

Mas por que não usar comentários?

Segundo o tio Bob, porque eles mentem. Quanto mais antigo um comentário for e quanto mais longe estiver do código o qual ele descreve, mais provável que esteja errado. Não é realístico que programadores consigam sempre manter atualizados.

Logo, se for para comentar, que seja somente o necessário e que seja revisado juntamente com o código que o acompanha.

Os pontos citados pelo autor sobre comentários em código são ótimos, em muitos casos comentários são adicionados para aliviar a consciência do programador após ter feito um código ruim, sendo assim, ao invés de escrever um comentário, reescreva seu código.

Houve uma época em que explicar o código em comentários poderia ser prático. Mas com os sistemas de controle de código, eles nos lembrarão. Não precisamos dos comentários, porque não perderemos.

4. Números mágicos

Números mágicos são valores numéricos ou textuais no código que não são auto descritivos.

Ao invés de usar números no meio do código é aconselhável criar constantes com nomes significativos, como no exemplo abaixo:

5. Formatação

A formatação do código também é muito importante para legibilidade do mesmo. Para manter o código limpo, pode-se seguir as seguintes práticas:

• Espaçamento vertical entre conceitos (linhas em branco);
• Declaração de variáveis o mais próximo possível de onde serão usadas;
• Se uma função chama outra, elas devem ficar verticalmente próximas;
• Manter linhas curtas. O limite adotado pelo autor é de 120 o comprimento máximo da linha;
• Utilizar a indentação.

Abaixo, um exemplo do uso errado, não legível do código, sem formatação, sem indentação, espaçamentos…

Agora olha como fica seguindo uma formatação padrão:

Por fim, o capítulo 17 fecha o livro com uma lista de “mau cheiros no código” e descobertas. Condensa as ideias do livro num formato direto e centrado no problema — ideal para revisão. E com 29 páginas, é como uma referência boa e concisa.

Para saber mais:

Se quiser entender mais sobre o conceito de Clean Code, recomendo o vídeo da Alura que também adentra nos princípios de SOLID.

Também recomendo ouvirem o “P de podcast” que fala sobre Código Limpo: https://anchor.fm/pdepodcast/episodes/Cdigo-limpo-ej4e73

E aí, me conta aqui nos comentários se já leu esse livro e o que achou👇.

Me siga nas redes sociais ▶️ https://beacons.page/letipires

Código Limpo — Parte 01 was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.

A modelagem de tópicos é um método que extrai tópicos ocultos de grandes volumes de texto. Ela utiliza as aplicações do processamento de linguagem natural para extrair os tópicos que as pessoas estão mais discutindo, dentre os volumes de texto apresentados.

E o modelo Latent Dirichlet Allocation (LDA) é um algoritmo utilizado para modelagem de tópicos que tem implementações no pacote Gensim do Python.

Esse processo é bem importante para as empresas que querem criar estratégias de monetização e melhoria de serviços, por exemplo, seja analisando avaliações de clientes, feedbacks de usuários, notícias, redes sociais, etc.

Sendo assim, o objetivo deste artigo é de criar um algoritmo automatizado que possa ler documentos e gerar os tópicos mais discutidos.

Para isso, é de extrema importância que os dados tenham qualidade no pré-processamento do texto e na melhor estratégia para encontrar o número de tópicos. Isso pode garantir uma qualidade maior, clareza e significância nos tópicos extraídos.

Esta análise foi realizada com dados extraídos de um repositório do Github nomeado “Manchetes Brasil”, de Paula Dornhofer Paro Costa (Costa, PDP), 2017. Essa base conta com dados de 500 manchetes de jornais brasileiros em datas específicas de dezembro de 2016 a agosto de 2017. Os jornais são: Valor Econômico, O Globo, Folha de S. Paulo e O Estado de S. Paulo.

O link para a base de dados pode ser acessada no link: https://github.com/pdpcosta/manchetesBrasildatabase

Como será estruturado este documento:

1. Importação de pacotes
2. Coleta de dados
3. Limpeza de dados
4. Modelagem de bigramas e trigramas
5. Transformação de dados: corpus e dicionário
6. Aplicação do modelo LDA
7. Métricas: coerência e complexidade
8. Encontrando o número ideal de tópicos
9. Conclusão
10. Referências

1. IMPORTAÇÃO DE BIBLIOTECAS

Para começar, foi necessário importar algumas bibliotecas importantes, dentre elas o pandas, numpy, matplotlib, nltk, re e gensim:

import re 
import numpy as np 
import pandas as pd 
from pprint import pprint 
import unicodedata  

# Importando a library Natural Language Toolkit - NLTK para tratamento de linguagem natural. 
import nltk 
nltk.download('wordnet') 
nltk.download('punkt')  

#Importando as stopwords 
from nltk.corpus import stopwords 
nltk.download('stopwords') 
language = 'portuguese'  
stopwords = stopwords.words(language) 
stopwords = list(set(stopwords))  

#Gensim 
import gensim 
import gensim.corpora as corpora 
from gensim.utils import simple_preprocess 
from gensim.models import CoherenceModel  

#Plotagem 
import matplotlib.pyplot as plt 
import matplotlib.colors as mcolors 
from wordcloud import WordCloud, STOPWORDS 
%matplotlib inline  
import logging 
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.ERROR)  

import warnings warnings.filterwarnings("ignore",category=DeprecationWarning)

2. COLETA DE DADOS

O conjunto de dados utilizado, como foi mencionado anteriormente, é a base de manchetes brasileiras.

Portanto, foi importado para dentro do Google Colab o arquivo csv, através do código abaixo. O arquivo contém colunas de dia, mês, ano, jornal e as headlines(notícias).

Para visualizar, foi aplicado o método head() que traz os 5 primeiros dados do nosso dataset:

caminho = '/content/manchetesBrasildatabase.csv'
dataframe = pd.read_csv(caminho, quotechar="'", header = None, names = ["Day", "Month", "Year", "Company", "Headline"])
dataframe.head()

Para este artigo, foi realizada a modelagem de tópicos somente para o jornal Folha de São Paulo, portanto, aplicou-se o método loc() para selecionar somente este jornal, atribuindo a uma nova variável, como mostra abaixo:

dataframe_folha = dataframe.loc[dataframe['Company'] == 'Folha'] dataframe_folha

Sendo assim, o dataframe ficou com 127 colunas e 5 colunas.

3. LIMPEZA DOS DADOS

Como é possível visualizar na coluna Headline, os textos apresentam pontuações, acentuações, letras maiúsculas, stopwords… Para aplicação do modelo LDA é necessário que as palavras estejam sem essas distrações.

Além disso, para ser consumido pelo LDA, é necessário fazer uma quebra de cada frase em palavras através da tokeinização.

Portando o seguinte processo foi realizado:

a) Conversão da coluna para lista, remoção de novas linhas e distrações:

# Convertendo para lista data = dataframe_folha.Headline.values.tolist()

# Removendo novas linhas 
data = [re.sub('\s+', ' ', sent) for sent in data]

# Removendo distrações 
data = [re.sub("\'", "", sent) for sent in data]

b) Substituição de letras maiúsculas por letras minúsculas:

#Aplicando função para deixar somente letras minúsculas.
def to_lowercase(words):
   new_words = []     
   for word in words: 
     new_word = word.lower()         
     new_words.append(new_word)     
   return new_words

c) Remoção de caracteres NON-ASCII:

#Aplicando função para remover os caracteres Non ASCII
def remove_non_ascii(words):

"""Remove non-ASCII characters from list of tokenized words"""
    new_words = []
    for word in words:
       new_word = unicodedata.normalize('NFKD', word).encode('ascii', 'ignore').decode('utf-8', 'ignore')
       new_words.append(new_word)
    return new_words

d) Remoção de stop words:

As stop words (ou palavras de parada) são palavras que podem ser consideradas irrelevantes para um conjunto de documentos. Ex: e, os, de, para, com, sem, foi.

def remove_stopwords(texts):
    return [[word for word in simple_preprocess(str(doc)) if word not in stopwords] for doc in texts]

# Removendo Stop Words
data_words_nostops = remove_stopwords(data_words)

Somente aplicando as stopwords do NLTK não é suficiente para as palavras em português, pois não possui uma base tão boa. Por isso, aplicou-se o método append() para algumas palavras identificadas na análise, adicionando-as à biblioteca de stopwords.

#Adicionando novas stopwords em português 
stopwords = nltk.corpus.stopwords.words('portuguese') stopwords.append('ja') 
stopwords.append('viu') 
stopwords.append('vai') 
stopwords.append('ne') 
stopwords.append('ai') 
stopwords.append('ta') 
stopwords.append('gente') 
stopwords.append('nao') 
stopwords.append('aqui') 
stopwords.append('tambem') 
stopwords.append('vc') 
stopwords.append('voce') 
stopwords.append('entao') 
stopwords.append('ate') 
stopwords.append('agora') 
stopwords.append('ser') 
stopwords.append('sempre') 
stopwords.append('ter') 
stopwords.append('so') 
stopwords.append('porque') 
stopwords.append('sobre') 
stopwords.append('ainda') 
stopwords.append('la') 
stopwords.append('tudo') 
stopwords.append('ninguem') 
stopwords.append('de')

e) Remoção de pontuação e tokeinização através do simple_preprocess do Geisim:

#Removendo pontuação e fazendo a tokeinização (para conseguir aplicar o modelo LDA)

def sent_to_words(sentences):
     for sentence in sentences:
         yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))  # deacc=True removes punctuations  

data_words = list(sent_to_words(data))

4. MODELAGEM DE BIGRAMAS E TRIGRAMAS

Os bigramas são duas palavras que ocorrem juntas num mesmo documentos e os trigramas são 3 palavras que ocorrem frequentemente juntas. Como exemplo temos a palavra ‘São Paulo’.

O Gensim apresenta um modelo Phrases que implementa esses bigramas e trigramas. Pra isso, é preciso passar dois argumentos importantes: o min_count e o threshold.

“Quanta mais altos os valores desses parâmetros, mais difícil será para as palavras serem combinadas com os bigramas.” (*PRABHAKARAN, 2020)

def make_bigrams(texts):
     return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
     return [trigram_mod[bigram_mod[doc]] for doc in texts]  

# Formando Bigrams 
data_words_bigrams = make_bigrams(data_words_nostops) data_words_bigrams

5. TRANSFORMAÇÃO DE DADOS: CORPUS E DICIONÁRIO

Para dar entrada no modelo LDA é necessário ter um dicionário (id2world) e o corpus. O código abaixo realiza essa passagem:

# Criando dicionário id2word = corpora.Dictionary(data_words_bigrams)  

# Criando corpus 
texts = data_words_bigrams  

# Frequencia do documento do termo 
corpus = [id2word.doc2bow(text) for text in texts]  

# visualizando 
print(corpus[:1])

#RESULTADO [[(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1)]]

6. APLICAÇÃO DO MODELO LDA

Com o corpus e o dicionário, é possível criar o modelo LDA. Além disso, é necessário incluir o número de topicos para treinar o modelo.

Outros parâmetros passados são:

• alpha e eta, que segundo a documentação do Gensim tem um padrão;
• chunksize que representa o numero de documentos que serão usados em um bloco de treinamento;
• update every mostra a frequência em que os parâmetros são atualizados;
• passes representa o total de passes para treinamento.

# Construindo LDA Model
lda_model = gensim.models.ldamodel.LdaModel(corpus=corpus, 
                                            id2word=id2word,
                                            num_topics=10,
                                            random_state=100,
                                            update_every=1,
                                            chunksize=100,
                                            passes=10,
                                            alpha='auto',
                                            per_word_topics=True)

# Imprindo as palavras chaves nos 10 tópicos pprint(lda_model.print_topics()) 
doc_lda = lda_model[corpus]

Neste modelo utilizou-se 10 tópicos diferentes, no qual cada tópico representa uma combinação de palavras-chave e cada uma possui uma contribuição com um nível de importância diferente (peso).

#RESULTADO:
[(0,
  '0.052*"lava" + 0.052*"jato" + 0.026*"ameaca" + 0.026*"economia" + '   '0.026*"novo" + 0.026*"pf" + 0.022*"manteve" + 0.022*"repasse" + '   '0.022*"ilicito" + 0.022*"retomada"'),
(1,
 '0.042*"lula" + 0.031*"trump" + 0.031*"diz" + 0.028*"menos" + '   '0.021*"politica" + 0.021*"mesquita" + 0.021*"ministros" + 0.021*"maior" + '   '0.018*"deflagra" + 0.018*"decreto"'),
(2,
'0.042*"pais" + 0.023*"crise" + 0.023*"presidente" + 0.020*"rio" + '   '0.020*"dias" + 0.020*"afirma" + 0.020*"cada" + 0.017*"colega" + '   '0.017*"elmar" + 0.017*"nascimento"'),
(3,
'0.027*"ataque" + 0.026*"deve" + 0.023*"deixa" + 0.023*"mortos" + '   '0.023*"helio" + 0.023*"schwartsman" + 0.023*"aposentadoria" + 0.023*"vira" '   '+ 0.023*"ato" + 0.023*"venezuela"'),
(4,
'0.058*"contra" + 0.044*"brasil" + 0.034*"coreia" + 0.034*"cria" + '   '0.034*"plano" + 0.034*"fuga" + 0.034*"embaixada" + 0.027*"maduro" + '   '0.024*"reformas" + 0.021*"temer"'),
(5,
'0.038*"stf" + 0.025*"oab" + 0.025*"pressiona" + 0.025*"convocar" + '   '0.025*"auxiliares" + 0.025*"apuracao" + 0.025*"acelerar" + 0.025*"juizes" + '   '0.010*"gera" + 0.005*"sabe"'),
(6,
'0.037*"temer" + 0.029*"admite" + 0.029*"plebiscito" + 0.029*"barbosa" + '   '0.029*"celso" + 0.025*"agradar" + 0.025*"trabalhadores" + 0.025*"tenta" + '   '0.025*"pacote" + 0.025*"empresarios"'),
(7,
'0.054*"odebrecht" + 0.020*"pt" + 0.020*"quer" + 0.020*"vitoria" + '   '0.020*"mulher" + 0.020*"corte" + 0.017*"refens" + 0.017*"psdb" + '   '0.017*"haddad" + 0.017*"atraso"'),
(8,
'0.048*"ano" + 0.032*"doria" + 0.028*"sp" + 0.027*"bi" + 0.024*"eike" + '   '0.024*"cuba" + 0.021*"prioriza" + 0.021*"zeladoria" + 0.021*"centro" + '   '0.021*"aposentado"'),
(9,
'0.029*"anos" + 0.025*"esquerda" + 0.025*"recorde" + 0.025*"deficit" + '   '0.022*"deve" + 0.022*"passado" + 0.022*"govwerno" + 0.022*"idade" + '   '0.022*"minima" + 0.022*"subir"')]

Podemos interpretar os tópicos da seguinte forma: o tópico 0 apresenta o seguinte:

'0.052*"lava" + 0.052*"jato" + 0.026*"ameaca" + 0.026*"economia" + '   '0.026*"novo" + 0.026*"pf" + 0.022*"manteve" + 0.022*"repasse" + '   '0.022*"ilicito" + 0.022*"retomada'

Ou seja, as 10 principais palavras chave que contribuem para o tópico são: lava, jato, ameaca, economia… e o peso de ‘lava’ é 0.052.

Dessa forma, olhando para essas palavras, é possível identificar qual o tópico macro seria? Entendendo mais do contexto, podemos dizer que o tópico seria ‘política’.

Da mesma forma podemos analisar as outras palavras chave e inferir o tópico sobre elas.

7. MÉTRICAS: COERÊNCIA E PERPLEXIDADE

A coerência e perplexidade fornecem uma medida para julgar se o modelo de tópico pode ser bom ou não. A coerência do modelo segundo referências externas, é o que melhor tem fornecido resultados úteis.

# Calculando a perplexidade print('\nPerplexity: ', lda_model.log_perplexity(corpus))  # a measure of how good the model is. lower the better.

# Calculando o score de coerência 
coherence_model_lda = CoherenceModel(model=lda_model, texts=data_words_bigrams, dictionary=id2word, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence() print('\nCoherence Score: ', coherence_lda)

8. ENCONTRANDO O NÚMERO IDEAL DE TÓPICOS

A forma utilizada para entender qual a quantidade de tópicos pode ser ideal para o modelo é escolhendo o maior valor de coerência fornecido.

“A escolha de um ‘k’ que marca o fim de um rápido crescimento da coerência do tópico geralmente oferece tópicos significativos e interpretáveis.” (*PRABHAKARAN, 2020)

A função abaixo treina vários modelos LDA e fornece as pontuações de coerência.

# Função para determinar a melhor quantidade de tópicos para a modelagem
def compute_coherence_values(dictionary, corpus, texts, limit, start=3, step=3):
    """     Compute c_v coherence para vários números de tópicos
            Parâmetros passados:
            ----------
            dicionário : Gensim dicionário
            corpus : Gensim corpus
            texto : Lista com os textos de entrada
            limite : número máximo de tópicos

Retorno:
            -------
            model_list : Lista de modelos de tópicos de LDA 
            coherence_values : Valor de coerência correspondente ao modelo LDA com o respectivo número de tópicos.
            """     
            coherence_values = []
            model_list = [] 
            for num_topics in range(start, limit, step): 
              model =gensim.models.ldamodel.LdaModel(corpus=corpus, num_topics=num_topics, id2word=id2word)
              model_list.append(model)         
              coherencemodel = CoherenceModel(model=model, texts=texts, dictionary=dictionary, coherence='c_v') 
             coherence_values.append(coherencemodel.get_coherence())            
            
            return model_list, coherence_values

#Pode demorar pra executar 
model_list, coherence_values = compute_coherence_values(dictionary=id2word, corpus=corpus, texts=data_words_bigrams, start=3, limit=40, step=6)

# Mostrando gráfico 
limit=40; start=3; step=6; 
x = range(start, limit, step) 
plt.plot(x, coherence_values) 
plt.xlabel("Num Topics") 
plt.ylabel("Coherence score") 
plt.legend(("coherence_values"), loc='best') 
plt.show()

# Lista dos valores de coerência, para melhor identificar o ponto de inflexão do gráfico 
for m, cv in zip(x, coherence_values):
     print("A quantidade de tópicos =", m, " tem um valor de coerência de ", round(cv, 4))

#RESULTADO 
A quantidade de tópicos = 3  tem um valor de coerência de  0.683 
A quantidade de tópicos = 9  tem um valor de coerência de  0.6061 
A quantidade de tópicos = 15  tem um valor de coerência de  0.4835 
A quantidade de tópicos = 21  tem um valor de coerência de  0.4506 
A quantidade de tópicos = 27  tem um valor de coerência de  0.4127 
A quantidade de tópicos = 33  tem um valor de coerência de  0.4037 
A quantidade de tópicos = 39  tem um valor de coerência de  0.4201

Pelo gráfico podemos entender que quanto menor o número de tópicos, maior é o CV.

Portanto, para as próximas etapas vou utilizar num_topics igual a 3, ou a posição 0 da lista acima.

# Selecionando o modelo  e imprimindo os tópicos. 
optimal_model = model_list[0] 
model_topics = optimal_model.show_topics(formatted=False)
pprint(optimal_model.print_topics(num_words=10))

#RESULTADO 
[(0,
   '0.011*"presidente" + 0.007*"ataque" + 0.007*"deixa" +
 0.007*"temer" + '   '0.007*"diz" + 0.006*"pais" + 0.005*"ano" +
 0.005*"reformas" + 0.005*"apoio" '   '+ 0.005*"esquerda"'),
  (1,
   '0.010*"deve" + 0.010*"governo" + 0.008*"trump" + 0.007*"apos" + '   '0.006*"maduro" + 0.006*"pais" + 0.006*"contra" + 0.006*"camara" + '   '0.005*"stf" + 0.005*"brasil"'),
  (2,
   '0.013*"diz" + 0.011*"temer" + 0.009*"crise" + 0.009*"menos" + 0.008*"doria" '   '+ 0.006*"preciso" + 0.005*"odebrecht" + 0.005*"lula" + 0.005*"sociedade" + '   '0.005*"poder"')]

9. ENCONTRANDO PALAVRAS CHAVE EM CADA DOCUMENTO

A modelagem de tópicos também permite determinar de qual tópico o documento trata.

A função abaixo encontra esses tópicos e mostra em um dataframe apresentável:

def format_topics_sentences(ldamodel=lda_model, corpus=corpus, texts=data):
     # Saída inicial
     sent_topics_df = pd.DataFrame()
      # Obtém o tópico principal em cada documento
     for i, row in enumerate(ldamodel[corpus]):
         row = sorted(row, key=lambda x: (x[1]), reverse=True)
         # Obtém o tópico dominante, contribuição em percentual e palavras-chave para cada documento
         for j, (topic_num, prop_topic) in enumerate(row):
             if j == 0:  # => tópico dominante
                 wp = ldamodel.show_topic(topic_num)
                 topic_keywords = ", ".join([word for word, prop in wp])
                 sent_topics_df = sent_topics_df.append(pd.Series([int(topic_num), round(prop_topic,4), topic_keywords]), ignore_index=True)
             else:
                 break
     sent_topics_df.columns = ['Tópico dominante', 'Percentual de Contribuição', 'Palavras Chave']
      # Adiciona o texto original no final da saída
     contents = pd.Series(texts)
     sent_topics_df = pd.concat([sent_topics_df, contents], axis=1)
     return(sent_topics_df)

df_topic_sents_keywords = format_topics_sentences(ldamodel=optimal_model, corpus=corpus, texts=data)  

# Formatando
 df_dominant_topic = df_topic_sents_keywords.reset_index()
 df_dominant_topic.columns = ['Número do documento', 'Tópico dominante', 'Perc. de Contribuição do Tópico', 'Palavras Chave', 'Transcription']  

# Mostre 
df_dominant_topic.head(10)

10. CONCLUSÃO

Por fim, gerou-se uma Wordcloud pra visualizar melhor os tópicos encontrados, através do modelo ótimo. A partir disso, é possível visualizar a relevância de cada palavra dentro de cada tópico.

# Criando wordclouds
 cols = [color for name, color in mcolors.XKCD_COLORS.items()]
 cloud = WordCloud(stopwords=stopwords,
                   background_color='white',
                   width=2500,
                   height=1800,
                   max_words=20,
                   colormap='tab10',
                   color_func=lambda *args,**kwargs: cols[i],
                   prefer_horizontal=1.0)
 topics = optimal_model.show_topics(formatted=False)
 fig, axes = plt.subplots(1, 3, figsize=(10,10), sharex=True, sharey=True)
 for i, ax in enumerate(axes.flatten()):
     fig.add_subplot(ax)
     topic_words = dict(topics[i][1])
     cloud.generate_from_frequencies(topic_words, max_font_size=600)
     plt.gca().imshow(cloud)
     plt.gca().set_title('Tópico ' + str(i), fontdict=dict(size=16))
     plt.gca().axis('off')
 plt.subplots_adjust(wspace=0, hspace=0)
 plt.axis('off')
 plt.margins(x=0, y=0)
 plt.tight_layout()
 plt.show()

11. REFERÊNCIAS

• Gensim Topic Modelling: https://www.machinelearningplus.com/nlp/topic-modeling-gensim-python/#:~:text=%2C per_word_topics%3DTrue-,13.,certain weightage to the topic.
• Como modelar tópicos através de Latent Dirichlet Allocation (LDA) através da biblioteca Gensim: https://medium.com/somos-tera/como-modelar-tópicos-através-de-latent-dirichlet-allocation-lda-através-da-biblioteca-gensim-1fa17357ad4b
• Topic Modeling and Latent Dirichlet Allocation (LDA) in Python: https://towardsdatascience.com/topic-modeling-and-latent-dirichlet-allocation-in-python-9bf156893c24
• Evaluate Topic Models: Latent Dirichlet Allocation (LDA): https://towardsdatascience.com/evaluate-topic-model-in-python-latent-dirichlet-allocation-lda-7d57484bb5d0

Modelagem de Tópicos em Python utilizando o Modelo de Alocação Latente de Dirichlet (LDA) was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.

Repost: Blog da Sauter Digital

Introdução

O Google Trends é uma ferramenta de propriedade do Google que analisa a popularidade dos termos em vários idiomas e regiões. Por exemplo, no site você pode encontrar palavras chaves das tendências, explorar tópicos relacionados, analisar popularidade de termos e mais. É uma ferramenta muito útil se você quer fazer previsões ou entender melhor o comportamento humano. O livro “Todo mundo mente”, cita muito sobre o Google Trends, mostrando que o que as pessoas falam nem sempre é o que elas buscam no Google. Inclusive, recomendo muito essa leitura!

Dessa forma, existe a biblioteca Pytrends python que pode ser utilizada para encontrar e explorar melhor as tendências. Pytrends, segundo a documentação Pytrends PyPI, é uma API não oficial do Google Trends que pode ser usada para extrair informações úteis usando uma interface simples.

Objetivos

Sendo assim, este artigo tem como objetivo mostrar o uso da ferramenta para tópicos de crescente popularidade e principais resultados da pesquisa. No entanto, ao invés de fazer busca por termos gerais, foi utilizado um dataset com trends extraídas do Twitter.

Especificações técnicas

O código foi desenvolvido em Python, com auxílio da API do Google e como IDE utilizou-se o Google Colab.

Instalação

A primeira etapa é instalar a biblioteca pytrends através do código abaixo. A documentação você encontra no link https://pypi.org/project/pytrends/

pip install pytrends

Implementação

Depois de instalar a biblioteca, é necessário fazer uma conexão com o Google, utilizando os seguintes comandos:

#Importando o método TrendReq do módulo de requisição do Pytrends 
from pytrends.request import TrendReq

#Execute o método TrendReq passando os parâmetros de linguagem e fuso horário
pytrends = TrendReq(hl='pt-BR', tz=360)

Em seguida é necessário construir uma carga útil. Essa carga irá conter informações de solicitação que ajudam o serviço a entender quais dados se deseja obter. Abaixo, um exemplo de como construir uma carga útil:

# Contruindo lista de palavras-chave 
kw_list = ["covid", "bolsonaro", "bbb"] 

# Consturindo a carga útil 
pytrends.build_payload (kw_list, timeframe = '2015-01-01 2021-01-01', geo = 'BR' )

No exemplo acima, o kw_list representa uma lista de palavras para obter os dados, geo é a localização geográfica e o timeframe é o prazo de interesse.

Aplicando à base de dados do Twitter

Como mencionado no início, utilizarei trends extraídas do twitter para gerar os tópicos de popularidade crescente e principais resultados da pesquisa. Por isso, inicialmente realizei algumas importações.

import pandas as pd
from pytrends.request import TrendReq
pytrends = TrendReq(hl='pt-BR', tz=360)

#Para limpeza de texto
import unicodedata
import re

#Coletando os dados
path = '<https://raw.githubusercontent.com/letpires/trends_twitter_pytrends/main/trends_twitter.csv%20-%20P%C3%A1gina1.csv>'
trends = pd.read_csv(path,encoding="ISO-8859-1", decimal=",", na_values="-", engine="python")
trends.head()

É posssível perceber que algumas trends vieram com caracteres especiais, por isso, optei por removê-los, utilizando a função abaixo, extraída do StackOverflow:

"""
A remoção de acentos foi baseada em uma resposta no Stack Overflow.
<http://stackoverflow.com/a/517974/3464573>
"""

def removerAcentosECaracteresEspeciais(palavra):

    # Unicode normalize transforma um caracter em seu equivalente em latin.
    nfkd = unicodedata.normalize('NFKD', palavra)
    palavraSemAcento = u"".join([c for c in nfkd if not unicodedata.combining(c)])

    # Usa expressão regular para retornar a palavra apenas com números, letras e espaço
    return re.sub('[^a-zA-Z \\\\\\]', '', palavraSemAcento)

Aplicando a função acima no dataframe, podemos obter o seguinte resultado:

#Aplicando a função para remover caracteres especiais
trends['trend'] = trends.apply(lambda row: removerAcentosECaracteresEspeciais(row['trend']), axis=1)
trends.head()

Em seguida, fiz a transformação dessas trends em lista, para poder passar pela API do Google:

# Convertendo para lista
df_list = trends["trend"].tolist()
df_list

Em seguida, apliquei o parâmetro related_topics para extrair as informações. Esse parâmetro retorna um dicionário contendo uma palavra chave e duas subchaves (‘rising’ e “top). Para extrair tópicos com popularidade crescente, temos o resultado do rising e para principais pesquisas tem-se os resultados do top .

A função abaixo extrai em forma de dataframe somente os principais tópicos de cada pesquisa:

def related_topics_top(trend):
		    #Colocando carga útil
        pytrends.build_payload(kw_list=[trend], timeframe='now 1-d', geo='BR', gprop='')
        related = pytrends.related_topics()
        try:
						#Transformando as informações me dataframe
            top = pd.DataFrame.from_dict(related[trend]['top'])
            
            return top
        except Exception as e:
            top = None
            raise e

Como temos uma lista de palavras do twitter, fiz uma iteração sobre cada um, através do código abaixo:

#Aplicando a função related_topics_top para cada item da lista

df_final = pd.DataFrame()

for item in df_list:
    print('----ITEM:', item)
    related = related_topics_top(item)

    #Inserindo o 'trend' nos dataframes
    related.insert(0, 'trend', item, allow_duplicates=True)
    df_final = df_final.append(related.head()).reset_index(drop=True)

print('--- DF Final ---')
df_final

O resultado obtido foi o seguinte:

Esses resultados não parecem tão interessantes visto que a palavra Xama está em 2 das linhas de topic title. Abaixo, a função para extrair somente os tópicos de popularidade crescente.

def related_topics_rising(trend):
	      
	#Colocando carga útil
        pytrends.build_payload(kw_list=[trend], timeframe='now 1-d', geo='BR', gprop='')
        related_rising = pytrends.related_topics()
        try:
	#Transformando as informações me dataframe
        rising = pd.DataFrame.from_dict(related_rising[trend]['rising'])
        return rising
        
except Exception as e:
            rising = None
            raise e

#Aplicando a função related_topics_rising para cada item da lista
df_final_rising = pd.DataFrame()

for item in df_list:
    print('----ITEM:', item)
    related2 = related_topics_rising(item)
    #Inserindo o 'trend' nos dataframes
    related2.insert(0, 'trend', item, allow_duplicates=True)
    df_final_rising = df_final_rising.append(related2.head()).reset_index(drop=True)

print('--- DF Final ---')
df_final_rising

O resultado obtido para tópicos de popularidade crescente foram:

No conjunto de resultados “crescentes”, podemos ver que as pesquisas instantâneas de seleção inglesa e Manchester estão entre os principais tópicos crescentes relacionados ao Harry Kane.

Conclusão:

Um ponto de atenção é com relação ao uso excessivo da API Pytrends, porque o Google pode limitar seu acesso. No entanto, esse limite da taxa de solicitação não é conhecido, segundo a página Pytrendd PyPI. Quando realizei esse trabalho, tive um problema similar de requisições. Segundo o site https://medium.com/the-data-science-publication/how-to-use-the-pytrends-api-to-get-google-trends-data-4378acbaaa8a, um usuário relatou que 1400 solicitações sequenciais em um período de 4 horas o levou ao imite.

Nesse link você encontra outras pessoas que relataram o mesmo problema — https://github.com/GeneralMills/pytrends/issues/231

Nesse link você encontra o código completo no meu Github — https://github.com/letpires/trends_twitter_pytrends

Referências:

https://medium.com/the-data-science-publication/how-to-use-the-pytrends-api-to-get-google-trends-data-4378acbaaa8a

https://pypi.org/project/pytrends/

Usando API Pytrends do Google para as trends do twitter — Encontrando tópicos de crescente… was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.

Quando eu estava entendendo melhor sobre a profissão de Cientista de Dados, eu comecei a pesquisar por livros que me mostrassem o que era e como se relacionava com as coisas, mas que não fossem livros técnicos. E essa listinha que trouxe aqui, são alguns que encontrei e que são muito recomendados. Alguns eu já li e outros estão na minha lista.

COMO MENTIR COM ESTATÍSTICA, DE DARRELL HUFF

O livro foi lançado em 1954 nos Estados Unidos e é um clássico quando o assunto é estatística. O autor apresenta várias situações em que números, gráficos e estatísticas são apresentadas de forma equivocada, mostrando como pode afetar uma pessoa desatenta. É a prova de que quem quiser manipular dados a seu favor, pode agir com facilidade. Apesar de ser escrito em 1954 com alguns fatos ocorridos nos Estados Unidos, mostra a semelhança com situações ainda do presente.

Quando eu vi esse livro eu pensei “quem vai ensinar alguém a mentir com estatística?”, e isso foi o que me motivou ainda mais a ler esse livro. Na verdade, o livro mostra um pouco mais como funcionam os estudos estatísticos e como NÃO sermos manipulados por eles.

O livro é bem didático, apresentando casos com situações profundas sobre métodos estatísticos utilizados e com situações não muito complexas. Em cada situação podemos entender melhor o método de análise, tendenciosidade, período histórico, condições para levantamento dos dados…

“Em uma lata com milho e ervilha, como descobrimos quantos milhos há na lata? A forma mais precisa seria contá-los. Muito trabalhoso? Podemos então contar uma parcela dos grãos de milhos e calcular a proporção para a lata inteira. Se essa porção, chamada de amostra, for grande o suficiente, será uma boa representação do total contido na lata. Se não for suficiente, será menos precisa e confiável, mas ainda assim permanecerá com o falso ar de “precisão científica”. Dessa forma, as conclusões, a partir dessas amostras tendenciosas e/ou reduzidas, representam grande parte do que lemos ou que acreditamos saber.

Dica extra: você pode conferir esses dois posts que fiz no meu Instagram (@leticiapyres) falando sobre o livro:

https://www.instagram.com/p/CHgYHgKl9hi/ | https://www.instagram.com/p/CKom2lKg-Dq/

TODO MUNDO MENTE, DE SETH STEPHENS-DAVIDOWITZ

O livro é resultado de uma pesquisa feita pelo próprio autor. Seth Stephens já trabalhou na Google e é cientista de dados e doutor em economia pela Harvard. O livro foi lançado na versão em português em 2018 e mostra que o ‘Google pode saber mais de você do que você mesmo”.

O autor prova, através do Big Data, que todo mundo mente, seja pra amigos, conhecidos e até mesmo família. Analisando os dados do Google Trends, ele mostra a controvérsia de pesquisas feitas por órgãos de competência, por exemplo. Além disso, ele aborda o tema, e as mentiras que contamos de maneira divertida.

A abordagem serve para mostrar que o Big Data vem para revolucionar a maneira como as pesquisas sobre opinião, bem como sobre comportamento, podem ser melhor tratadas com a enorme quantidade de dados que há hoje a disposição na rede.

Portanto você pode até dizer para todo mundo que não é racista, mas sem que ninguém saiba, você faz perguntas preconceituosas para o Google, ou seja o Google sabe quem você realmente é.

ESTATÍSTICA: O QUE É, PARA QUE SERVE, COMO FUNCIONA, DE CHARLES WHEELA

O economista Charles Wheelan apresenta a estatística de um jeito não muito técnico, trazendo exemplos reais com assuntos que interessam a todos. O livro ajuda a entender conceitos estatísticos importantes para a vida cotidiana como inferência, correlação e análise de dados, mas sem trazer muita matemática, gráficos e equações. Dessa forma, o autor torna a estatística acessível não só para os que estudam estatística, mas qualquer um que deseje compreender melhor os desafios do mundo em que vivemos.

Ele mostra que com os dados certos e ferramentas estatísticas adequadas, podemos responder algumas perguntas, como: quais substâncias ou comportamentos causam câncer, o que está provocando o aumento da incidência de autismo e como a Netflix sabe quais filmes você gosta.

O SINAL E O RUÍDO, DE NATE SILVER

O livro foi publicado em 2012 por Nate Silver, que ficou conhecido por ter criado um modelo preditivo que rendeu ótimo desempenho nas eleições dos EUA em 2008 e 2012.

No livro, o autor chama de ruído, quando precisamos tomar decisões ou fazer previsões de dados existentes, mas não sabemos o quão correto é. E o ruído pode atrapalhar o sinal, fazendo tomar decisões incorretas.

De modo geral, o autor mostra que muitas das previsões feitas hoje são falhas e nos mostra o que pode estar por trás desses erros.

Além disso, também examina casos que tiveram sucessos e fracassos pra determinar o que as melhores predições apresentam em comum, como avaliar o desempenho de um político em campanha, o estrago esperado de um furacão ou um avanço de uma epidemia perigosa.

Sendo assim, o autor Silver demonstra que a interpretação correta de dados numéricos é essencial para a segurança e o progresso de nossa sociedade.

DATA SCIENCE PARA NEGÓCIOS, DE FOSTER PROVOST & TOM FAWCETT

O livro aborda alguns assuntos de principais algoritmos como k-NN, árvores de decisão, regressão logística mas sem ser muito técnico. Um ponto interessante do livro é que o autor traz uma diversidade de explicações, utilizando recursos visuais pra explicar os algoritmos. Além disso, o autor traz essas explicações com aplicações práticas, o que torna mais tangível a teoria.

De modo geral, o livro apresenta os princípios fundamentais de Data Science, orientando através de um pensamento analítico a extrair conhecimento e valor de negocio a partir dos dados que obtemos.

STORYTELLING COM DADOS, DE COLE NUSSBAUMER KNAFLIC

O livro é muito indicado pra quem pensa em trabalhar ou quer melhorar e otimizar as apresentações e visualizações de dados. Além disso, a autora traz várias dicas e insights, mostrando exemplos reais de como como otimizar a visualização de gráficos e atribuir mais contexto as apresentações de resultados.

As principais ideias do livro são: entender o contexto (o quê, quem, onde, como e porque), escolher uma apresentação visual adequada ao público, eliminar saturação das imagens, focar atenção no que deseja, pensar qual a função da apresentação e a meta, contar uma história.

(EXTRA) MACHINE LEARNING: GUIA DE REFERÊNCIA RÁPIDA, DE MATT HARRISON

Como bônus, trouxe um livro mais técnico que me ajudou muito a desenvolver projetos de Machine Learning. Você pode conferir um projeto que fiz com base no livro, nesse link: Predição da necessidade de leitos de UTI no Hospital Sírio Libanês.

Curtiu? Então compartilha, comenta, curte e me segue nas redes sociais:

https://beacons.page/letipires

6 livros sobre ciência de dados (não técnicos) was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.

Quer me ajudar com algum projeto envolvendo dados? Tem alguma ideia? Encontrou algum erro? Ou tem uma vaga pra mim?! Não é nada disso? Tudo bem, podemos bater um papo sobre Data Science e todo seu universo :).

Instagram: https://www.instagram.com/letispires/

LinkedIn: linkedin.com/in/leticia-pires

Github: github.com/letpires

Comunidade no Discord: https://discord.gg/7TVrKPMrYd

Youtube: https://www.youtube.com/channel/UC7C3taM54q4rsEIDPFNVsLg

Twitch: https://www.twitch.tv/leti_pires

E-mail: leticiapyres@gmail.com

Entre em contato was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.

Esse foi o tema do meu primeiro projeto de Machine Learning que desenvolvi no Bootcamp de Data Science Aplicada da Alura (que orgulho que me deu 🤩). E hoje vim aqui compartilhar um pouco mais sobre o projeto e como foi estruturado.

O livro que utilizei como referência para esse estudo (além das aulas do curso) foi o “Machine Learning: Guia de Referência Prática”. Esse livro simplesmente me salvou! (Vou fazer um post só sobre ele, mas de modo geral ele auxilia a seguir um fluxo de ideias pro projeto, desde a limpeza dos dados até a avaliação dos modelos preditivos).

Introdução

A pandemia de COVID-19 atingiu o mundo inteiro, sobrecarregando os sistemas de saúde — despreparados para uma solicitação tão intensa e demorada de leitos de UTI, profissionais, equipamentos de proteção individual e recursos de saúde. Países como o Brasil, que já possui sistema de saúde superlotados, vem sofrendo com a falta de leitos de Unidade de Terapia Intensiva (UTI) na internação de seus pacientes.

Com base nesses acontecimentos e até mesmo na prevenção de sobrecarga do sistema de saúde das redes privadas, o Hospital Sírio-Libanês, busca prevenir e até mesmo predizer, com base em dados clínicos de seus pacientes, conforme forem sendo admitidos no ambiente hospitalar, a necessidade ou não de internação nas UTIs nas próximas horas. A proposta feita pelo Hospital Sírio Libanês está disposta nesse link do Kaggle.

Sendo assim, o objetivo desse projeto foi de prever quais pacientes precisariam ser admitidos na unidade de terapia intensiva e assim, definir qual a necessidade de leitos de UTI do hospital, a partir dos dados clínicos individuais disponíveis.

A ideia deste artigo é ser um ponto de referência e geração de insights para seus projetos. Você pode ter acesso completo ao notebook desse projeto clicando no link abaixo:

letpires/ICU_prediction_sirio_libanes

Para contextualizar, o conjunto de dados está dividido em janelas pacientes que fizeram admissão na UTI, como mostra a figura abaixo:

Para realizar o projeto, alguns critérios foram obrigatórios. Não pude utilizar os dados quando o paciente deu entrada na UTI -> ICU = 1, pois estes já terão ido diretamente para a UTI nas 2 primeiras horas, não importando para a predição.

O projeto ficou dividido nas seguintes etapas:

1. Importações

Para começar, importei algumas bibliotecas importantes para esse trabalho. Dentre elas, utilizei: pandas, numpy, seaborn, matplotlib, sklearn, yellowbrick e xgboost:

2. Coleta de dados

Carreguei o arquivo csv com os atributos das amostras do Covid 19. Esse arquivo contém várias colunas, incluindo uma coluna relacionada à UTI (ICU em inglês).

Para visualizar os dados, apliquei o método head() que nos trazer os 5 primeiros dados do nosso dataset:

O dataset acima não está completo, pois ele possui 231 colunas. Explicando melhor sobre o dataset, temos pacientes positivos para COVID-19 internados no Hospital Sírio Libânes de São Paulo-SP e Brasília-DF. De forma geral, temos até 5 entradas que representam dados de um mesmo paciente. Essas entradas são referentes à diferentes janelas de tempo (0–2, 2–4, 4–6, 6–12, >12) em que os pacientes foram acompanhados. Para cada uma das janelas, foram dosados diversos marcadores biológicos e sinais vitais.

Resumidamente, o layout dos dados estruturados e a estrutura do banco é a seguinte:

3. Limpeza dos dados

Depois de conhecer melhor os dados, realizei uma limpeza neles.

É importante garantir que os dados estejam em um formato adequado para criar o modelo posteriormente. A maioria dos modelos do scikit learn exige que nossos atributos sejam numéricos. Além disso, muitos modelos falham caso recebam dados ausentes (NaN).

Para isso, inicialmente apliquei a função fill_table (criei funções para facilitar no desenvolvimento do projeto) para agrupar a coluna PATIENT_VISIT_IDENTIFIER e preencher dados faltantes através dos métodos bfill() e ffill().

Em seguida, realizei uma query por todas as colunas/linhas que possuem WINDOW=='0-2' eICU==1, que deverão ser removidas da base de dados, como mencionado lá no início. Em seguida, utilizei o dropna para remover dados NaN.

Em seguida, identifiquei que o dataset ainda apresentava colunas do tipo string, AGE_PERCENTIL e WINDOW . Como mencionei, essas colunas podem atrapalhar no modelo depois. Então para resolver, utilizei uma solução encontrada no livro de Matt Harrison. Criei colunas dummy a partir de colunas de string, e aplicando o get_dummies, foi criada uma coluna pra cada valor, sendo preenchido por 0 e 1.

Além disso, inicialmente também foi aplicado a funçãoprepare_window para ficar somente com o quadro de pacientes que entram nas primeiras 2 horas.

Depois de fazer a limpeza inicial dos dados, fiz um novo tratamento, pois talvez nem todas as colunas sejam necessárias, podendo atrapalhar nas predições.

Segundo Harrison (2020), “removemos qualquer coluna com uma correlação perfeita ou com uma correlação positiva ou negativa bem alta. A multicolinearidade pode causar impactos na interpretação da importância dos atributos e dos coeficientes em alguns modelos”.

Então removi todas as colunas com correlação perfeita ou alta correlação. Para fazer isso utilizei a técnica elaborado pelos instrutores do Bootcamp, Thiago Gonçalves e Alan Spadinni nas aulas do Módulo 6, que consiste na criação de correlação de todas as linhas a partir da quarta coluna e antepenúltima (sem considerar WINDOW e ICU). Em seguida é gerado uma correlação e transformação dos valores para absoluto (não negativos).

“A correlação vai de -1 a 1. Altas correlações aproximam de -1 e +1. Quando é próxima de -1 ocorre o inverso, então uma variável cresce e outra sobre. Quando é próxima de +1, é proporcional, quando uma sobre a outra também sobe.”

Em seguida o any busca dentro dentro da matriz de correlação variáveis com alta correlação (valores acima do valor_corte) e através do laço for, isso é repetido pra todas as colunas. E caso seja verdadeiro, fica armazenado dentro de uma lista.

No entanto, fazendo somente essas ações não é possível, visto que, todas as colunas seriam excluídas. Por isso, podemos observar através da figura abaixo que a coluna na diagonal é igual a 1, e o triângulo superior é um espelho do inferior. Sendo assim, aplicando o where, np.ones(matriz com 1s) e np.triu(elimina triângulo abaixo da diagonal igual a 1).

4. Separação das amostras

Segundo Harrison (2020) sempre devemos fazer treinamento e testes em dados distintos. Caso contrário, você não saberá realmente quão bem seu modelo poderá ser generalizado para dados que ainda não tenham sido vistos antes.

Utilizei o scikit-learn para fazer essa separação dos dados através do método train_test_split :

5. Criando o modelo

Para o projeto decidi fazer a análise utilizando 4 modelos de classificação: Regressão Logística, Árvore de Decisão, Floresta Aleatória e o XGBoost.

No entanto, para exemplificar aqui, vou utilizar somente o modelo de Floresta Aleatória (ou Random Forest), que aparentemente se apresentou melhor na análise.

Uma floresta aleatória é um conjunto de árvores de decisão. Ao criar árvores treinadas com sub-amostras e atributos aleatórios de dados, a variância é reduzida. A ideia das florestas aleatórias é criar uma “floresta” de árvores de decisão treinadas em diferentes colunas de dados de treinamento.

Então, inicialmente passei a biblioteca RandomForestClassifier . Apliquei um n_estimators = 100 , que representa a adição de mais árvores, evitando uma superadequação.

Em seguida, para treinar o modelo, é necessário passar o método .fit com os dados de treino e para fazer a predição aplicar o método .predict com o x_test.

Como comentei anteriormente, automatizei esse processo dentro de funções. Então apliquei a separação dos dados de treino e teste, treinamento e predição em cada função de métrica, como mostra o tópico seguinte.

6. Métricas e avaliação de classificação

A fim de avaliar o comportamento do modelo, utilizei as seguintes métricas: acurácia, matriz de confusão, recall, precisão, F1 e curva ROC.

6.1. Acurácia

A acurácia representa a porcentagem de classificações corretas do modelo. Ou seja, quanto maior a acurácia, mais próximo da referência ou valor real. Através da função abaixo, separei meus dados de treino e teste, treinei o modelo, fiz a predição e calculei a acurácia.

Passando os dados e o modelo de Floresta Aleatória na função, tem-se o seguinte:

O valor de acurácia obtido do modelo foi de 65,91%. Ou seja, de todas as classificações, somente 65,91% foram corretas.

6.2. Matriz de Confusão

Outra métrica importante para avaliar os modelos de Machine Learning é a Matriz de Confusão. Ela pode ajudar a compreender o desempenho de um classificador. Um classificador binário pode ter quatro resultados de classificação:

• VP: verdadeiro positivo (a pessoa precisa de UTI e o modelo acertou)
• VN: verdadeiro negativo (acerto para quando a pessoa não precisa de UTI)
• FP: falso positivo (O modelo diz que é 1, mas a label é 0)
• FN: falso negativo (o modelo diz que é 0, mas a label é 1)

As duas primeiras classificações representam a maneira correta.

Para entender mais sobre matriz de confusão, clique nesse link.

A função abaixo separa os dados de treino e teste, treina o modelo, faz a predição e cria o gráfico de matriz de confusão.

O resultado da matriz gerada é o seguinte:

Em resumo, o modelo acertou 24 vezes para pacientes que devem ser internados na UTI (verdadeiro positivo) e 34 vezes para pacientes que não devem ser internados (verdadeiro negativo).

No entanto, o modelo previu 13 vezes para pacientes que devem ser internados (falso positivo), que na realidade não devem. E previu 17 vezes para pacientes que não deveriam ser internados (falso negativo), sendo que deveriam ser.

É insano prever que uma pessoa não precisa de leito, sendo que precisa. Assim como também, superlotar leitos de UTI com pessoas que não precisariam estar ali.

6.3. Precisão, Recall e F1

Aprofundando mais as métricas, podemos utilizar o ClassificationReport para encontrar a precisão, recall e F1. A função abaixo roda_modelo gera essas métricas.

O resultado obtido foi o seguinte:

Para valores igual a 0 (pacientes que não precisam de UTI), possuimos uma precisão de 73% e para valores igual a 1 (pacientes que precisam de UTI) a precisão é de 67%. Segundo este artigo, a PRECISÃO pode ser usada em situação em que os falsos positivos são considerados mais prejudiciais que os falsos negativos, ou seja, será importante para o caso de estarmos internando mais pessoas do que o necessário, superlotando o hospital e fazendo com que pessoas que precisem de fato, fiquem sem leitos de UTI.

Já o RECALL pode ser usada em uma situação em que os Falsos Negativos são considerados mais prejudiciais que os Falsos Positivos. Por exemplo, o modelo deve de qualquer maneira encontrar todos os pacientes que precisam de UTI, mesmo que classifique os que não precise (situação de Falso Positivo). Ou seja, o modelo deve ter alto recall ou alta sensibilidade, pois imagina classificar pacientes que precisam de UTI como pacientes que não precisam, seria um problema muito grave.

No caso, nosso recall apresentou para 0, um desempenho alto de 70%, enquanto para a classe 1, 71%.

O f1 score nos mostra uma média harmônica entre precisão e recall. Para 0, apresentou 72% e para 1, 69% (representa que ou recall ou precisão estão baixos).

6.4. Curva ROC

Outra métrica utilizada é o roc_auc, ou área sob a curva ROC (Receiver Operator Characteristic). A curva ROC mostra o desempenho do classificador, exibindo taxa de verdadeiros positivos à medida que a taxa de falsos positivos muda. A regra geral é que o gráfico deve ter uma protuberância em direção ao canto superior esquerdo. Um traçado que esteja à esquerda e acima de outro sinaliza um desempenho melhor.

A função abaixo plota a curva ROC:

Chamando a função…

O valor AUC ficou em 0.79, que pode ser considerado um bom desempenho. Modelos com AUC igual a 0 representam previsões 100% erradas. Quanto mais próximo de 1, melhor o modelo é.

Comparando com os outros modelos utilizados no projeto, este apresentou um valor de AUC melhor, mas o modelo ainda depende de hiperparâmetros para melhorar seu desempenho. Pra otimizar o modelo, utilizamos a curva de validação.

8. Seleção do modelo

Existem duas formas possíveis de avaliar um modelo. Através da Curva de Validação e Curva de Aprendizagem.

• Curva de Validação: é uma forma de determinar um valor apropriado para um hiperparâmetro. Uma curva de validação é um gráfico que mostra como o desempenho do modelo responde a mudanças no valor do hiperparâmetro. O gráfico mostra tanto os dados de treinamento como de validação. As pontuações dos dados de validação nos permitem inferir como o modelo responderia a dados não vistos anteriormente. Em geral, escolhemos um hiperparâmetro que maximize a pontuação dos dados de validação.
• Curva de Aprendizagem: pode nos ajudar a seguinte pergunta: Quantos dados sserão necessários para selecionar o melhor modelo para o projeto? O gráfico mostra as instâncias de treinamento e a pontuação para validação cruzada a medida que criamos modelos com mais amostras. Se a pontuação da validação cruzada continuar a subir, por exemplo, poderá ser sinal de que mais dados ajudariam o modelo a ter melhor desempenho. Se houver variabilidade (uma área sombreada grande) na pontuação de dados de treinamento, é sinal de que o modelo sofre de erros de viés e é simples demais (há subadequação). Se houver variabilidade na pontuação para validação cruzada, é porque o modelo está sujeito a erros de variância e é complicado demais (há superadequação).

Através da função abaixo, criei o gráfico de Curva de Validação para o modelo citado:

Aplicando a função…

O resultado obtido para a Curva de Validação foi o seguinte:

A linha azul representa os dados de treino. Essa linha mostra, que a cada valor max_depth, a pontuação se aproxima de 1.00, que pode levar a um overfitting. O overfitting ocorre quando o modelo se adaptou muito bem aos dados com os quais está sendo treinado, porém, não generaliza bem para novos dados. Ou seja, o modelo decorou o conjunto de dados de treino, mas não aprendeu de fato o que diferencia aqueles dados para quando enfrentar novos testes. E isso, podemos perceber através da linha verde (que representa os dados de teste), que fica sempre no intervalo de 0.60 a 0.85.

E a função abaixo representa o gráfico da Curva de Aprendizagem para o modelo citado:

Aplicando a função…

O resultado obtido para a Curva de Aprendizagem foi o seguinte:

Na Curva de Aprendizagem do modelo, percebe-se que a curva de Validação Cruzada (verde) começa a subir, o que pode ser um sinal de que mais dados ajudariam o modelo a ter um desempenho melhor. Mas parece manter constante depois mesmo adicionando dados.

A pontuação da validação cruzada (curva verde) apresenta uma variabilidade (área sombreada grande), indicando que o modelo está sujeito a erros de variância e é complicado demais, ou seja, há superadequação.

E os dados de treinamento (linha azul) apresenta um desempenho constante. Adicionar mais dados, não vai influenciar no modelo.

7. Validação Cruzada

A validação cruzada é uma técnica para avaliar a capacidade de generalização de um modelo, a partir de um conjunto de dados. Ou seja, busca-se estimar o quão preciso é este modelo na prática, o seu desempenho para um novo conjunto de dados.

Uma das maneiras de fazer a divisão desses dados é usando o método holdout, ele consiste em dividir os dados em 70–30 de maneira aleatória. Ou seja, 70% dos dados para treino e 30% para teste.

Para fazer isso, é utilizado o cross_validate, que tem como principal objetivo evitar problemas de aleatoriedade.

O cross_validate pega os dados, separa em porções de treino e teste, embaralha os dados e divide em k números de dobras (grupos), para assim termos conjuntos diferentes de dados para treino e teste. O resultado do nosso modelo vai ser a média dos valores de cada um desses grupos.

* A única desvantagem de utilizar o cross_validate é o desempenho, se você tiver uma base de dados muito grande rodar um cross validation vai ser muito custoso computacionalmente.

Utilizei a função abaixo para calcular a Validação Cruzada.

Aplicando a função no modelo…

O resultado obtido foi um AUC de 0.7955–1.0, mostrando um desempenho melhor comparado aos outros modelos.

Conclusões

Considerando a situação emergencial do COVID-19 no Brasil, a necessidade de uma solução rápida, todo esse processo de criação de um modelo deve ser tratado da forma mais séria possível. Trabalhar com dados reais pode ser algo muito complexo nesse caso.

Este projeto está finalizado no momento, no entanto, ao longo dos próximos meses será aperfeiçoado, conforme a nova remessa de dados e meus novos aprendizados sobre Machine Learning.

Para conferir mais sobre meu projeto, só acessar o link do meu repositório no Github: https://github.com/letpires/ICU_prediction_sirio_libanes

Predição da necessidade de leitos de UTI no Hospital Sírio Libanês was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.

Minha história sai um pouco da curva eu diria. Tudo começou em 2015, quando eu disse que gostaria de fazer engenharia e que “a única coisa de faculdade que eu não faria seria algo que envolvesse programação e códigos” (mal sabia ela kkk).

Mas antes de eu chegar na conclusão de que queria engenharia, eu fiz engenharia de pesca na UDESC por 1 ano 😱. Tudo isso com o intuito de ir pra arquitetura (que era no mesmo campus). Só que me apaixonei por engenharia e exatas (já fui chamada de louca por isso haha😛).

Então, em 2015 me mudei pra Blumenau e comecei Engenharia Civil. Próximo de me formar eu tive algumas frustrações na área já, e comecei a olhar pra outros campos que me chamavam mais atenção. Como eu falei, sempre fui apaixonada por exatas, mas também por inovação e tecnologia. Durante a faculdade mesmo eu participei de um projeto de inovação junto com meus amigos, a Padiolax, e por um bom tempo fiquei envolvida com isso.

Ali no último semestre do curso, eu comecei a pesquisar mais sobre a área de tecnologia e descobri a Ciência de Dados. E “fuçando” nos meus arquivos, encontrei um cronograma de estudos que fiz na época, de setembro de 2019 (eu particularmente, não lembrava que já tinha feito isso em 2019 hehehe):

Bom, mas como eu tinha o TCC na época, não levei o assunto muito pra frente. Então, graduei no final de 2019 e comecei a luta por emprego na área de engenharia civil. Só frustração. E daí veio pandemia. Mais frustração.

Esse período me fez cada vez mais repensar sobre o que eu queria de fato pra minha vida. Eu queria mesmo me tornar Engenheira Civil?

Durante todo esse tempo eu estive rodeada por pessoas da área de tecnologia, e em 2020 eu descobri que queria seguir a carreira na área de dados. E foi aí que minha jornada de transição de carreira de fato começou.

Eu simplesmente me encantei com a área de Ciência de Dados, por unir tecnologia e exatas ❤. Então eu conheci a plataforma da Alura, que na minha opinião, é a melhor plataforma de cursos pra essa área💙.

Fiz um tabelão de cursos que eu precisava fazer pra me tornar uma Cientista de Dados (faço tabela pra tudo heheh), e comecei a maratonar os cursos. E em outubro de 2020 a Alura lançou o Bootcamp de Data Science Aplicada, que mudou totalmente minha transição de carreira. Iniciei em novembro e finalizei em abril de 2021. Foi uma experiência incrível! Conheci muitas pessoas, aprendi muito Python, Machine Learning, foi uma imersão completa, que sou extremamente grata por ter feito parte.

Coloquei muita dedicação no bootcamp e em especial no projeto final (virei algumas noites pra terminar), detalhei ele, documentei, criei esse blog, postei nas redes sociais… e esse projeto foi a minha porta de entrada no mercado de dados. Dia 12/04/2021 iniciei como Cientista de Dados Jr. na Sauter Digital (empresa que me acolheu tão bem🥰) .

E desde então, venho enfrentando muitos desafios, aprendendo muitas coisas nessa empresa maravilhosa. E tenho compartilhado todo esse processo lá no meu instagram. Uma das coisas que mais amo é poder compartilhar experiências, aprender com outras pessoas, conhecer pessoas🧡.

Aaah, e além de toda essa paixão por exatas e tecnologia, também sou a louca da organização (gosto de um post-it, viu?!). Sempre estou buscando formas de melhorar minha produtividade através da organização.

Link das redes sociais: https://beacons.page/letipires

Entrevistas que falo um pouco sobre minha transição de carreira:

Me conheça was originally published in Letis Pires on Medium, where people are continuing the conversation by highlighting and responding to this story.