<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Fabricio Zillig on Medium]]></title>
        <description><![CDATA[Stories by Fabricio Zillig on Medium]]></description>
        <link>https://medium.com/@zfab?source=rss-3efc579adea5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*pcoaCkzppdNiju8up3C7dg.jpeg</url>
            <title>Stories by Fabricio Zillig on Medium</title>
            <link>https://medium.com/@zfab?source=rss-3efc579adea5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:52:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@zfab/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Não, você não precisa de um LLM…]]></title>
            <link>https://zfab.medium.com/n%C3%A3o-voc%C3%AA-n%C3%A3o-precisa-de-um-llm-1f5d61e7fcee?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f5d61e7fcee</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Mon, 07 Jul 2025 18:05:18 GMT</pubDate>
            <atom:updated>2025-07-07T18:05:18.012Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x93pENUVHPj6syE5IiGtGA.png" /></figure><h4>Nem sempre (na verdade poucas vezes) a resposta para um problema será um Large Language Model</h4><blockquote>Nem sempre (na verdade poucas vezes) a resposta para um problema será um Large Language Model</blockquote><p>A cada dia que passa, observo na área de Machine Learning o surgimento do que chamo de <strong>“Efeito Airfryer”</strong>. Hoje, as pessoas não conseguem viver sem essa tecnologia e a utilizam para tudo, desde fritar batatas até fazer bolos de caneca. Quando a fritadeira elétrica surgiu em 2010, ela veio para solucionar um problema específico: como fritar alimentos sem precisar mergulhá-los em litros de óleo. Com o passar dos anos, descobrimos que ela era útil não apenas para fritar, mas também para assar, cozinhar, aquecer e muito mais. A partir daí, seu uso se expandiu e foi só ladeira abaixo.</p><blockquote>O que antes era uma ferramenta incrível para o propósito que foi projetada passou a ser adaptada para resolver outros problemas para os quais já existem soluções, muitas vezes, muito mais eficientes que a Air Fryer. Você não precisa fazer arroz nela, acredite!</blockquote><p>Atualmente, graças ao hype da Inteligência Artificial, tudo se resumiu a <strong>LLMs</strong>. Vemos pessoas implementando modelos de linguagem complexos para resolver problemas simples que poderiam ser f<strong>acilmente solucionados com algoritmos tradicionais</strong> ou até mesmo com regras de negócio bem definidas.</p><p>Recentemente vi uma postagem de uma empresa que precisava classificar conteúdo de texto e, para isso, utilizou um LLM. Vamos ser diretos: em muitos cenários, usar um LLM padrão para resolver um problema de classificação específico não é apenas um exagero, é a <strong>abordagem errada</strong>.</p><h3>Um Experimento…</h3><p>Para demonstrar meu ponto, realizei um experimento: utilizei diferentes abordagens para resolver um problema comum na área, classificação de texto, e comparei seus resultados com aqueles obtidos por meio de um LLM.</p><h4>O dataset</h4><p>O dataset utilizado foi adquirido no Kaggle e consistia em uma série de tweets sobre COVID já classificados como Positivo, Neutro ou Negativo. Retirei, de forma aleatória e estratificada, 1000 tweets e suas classificações para utilizar como base Holdout, ou seja, como base para comparação do desempenho das soluções.</p><p>Para o conjunto de treino, selecionei aproximadamente 4 mil registros, que foram utilizados para realizar o treinamento das diferentes abordagens</p><h4>As técnicas</h4><p>Utilizei três técnicas distintas para solucionar o problema, começando com uma abordagem simples, passando por uma mais sofisticada e chegando ao padrão ouro atual: transformers. Por fim, realizei predições usando um LLM através de Zero-Shot e comparei os resultados.</p><ul><li>Abordagem 1: A Baseline (TF-IDF + SVM)</li><li>Abordagem 2: Adicionando Contexto (Embedding + XGBoost)</li><li>Abordagem 3: O Padrão-Ouro (Fine-tuning de um Transformer)</li></ul><p>⚠️ <strong>Aqui vale um disclaimer</strong>: o objetivo<strong> não foi treinar os melhores modelos</strong> possíveis ou investir muito esforço nos testes. Por isso, não realizei nenhum trabalho de fine-tuning de hiperparâmetros ou utilizei técnicas para melhorar o desempenho em cada abordagem. Com certeza há muito espaço para melhoria em todas elas, mas meu objetivo era responder de forma simples: existem soluções melhores do que simplesmente pedir para um LLM?</p><h3>Resultados</h3><p>Após implementar as soluções de forma simples, realizei as previsões com o conjunto de Holdout e extraí métricas que utilizei para fazer a comparação final.</p><h4>🗺️ A Baseline (TF-IDF + SVM) — Resultado</h4><p>A primeira abordagem foi simplesmente transformar os tweets em um vetor, utilizando TF-IDF e passando esse vetor como features para um SVM aprender a classificar. Com essa técnica obtivemos os seguintes resultados</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6Z7ympRzEul2x7TwjQPieQ.png" /></figure><p>Ao analisar o F1-Score, percebemos que a performance é interessante para as classes majoritárias (Negativo e Positivo), mas deficiente na classe Neutra.</p><p>A precisão para “Neutro” é de apenas 50%, o que significa que metade das vezes que o modelo classifica um tweet como neutro, ele está, na verdade, errado. Esse resultado era esperado, já que essa abordagem considera as palavras e suas frequências, mas não consegue captar o contexto em que elas aparecem.</p><h4>📑 Adicionando Contexto (Embedding + XGBoost) — Resultado</h4><p>A próxima técnica utilizada foi para tentar resolver o problema de falta de contexto da anterior. Dessa vez utilizamos o poder dos Embeddings para transformar os tweets em um vetor, passando esses vetores como features para um XGBoost, o queridinho dos dados tabulares. Com isso o resultado foi o seguinte</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_3n21VuCJGx44Mf0efDdDA.png" /></figure><p>Aparentemente o plano não deu muito certo, o resultado piorou. A acurácia e o F1-Score caíram. O recall da classe neutra despencou para 23%. Aqui temos uma lição: mais complexidade não garante um melhor resultado. O motivo disso pode ter várias explicações, como a escolha de uma arquitetura não ideal para lidar com features que possuem as características dos embeddings, por exemplo.</p><h4>🥇 O Padrão-Ouro: Fine-tuning de um Transformer</h4><p>O estado da arte para processamento de texto são os transformers, que foram utilizados na última abordagem: distilbert-base-cased com fine-tuning no nosso conjunto de dados de treinamento. Apesar de usar praticamente a mesma arquitetura dos LLMs, estamos falando de um modelo em ordens de grandeza menores que os LLMs SOTA atuais.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n1VdV-BxL2nR4l716rrMEQ.png" /></figure><p>Agora vimos um salto significativo no desempenho. A acurácia aumentou quase 10 pontos percentuais em relação ao TF-IDF + SVM. Esse modelo demonstrou uma compreensão mais equilibrada das três classes, com um recall sólido em todas elas (81% para negativo, 57% para neutro e 77% para positivo).</p><p>Esse resultado não é surpreendente. Quando você tem um conjunto de dados anotado, mesmo que não seja massivo, o fine-tuning de um modelo pré-treinado geralmente oferece um desempenho de ponta.</p><h4>💬 O queridinho da Vez (Zero-Shot com GPT-4o e 4o-mini)</h4><p>Chegou a hora da verdade, será que um LLM SOTA conseguirá um bom desempenho na classificação utilizando <strong>Zero-Shot</strong>, ou seja, sem especialização ou qualquer exemplo: vamos simplesmente pedir a ele para classificar.</p><p>Testamos usando as APIs do <strong>GPT-4o</strong> e do <strong>GPT-4o-mini</strong> passando uma frase e pedindo para responder apenas com a classificação. O prompt era simples:</p><blockquote><em>“Classifique o sentimento da seguinte frase como POSITIVO, NEUTRO ou NEGATIVO. Responda apenas com a categoria.”</em></blockquote><p><strong>Resultados do GPT-4o-mini no Holdout:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9S6VUPtbxuXZGcqE9Mee0w.png" /></figure><p><strong>Resultados do GPT-4o no Holdout:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*60bg5D6MhoQYPhzdoyGUNQ.png" /></figure><p>Os resultados foram… decepcionantes. Ambos os modelos tiveram um desempenho <strong>significativamente pior</strong> não apenas que o Transformer fine-tuned, mas também que as abordagens de Machine Learning muito mais simples.</p><p>Eles demonstraram extrema dificuldade em identificar o sentimento, especialmente com a classe positiva, onde tivemos muitos Falsos Negativos (Recall de apenas 22% com o GPT 4o, ou seja, 78% dos casos positivos foram classificados incorretamente).</p><h3>A Lição Aprendida</h3><p>Vamos resumir nossos resultados na tabela abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ggeFM15tRZLTVVcmC6OpEw.png" /></figure><p>As conclusões aqui são claras:</p><ol><li><strong>Se você tem dados anotados, use-os!</strong> O salto de desempenho do modelo de Transformer fine-tuned em comparação com as abordagens zero-shot do GPT é enorme. O fine-tuning permite que o modelo se especialize na sua tarefa, superando em muito a capacidade de um modelo geral, não importa quão poderoso ele seja.</li><li><strong>O mais simples pode ser surpreendentemente bom.</strong> O TF-IDF + SVM superou o modelo de embedding e ambos os LLMs, fornecendo um baseline sólido e eficiente. Para muitos projetos, essa pode ser uma solução “boa o suficiente” e muito mais barata de implementar e manter.</li><li><strong>LLMs como solução “zero-shot” são caros e nem sempre eficazes.</strong> Usar a API do GPT resultou no pior desempenho entre todos os modelos testados. Os LLMs são generalistas — pedir-lhes para realizar uma tarefa de nicho sem contexto ou exemplos dificilmente é uma boa escolha.</li></ol><h3>Usando LLMs de forma eficaz</h3><p>Os LLMs seriam, portanto, inadequados para este tipo de tarefa? Absolutamente não. É necessário apenas aplicá-los de maneira correta e eficiente.</p><p>Considere um cenário em que <strong>dados anotados não estão disponíveis</strong>. Iniciar um projeto nestas condições representa um desafio significativo. Neste contexto, um LLM pode funcionar como um catalisador. Em vez de utilizá-lo como modelo definitivo em ambiente de produção, empregue-o para <strong>gerar seu conjunto inicial de dados de treinamento</strong>.</p><p>Um possível processo é o chamado weak labeling ou rotulagem fraca, onde combinamos a capacidade de um LLM com supervisão humana para criar um dataset de qualidade.</p><p>Primeiramente, selecionamos uma amostra representativa dos dados não rotulados e utilizamos a API de um LLM avançado (como o GPT-4o) para gerar rótulos preliminares, criando o que chamamos de “weak labels”. Em seguida, implementamos uma etapa de revisão humana para converter esses rótulos preliminares em “gold labels” — dados de alta qualidade verificados por especialistas humanos.</p><p>Este processo híbrido é significativamente mais eficiente que a rotulagem manual completa, pois os revisores humanos apenas precisam corrigir as classificações inadequadas do LLM.</p><p>Com este conjunto de dados gold-standard em mãos, podemos <strong>treinar de um modelo mais compacto e eficiente</strong>, como DistilBERT ou mesmo XGBoost, que será otimizado especificamente para nosso domínio.</p><p>Esta abordagem integra as vantagens de ambas as tecnologias. Aproveita-se o vasto conhecimento enciclopédico do LLM para inicializar o processo de rotulagem e, subsequentemente, desenvolve-se um modelo especializado, eficiente e economicamente viável para implementação em produção que, conforme demonstrado pelos resultados, provavelmente apresentará desempenho superior.</p><blockquote>Tenho um projeto semelhante onde utilizei LLMs como “gold labelers”, mas a lógica geral é a mesma. Caso tenha curiosidade acesso o repositório no meu github: <a href="https://github.com/z-fab/sentiment-analysis">https://github.com/z-fab/sentiment-analysis</a></blockquote><h3>Conclusão</h3><p>A ascensão dos LLMs é, sem dúvida, um divisor de águas para a Ciência de Dados. Mas eles são uma ferramenta, não uma bala de prata. O verdadeiro ofício da nossa profissão reside em <strong>entender o problema</strong> em questão e escolher a abordagem<strong> mais adequada</strong>, equilibrando desempenho, custo, tempo de desenvolvimento e capacidade de manutenção.</p><p>Da próxima vez que você se deparar com um problema de classificação de texto, por exemplo, antes de correr para a documentação da API mais recente, pare e pergunte: “Quais dados eu tenho?” Se a resposta for “um conjunto de dados anotado”, você provavelmente obterá resultados melhores, mais rápidos e mais baratos ao treinar seu próprio modelo. E se a resposta for “nenhum”, talvez um LLM seja o <strong>ponto de partida</strong>, mas não necessariamente o <strong>destino final</strong>.</p><p>Os códigos dos textes podem ser encontrados no repositório no meu Github: <a href="https://github.com/z-fab/expe-class-llm">https://github.com/z-fab/expe-class-llm</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f5d61e7fcee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM do Zero: Treinando um Foundational Model]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-do-zero-treinando-um-foundational-model-a44d2d0abc6d?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/a44d2d0abc6d</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Wed, 26 Mar 2025 12:28:58 GMT</pubDate>
            <atom:updated>2025-03-26T12:28:58.467Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s5nUUar5wq7eINWcmAuEmA.png" /></figure><h4><em>Entendendo a Arte de Treinar um LLM: Dando vida ao nosso modelo GPT</em></h4><p>Com a arquitetura do nosso modelo concluída, alcançamos o primeiro objetivo desta série: construir um LLM do zero. No entanto, nosso modelo atual consiste apenas em matrizes aleatórias que produzem texto sem significado. Neste artigo, daremos um passo crucial: transformar esse modelo em uma ferramenta capaz de gerar texto (um pouco mais) coerente.</p><p>Para alcançar esse objetivo, precisamos treinar o modelo com um imenso volume de texto, ensinando-o a prever o próximo token com base nos anteriores. Este processo, conhecido como pré-treino, é o que nos entregará nosso Modelo Fundacional.</p><p>Este é o penúltimo artigo da nossa série. Se perdeu algum, leia os artigos anteriores:</p><ol><li><a href="https://blog.zfab.me/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa">Introdução</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-tokeniza%C3%A7%C3%A3o-um-mal-necess%C3%A1rio-dfaab5dc9488">Tokenização</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-criando-significado-com-embeddings-3ede12925b79">Embedding</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-aten%C3%A7%C3%A3o-%C3%A9-tudo-o-que-precisamos-ee42e3c42faf">Mecanismo de Atenção</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-bloco-transformer-72b895feb846">Bloco Transformer</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-gpt-do-token-ao-texto-7467f9cbdccf">Criando um GPT</a></li><li><strong>Treinando um Foundational Model</strong><em> </em>(Você está aqui!)</li><li><em>Especializando</em></li></ol><h3>Modelos Fundacionais</h3><p>Um Modelo Fundacional (Foundational Model) é um LLM pré-treinado em uma vasta quantidade de dados não rotulados — no nosso caso, textos de diversas origens. São chamados “fundacionais” porque estabelecem uma base de conhecimento que pode ser adaptada para múltiplos propósitos.</p><p>Os modelos opensource, como os que encontramos no HuggingFace, eles são identificados com sufixos como “-base” ou “-pt” (pré-treinado). Por exemplo, “bert-base” ou “gemma3–4b-pt” indicam versões fundacionais que passaram apenas pela fase de pré-treino, sem especialização para tarefas específicas.</p><p>Por si só, esses modelos pré-treinados são excelentes completadores de frases: dados os tokens anteriores, eles preveem o próximo e, ao realizar esse processo recursivamente, geram conteúdo.</p><p>Uma descoberta interessante foi a capacidade desses modelos de realizar tarefas sem treino específico, conhecido como “<strong>zero-shot learning</strong>”. Pesquisadores observaram que modelos pré-treinados em grandes volumes de texto conseguiam responder perguntas, classificar textos e até resolver problemas simples de raciocínio sem nunca terem sido explicitamente treinados para isso.</p><p>Esse fenômeno sugere que o processo de pré-treino não apenas ensina o modelo a prever palavras, mas também permite que ele desenvolva uma compreensão mais profunda da linguagem e do conhecimento contido nos textos. No entanto, o desempenho zero-shot geralmente é inferior ao de modelos especializados, justificando a necessidade de fine-tuning para tarefas específicas como conversação ou classificação de texto.</p><h3>Processo de Treinamento</h3><p>Vamos começar instanciando nosso modelo e gerando alguns textos para avaliarmos após o pré treinamento seu desempenho.</p><p>Vamos instanciar nosso tokenizer, que criamos no segundo artigo da série, e o GPTModel que finalizamos no artigo passado</p><pre># Carregando o Tokenizer e o Modelo<br>tk = spm.SentencePieceProcessor(<br>    model_file=&quot;../models/gigaverbo_tk.model&quot;<br>)<br><br>MODEL = GPTModel(<br>    d_vocab=tk.vocab_size(),<br>    d_emb=768,<br>    context_length=256,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=True,<br>)<br><br>total_params = sum(p.numel() for p in MODEL.parameters())<br>print(f&quot;Total de parâmetros: {total_params:,}&quot;)<br><br># OUTPUT<br># Total de parâmetros: 88,398,336</pre><p>Nosso objetivo não é criar uma nova família de modelos ou competir com as Big Techs, por isso nosso modelo será pequeno — muito pequeno: apenas <strong>88M de parâmetros</strong>. Para colocar em perspectiva, hoje em dia até os modelos considerados pequenos têm alguns <strong>bilhões de parâmetros</strong>.</p><p>Como nosso foco é entender o funcionamento dos LLMs, desde sua arquitetura até seu treinamento, não precisamos gastar processamento com um modelo gigante. O que diferencia nosso modelo dos demais será basicamente seu tamanho, a quantidade de tokens processados no pré-treinamento e, consequentemente, o tempo de treinamento.</p><p>Se você tiver uma GPU disponível e quiser treinar um modelo maior, poderá usar o mesmo código — basta ajustar parâmetros como janela de contexto, número de blocos transformers e tamanho dos embeddings.</p><p>Por enquanto, para nosso objetivo de aprendizado, esse modelinho será mais que suficiente.</p><pre>responses = []<br>for i in range(5):<br>    response = generate_sample(<br>        model=MODEL, <br>        device=&quot;cpu&quot;, <br>        tokenizer=tk, <br>        input_text=&quot;O Brasil é um&quot;, <br>        max_token=30, <br>        temperature=0.4,<br>        top_k=40,<br>        top_p=0.9<br>    )<br>    responses.append(response)<br>print(&quot;&quot;)<br>for i, response in enumerate(responses):<br>    print(f&quot;Resposta {i+1}: {response}&quot;)<br><br>#OUTPUT<br># Gerando Tokens...: 100%|██████████| 30/30 [00:01&lt;00:00, 15.56it/s]<br># Gerando Tokens...: 100%|██████████| 30/30 [00:01&lt;00:00, 17.86it/s]<br># Gerando Tokens...: 100%|██████████| 30/30 [00:01&lt;00:00, 18.20it/s]<br># Gerando Tokens...: 100%|██████████| 30/30 [00:01&lt;00:00, 17.56it/s]<br># Gerando Tokens...: 100%|██████████| 30/30 [00:01&lt;00:00, 21.82it/s]<br>#<br># Resposta 1: O Brasil é umiros alterna frase Terposição maneirasró ide ganiros� benefíciosbilidades bas baix tele baixaérciobilidades necessidade acab específicasab espera negócios� fecoocê<br># Resposta 2: O Brasil é um descont Eleeio fe relexto programater.bilidades legumes resumociar sequin bollialia noviros baixa eventos muitoodos tradicionalhhe sequ tentume<br># Resposta 3: O Brasil é umbilidades minha mund x fraseá mó medoientocê minhatório programa situocê mon Pateretes vi espa profissionalard Googleale notícias nov baixaocê<br># Resposta 4: O Brasil é ummicas interaçãoando especial&quot; candida Reitos prática Sim passos na tarocêritân emissões partetional amigo Falvamalidade tradicional parte benefícios usar iP muito facil facil<br># Resposta 5: O Brasil é um candidats saudável perguntasYáticas negócios frutas tele Ol descont capacidadearami cai� tele emp usadasumeing Ro lamico escolhabilidades negóciosbilidades segundo</pre><p>Como podemos observar, nosso modelo atual é apenas um gerador de palavras sem sentido. Ao fornecer a entrada “O Brasil é um”, ele gera frases completamente aleatórias. Nosso objetivo é que, após o pré-treinamento, o modelo seja capaz de construir frases mais coerentes.</p><h3>Preparando o Dataset</h3><p>A preparação adequada dos dados é um elemento crítico no treinamento de modelos de linguagem. O processo envolve fornecer tokens de entrada ao modelo para que ele aprenda a prever o próximo token da sequência.</p><p>Para isso, precisamos estruturar nosso dataset de maneira específica, permitindo que o modelo desenvolva a capacidade de fazer previsões contextualizadas.</p><pre>phrase = &quot;O Brasil é um país muito bonito &lt;|eos|&gt;&quot;<br>words = phrase.split()<br><br>context_window = 3<br><br>for i in range(len(words)-3):<br>    print(&quot;Iteração&quot;, i+1)<br>    print(f&quot;Input:\t{words[i:i+3]}&quot;)<br>    print(f&quot;Output:\t{words[i+1:i+4]}&quot;)<br>    print(&quot;---&quot;)<br><br>#OUTPUT<br># Iteração 1<br># Input: [&#39;O&#39;, &#39;Brasil&#39;, &#39;é&#39;]<br># Output: [&#39;Brasil&#39;, &#39;é&#39;, &#39;um&#39;]<br># ---<br># Iteração 2<br># Input: [&#39;Brasil&#39;, &#39;é&#39;, &#39;um&#39;]<br># Output: [&#39;é&#39;, &#39;um&#39;, &#39;país&#39;]<br># ---<br># Iteração 3<br># Input: [&#39;é&#39;, &#39;um&#39;, &#39;país&#39;]<br># Output: [&#39;um&#39;, &#39;país&#39;, &#39;muito&#39;]<br># ---<br># Iteração 4<br># Input: [&#39;um&#39;, &#39;país&#39;, &#39;muito&#39;]<br># Output: [&#39;país&#39;, &#39;muito&#39;, &#39;bonito&#39;]<br># ---<br># Iteração 5<br># Input: [&#39;país&#39;, &#39;muito&#39;, &#39;bonito&#39;]<br># Output: [&#39;muito&#39;, &#39;bonito&#39;, &#39;&lt;|eos|&gt;&#39;]<br># ---</pre><p>No exemplo acima, usando uma janela de contexto de 3 tokens e a frase O Brasil é um país muito bonito &lt;|eos|&gt; como dado de treinamento, precisamos estruturar o dataset para ter 3 tokens de entrada, com a saída sendo os mesmos 3 tokens deslocados uma posição para a direita.</p><p>Por exemplo, quando usamos como input o início O Brasil é, o output correspondente será Brasil é um , assim o modelo aprenderá a prever qual token deve vir após certas palavras, dado certos contextos.</p><p>Na hora de preparar o dataset, além da janela de contexto, para podermos “separar” os inputs, outra informação importante é o que chamamos de stride, que determina o tamanho do “passo” entre as janelas de contexto consecutivas.</p><p>Um stride menor cria mais sobreposição entre as janelas, gerando mais dados de treinamento, enquanto um stride maior reduz a sobreposição e economiza memória. A escolha do stride ideal é um trade-off entre volume de dados e eficiência computacional.</p><pre>phrase = &quot;O Brasil é um país muito bonito &lt;|eos|&gt;&quot;<br>words = phrase.split()<br><br>context_window = 3<br>stride = 2<br><br>for i in range(0, len(words)-3, stride):<br>    print(&quot;Iteração&quot;, (i//stride)+1)<br>    print(f&quot;Input:\t{words[i:i+3]}&quot;)<br>    print(f&quot;Output:\t{words[i+1:i+4]}&quot;)<br>    print(&quot;---&quot;)<br><br>#OUTPUT<br># Iteração 1<br># Input: [&#39;O&#39;, &#39;Brasil&#39;, &#39;é&#39;]<br># Output: [&#39;Brasil&#39;, &#39;é&#39;, &#39;um&#39;]<br># ---<br># Iteração 2<br># Input: [&#39;é&#39;, &#39;um&#39;, &#39;país&#39;]<br># Output: [&#39;um&#39;, &#39;país&#39;, &#39;muito&#39;]<br># ---<br># Iteração 3<br># Input: [&#39;país&#39;, &#39;muito&#39;, &#39;bonito&#39;]<br># Output: [&#39;muito&#39;, &#39;bonito&#39;, &#39;&lt;|eos|&gt;&#39;]<br># ---</pre><p>Ao adicionar o stride ao nosso exemplo, vemos que entre as iterações estamos pulando 2 palavras (em vez de uma). Por exemplo, se na primeira janela pegamos O Brasil é, na próxima pegaremos é um país, pulando O e Brasil.</p><p>Com stride igual a 2, obtivemos apenas 3 conjuntos de inputs com a frase, em comparação aos 5 conjuntos obtidos sem stride (ou com stride igual a 1).</p><p>Para nosso treinamento, precisaremos de mais conteúdo que apenas uma frase. Por isso, criaremos o dataset com o mesmo corpus usado para gerar o tokenizer: uma parte do dataset <strong>GigaVerbo</strong>. Nosso corpus contém aproximadamente 25 milhões de tokens.</p><pre>with open(&quot;../data/gigaverbo_tokenized.txt&quot;, &quot;r&quot;, encoding=&quot;utf-8&quot;) as f:<br>    text_tokenized = f.read()<br><br>num_tokens = len(text_tokenized.split())<br>print(f&quot;Número de tokens no corpus: {num_tokens:,}&quot;)<br><br>#OUTPUT<br># Número de tokens no corpus: 24,982,439</pre><p>Além de organizar os tokens do nosso corpus nesse formato de input e output, precisamos também agrupar os inputs e seus respectivos outputs esperados (que chamaremos de targets) em conjuntos chamados batches, para otimizar o processo de treinamento.</p><p>Um batch reúne múltiplos exemplos para processamento simultâneo pelo modelo, tornando o treinamento mais eficiente.</p><pre>phrase = &quot;O Brasil é um país da América do Sul &lt;|eos|&gt;&quot;<br>words = phrase.split()<br><br>context_window = 3<br>stride = 2<br>batch_size = 2  # Number of examples per batch<br><br>inputs = []<br>targets = []<br><br>for i in range(0, len(words)-3, stride):<br>    inputs.append(words[i:i+3])<br>    targets.append(words[i+1:i+4])<br><br># Reshape the list to batch_size x num_examples x num_words<br>inputs = np.array(inputs).reshape(batch_size, -1, 3)<br>targets = np.array(targets).reshape(batch_size, -1, 3)<br><br>print(f&quot;Shape (Batch x Trecho x Tokens): {inputs.shape}\n&quot;)<br>for i in range(batch_size):<br>    print(f&quot;Batch {i+1}&quot;)<br>    print(f&quot;Input:\n{inputs[i]}&quot;)<br>    print(f&quot;Target:\n{outputs[i]}&quot;)<br>    print(&quot;---&quot;)<br><br>#OUTPUT<br># Shape (Batch x Trecho x Tokens): (2, 2, 3)<br># <br># Batch 1<br># Input:<br># [[&#39;O&#39; &#39;Brasil&#39; &#39;é&#39;]<br>#  [&#39;é&#39; &#39;um&#39; &#39;país&#39;]]<br># Target:<br># [[&#39;Brasil&#39; &#39;é&#39; &#39;um&#39;]<br>#  [&#39;um&#39; &#39;país&#39; &#39;da&#39;]]<br># ---<br># Batch 2<br># Input:<br># [[&#39;país&#39; &#39;da&#39; &#39;América&#39;]<br>#  [&#39;América&#39; &#39;do&#39; &#39;Sul&#39;]]<br># Target:<br># [[&#39;da&#39; &#39;América&#39; &#39;do&#39;]<br>#  [&#39;do&#39; &#39;Sul&#39; &#39;&lt;|eos|&gt;&#39;]]<br># ---</pre><p>Para fazer todo esse processamento, usaremos duas classes da biblioteca PyTorch que facilitam a estruturação e o gerenciamento dos inputs e targets usados no treinamento.</p><p>Criaremos uma classe que herda de Dataset para representar nossos dados, enquanto usaremos o DataLoader para gerenciar o carregamento e a distribuição dos dados durante o treinamento.</p><pre>class GPTDataset(Dataset):<br>    def __init__(self, txt, tokenizer, max_length, stride):<br>        self.input_ids = []<br>        self.target_ids = []<br><br>        token_ids = tokenizer.encode(txt)<br><br>        for i in range(0, len(token_ids) - max_length, stride):<br>            input_chunk = token_ids[i : i + max_length]<br>            target_chunk = token_ids[i + 1 : i + max_length + 1]<br>            self.input_ids.append(torch.tensor(input_chunk))<br>            self.target_ids.append(torch.tensor(target_chunk))<br><br>    def __len__(self):<br>        return len(self.input_ids)<br><br>    def __getitem__(self, idx):<br>        return self.input_ids[idx], self.target_ids[idx]<br><br>def create_dataloader(<br>    txt,<br>    batch_size=4,<br>    max_length=256,<br>    stride=128,<br>    shuffle=True,<br>    drop_last=True,<br>    num_workers=0,<br>):<br>    dataset = GPTDataset(txt, tk, max_length, stride)<br>    dataloader = DataLoader(<br>        dataset,<br>        batch_size=batch_size,<br>        shuffle=shuffle,<br>        drop_last=drop_last,<br>        num_workers=num_workers,<br>        pin_memory=True,<br>    )<br><br>    return dataloader</pre><p>Reparem que nossa classe Dataset está separando o conteúdo passado (txt) em inputs e targets usando a mesma lógica que vimos anteriormente. Além disso precisamos implementar a função __len__ e __getitem__ que são métodos especiais do Python necessários para que nossa classe funcione corretamente com o DataLoader. O método <strong>len</strong> retorna o tamanho total do dataset, enquanto <strong>getitem</strong> permite acessar um elemento específico através de seu índice.</p><p>A função que create_dataloader que criamos serve para criar o Dataset e passa-lo para um DataLoader que cuidará de gerenciar e separar nossos batchs. Ao criar o Dataloader estamos definindo alguns parametros para configurar como nossos dados serão gerenciados e disponibilizados para o modelo:</p><ul><li>batch_size : Quantas “frases” teremos dentro de cada batch</li><li>shuffle : Controla se os dados serão embaralhados aleatoriamente durante o treinamento</li><li>drop_last : Define se o último batch será descartado caso seja menor que o tamanho definido</li><li>num_workers : Número de processos paralelos para carregamento dos dados</li><li>pin_memory : Define se os tensores serão alocados em uma região de memória específica da CPU que permite transferência mais rápida para a GPU</li></ul><p>Vamos testar e ver se a classe e a função estão funcionando corretamente</p><pre>phrase = &quot;O Brasil é um país da América do Sul &lt;|eos|&gt;&quot;<br>dataloader = create_dataloader(phrase, batch_size=2, max_length=3, stride=2)<br><br>for i, (input_ids, target_ids) in enumerate(dataloader):<br>    print(f&quot;Batch {i+1}&quot;)<br>    print(f&quot;Input:\n{input_ids}&quot;)<br>    print(f&quot;Target:\n{target_ids}&quot;)<br>    print(&quot;---&quot;)<br><br>#OUTPUT<br># Batch 1<br># Input:<br># tensor([[ 355,  474,  385],<br>#         [ 323,  313, 1040]])<br># Target:<br># tensor([[ 474,  385,  363],<br>#         [ 313, 1040,  334]])<br># ---<br># Batch 2<br># Input:<br># tensor([[1040,  334, 3268],<br>#         [ 385,  363,  323]])<br># Target:<br># tensor([[ 334, 3268,  320],<br>#         [ 363,  323,  313]])<br># ---</pre><p>Observe que obtivemos a mesma estrutura do nosso exemplo manual, mas agora com números (os IDs dos tokens) no lugar das palavras.</p><p>Como em todo processo de treinamento vamos separar uma parte do nosso corpus para validação e manter o restante para treinamento</p><pre>with open(&quot;../data/gigaverbo.txt&quot;, &quot;r&quot;, encoding=&quot;utf-8&quot;) as f:<br>    text = f.read()<br><br>train_ratio = 0.9<br>split_idx = int(len(text) * train_ratio)<br><br>train_data = text[:split_idx]<br>val_data = text[split_idx:]</pre><p>Após separar, vamos criar nossos Dataloader, um para treino e outro para validação</p><pre>train_dataloader = create_dataloader(<br>    train_data,<br>    batch_size=8,<br>    max_length=256,<br>    stride=128,<br>    drop_last=True,<br>    shuffle=True,<br>    num_workers=0<br>)<br><br>val_dataloader = create_dataloader(<br>    val_data,<br>    batch_size=8,<br>    max_length=256,<br>    stride=128,<br>    drop_last=True,<br>    shuffle=False,<br>    num_workers=0<br>)</pre><p>Estas configurações e tamanhos de batch são apenas exemplos ilustrativos. As configurações reais utilizadas no treinamento podem ser encontradas no arquivo de treino no github do projeto.</p><pre>def get_tensor_size(tensor):<br>    return tensor.element_size() * tensor.nelement()<br><br>def get_dataset_tensor_memory(dataset):<br>    input_size = sum(get_tensor_size(tensor) for tensor in dataset.input_ids)<br>    target_size = sum(get_tensor_size(tensor) for tensor in dataset.target_ids)<br>    return input_size + target_size<br><br>tensor_mem = get_dataset_tensor_memory(train_dataloader.dataset)<br>print(f&quot;Memória ocupada pelo dataset de Treino: {tensor_mem/1024/1024:.2f} MB&quot;)<br><br>tensor_mem = get_dataset_tensor_memory(val_dataloader.dataset)<br>print(f&quot;Memória ocupada pelo dataset de Validação: {tensor_mem/1024/1024:.2f} MB&quot;)<br><br>#OUTPUT<br># Memória ocupada pelo dataset de Treino: 678.52 MB<br># Memória ocupada pelo dataset de Validação: 83.88 MB</pre><p>Analisando o consumo de memória inicial, nosso dataset ocupa aproximadamente 760 MB. Quando adicionamos o modelo, que utiliza cerca de 300 MB, chegamos a um total de 1 GB de memória dedicada apenas ao armazenamento dos tensores. Durante o treinamento, esse consumo aumenta significativamente devido à necessidade de armazenar gradientes, estados do otimizador, caches de atenção e outras estruturas temporárias.</p><p>Isso evidencia que um dos principais desafios no treinamento de modelos de linguagem não se limita apenas ao poder de processamento, mas também à gestão eficiente da memória disponível.</p><p>Para nosso modelo relativamente pequeno e dataset reduzido, manter todos os dados na memória RAM é viável. No entanto, em cenários de treinamento de modelos maiores com datasets gigantescos, este se torna um dos principais gargalos.</p><p>Agora que o DataLoader está configurado, podemos passar para o treinamento. Antes, porém, vamos entender como avaliar o desempenho do modelo durante esse processo para ajustar corretamente seus pesos e bias.</p><h3>A Função de Perda</h3><p>No centro de todo treinamento de modelos está a função de perda (Loss Function), que mede quanto as previsões do modelo se desviam dos valores reais para então ajustar os parâmetros com o objetivo de diminuir progressivamente o erro. No nosso caso, a função de perda indica o quanto o modelo está distante de prever corretamente o próximo token.</p><p>Existem várias formas de calcular esse valor de perda. Para o tipo de problema que estamos abordando — que é essencialmente um problema de classificação multiclasse — a mais comum é a Cross-Entropy.</p><p>A Cross-Entropy (Entropia Cruzada) é uma medida da diferença entre duas distribuições de probabilidade: a distribuição prevista pelo modelo e a distribuição real dos dados. Em termos matemáticos, para um problema de classificação com © classes, a cross-entropy é definida como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/562/1*ZsLP6-ip-ztLlaLc-Q3OhA.png" /></figure><p>Onde:</p><p>• y_i é a probabilidade real (geralmente 0 ou 1 em classificação)</p><p>• y_hat é a probabilidade prevista pelo modelo</p><p>Para entendermos como a Cross-Entropy funciona na prática, vamos analisar um exemplo:</p><pre>phrase = &quot;O gato que gostava de andar de bicicleta&quot;<br>dataloader = create_dataloader(phrase, batch_size=2, max_length=3, stride=2)<br><br>first_batch = next(iter(dataloader))<br><br>print(f&quot;Input shape: {first_batch[0].shape}&quot;)<br>print(first_batch[0])<br>print(&quot;---&quot;)<br>print(f&quot;Target shape: {first_batch[1].shape}&quot;)<br>print(first_batch[1])<br><br>#OUTPUT<br># Input shape: torch.Size([2, 3])<br># tensor([[ 355, 3757,  302],<br>#         [ 306,  364,  269]])<br># ---<br># Target shape: torch.Size([2, 3])<br># tensor([[3757,  302, 1680],<br>#         [ 364,  269, 2169]])</pre><p>Neste exemplo, temos duas sequências de entrada e seus respectivos alvos (targets), que são as sequências deslocadas em uma posição. Vamos passar os inputs para o modelo e verificar o que ele está prevendo</p><pre>with torch.no_grad():<br>    logits = MODEL(first_batch[0])<br><br>probas = torch.softmax(logits, dim=-1)<br>probas.shape<br><br>#OUTPUT<br># torch.Size([2, 3, 4096])</pre><p>Como vimos no artigo anterior, nosso modelo retorna um tensor que contém, para cada token em cada frase, a probabilidade de cada um dos 4.096 tokens do vocabulário ser a próxima palavra. Vamos pegar o ID do token com maior probabilidade</p><pre>tokens_id = torch.argmax(probas, dim=-1)<br>print(f&quot;Output previsto (y_hat):\n{tokens_id.numpy()}&quot;)<br><br>#OUTPUT<br># Output previsto (y_hat):<br># [[1452  223 3121]<br>#  [3119  722  651]]</pre><p>Este é o output que nosso modelo está gerando. Por exemplo, para o trecho O gato que, que foi convertido para os tokens de IDs 355, 3757 e 302, e usado como primeira entrada, o modelo previu que o próximo token seria lo (último token do primeiro tensor de output, com ID 3121).</p><pre>phrase_target = tk.decode(first_batch[1][0].numpy().reshape(-1).tolist())<br>phrase_hat = tk.decode(tokens_id[0].numpy().reshape(-1).tolist())<br><br>print(f&quot;Target (y):\n{phrase_target} ({first_batch[1][0]})&quot;)<br>print(f&quot;Predicted (y_hat):\n{phrase_hat} ({tokens_id[0]})&quot;)<br><br>#OUTPUT<br># Target (y):<br># gato que gos (tensor([3757,  302, 1680]))<br># Predicted (y_hat):<br># lo� nossas (tensor([1452,  223, 3121]))</pre><p>Ao observar nosso target, ou seja, a resposta esperada, o próximo token deveria ser gos (representado pelo ID 1680). Como imaginamos, nosso modelo errou bastante. Mas como podemos quantificar esse “bastante”? É aí que entra a função de perda.</p><p>Para cada token de entrada, nosso modelo calcula a probabilidade de cada um dos 4096 tokens possíveis do nosso vocabulário. Como o modelo ainda não foi treinado, ele distribui as probabilidades de forma uniforme, resultando em aproximadamente 1/4096 de chance para cada token.</p><p>Podemos ver as probabilidades dos tokens</p><pre>proba_tokens_output = probas[0, [0, 1, 2], tokens_id[0]]<br>proba_tokens_target = probas[0, [0, 1, 2], first_batch[1][0]]<br><br>print(f&quot;Probabilidades para os tokens previstos:\n{proba_tokens_output}&quot;)<br>print(f&quot;Probabilidades para os tokens alvo:\n{proba_tokens_target}&quot;)<br><br>#OUTPUT<br># Probabilidades para os tokens previstos:<br># tensor([0.0015, 0.0017, 0.0016])<br># Probabilidades para os tokens alvo:<br># tensor([0.0002, 0.0003, 0.0002])</pre><p>Nosso objetivo é maximizar a probabilidade dos tokens do target (no exemplo acima ficaram próximos de 0,0002) e minimizar a dos tokens restantes. Assim, o modelo aprenderá a prever corretamente o output.</p><pre>cross_entropy = torch.log(proba_tokens_target) * -1<br>avg_log_proba = torch.mean(cross_entropy)<br>avg_log_proba<br><br>#OUTPUT<br># tensor(8.4868)</pre><p>O código acima implementa a fórmula de Cross-Entropy que vimos anteriormente, mas com algumas otimizações importantes:</p><p>O output do modelo é um vetor que contém as probabilidades para cada um dos 4.096 tokens do vocabulário. O target também precisa ser representado como um vetor de probabilidades. Como sabemos qual é o token correto, esse vetor se torna um one-hot encoding — com valor 1 na posição do token esperado e 0 nas demais posições.</p><p>Esta representação torna nosso cálculo mais simples: como a multiplicação por zero elimina a maioria dos termos da soma, precisamos calcular apenas o logaritmo da probabilidade do token alvo. Embora matematicamente equivalente à fórmula original da Cross-Entropy, esta abordagem é computacionalmente mais eficiente.</p><p>Como nossa sequência possui 3 tokens no output, calculamos a média das perdas individuais para obter uma única medida de perda para todo o input.</p><p>Em nosso código usaremos a função cross_entropy da biblioteca Pytorch já que oferece otimizações integradas e nos poupa de implementar esse cálculo manualmente</p><pre>loss = torch.nn.functional.cross_entropy(logits[0], first_batch[1][0])<br>loss<br><br>#OUTPUT<br># tensor(8.4868)</pre><p>Para facilitar o cálculo e uso dessa informação durante o treinamento, vamos criar duas funções. A primeira, chamada loss_batch, calculará a perda para todo o conjunto quando receber um batch (conjunto de inputs e targets).</p><p>A segunda função, loss_loader, terá foco no Dataloader completo, onde especificamos um dataloader e a quantidade de batches para calcular a perda. Isso nos permite fazer uma avaliação mais abrangente do comportamento do modelo. Por exemplo, podemos calcular a perda média em um conjunto de validação para monitorar se o modelo está melhorando sua capacidade de generalização durante o treinamento.</p><pre>def loss_batch(input_batch, target_batch, model, device):<br>    was_training = model.training<br>    model.eval()<br><br>    input_batch, target_batch = input_batch.to(device, non_blocking=True), target_batch.to(device, non_blocking=True)<br><br>    logits = model(input_batch)<br>    logits_flat = logits.flatten(0, 1)<br>    target_flat = target_batch.flatten()<br><br>    if was_training:<br>        model.train()<br><br>    return torch.nn.functional.cross_entropy(logits_flat, target_flat)<br><br>def loss_loader(data_loader, model, device, num_batchs = None):<br>    total_loss = 0.<br><br>    # Verifica se o dataloader está vazio<br>    if len(data_loader) == 0:<br>        return float(&quot;nan&quot;)<br>    # Se num_batchs for None, calcula a loss para todos os batchs<br>    elif num_batchs is None:<br>        num_batchs = len(data_loader)<br>    # Se num_batchs for maior que o tamanho do dataloader, calcula a loss para todos os batchs do data loader<br>    else:<br>        num_batchs = min(num_batchs, len(data_loader))<br><br>    for i, (x, y) in enumerate(data_loader):<br>        if i &lt; num_batchs:<br>            loss = loss_batch(x, y, model, device)<br>            total_loss += loss.item()<br>        else:<br>            break<br><br>    return total_loss / num_batchs<br><br>loss_batch_result = loss_batch(first_batch[0], first_batch[1], MODEL, &quot;cpu&quot;)<br>print(f&quot;Loss do primeiro batch: {loss_batch_result:.4f}&quot;)<br><br>loss_loader_result = loss_loader(dataloader, MODEL, &quot;cpu&quot;)<br>print(f&quot;Loss do dataloader de exemplo: {loss_loader_result:.4f}&quot;)<br><br>#OUTPUT<br># Loss do primeiro batch: 8.3901<br># Loss do dataloader de exemplo: 8.5045</pre><p>É importante notar que os valores de Loss são diferentes porque calculamos primeiro para um único exemplo do batch, depois para o primeiro batch completo e, por fim, para todos os batches do dataloader.</p><pre>MODEL.to(get_device())<br><br>loss_loader_train = loss_loader(train_dataloader, MODEL, get_device(), 10)<br>print(f&quot;Loss Dataset de Treino: {loss_loader_train:.4f}&quot;)<br><br>loss_loader_val = loss_loader(val_dataloader, MODEL, get_device(), 10)<br>print(f&quot;Loss Dataset de Validação: {loss_loader_val:.4f}&quot;)<br><br>#OUTPUT<br># Loss Dataset de Treino: 8.5007<br># Loss Dataset de Validação: 8.5155</pre><p>Podemos ver que a loss, calculada com alguns batches dos datasets de Treino e Validação, está alta. Nosso objetivo com o treinamento será diminuí-la</p><h4>Perplexidade</h4><p>A perplexidade é uma métrica fundamental na avaliação de modelos de linguagem e vale entendermos um pouco sobre ela. Matematicamente, é expressa como o exponencial da cross-entropy:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*7zA5iKa-mL_xrU5tXuFxMQ.png" /></figure><p>Quanto menor a perplexidade, melhor o desempenho do modelo. Em termos práticos, a perplexidade pode ser interpretada como o número médio de escolhas prováveis que o modelo considera ao fazer uma previsão.</p><ul><li><strong>Perplexidade = 1:</strong> Representa um modelo perfeito, que prevê com 100% de certeza cada token correto.</li><li><strong>Perplexidade = 4:</strong> Sugere que o modelo está, em média, “escolhendo” entre 4 opções igualmente prováveis para cada previsão.</li><li><strong>Perplexidade = V:</strong> (onde V é o tamanho do vocabulário) Indica um modelo que atribui probabilidade igual a todos os tokens, equivalente a fazer previsões aleatórias.</li></ul><pre>perplexity = torch.exp(loss_batch_result)<br>perplexity<br><br>#OUTPUT<br># tensor(4403.2520, grad_fn=&lt;ExpBackward0&gt;)</pre><p>A perplexidade de 4403,25 indica que o modelo está efetivamente “indeciso” entre cerca de 4403 tokens diferentes para cada previsão. Este valor excede o tamanho do vocabulário (4096) porque, sem treinamento, o modelo produz distribuições de probabilidade muito dispersas e desequilibradas, gerando uma incerteza maior do que teríamos com uma distribuição uniforme sobre o vocabulário.</p><h3>Loop de Treinamento</h3><p>O treinamento de um LLM é um processo iterativo onde cada passo é repetido — daí o termo “loop” — até que o modelo atinja um nível aceitável de erro (a loss). Os passos seguidos são iguais ao treinamento de qualquer modelo de Deep Learning:</p><ol><li>Iterar sobre cada <strong>época</strong></li><li>Iterar sobre cada <strong>batch de treino</strong></li><li><strong>Resetar os gradientes</strong> da iteracao anterior</li><li>Calcular a loss do batch (<strong>Forward</strong>)</li><li>Calcular os gradientes (<strong>Backward</strong>)</li><li><strong>Atualizar</strong> os parametros do modelo</li><li>A cada N passagens vamos avaliar o modelo no conjunto de Validação</li></ol><p>Vamos criar uma função para facilitar esse processo</p><pre>def train_model(<br>        model, # Modelo a ser treinado<br>        train_loader, # Dataloader de treino<br>        val_loader, # Dataloader de validação<br>        optimizer, # Otimizador<br>        device, # Dispositivo onde o modelo será treinado<br>        num_epochs, # Número de épocas<br>        eval_freq, # Frequência de avaliação<br>        num_eval_batchs, # Número de batchs usados para avaliação<br>        start_context, # Contexto inicial para geração de texto<br>        tokenizer # Tokenizador<br>    ):<br><br>    train_losses, val_losses, track_tokens_seen = [], [], []<br>    tokens_seen, global_step = 0, -1<br><br>    for epoch in range(num_epochs): # (Passo 1)<br>        model.train()<br><br>        for x_batch, y_batch in train_loader: # (Passo 2)<br><br>            optimizer.zero_grad() # (Passo 3)<br>            loss = loss_batch(x_batch, y_batch, model, device) # (Passo 4)<br>            loss.backward() # (Passo 5)<br>            optimizer.step() # (Passo 6)<br><br>            tokens_seen += x_batch.numel()<br>            global_step += 1<br>            <br>            # Verifica se é necessário avaliar o modelo (Passo 7)<br>            if global_step % eval_freq == 0:<br>                <br>                train_loss = loss_loader(train_loader, model, device, num_batchs=num_eval_batchs)<br>                val_loss = loss_loader(val_loader, model, device, num_batchs=num_eval_batchs)<br>                <br>                train_losses.append(train_loss)<br>                val_losses.append(val_loss)<br>                track_tokens_seen.append(tokens_seen)<br><br>                print(<br>                    f&quot;Epoch {epoch + 1} [Global step {global_step:04d}]: &quot;<br>                    f&quot;Train loss: {train_loss:.3f} | &quot;<br>                    f&quot;Val loss: {val_loss:.3f}&quot;<br>                )<br><br>                if global_step % (eval_freq * 5) == 0:<br>                    sample = generate_sample(<br>                        model = model, <br>                        device = device, <br>                        tokenizer= tokenizer, <br>                        input_text= start_context, <br>                        max_token=50, <br>                        temperature=0.8<br>                    )<br>                <br>                    print(f&quot;Generated text: {sample}\n&quot;)<br><br>    return train_losses, val_losses, track_tokens_seen</pre><p>Com essa estrutura básica, podemos começar a treinar nosso modelo. Vamos testar em um corpus reduzido para compreender o funcionamento do loop de treinamento.</p><pre>torch.manual_seed(123)<br>MODEL.to(get_device())<br><br>train_dataloader_short = create_dataloader( # (1)<br>    txt = train_data[:50000],<br>    batch_size= 2,<br>    max_length= 256,<br>    stride= 128,<br>    drop_last= True,<br>    shuffle= True<br>)<br><br>val_dataloader_short = create_dataloader( # (1)<br>    txt = val_data[:50000],<br>    batch_size= 2,<br>    max_length= 256,<br>    stride= 128,<br>    drop_last= True,<br>    shuffle= False<br>)<br><br>optimizer = torch.optim.AdamW(MODEL.parameters(), lr=4e-5, weight_decay=0.01) # (2)<br>num_epochs = 10<br><br>train_losses, val_losses, tokens_seen = train_model(<br>    model=MODEL,<br>    train_loader=train_dataloader_short,<br>    val_loader=val_dataloader_short,<br>    optimizer=optimizer,<br>    device=get_device(),<br>    num_epochs = num_epochs,<br>    eval_freq=5,<br>    num_eval_batchs=5,<br>    start_context=&quot;Se você planeja visitar&quot;,<br>    tokenizer=tk<br>)</pre><p>Criamos dois dataloaders <strong>(1)</strong> usando apenas os primeiros 50 mil caracteres iniciais dos nossos conjuntos de Treino e Validação. Em seguida instanciamos um otimizador chamado AdamW <strong>(2)</strong> que será o responsável por atualizar os pesos do modelo durante o treinamento.</p><p>O AdamW é uma variante do otimizador Adam que implementa um decaimento de peso (weight decay) de forma mais eficiente, ajudando a reduzir o overfitting. A taxa de aprendizado (learning rate) de 4e-5 foi escolhida por ser um valor conservador que permite um treinamento estável.</p><pre>def plot_losses(epochs_seen, tokens_seen, train_losses, val_losses):<br>    fig, ax1 = plt.subplots(figsize=(10, 5))<br>    <br>    # Use seaborn for plotting<br>    sns.lineplot(x=epochs_seen.numpy(), y=train_losses, ax=ax1, label=&quot;Training loss&quot;)<br>    sns.lineplot(x=epochs_seen.numpy(), y=val_losses, ax=ax1, label=&quot;Validation loss&quot;, <br>                 linestyle=&quot;--&quot;)<br>    <br>    ax1.set_xlabel(&quot;Epochs&quot;)<br>    ax1.set_ylabel(&quot;Loss&quot;)<br>    ax1.legend(loc=&quot;upper right&quot;)<br>    ax1.xaxis.set_major_locator(MaxNLocator(integer=True))<br>    <br>    ax2 = ax1.twiny()<br>    # Just to establish the twin x scale, not showing this line<br>    ax2.plot(tokens_seen, [train_losses[0] for _ in tokens_seen], alpha=0)<br>    ax2.set_xlabel(&quot;Tokens seen&quot;)<br>    <br>    # Add grid and set style<br>    ax1.grid(True, linestyle=&#39;--&#39;, alpha=0.7)<br>    sns.despine(fig=fig)<br>    <br>    fig.tight_layout()<br>    plt.show()<br><br><br>epochs_tensor = torch.linspace(0, num_epochs, len(train_losses))<br>plot_losses(epochs_tensor, tokens_seen, train_losses, val_losses)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*DQS7WlzRaoICmqKmcwHauA.png" /></figure><p>Como podemos observar, o valor da loss de treinamento foi diminuindo gradativamente, começando em 8 e terminando próximo de 2. No entanto, não vemos esse mesmo comportamento com a loss do conjunto de validação. Isso demonstra um clássico caso de <strong>overfitting</strong>, onde o modelo memoriza os dados do conjunto de treinamento, mas não consegue generalizar para gerar boas previsões com dados que não viu.</p><p>Este teste inicial serviu apenas para entendermos o loop de treinamento, sem pretensão de obter bons resultados. Isso porque utilizamos um conjunto de treinamento pequeno (o modelo processou pouco mais de 300k tokens) e não implementamos algumas técnicas de otimização que melhoram a performance e auxiliam a evitar o overfitting.</p><h3>Treinando nosso Modelo</h3><p>Para fins de eficiência, praticidade e organização, criei o script de treinamento fora do Jupyter Notebook. Dentro da pasta src no repositório do projeto, encontramos 4 arquivos que usaremos para treinar nosso modelo:</p><ul><li>main.py → Responsável por instanciar as classes necessárias e iniciar o treinamento</li><li>dataloader.py → Contém a classe do Dataset e a função de criação do dataloader</li><li>model.py → Contém as classes do nosso modelo</li><li>train_model.py → Classe contendo o loop de treinamento</li></ul><p>O conteúdo dos arquivos é essencialmente o mesmo que vimos e testamos no Jupyter Notebook, porém com alguns ajustes para otimizar o treinamento e evitar overfitting</p><h4>Decaimento de Peso Diferenciado</h4><p>Na classe TrainModel podemos observar que estamos usando o mesmo otimizador, porém com uma diferença importante: fazemos uma distinção entre as camadas nas quais aplicaremos o decaimento de peso e aquelas nas quais não aplicaremos</p><pre>p_dict = {p_name: p for p_name, p in self.MODEL.named_parameters() if p.requires_grad}<br>weight_decay_p = [p for n, p in p_dict.items() if p.dim() &gt;= 2]<br>no_weight_decay_p = [p for n, p in p_dict.items() if p.dim() &lt; 2]<br><br>optimizer_groups = [<br>    {&quot;params&quot;: weight_decay_p, &quot;weight_decay&quot;: 0.01},<br>    {&quot;params&quot;: no_weight_decay_p, &quot;weight_decay&quot;: 0.0}<br>]<br><br>self.OPTIMIZER = torch.optim.AdamW(<br>    optimizer_groups,<br>    lr=self.LR,<br>    betas=(0.9, 0.999),<br>    eps=1e-8<br>)</pre><p>Essa estratégia implementa a <strong>regularização L2</strong> (weight decay) de maneira seletiva. O processo é aplicado apenas às <strong>matrizes bidimensionais</strong> do modelo, que são principalmente os pesos das camadas lineares, onde a regularização é mais benéfica. Por outro lado, <strong>vetores unidimensionais</strong>, como <em>bias</em> e <em>embeddings</em>, são <strong>deliberadamente excluídos</strong> da regularização, pois estes componentes geralmente não contribuem significativamente para o overfitting.</p><p>Ao evitar a regularização excessiva de parâmetros que não precisam dela, o modelo mantém sua capacidade de aprendizado em áreas críticas enquanto previne o overfitting nas camadas mais propensas a este problema. Esta técnica tem se tornado um padrão em muitas implementações modernas de transformers.</p><h4>Schedule OneCycleLR</h4><p>Um dos parâmetros mais importantes é a taxa de aprendizado, ou Learning Rate, que controla a magnitude das atualizações de peso durante o treinamento.</p><p>Uma boa prática que auxilia nossa rede a convergir é variar essa taxa ao longo do treinamento, em vez de mantê-la constante, e é para isso que servem os <strong>schedules</strong></p><pre>self.SCHEDULER = OneCycleLR(<br>    self.OPTIMIZER,<br>    max_lr=self.LR,<br>    total_steps= len(self.TRAIN_LOADER) * self.NUM_EPOCHS,<br>    pct_start=0.1,  # 10% dos steps para warmup<br>    div_factor=10,  # lr_inicial = max_lr/10<br>    final_div_factor=100  # lr_final = lr_inicial/100<br>)</pre><p>O agendador OneCycleLR, que utilizamos, orquestra o ciclo de aprendizado em 3 fases distintas:</p><ol><li><strong>Warm-up</strong>: Inicia o treinamento com uma taxa de aprendizado <strong>baixa</strong> (configuramos para dividir o learning rate por 10) e a aumenta gradualmente durante os primeiros 10% dos passos de treinamento. Essa fase inicial estabiliza o treinamento e evita oscilações bruscas.</li><li><strong>Pico de Taxa</strong>: A taxa de aprendizado atinge seu valor <strong>máximo</strong> no meio do ciclo e permanece assim por um curto período. Essa fase permite uma exploração eficiente do espaço de parâmetros, buscando encontrar regiões promissoras para a solução.</li><li><strong>Annealing</strong>: A taxa de aprendizado é gradualmente <strong>reduzida</strong> até um valor muito pequeno (configuramos para dividir o learning rate por 1000) ao final do treinamento. Essa fase final facilita a convergência fina, permitindo que o modelo se ajuste com precisão aos mínimos locais do espaço.</li></ol><p>Podemos ver esse comportamento no gráfico abaixo obtido durante o treinamento do modelo</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZEfDYw2wXKIXDW-Sk-aZ5A.png" /></figure><p>Vemos que o Learning Rate sobe rapidamente, em seguida permanece alto por um curto período e em seguida diminui mais lentamente. Essa abordagem cíclica e dinâmica da taxa de aprendizado oferece uma série de benefícios, incluindo maior estabilidade no início do treinamento, exploração eficiente do espaço de parâmetros e convergência aprimorada na fase final do aprendizado.</p><h4>Clipping de Gradiente</h4><p>Implementamos o clipping de gradiente como uma técnica crucial para controlar a <strong>explosão de gradientes</strong>.</p><p>O <strong>gradiente</strong>, no contexto de redes neurais, funciona como uma bússola que indica a direção e intensidade necessárias para ajustar os parâmetros do modelo, visando reduzir a loss.</p><p>A <strong>norma do gradiente</strong> mensura a intensidade dessas mudanças necessárias em cada etapa do treinamento. Quando essa norma atinge valores muito <strong>elevados</strong>, significa que pequenas alterações nos parâmetros estão causando mudanças drásticas na função de perda. Em redes neurais profundas, isso pode desencadear um efeito cascata onde os gradientes crescem <strong>exponencialmente</strong> — fenômeno conhecido como <strong>explosão de gradientes</strong>.</p><p>Para solucionar esse desafio, o <strong>clipping de gradiente</strong> estabelece um limite máximo para a magnitude dos gradientes, preservando sua direção mas evitando atualizações bruscas que poderiam desestabilizar o aprendizado.</p><pre>torch.nn.utils.clip_grad_norm_(self.MODEL.parameters(), max_norm=1.0)</pre><p>Dessa forma, evitamos uma possível desestabilização da rede durante o treinamento. O gráfico da norma extraído do treinamento mostra que houve momentos em que a norma ultrapassou o limiar de 1 — especialmente no início do treinamento — e nesses momentos o clipping foi fundamental para manter a estabilidade da rede.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bw5AZ5QD9R3w3eFJsf_J8Q.png" /></figure><h4>Monitoramento e Métricas</h4><p>Para monitorar o progresso e desempenho do nosso modelo durante o treinamento, integramos o <strong>Weights &amp; Biases (wandb)</strong> — uma plataforma moderna de experimentação para machine learning. Através dela, registramos e visualizamos em tempo real diversas métricas essenciais:</p><ul><li><strong>Loss (Treino e Validação)</strong>: Acompanhamos a função de perda tanto no conjunto de treinamento quanto no de validação, permitindo avaliar o aprendizado do modelo e identificar possíveis casos de overfitting.</li><li><strong>Perplexidade</strong>: A métrica que vimos anteriormente que indica quão “surpreso” o modelo fica com os dados. Quanto menor a perplexidade, melhor o desempenho do modelo.</li><li><strong>Diferença Treino-Validação</strong>: Monitoramos a diferença entre as losses de treino e validação para detectar precocemente sinais de overfitting, quando o modelo começa a memorizar o conjunto de treinamento.</li><li><strong>Norma do Gradiente</strong>: Acompanhamos a magnitude dos gradientes para garantir um treinamento estável e efetivo, identificando possíveis casos de explosão ou desvanecimento de gradientes.</li><li><strong>Learning Rate</strong>: Visualizamos as mudanças na taxa de aprendizado ao longo do tempo, confirmando que o scheduler OneCycleLR está funcionando conforme esperado.</li></ul><h3>Resultado do Treinamento</h3><p>Para agilizar o processo de treinamento, optei por alugar uma máquina virtual com GPU em vez de treinar localmente o modelo. Utilizei o serviço da RunPod e instanciei uma VM com uma <strong>RTX 2000 Ada</strong> (16GB VRAM / 31GB RAM), utilizando-a por 3h30 para executar o script de treino, o que custou menos de $1.</p><p>Este tempo foi mais que suficiente para nosso teste e experimentação. Ao todo, nosso modelo foi treinado por mais de 4 mil passos e processou quase 33M de tokens (muito além dos 300k tokens do nosso teste no Jupyter Notebook)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ftiO7b6Ua3lQVZ8rULMr2A.png" /></figure><p>Com isso, conseguimos atingir uma loss de 3.5 no conjunto de validação e uma perplexidade de 34, resultados que considerei satisfatórios para nosso teste.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s4vQy_wNU6qzphhjEtluaA.png" /></figure><p>O script salvou checkpoints durante o treinamento e com isso podemos agora recuperar o modelo e compara-lo com o modelo que treinamos anteriormente no Jupiter Notebook</p><pre>responses = []<br>for i in range(5):<br>    response = generate_sample(<br>        model=MODEL, <br>        device=get_device(), <br>        tokenizer=tk, <br>        input_text=&quot;O Brasil é&quot;, <br>        max_token=30, <br>        temperature=0.4,<br>        top_k=40,<br>        top_p=0.9<br>    )<br>    responses.append(response)<br>print(&quot;&quot;)<br>for i, response in enumerate(responses):<br>    print(f&quot;Resposta {i+1}: {response}&quot;)<br><br>#OUTPUT<br># Resposta 1: O Brasil é e suaset se de L que parag:<br># <br># 1. Tf, a S, poden. Met (2.&lt;|eos|&gt;<br># Resposta 2: O Brasil é o dondia de 1220019.&lt;|eos|&gt;<br># Resposta 3: O Brasil é em b�1, Mett ( de Jor, 192, e ao norte com a uma colôo<br># Resposta 4: O Brasil é de Js da um St, Mos, que Seterndiap, Mos e é 11, At mais<br># Resposta 5: O Brasil é e arrem em 1212010, a ar queem Batr, J com Jw e mais de#OUTPUT<br># Resposta 1: O Brasil é e suaset se de L que parag:<br># <br># 1. Tf, a S, poden. Met (2.&lt;|eos|&gt;<br># Resposta 2: O Brasil é o dondia de 1220019.&lt;|eos|&gt;<br># Resposta 3: O Brasil é em b�1, Mett ( de Jor, 192, e ao norte com a uma colôo<br># Resposta 4: O Brasil é de Js da um St, Mos, que Seterndiap, Mos e é 11, At mais<br># Resposta 5: O Brasil é e arrem em 1212010, a ar queem Batr, J com Jw e mais de</pre><p>Podemos ver que nosso modelo, treinado rapidamente em 300k tokens ainda é muito semelhante ao sem treinamento, gerando textos completamente aleatórios. Vamos comparar com o desempenho do modelo que pré treinei em 33M de tokens</p><pre>MODEL_PT = GPTModel(<br>    d_vocab=tk.vocab_size(),<br>    d_emb=768,<br>    context_length=256,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=True,<br>).to(get_device())<br><br>state_dict = torch.load(&quot;../models/pretrain/checkpoint.pth&quot;, weights_only=False, map_location=get_device())<br>MODEL_PT.load_state_dict(state_dict[&#39;model_state_dict&#39;])<br><br>responses = []<br>for i in range(5):<br>    response = generate_sample(<br>        model=MODEL_PT, <br>        device=get_device(), <br>        tokenizer=tk, <br>        input_text=&quot;O Brasil é&quot;, <br>        max_token=30, <br>        temperature=0.4,<br>        top_k=40,<br>        top_p=0.9<br>    )<br>    responses.append(response)<br>print(&quot;&quot;)<br>for i, response in enumerate(responses):<br>    print(f&quot;Resposta {i+1}: {response}&quot;)<br><br>#OUTPUT<br># Resposta 1: O Brasil é o maior país do mundo.&lt;|eos|&gt;<br># Resposta 2: O Brasil é o maior país do mundo, com cerca de 300 milhões de habitantes.&lt;|eos|&gt;<br># Resposta 3: O Brasil é um dos maiores jogadores de todos os tempos.&lt;|eos|&gt;<br># Resposta 4: O Brasil é um dos maiores produtores de todos os tempos.<br># <br># A Basta é um dos maiores produtores de todos os tempos, com uma ampla<br># Resposta 5: O Brasil é o maior país do mundo, com uma população de 12.20.000 habitantes, com uma população de 2.</pre><p>É possível observar uma melhora significativa. Embora as frases ainda apresentem erros evidentes e imperfeições, o modelo claramente aprendeu padrões básicos da língua portuguesa e consegue gerar estruturas mais coerentes, mesmo que nem sempre precisas.</p><p>Vale ressaltar que estamos trabalhando com um modelo de 88 milhões de parâmetros, treinado com apenas 33 milhões de tokens. Em comparação, os modelos modernos possuem dezenas ou centenas de bilhões de parâmetros e são treinados com trilhões de tokens.</p><p>Ainda assim, é notável que nosso humilde modelo tenha conseguido aprender padrões básicos de linguagem e demonstrar capacidade generativa, mesmo que limitada.</p><h3>Conclusão</h3><p>Mais uma etapa concluída na nossa jornada de aprendizado sobre LLMs! Neste artigo, nos dedicamos a entender e implementar o treinamento de um modelo de linguagem desde a estaca zero. Percorremos um longo caminho, desde a definição da arquitetura GPT até a organização dos dados e a configuração do processo de treinamento.</p><p>O modelo que criamos, embora ainda distante dos modelos estado da arte (SOTA), demonstrou o potencial da arquitetura Transformer e nos proporcionou uma compreensão de como esses sistemas operam em suas entranhas.</p><p>Para finalizar nossa série, no próximo artigo vamos dar um passo adiante e descobrir como podemos aprimorar modelos pré treinados, utilizando a técnica de <em>fine-tuning</em> para adaptá-los a tarefas bem definidas. Prepare-se para o nosso próximo e, possivelmente, último capítulo desta saga!</p><p>Você pode acessar e acompanhar os artigos e códigos diretamente no meu github: <a href="https://github.com/z-fab/llm-zero/tree/master">https://github.com/z-fab/llm-zero/tree/master</a></p><p>Você também pode acessar o modelo pré treinado no Hugging Face: <a href="https://huggingface.co/zfab/llmdozero">https://huggingface.co/zfab/llmdozero</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a44d2d0abc6d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM do Zero: GPT — Do Token ao Texto]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-do-zero-gpt-do-token-ao-texto-7467f9cbdccf?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/7467f9cbdccf</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Wed, 05 Mar 2025 22:20:53 GMT</pubDate>
            <atom:updated>2025-03-05T22:20:53.839Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8MuLBpaNYUznUzOwWHpfaA.png" /></figure><h3><strong>Construindo um LLM do Zero: GPT — Do Token ao Texto</strong></h3><h4>Unindo os componentes em uma arquitetura final, pronta para ser pré-treinada</h4><p>Chegamos ao momento em que concluímos nosso modelo e o deixamos pronto para ser pré-treinado. Nos artigos anteriores, exploramos os conceitos fundamentais de tokenização, embeddings, multi-head attention e a arquitetura do bloco Transformer. Agora, daremos o passo final: montar o modelo <strong>GPT completo</strong> e <strong>funcional</strong>.</p><p>Este é o sexto artigo de uma série de oito. Não deixe de ler os artigos anteriores da série:</p><ol><li><a href="https://blog.zfab.me/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa">Introdução</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-tokeniza%C3%A7%C3%A3o-um-mal-necess%C3%A1rio-dfaab5dc9488">Tokenização</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-criando-significado-com-embeddings-3ede12925b79">Embedding</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-aten%C3%A7%C3%A3o-%C3%A9-tudo-o-que-precisamos-ee42e3c42faf">Mecanismo de Atenção</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-bloco-transformer-72b895feb846">Bloco Transformer</a></li><li><strong>Criando um GPT</strong> (Você está aqui!)</li><li><em>Treinando um Foundational Model</em></li><li><em>Especializando</em></li></ol><h3>Finalizando a arquitetura GPT</h3><p>A arquitetura GPT (Generative Pre-trained Transformer) é baseada em uma pilha de blocos Transformer, especificamente o decodificador. Sua principal característica é ser um modelo autoregressivo, ou seja, gera um token com base nos tokens anteriores, e esse resultado é alimentado como entrada para geração do próximo token. Este processo se repete até que uma condição de parada seja atingida, geralmente a presença de um token especial de fim de sentença (eos).</p><p>Fazendo uma retrospectiva dos artigos anteriores, já temos todos os blocos necessários para a construção do nosso modelo</p><ul><li><strong>Camada de Embedding</strong>: Converte tokens em representações vetoriais contínuas.</li><li><strong>Embeddings Posicionais</strong>: Adiciona informações de posição aos embeddings de tokens para manter a ordem sequencial.</li><li><strong>Blocos Transformer</strong>: Cada bloco contém mecanismos de atenção mascarada, normalização e redes feedforward.</li></ul><p>Agora precisamos apenas conectar tudo isso e adicionar duas últimas camadas ao final do último bloco transformer: uma <strong>Layer Normalizatio</strong>n, que vimos no artigo anterior, e uma <strong>camada Linear</strong>, semelhante a Feed Foward Network que também vimos anteriormente</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5PGFtr62eSKH3_h3dYzCNA.png" /></figure><p>A camada LayerNorm, como discutido anteriormente, servirá para normalizar as representações garantindo estabilidade numérica. Já a camada linear tem a função crucial de <strong>projetar os vetores</strong> da dimensão do embedding (tamanho d_emb) para a dimensão do vocabulário completo, transformando matrizes de formato (Número de Tokens × Tamanho do Embedding) em (Número de Tokens × Tamanho do Vocabulário).</p><p>Com essa transformação, o modelo gera, para cada posição na sequência de entrada, um vetor contendo valores logit para cada token do vocabulário. Logits são valores numéricos que representam as “pontuações brutas” atribuídas pelo modelo a cada token do vocabulário.</p><p>Ao aplicarmos a função softmax nos logits, eles se convertem em distribuições de probabilidade sobre todo o vocabulário, indicando a chance de cada token ser o próximo na sequência. Com essa informação conseguimos, por exemplo, prever o próximo token como aquele com maior probabilidade e então concatenar esse novo token à sequência e jogá-la toda novamente para dentro do modelo.</p><p>Vamos criar, finalmente nosso modelo:</p><pre>class GPTModel(nn.Module):<br>    def __init__(self, <br>        d_vocab,<br>        d_emb,<br>        context_length,<br>        n_layers,<br>        n_heads,<br>        dropout,<br>        qkv_bias        <br>    ):<br>        super().__init__()<br>        self.context_length = context_length<br><br>        # Embedding de tokens e de posição<br>        self.tok_emb = nn.Embedding(d_vocab, d_emb)<br>        self.pos_emb = nn.Embedding(context_length, d_emb)<br>        self.drop_emb = nn.Dropout(dropout)<br><br>        # Sequência de Blocos Transformers<br>        self.trf_blocks = nn.Sequential(<br>            *[TransformerBlock(d_emb, n_heads, context_length, dropout, qkv_bias) for _ in range(n_layers)]<br>        )<br><br>        # Normalização e projeção para o vocabulário<br>        self.final_norm = LayerNorm(d_emb)<br>        self.out_head = nn.Linear(d_emb, d_vocab, bias=False)<br>        <br>        # Inicialização dos pesos<br>        self.apply(self._init_weights)<br><br>    def _init_weights(self, module):<br>        if isinstance(module, nn.Linear):<br>            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)<br>            if module.bias is not None:<br>                torch.nn.init.zeros_(module.bias)<br><br>        elif isinstance(module, nn.Embedding):<br>            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)<br><br>    def forward(self, in_idx):<br>        batch_size, seq_len = in_idx.shape<br><br>        # Embedding de tokens e de posição<br>        tok_embeds = self.tok_emb(in_idx)<br>        pos_embeds = self.pos_emb(torch.arange(seq_len, device=in_idx.device))<br>        x = tok_embeds + pos_embeds<br>        x = self.drop_emb(x)<br><br>        # Sequência de Blocos Transformers<br>        x = self.trf_blocks(x)<br><br>        # Normalização e projeção para o vocabulário<br>        x = self.final_norm(x)<br>        logits = self.out_head(x)<br>        return logits<br>    <br>    # Função para gerar texto<br>    def generate(self, input, max=200):<br>        for _ in tqdm(range(max), desc=&quot;Gerando Tokens...&quot;):<br>            input = input[:, -self.context_length:] # Garantindo que o seja no máximo do tamanho do contexto. <br>            logits = self(input)<br>            logits = logits[:, -1, :]<br>            prob = F.softmax(logits, dim=-1)<br>            next_token = torch.multinomial(prob, num_samples=1)<br>            input = torch.cat([input, next_token], dim=-1)<br>        return input</pre><p>Como podem ver, estamos simplesmente pegando nosso vetor de tokens, transformando-os em embeddings, passando esses embeddings pelos blocos transformers e, ao final, normalizando e projetando esses embeddings na dimensão do vocabulário.</p><p>Também que estamos aplicando uma <strong>função para inicializar os pesos </strong>do modelo. Essa inicialização serve para termos uma convergência mais estável e rápida durante o treinamento.</p><p>Estamos utilizando a inicialização normal (gaussiana) com média 0 e desvio padrão de 0.02 para os pesos lineares e de embedding, ou seja, os pesos iniciais são amostrados com essa distribuição. Os vieses (quando presentes) inicializamos com zeros.</p><p>Essas escolhas de inicialização baseiam-se em práticas padrão que se mostraram eficazes em modelos transformers. Como ocorre com muitos aspectos na área de Deep Learning, não sabemos exatamente o porquê funciona — temos uma noção, mas não a certeza — e por isso continuamos aplicando.</p><p>Agora vamos testar nosso modelo. Primeiro, criaremos duas frases de exemplo e converteremos essas frases em vetores de tokens usando nosso tokenizador, que foi desenvolvido no segundo artigo desta série.</p><pre>frase_1 = &quot;Olá Mundo, tudo bem?&lt;|eos|&gt;&quot;<br>frase_2 = &quot;Criando meu primeiro LLM&lt;|eos|&gt;&quot;<br><br>tk = spm.SentencePieceProcessor(<br>    model_file=&quot;../models/gigaverbo_tk.model&quot;<br>)  # Instanciando o tokenizador treinado<br><br>frase_1_encode = tk.encode(frase_1)<br>frase_2_encode = tk.encode(frase_2)<br><br>batch = torch.tensor([frase_1_encode, frase_2_encode])<br><br>print(&quot;Frase 1&quot;, frase_1_encode)<br>print(&quot;Frase 2&quot;, frase_2_encode)<br><br>#OUTPUT<br># Frase 1 [3188, 4047, 2362, 341, 4040, 1927, 824, 4091, 3]<br># Frase 2 [346, 444, 341, 2390, 1429, 495, 4085, 4068, 3]</pre><p>Agrupamos as duas frases em um batch (conjunto) e passaremos ele como entrada pro nosso modelo. Vamos criar um modelo usando as configurações do <em>GPT-2 small</em></p><pre>torch.manual_seed(123)<br>model = GPTModel(<br>    d_vocab=tk.vocab_size(),<br>    d_emb=768,<br>    context_length=1024,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=False,<br>)<br><br>out = model(batch)<br>print(&quot;Input batch:&quot;, batch.shape)<br>print(&quot;Output shape: &quot;, out.shape)<br>print(&quot;Logits (Último Token, Primeira frase): &quot;, out[0, -1, :])<br><br>#OUTPUT<br># Input batch: torch.Size([2, 9])<br># Output shape:  torch.Size([2, 9, 4096])<br># Logits (Último Token, Primeira frase):  tensor([ 0.7082,  0.7826, -0.1804,  ...,  1.1423,  0.1249,  0.4783],<br>#        grad_fn=&lt;SliceBackward0&gt;)</pre><p>Como entrada (input batch) temos nossas 2 frases, ambas com o comprimento de 9 tokens (o equivalente a [2, 9, 1]). Ao passar pelo modelo, vemos que a saída é um tensor ainda com 2 frases de 9 tokens, porém agora a última dimensão tem tamanho 4096, que corresponde ao tamanho do nosso vocabulário.</p><p>Para prevermos a próxima palavra, sempre pegaremos o último token da frase (já que ele está prevendo sempre o próximo token) e, com base nos logits, escolhemos qual seria o token mais provável dentre as 4096 opções que nosso vocabulário oferece.</p><pre>top5 = torch.topk(out[0, -1, :], k=5).indices<br>print(&quot;Top 5 IDs tokens mais prováveis: &quot;, top5)<br>for i in top5:<br>    print(f&quot;Token ({i.item()}): {tk.decode_ids([i.item()])}&quot;)<br><br># OUTPUT<br># Top 5 IDs tokens mais prováveis:  tensor([ 114, 2943, 3100, 1369, 3151])<br># Token (114): n<br># Token (2943): quí<br># Token (3100): Aqui<br># Token (1369): animais<br># Token (3151): istir</pre><p>Analisando a primeira frase e o último token, podemos identificar os maiores logits e definir uma regra de seleção, como escolher o token com o maior valor. No exemplo acima, listamos os 5 tokens com os maiores logits, obtivemos seus IDs (identificando suas posições no vetor) e verificamos no vocabulário quais palavras eles representam.</p><p>É importante destacar que poderíamos aplicar a função softmax nos logits para obter as probabilidades associadas a cada token, convertendo os valores brutos em uma distribuição de probabilidade normalizada. No entanto, ao buscarmos apenas os tokens com os maiores valores, como fizemos com a função torch.topk(), não precisamos da softmax. Isso ocorre porque a função softmax preserva a ordem dos valores—o maior logit continuará correspondendo à maior probabilidade—portanto, para simplesmente identificar os tokens mais prováveis, podemos trabalhar diretamente com os logits.</p><p>Nesse nosso exemplo, o token com maior logit é o 114, que representa a letra “n”. Portanto, nosso modelo está prevendo que para a sequência Olá Mundo, tudo bem?&lt;|eos|&gt; o próximo token seria n.</p><p>Obviamente não faz sentido, mas vale lembrarmos que não treinamos ainda o modelo — ele está com os pesos aleatórios e, portanto, está funcionando de maneira totalmente estocástica. Ou seja, prever com ele ou fazendo uma jogada de moeda pra cima, dá no mesmo.</p><p>Pronto, temos nosso modelo funcional, basta treina-lo para que ele comece a se comportar como um LLM de verdade. Vamos verificar com quantos parâmetros nosso modelo ficou</p><pre>model_gpt2 = GPTModel(<br>    d_vocab=50257, # Nosso vocabulário é muito menor que o do GPT-2<br>    d_emb=768,<br>    context_length=1024,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=False,<br>)<br><br>total_params = sum(p.numel() for p in model.parameters())<br>print(f&quot;Número de Parâmetros: {total_params:,}&quot;)<br><br>total_params = sum(p.numel() for p in model_gpt2.parameters())<br>print(f&quot;Número de Parâmetros GPT-2 Small: {total_params:,}&quot;)<br><br>#OUTPUT<br># Número de Parâmetros: 92,106,240<br># Número de Parâmetros GPT-2 Small: 163,009,536</pre><p>Vemos que nosso modelo ficou com “apenas” 92 milhões de parâmetros. Apesar da arquitetura e configurações serem praticamente as mesmas do GPT-2 Small, temos um vocabulário mais de 10x menor, o que resulta nessa diferença significativa.</p><p>Leitores mais curiosos notarão que o GPT-2 em sua versão Small tem cerca de 124 milhões de parâmetros, porém a nossa “replica” aparece com 163M. Por que essa diferença?</p><h3>Weight Tying</h3><p>Uma técnica usada na construção de LLMs é o conceito de <strong>weight tying</strong> (compartilhamento de pesos). Esta prática consiste em compartilhar os mesmos pesos entre a camada de embedding de entrada e a camada linear de saída do modelo, que projeta os embeddings de volta em tokens.</p><p>Em nossa replica do GPT, isso significaria que os pesos da camada tok_emb (responsável por converter IDs de tokens em embeddings) seriam os mesmos utilizados na camada out_head (que projeta os embeddings de volta para o espaço do vocabulário).</p><pre>print(&quot;Camada Token -&gt; Embedding (tok_emb):&quot;, model.tok_emb.weight.shape)<br>print(&quot;Camada Embedding -&gt; Token (out_head):&quot;, model.out_head.weight.shape)<br><br>#OUTPUT<br># print(&quot;Camada Token -&gt; Embedding (tok_emb):&quot;, model.tok_emb.weight.shape)<br># print(&quot;Camada Embedding -&gt; Token (out_head):&quot;, model.out_head.weight.shape)</pre><p>O weight tying oferece algumas vantagens:</p><ul><li><strong>Redução significativa de parâmetros:</strong> Para um vocabulário típico de 50.000 tokens e dimensão de embedding de 768, economizamos cerca de 38 milhões de parâmetros (50.000 × 768).</li><li><strong>Melhoria na generalização:</strong> O compartilhamento de pesos funciona como uma forma de regularização, forçando o modelo a aprender representações mais robustas e coerentes.</li><li><strong>Aceleração da convergência:</strong> Modelos com weight tying tendem a convergir mais rapidamente durante o treinamento.</li></ul><p>A intuição por trás dessa técnica é que existe uma relação simétrica entre a tarefa de converter tokens em representações semânticas (embedding) e a tarefa inversa de projetar representações semânticas de volta para probabilidades sobre o vocabulário (classificação).</p><p>Estudos empíricos, como o apresentado no artigo <a href="https://arxiv.org/abs/1608.05859"><em>Using the Output Embedding to Improve Language Models</em></a> (Press &amp; Wolf, 2016), demonstraram que esta técnica não apenas reduz a quantidade de parâmetros, mas também melhora o desempenho do modelo em várias tarefas de linguagem.</p><p>Para implementar o weight tying em nosso modelo GPT, basta adicionar uma linha de código após a inicialização das camadas no método __init__:</p><pre>class GPTModel(nn.Module):<br>    def __init__(self, <br>        d_vocab,<br>        d_emb,<br>        context_length,<br>        n_layers,<br>        n_heads,<br>        dropout,<br>        qkv_bias        <br>    ):<br>        <br>        # ... Código identico ....<br><br>        # Weights tying<br>        self.out_head.weight = self.tok_emb.weight<br><br>    # ... Código identico ....</pre><p>Esta simples modificação tornará nosso modelo mais eficiente tanto em termos de memória quanto de desempenho. Vamos verificar os parâmetros novamente</p><pre>model = GPTModel(<br>    d_vocab=tk.vocab_size(),<br>    d_emb=768,<br>    context_length=1024,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=False,<br>)<br><br>model_gpt2 = GPTModel(<br>    d_vocab=50257,  # Nosso vocabulário é muito menor que o do GPT-2<br>    d_emb=768,<br>    context_length=1024,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=False,<br>)<br><br>total_params_model = sum(p.numel() for p in model.parameters())<br>print(f&quot;Número de Parâmetros: {total_params_model:,}&quot;)<br><br>total_params_model_gpt2 = sum(p.numel() for p in model_gpt2.parameters())<br>print(f&quot;Número de Parâmetros GPT-2 Small: {total_params_model_gpt2:,}&quot;)<br><br>#OUTPUT<br># Número de Parâmetros: 88,960,512<br># Número de Parâmetros GPT-2 Small: 124,412,160</pre><p>Enquanto nosso modelo “perdeu” cerca de 3M de parâmetros, a nossa réplica do GPT-2 chegou aos famosos 124M. Com isso conseguimos calcular o tamanho que esses modelos ocupariam na memória.</p><pre>total_size_bytes = total_params_model * 4<br>total_size_mb = total_size_bytes / (1024 * 1024)<br>print(f&quot;Tamanho total do modelo: {total_size_mb:.2f} MB&quot;)<br><br>total_size_bytes = total_params_model_gpt2* 4<br>total_size_mb = total_size_bytes / (1024 * 1024)<br>print(f&quot;Tamanho total do modelo GPT-2 Small: {total_size_mb:.2f} MB&quot;)<br><br>#OUTPUT<br># Tamanho total do modelo: 339.36 MB<br># Tamanho total do modelo GPT-2 Small: 474.59 MB</pre><p>Para calcular o tamanho, multiplicamos o número de parâmetros pelo espaço necessário para armazenar cada um em ponto flutuante (4 bytes para precisão simples). Por exemplo, usando precisão simples (float32), nosso modelo de ~89M de parâmetros ocuparia aproximadamente 339 MB apenas para os pesos, enquanto o GPT-2 Small necessitaria de cerca de 474 MB.</p><h3>Geração de Texto com o nosso Modelo</h3><p>Antes de partirmos para o pré-treinamento, é interessante entender como utilizaremos o output do nosso modelo para gerar texto. O processo é autoregressivo: alimentamos o modelo com as previsões anteriores até atingirmos o comprimento desejado ou um token de parada.</p><p>Leitores mais atentos notaram que adicionamos uma função de geração no código do modelo. Vamos entendê-la:</p><pre>def generate(self, input, max=200):<br>        for _ in tqdm(range(max), desc=&quot;Gerando Tokens...&quot;):<br>            input = input[:, -self.context_length:] # (1) Garantindo que o seja no máximo do tamanho do contexto. <br>            logits = self(input) # (2)<br>            logits = logits[:, -1, :] # (3)<br>            prob = F.softmax(logits, dim=-1) # (4)<br>            next_token = torch.multinomial(prob, num_samples=1) # (5)<br>            input = torch.cat([input, next_token], dim=-1) # (6)<br>        return input</pre><p>A função recebe uma sequência de tokens (input) e repete uma série de passos para gerar uma quantidade predeterminada de tokens (max).</p><p>Em cada iteração, primeiro truncamos o input (1) para garantir que não exceda o tamanho máximo do contexto (definimos em nosso modelo 1024 tokens). Em seguida, passamos o input pelo modelo (2) para obter os logits e selecionamos apenas os logits do último token da sequência (3).</p><p>Aplicamos a função softmax para converter os logits em probabilidades (4) e, usando a função multinomial, amostramos o próximo token (5).</p><p>Por fim, concatenamos o token amostrado à sequência de input (6), que será usado na próxima iteração (1).</p><p>Vamos criar uma função de apoio para auxiliar a geração de texto</p><pre>@torch.no_grad()  # (1)<br>def generate_sample(model, input_text, max_token=200):<br>    input_tokens = torch.tensor(tk.encode(input_text), dtype=torch.long)  # (2)<br>    input_tokens = input_tokens.unsqueeze(0)  # (3)<br><br>    output = model.generate(input_tokens, max_token)  # (4)<br>    output_text = tk.decode(output.squeeze().tolist())  # (5)<br><br>    return output_text  # (6)</pre><p>Essa função recebe uma string de texto e a quantidade máxima de tokens como entrada. Ela prepara o texto para ser enviado ao modelo e, posteriormente, converte a saída do modelo de volta para texto.</p><p>O decorador @torch.no_grad (1) desativa o cálculo de gradientes durante a inferência, pois estes são necessários apenas durante o treinamento.</p><p>Em seguida, convertemos o texto de entrada em tokens usando nosso tokenizador (2) e adicionamos uma dimensão extra (3), pois precisamos passar o tensor no formato (batch x tokens). Depois, chamamos a função generate do modelo (4) que vimos anteriormente.</p><p>O output do modelo é então convertido de volta em texto usando o decode do tokenizador (5) e, por fim, retornamos o texto gerado (6).</p><pre>texto_gerado = generate_sample(model, &quot;Olá Mundo, tudo bem?&quot;, 15)<br>print(texto_gerado)<br><br>texto_gerado = generate_sample(model, &quot;Olá Mundo, tudo bem?&quot;, 15)<br>print(texto_gerado)<br><br>#OUTPUT<br># Gerando Tokens...: 100%|██████████| 15/15 [00:00&lt;00:00, 19.94it/s]<br># Olá Mundo, tudo bem? conse Norte &quot;� experiência�[ blog cheg� fundo virtuigu temp coisas<br># Gerando Tokens...: 100%|██████████| 15/15 [00:00&lt;00:00, 25.05it/s]<br># Olá Mundo, tudo bem?é escola dese Desde esti animais partir entregaueise ideiamas sites gerenciar sustentável</pre><p>Podemos ver que está funcionando. O resultado ainda é sem sentido mas podemos ver que mesmo passando a mesma frase de entrada obtemos resultados diferentes.</p><p>Diferente do <strong>método <em>greedy</em></strong>, que usamos anteriormente, onde simplesmente selecionamos o token com o maior logit (e, portanto, maior probabilidade), a amostragem probabilística oferece uma abordagem mais rica e flexível. Em vez de uma escolha determinística (maior logit), usamos uma função multinomial para sortear o próximo token, com base em sua probabilidade.</p><p>A função torch.multinomial é a chave para essa amostragem baseada em probabilidades. Imagine um sorteio de palavras do vocabulário, onde cada palavra tem um peso proporcional à sua probabilidade. Palavras com maior probabilidade têm mais chances de serem sorteadas, mas palavras com menor probabilidade ainda têm uma chance de serem escolhidas. Este processo introduz uma aleatoriedade controlada na geração, permitindo que o modelo explore diferentes caminhos e evite respostas repetitivas.</p><p>É por isso que, mesmo fornecendo o mesmo texto de entrada, obtemos resultados diferentes, diferentemente do que aconteceria se sempre escolhêssemos o token com maior logit. Como o processo é autoregressivo, essas pequenas variações se acumulam durante a geração, resultando em frases completamente distintas.</p><p>Mas como podemos controlar essa aleatoriedade e direcionar a geração para resultados mais “criativos” quando necessário e mais conservadores em outros momentos? Para isso, existem algumas técnicas de amostragem:</p><h3>Temperature Scaling (T)</h3><p>O parâmetro <strong>Temperature (T)</strong> é um hiperparâmetro crucial que ajusta a distribuição de probabilidades dos tokens. Em essência, ele “achata” ou “aguça” a distribuição de probabilidades, influenciando a diversidade das saídas.</p><p>Para isso, basta dividirmos os logits por (T) antes de aplicar a função softmax. Essa simples divisão traz um comportamento interessante:</p><ul><li><strong>(T &gt; 1): Mais Criatividade </strong>— Uma temperatura maior que 1 torna a distribuição mais uniforme, dando mais chances para tokens menos prováveis. Isso resulta em texto mais diverso, criativo. Use (T &gt; 1) para tarefas que exigem um toque artístico, como:</li><li><strong>(T &lt; 1): Mais Precisão </strong>— Uma temperatura menor que 1 concentra a distribuição nos tokens mais prováveis, tornando a geração mais conservadora e precisa.</li><li><strong>(T = 1): Equilíbrio </strong>— Uma temperatura igual a 1 mantém a distribuição original sem modificação, oferecendo um ponto de partida neutro.</li></ul><pre># Criando uma distribuição aleatória de 15 tokens<br>np.random.seed(42)<br>random_probs = np.random.dirichlet(<br>    np.ones(15) * 0.5<br>)<br>probs = torch.tensor(random_probs, dtype=torch.float32)<br>num_tokens = len(probs)<br><br># Temperaturas para os gráficos de barras<br>temp_low = 0.3  # Temperatura baixa<br>temp_high = 2.0  # Temperatura alta<br><br># Calculando as probabilidades com temperaturas ajustadas<br>logits = torch.log(probs)  # Convertendo probabilidades de volta para logits<br>probs_low = F.softmax(logits / temp_low, dim=0).numpy()<br>probs_high = F.softmax(logits / temp_high, dim=0).numpy()<br><br># Preparando o gráfico<br>fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharey=True)<br><br># Gráfico de barras para temperatura baixa<br>sns.barplot(<br>    x=np.arange(num_tokens), <br>    y=probs_low, <br>    ax=axes[0], <br>    hue=np.arange(num_tokens), <br>    legend=False, <br>    palette=&quot;Blues_d&quot;<br>)<br>axes[0].set_title(f&quot;Temperatura Baixa (T = {temp_low})&quot;)<br>axes[0].set_xlabel(&quot;Índice do Token&quot;)<br>axes[0].set_ylabel(&quot;Probabilidade&quot;)<br>axes[0].set_xticks(np.arange(num_tokens))<br>axes[0].set_ylim(<br>    0, max(np.max(probs_low), np.max(probs.numpy()), np.max(probs_high)) * 1.1<br>)<br><br># Gráfico da distribuição original<br>sns.barplot(<br>    x=np.arange(num_tokens), <br>    y=probs.numpy(), <br>    ax=axes[1], <br>    hue=np.arange(num_tokens), <br>    legend=False, <br>    palette=&quot;Reds_d&quot;<br>)<br>axes[1].set_title(&quot;Distribuição Original (T = 1.0)&quot;)<br>axes[1].set_xlabel(&quot;Índice do Token&quot;)<br>axes[1].set_xticks(np.arange(num_tokens))<br><br># Gráfico de barras para temperatura alta<br>sns.barplot(<br>    x=np.arange(num_tokens),<br>    y=probs_high,<br>    ax=axes[2],<br>    hue=np.arange(num_tokens),<br>    legend=False,<br>    palette=&quot;Greens_d&quot;,<br>)<br>axes[2].set_title(f&quot;Temperatura Alta (T = {temp_high})&quot;)<br>axes[2].set_xlabel(&quot;Índice do Token&quot;)<br>axes[2].set_xticks(np.arange(num_tokens))<br><br>plt.tight_layout()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iPGkR9C5yZ_uXOIDr42ziA.png" /></figure><p>Podemos perceber pelos gráficos que temperaturas mais baixas modificam a distribuição de modo a realçar os picos da distribuição original, enquanto temperaturas altas tendem a equalizar as probabilidades.</p><h3>Top-k Sampling</h3><p>A técnica <strong>Top-k Sampling</strong> restringe a amostragem apenas aos (k) tokens mais prováveis, ajudando a evitar escolhas improváveis que poderiam prejudicar a coerência do texto. Pense nisso como um filtro que remove as opções mais “malucas” do sorteio.</p><p>O valor de (k) é crucial. Um valor <strong>muito baixo pode tornar o texto repetitivo</strong> e previsível, enquanto um valor <strong>muito alto pode não filtrar</strong> suficientemente as opções indesejadas.</p><pre># Criando uma distribuição aleatória de 15 tokens<br>np.random.seed(42)<br>random_probs = np.random.dirichlet(<br>    np.ones(15) * 0.5<br>)  # Distribuição Dirichlet para gerar probabilidades aleatórias<br>probs = torch.tensor(random_probs, dtype=torch.float32)<br>num_tokens = len(probs)<br><br># Definindo o valor de k para o Top-K Sampling<br>k = 5<br><br># Aplicando Top-K Sampling<br>values, indices = torch.topk(probs, k=k)<br>top_k_probs = torch.zeros_like(probs)<br>top_k_probs[indices] = values<br><br># Renormalizando as probabilidades após o Top-K<br>top_k_probs = top_k_probs / top_k_probs.sum()<br><br># Preparando o gráfico<br>fig, axes = plt.subplots(1, 2, figsize=(14, 6), sharey=True)<br><br># Criando uma paleta de cores para destacar os tokens selecionados<br>colors_original = [&quot;#3498db&quot; if i in indices else &quot;#e74c3c&quot; for i in range(num_tokens)]<br>colors_topk = [&quot;#3498db&quot; if i in indices else &quot;#e74c3c&quot; for i in range(num_tokens)]<br><br># Gráfico da distribuição original<br>sns.barplot(<br>    x=np.arange(num_tokens),<br>    y=probs.numpy(),<br>    ax=axes[0],<br>    hue=np.arange(num_tokens),<br>    legend=False,<br>    palette=colors_original,<br>)<br>axes[0].set_title(&quot;Distribuição Original (Top 5 probabilidade = Azul)&quot;)<br>axes[0].set_xlabel(&quot;Índice do Token&quot;)<br>axes[0].set_xticks(np.arange(num_tokens))<br><br># Gráfico de barras para Top-K Sampling<br>sns.barplot(<br>    x=np.arange(num_tokens), y=top_k_probs.numpy(), ax=axes[1], hue=np.arange(num_tokens), legend=False, palette=colors_topk<br>)<br>axes[1].set_title(f&quot;Top-{k} Sampling&quot;)<br>axes[1].set_xlabel(&quot;Índice do Token&quot;)<br>axes[1].set_ylabel(&quot;Probabilidade&quot;)<br>axes[1].set_xticks(np.arange(num_tokens))<br>axes[1].set_ylim(<br>    0, max(np.max(probs.numpy()), np.max(top_k_probs.numpy())) * 1.1<br>)<br><br>plt.tight_layout()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qkwWLVLOTP7U96jckNIMNQ.png" /></figure><p>O gráfico demonstra claramente o efeito da técnica Top-K: ela remove da “disputa” todos os tokens que não estão entre os K mais prováveis e reajusta as probabilidades apenas para esses tokens selecionados</p><h3>Top-P (Nucleus) Sampling</h3><p>O <strong>Top-P Sampling</strong>, também conhecido como <strong>Nucleus Sampling</strong>, é uma técnica que, diferentemente do Top-k, não fixa um número arbitrário de tokens. Em vez disso, seleciona o menor conjunto de tokens cuja probabilidade cumulativa excede um limiar (p).</p><p>Imagine que estamos construindo um “núcleo” de tokens: começamos pelos mais prováveis e vamos adicionando outros até que a probabilidade total desse núcleo atinja (p). A amostragem considera apenas os tokens dentro desse núcleo.</p><p>Quando o modelo está muito confiante em alguns tokens, o núcleo permanece pequeno, favorecendo a precisão. Quando está incerto, o núcleo se expande, permitindo maior diversidade.</p><pre># Criando uma distribuição aleatória de 15 tokens<br>np.random.seed(42)<br>random_probs = np.random.dirichlet(<br>    np.ones(15) * 0.5<br>)  # Distribuição Dirichlet para gerar probabilidades aleatórias<br>probs = torch.tensor(random_probs, dtype=torch.float32)<br>num_tokens = len(probs)<br><br># Definindo o valor de p para o Top-P (Nucleus) Sampling<br>p = 0.85  # Vamos manter tokens que somam 70% da probabilidade total<br><br># Aplicando Top-P Sampling<br>sorted_probs, sorted_indices = torch.sort(probs, descending=True)<br>cumulative_probs = torch.cumsum(sorted_probs, dim=0)<br>sorted_indices_to_remove = cumulative_probs &gt; p<br><br>nucleus_mask = torch.ones_like(probs, dtype=torch.bool)<br>nucleus_mask[sorted_indices[sorted_indices_to_remove]] = False<br><br># Aplicando a máscara para obter as probabilidades após o Top-P<br>top_p_probs = probs.clone()<br>top_p_probs[~nucleus_mask] = 0<br><br># Renormalizando as probabilidades após o Top-P<br>top_p_probs = top_p_probs / top_p_probs.sum()<br><br># Contando quantos tokens foram mantidos<br>num_tokens_kept = nucleus_mask.sum().item()<br><br># Preparando o gráfico<br>fig, axes = plt.subplots(1, 2, figsize=(14, 6), sharey=True)<br><br># Criando uma paleta de cores para destacar os tokens selecionados<br>colors_original = [<br>    &quot;#3498db&quot; if nucleus_mask[i] else &quot;#e74c3c&quot; for i in range(num_tokens)<br>]<br>colors_topp = [&quot;#3498db&quot; if nucleus_mask[i] else &quot;#e74c3c&quot; for i in range(num_tokens)]<br><br># Gráfico da distribuição original<br>sns.barplot(<br>    x=np.arange(num_tokens),<br>    y=probs.numpy(),<br>    ax=axes[0],<br>    hue=np.arange(num_tokens),<br>    legend=False,<br>    palette=colors_original,<br>)<br>axes[0].set_title(&quot;Distribuição Original&quot;)<br>axes[0].set_xlabel(&quot;Índice do Token&quot;)<br>axes[0].set_xticks(np.arange(num_tokens))<br><br># Adicionando uma linha horizontal para mostrar o &quot;corte&quot; do Top-P<br>cumsum_threshold = None<br>for i, cum_prob in enumerate(cumulative_probs):<br>    if cum_prob &gt; p:<br>        cumsum_threshold = i<br>        break<br><br>if cumsum_threshold is not None:<br>    # Adicionando uma linha no gráfico original para mostrar o limite do Top-P<br>    axes[0].axhline(<br>        y=sorted_probs[cumsum_threshold - 1],<br>        color=&quot;#f39c12&quot;,<br>        linestyle=&quot;--&quot;,<br>        linewidth=2,<br>    )<br>    axes[0].text(<br>        num_tokens / 2,<br>        sorted_probs[cumsum_threshold - 1] * 1.05,<br>        f&quot;Limite do Top-P = ~{p * 100:.0f}%&quot;,<br>        ha=&quot;center&quot;,<br>        color=&quot;#f39c12&quot;,<br>        fontweight=&quot;bold&quot;,<br>    )<br><br># Gráfico de barras para Top-P Sampling<br>sns.barplot(<br>    x=np.arange(num_tokens),<br>    y=top_p_probs.numpy(),<br>    ax=axes[1],<br>    hue=np.arange(num_tokens),<br>    legend=False,<br>    palette=colors_topp,<br>)<br>axes[1].set_title(f&quot;Top-P Sampling (p={p})&quot;)<br>axes[1].set_xlabel(&quot;Índice do Token&quot;)<br>axes[1].set_ylabel(&quot;Probabilidade&quot;)<br>axes[1].set_xticks(np.arange(num_tokens))<br>axes[1].set_ylim(<br>    0, max(np.max(probs.numpy()), np.max(top_p_probs.numpy())) * 1.1<br>)<br><br>plt.tight_layout()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pHvMZ6L5AEOx5iZS9GEynQ.png" /></figure><p>No gráfico vemos que os tokens com maior probabilidade são selecionados até atingir a probabilidade cumulativa definida por p (no gráfico é 85%). Ou seja, se somarmos as probabilidades da barras azuis do gráfico da esquerda teremos um valor próximo de 85%.</p><h3>Ajustando nossa função</h3><p>A beleza dessas técnicas reside em sua capacidade de serem combinadas para obter resultados ainda melhores. Por exemplo, é comum usar Temperature junto com Top-k Sampling ou Top-P Sampling para ter um controle mais fino sobre a aleatoriedade, mantendo a coerência do texto.</p><p>Ao ajustar cuidadosamente os parâmetros de Temperature, Top-k e Top-P, podemos guiar nossos modelos de linguagem para gerar textos que sejam, ao mesmo tempo, criativos, coerentes e relevantes para a tarefa.</p><p>Vamos adicionar esses 3 parâmetros em nosso modelo</p><pre>class GPTModel(nn.Module):<br>    <br>    # ... Código identico .... <br>    <br>    # Função para gerar texto<br>    def generate(self, input, max=200, temperature=1.0, top_k=0, top_p=1.0):<br>        for _ in tqdm(range(max), desc=&quot;Gerando Tokens...&quot;):<br>            input = input[<br>                :, -self.context_length :<br>            ]  # Garantindo que o seja no máximo do tamanho do contexto.<br>            logits = self(input)<br>            logits = logits[:, -1, :]<br>            <br>            # Aplicando temperature<br>            logits = logits / temperature<br>            <br>            # Aplicando top_k se especificado<br>            if top_k &gt; 0:<br>                top_k_values, top_k_indices = torch.topk(logits, min(top_k, logits.size(-1)))<br>                logits = torch.full_like(logits, float(&#39;-inf&#39;))<br>                logits.scatter_(1, top_k_indices, top_k_values)<br>            <br>            # Aplicando top_p (nucleus sampling) se menor que 1.0<br>            if top_p &lt; 1.0:<br>                sorted_logits, sorted_indices = torch.sort(logits, descending=True)<br>                cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)<br>                <br>                # Remove tokens com probabilidade cumulativa acima do threshold<br>                sorted_indices_to_remove = cumulative_probs &gt; top_p<br>                # Shift para manter pelo menos um token<br>                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()<br>                sorted_indices_to_remove[..., 0] = 0<br>                <br>                indices_to_remove = sorted_indices[sorted_indices_to_remove]<br>                logits[..., indices_to_remove] = float(&#39;-inf&#39;)<br>            <br>            # Convertendo para probabilidades e amostrando<br>            prob = F.softmax(logits, dim=-1)<br>            next_token = torch.multinomial(prob, num_samples=1)<br>            input = torch.cat([input, next_token], dim=-1)<br>        return input</pre><p>A função acima foi modificada para incorporar as técnicas que estudamos anteriormente. Embora o código pareça complexo, sua essência realiza exatamente o que vimos:</p><ul><li><strong>Temperature</strong> divide os logits pelo valor do parâmetro Temperature</li><li><strong>Top K </strong>seleciona os K maiores logits e define o restante como -inf, fazendo com que a Softmax resulte em zero para esses valores (seguindo o mesmo princípio usado para zerar a probabilidade dos tokens futuros no mecanismo de atenção)</li><li><strong>Top P</strong> converte os logits em probabilidades usando Softmax, seleciona os maiores tokens até que sua soma atinja o valor p, e atribui -inf aos logits restantes</li></ul><p>Após essas modificações nos logits, aplicamos a softmax para gerar a distribuição de probabilidade e selecionamos o próximo token usando a função multinomial</p><pre>model = GPTModel(<br>    d_vocab=tk.vocab_size(),<br>    d_emb=768,<br>    context_length=1024,<br>    n_layers=12,<br>    n_heads=12,<br>    dropout=0.1,<br>    qkv_bias=False,<br>)<br><br>@torch.no_grad()<br>def generate_sample(model, input_text, max_token=200, temperature=1, top_k=0, top_p=1):<br>    input_tokens = torch.tensor(tk.encode(input_text), dtype=torch.long)<br>    input_tokens = input_tokens.unsqueeze(0)<br><br>    output = model.generate(input_tokens, max_token, temperature, top_k, top_p)<br>    output_text = tk.decode(output.squeeze().tolist())<br><br>    return output_text<br><br><br>texto_gerado = generate_sample(model, &quot;Olá Mundo, tudo bem?&quot;, 15, 0.7, 50, 0.9)<br>print(texto_gerado)<br><br>#OUTPUT<br># Gerando Tokens...: 100%|██████████| 15/15 [00:00&lt;00:00, 23.47it/s]<br># Olá Mundo, tudo bem? benefícios risco un depoisgaG Enquantoânndemia telaga quí pe então depois</pre><p>Podemos testar nossa nova função. Obviamente o resultado ainda é totalmente sem sentido mas isso mudará a partir do próximo artigo!</p><h3>Conclusão</h3><p>Neste artigo, finalizamos a montagem do nosso GPT — um <strong>LLM criado do zero</strong>! Ao longo desta série, exploramos em profundidade sua arquitetura e funcionamento, implementamos todos os componentes essenciais (desde a camada de embeddings até o decoder transformer completo) e concluímos com técnicas de geração de texto.</p><p>Descobrimos que mesmo um modelo relativamente “pequeno” como o nosso, com cerca de 89M de parâmetros, apresenta uma complexidade considerável em sua arquitetura e requisitos computacionais.</p><p>No próximo artigo, abordaremos o momento mais aguardado: o pré-treinamento do nosso modelo, que o transformará de um simples gerador de tokens aleatórios em um <strong>verdadeiro modelo de linguagem em grande escala</strong></p><p>Você pode acessar e acompanhar os artigos e códigos diretamente no meu github: <a href="https://github.com/z-fab/llm-zero/tree/master">https://github.com/z-fab/llm-zero/tree/master</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7467f9cbdccf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM do Zero: Bloco Transformer]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-do-zero-bloco-transformer-72b895feb846?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/72b895feb846</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Fri, 21 Feb 2025 22:26:30 GMT</pubDate>
            <atom:updated>2025-02-21T22:26:30.050Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sc_gIVotz_steedKbHxhJg.png" /></figure><h4>Explorando o Bloco Transformer: Normalização, Ativação GeLU, FeedForward e Shortcut Connections</h4><p>Os <strong>Transformers</strong> revolucionaram o processamento de linguagem natural. No coração dessa revolução está o <strong>Bloco Transformer</strong>, o módulo central das arquiteturas de LLMs, como a que estamos construindo.</p><p>Em nosso artigo anterior, exploramos o famoso <strong>mecanismo de atenção</strong>, um componente central do bloco Transformer. No entanto, este mecanismo sozinho não é suficiente para alcançar os resultados que observamos nos LLMs — precisamos incorporar outros componentes estruturais que, embora mais simples, são cruciais para o funcionamento do modelo.</p><p>Vamos examinar quatro elementos fundamentais que, junto com o Multi-Head Attention, compõem o Bloco Transformer:</p><ol><li><strong>Camadas de Normalização (Layer Normalization)</strong> — estabilizam o treinamento e aumentam a eficiência da rede.</li><li><strong>Ativação GeLU (Gaussian Error Linear Unit)</strong> — Função de ativação usada na FeedForward Network que oferece uma transição mais suave que o ReLU (função comumente usada em redes neurais), melhorando assim a capacidade de aprendizado do modelo.</li><li><strong>Camadas FeedForward</strong> — redes neurais dentro de cada bloco Transformer que processam as representações de forma não-linear.</li><li><strong>Shortcut Connections (Residual Connections)</strong> — permitem o fluxo direto de informação, prevenindo o problema do Vanishing Gradient.</li></ol><p>Não podemos esquecer que este é o quinto artigo de uma série de oito. Para uma compreensão completa do conteúdo que abordaremos aqui, recomendo a leitura dos artigos anteriores da série:</p><ol><li><a href="https://blog.zfab.me/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa">Introdução</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-tokeniza%C3%A7%C3%A3o-um-mal-necess%C3%A1rio-dfaab5dc9488">Tokenização</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-criando-significado-com-embeddings-3ede12925b79">Embedding</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-aten%C3%A7%C3%A3o-%C3%A9-tudo-o-que-precisamos-ee42e3c42faf">Mecanismo de Atenção</a></li><li><strong>Bloco Transformer</strong><em> </em>(Você está aqui!)</li><li><em>Criando um GPT</em></li><li><em>Treinando um Foundational Model</em></li><li><em>Especializando</em></li></ol><h3>O Papel do Bloco Transformer</h3><p>Antes de mergulharmos nos detalhes técnicos de cada camada, é essencial entender <strong>onde</strong> esses componentes se encaixam no fluxo de um bloco Transformer.</p><p>Um Bloco Transformer é composto por duas seções principais: <strong>Mecanismo de Atenção (Multi-Head Attention)</strong> e <strong>Camada FeedForward</strong>. Cada uma dessas partes é precedida por <strong>Layer Normalization</strong> e seguida por <strong>Shortcut Connections</strong>. O modelo também utiliza camadas de Dropout (como as que vimos no Mecanismo de Atenção) para prevenir overfitting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h654AdOQcSf75LklA6Up2w.png" /></figure><p>Essa estrutura modular é replicada múltiplas vezes na arquitetura de um Transformer. O <strong>GPT-2</strong> <strong>Small</strong> (com 117M de parâmetros) utiliza 12 blocos de atenção, enquanto o <strong>GPT-2 XL</strong> (com 1.5B de parâmetros) emprega 48 blocos. O processo funciona como uma sequência de blocos idênticos: os tensores entram em um bloco, são processados e seguem para o próximo, que mantém a mesma estrutura..</p><p>Agora que temos uma visão geral, vamos explorar os componentes desse bloco</p><h3>1. Camadas de Normalização (Layer Normalization)</h3><p>Redes neurais profundas enfrentam dois grandes desafios durante o treinamento: <strong>Gradientes Explosivos</strong> (Exploding Gradient) — quando os pesos são atualizados de forma exponencial, desestabilizando o treinamento, e <strong>Gradientes Desaparecendo</strong> (Vanishing Gradient) — quando os gradientes se tornam tão pequenos que as camadas iniciais da rede praticamente param de aprender.</p><p>Para evitar principalmente o problema do Vanishing Gradient, os Transformers utilizam <strong>Layer Normalization (LayerNorm)</strong>, que normaliza as ativações para que tenham média 0 e variância 1, também conhecida como variância unitária, garantindo que os valores de ativação fiquem em uma escala previsível.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/824/1*0Q5BmHK8N__1Mq5_9CqzSw.png" /></figure><p>Na equação do LayerNorm mostrada, temos:</p><ul><li><strong>x</strong>: é o valor de entrada a ser normalizado</li><li><strong>μ</strong> (mu): é a média do vetor de entrada</li><li><strong>σ²</strong> (sigma²): é a variância do vetor</li><li><strong>ε</strong> (epsilon): é um pequeno valor para evitar divisão por zero</li></ul><p>Além disso, LayerNorm possui dois parâmetros treináveis:</p><ul><li><strong>γ</strong> (gamma): é um parâmetro treinável que ajusta a escala da normalização</li><li><strong>β</strong> (beta): é um parâmetro treinável que adiciona um deslocamento para preservar a expressividade</li></ul><p>Esses parâmetros treináveis permitem que a rede ajuste a distribuição dos dados durante o treinamento. O gamma (γ) controla a amplitude da normalização, enquanto o beta (β) permite deslocar os valores normalizados para qualquer média desejada. Isso dá à rede a flexibilidade de aprender a representação mais adequada para cada camada.</p><p>Vamos fazer um exemplo, ignorando os parâmetros treináveis por enquanto. Considere 3 tensores de tamanho 6 (que podemos interpretar como 3 tokens com um embedding de dimensão 6). Vamos processar esses tensores através de uma camada linear simples, que retornará os mesmos 3 tensores, porém agora com dimensão 4.</p><pre>torch.manual_seed(42)<br><br>inp = torch.randn(3, 6)<br>layer = nn.Linear(6, 4)<br>out = layer(inp)<br><br>print(f&quot;Entrada:\n{inp}&quot;)<br>print(f&quot;Saida:\n{out}&quot;)<br><br>#OUTPUT<br># Entrada:<br># tensor([[ 1.9269,  1.4873, -0.4974,  0.4396, -0.7581,  1.0783],<br>#         [ 0.8008,  1.6806,  0.3559, -0.6866,  0.6105,  1.3347],<br>#         [-0.2316,  0.0418, -0.2516,  0.8599, -0.3097, -0.3957]])<br># Saida:<br># tensor([[ 0.3800, -0.5400,  0.5123, -0.4735],<br>#         [ 0.2889, -0.6716,  0.1246,  0.0287],<br>#         [ 0.6655, -0.0524, -0.1044, -0.1135]], grad_fn=&lt;AddmmBackward0&gt;)</pre><p>Em seguida, se tirarmos a média e a variância desses 3 tensores percebemos que os valores não seguem média zero e variância um.</p><pre>mean_out = out.mean(dim=-1, keepdim=True)<br>var_out = out.var(dim=-1, keepdim=True, unbiased=False)<br><br>print(f&quot;Média:\\n{mean_out}&quot;)<br>print(f&quot;Variância:\\n{var_out}&quot;)<br>#OUTPUT<br># Média:<br># tensor([[-0.0303],<br>#         [-0.0574],<br>#         [ 0.0988]], grad_fn=&lt;MeanBackward1&gt;)<br># Variância:<br># tensor([[0.2297],<br>#         [0.1344],<br>#         [0.1076]], grad_fn=&lt;VarBackward0&gt;)</pre><p>É nesse momento que aplicamos a fórmula do LayerNorm para normalizar esses valores. O processo consiste em subtrair a média dos valores e dividir o resultado pela raiz quadrada da variância (também conhecida como desvio padrão)</p><pre>out_norm = (out - mean_out) / torch.sqrt(var_out)<br>mean_norm = out_norm.mean(dim=-1, keepdim=True)<br>var_norm = out_norm.var(dim=-1, keepdim=True, unbiased=False)<br><br>torch.set_printoptions(sci_mode=False) # Desabilita a notação científica<br><br>print(f&quot;Saida normalizada:\\n{out_norm}&quot;)<br>print(f&quot;Média:\\n{mean_norm}&quot;)<br>print(f&quot;Variância:\\n{var_norm}&quot;)<br><br>#OUTPUT<br>#Saida normalizada:<br>#tensor([[ 0.8560, -1.0633,  1.1320, -0.9247],<br>#        [ 0.9444, -1.6753,  0.4963,  0.2346],<br>#        [ 1.7277, -0.4610, -0.6194, -0.6473]], grad_fn=&lt;DivBackward0&gt;)<br>#Média:<br>#tensor([[    -0.0000],<br>#        [     0.0000],<br>#        [     0.0000]], grad_fn=&lt;MeanBackward1&gt;)<br>#Variância:<br>#tensor([[1.0000],<br>#        [1.0000],<br>#        [1.0000]], grad_fn=&lt;VarBackward0&gt;)</pre><p>Agora temos nossos tensores com valores normalizados (média zero e variância unitária). Na fórmula, podemos observar a presença do ε (epsilon) no denominador da divisão.</p><p>Este epsilon é um valor minúsculo adicionado para evitar um problema matemático: a divisão por zero que ocorreria caso a variância fosse zero. Para prevenir essa situação, incluímos esse valor infinitesimal no denominador da fórmula.</p><p>Vamos agora criar uma classe de <strong>LayerNorm</strong> usando a fórmula que vimos acima e adicionando os dois parâmetros treináveis</p><pre>class LayerNorm(nn.Module):<br>    def __init__(self, embedding_size):<br>        super().__init__()<br>        self.eps = 1e-6  # Epsilon para evitar divisão por zero<br>        self.scale = nn.Parameter(torch.ones(embedding_size)) # Gamma - Inicializando com 1 para não alterar a escala<br>        self.shift = nn.Parameter(torch.zeros(embedding_size)) # Beta - Inicializando com 0 para não alterar o deslocamento<br><br>    def forward(self, x):<br>        mean = x.mean(dim=-1, keepdim=True)<br>        var = x.var(dim=-1, keepdim=True, unbiased=False)<br>        norm_x = (x - mean) / torch.sqrt(var + self.eps)<br>        return self.scale * norm_x + self.shift # Gamma * x_norm + Beta</pre><p>Criamos uma camada que implementa exatamente a fórmula vista anteriormente: ela normaliza os tensores de entrada (subtraindo a média e dividindo pela soma do epsilon com a raiz quadrada da variância), multiplica por Gamma e soma com Beta — parâmetros que a camada aprenderá durante o treinamento.</p><p>Inicializamos Gamma e Beta com 1 e 0, respectivamente, para que inicialmente não alterem o resultado, mantendo a média zero e a variância unitária. Durante o treinamento, a rede aprenderá e ajustará esses valores para otimizar a distribuição dos dados de acordo com os resultados esperados.</p><p>Vamos passar pela nossa camada de normalização o mesmo tensor que obtivemos anteriormente (3 tensores de tamanho 4)</p><pre>ln = LayerNorm(embedding_size=4)<br><br>out_ln = ln(out)<br>mean_ln = out_ln.mean(dim=-1, keepdim=True)<br>var_ln = out_ln.var(dim=-1, unbiased=False, keepdim=True)<br><br>print(f&quot;Saida normalizada:\\n{out_ln}&quot;)<br>print(f&quot;Média:\\n{mean_ln}&quot;)<br>print(f&quot;Variância:\\n{var_ln}&quot;)<br><br>#OUTPUT<br># Saida normalizada:<br># tensor([[ 0.8560, -1.0633,  1.1320, -0.9247],<br>#         [ 0.9444, -1.6753,  0.4963,  0.2346],<br>#         [ 1.7277, -0.4610, -0.6194, -0.6473]], grad_fn=&lt;AddBackward0&gt;)<br># Média:<br># tensor([[    -0.0000],<br>#         [     0.0000],<br>#         [     0.0000]], grad_fn=&lt;MeanBackward1&gt;)<br># Variância:<br># tensor([[1.0000],<br>#         [1.0000],<br>#         [1.0000]], grad_fn=&lt;VarBackward0&gt;)</pre><p>Como podemos observar, o resultado foi exatamente o esperado: média zero e variância unitária, exatamente igual nossa conta anterior.</p><p>Já temos mais um componente para a construção do nosso bloco Transformer. Vamos falar um pouco agora função de ativação GeLU, que usaremos em nossa camada FeedFoward</p><h3>2. Ativação GeLU: Uma Alternativa ao ReLU</h3><p>A função de ativação <strong>ReLU (Rectified Linear Unit)</strong> é amplamente utilizada em redes neurais devido à sua simplicidade e eficiência computacional. Ela funciona zerando todos os valores negativos e mantendo os valores positivos inalterados, criando uma relação linear para x &gt; 0.</p><p>Embora seja eficiente e útil, a ReLU possui duas limitações principais que podem afetar significativamente o desempenho do modelo:</p><ol><li><strong>Morte de Neurônios</strong> — quando valores negativos são completamente descartados (zerados), alguns neurônios podem entrar em um estado onde sempre produzem saída zero, independentemente da entrada. Este fenômeno é conhecido como “dying ReLU”. Uma vez neste estado, o neurônio deixa de contribuir para a rede e não recebe atualizações significativas de gradiente, efetivamente “morrendo”.</li><li><strong>Descontinuidades no Gradiente</strong> — a mudança abrupta na função ReLU em x = 0 cria uma descontinuidade no gradiente. Enquanto para x &gt; 0 o gradiente é 1, para x &lt; 0 o gradiente é 0, sem uma transição suave entre estes estados. Esta característica pode causar saltos bruscos durante o treinamento, potencialmente levando a instabilidades na otimização e dificultando a convergência do modelo para um mínimo ótimo.</li></ol><p>Para solucionar esses problemas foi criado a função de ativação <strong>GeLU</strong> (Gaussian Error Linear Unit) que <strong>suaviza a transição entre valores positivos e negativos</strong>. Em vez de simplesmente zerar os valores negativos como a ReLU, a GeLU aplica uma transformação probabilística baseada na distribuição normal.</p><p>Esta função pode ser implementada de várias maneiras; a versão exata é definida como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*CF8YQN_Bp-LHH73eaZK2gg.png" /></figure><p>onde <strong>erf</strong> é a função erro de Gauss</p><p>Na prática, no entanto, é comum implementar uma aproximação computacionalmente mais eficiente. A fórmula é aproximada substituindo a função de erro de Gauss pela <strong>tanh</strong> e <strong>um termo cúbico extra</strong> para um ajuste mais preciso, como mostrado abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*_fxhXrXeHbHYbnpvlo_UFQ.png" /></figure><p>Vamos implementar essa função para utilizarmos posteriormente em nossa FNN (Feed Foward Network)</p><pre>class GeLU(nn.Module):<br>    def __init__(self):<br>        super().__init__()<br><br>    def forward(self, x):<br>        return (<br>            0.5<br>            * x<br>            * (<br>                1<br>                + torch.tanh(<br>                    torch.sqrt(torch.tensor(2.0 / torch.pi))<br>                    * (x + 0.044715 * torch.pow(x, 3))<br>                )<br>            )<br>        )<br></pre><p>Como vimos, implementamos a fórmula matemática descrita anteriormente. Para entender melhor a diferença entre as funções de ativação ReLU e GeLU, vamos compará-las visualmente e através de um exemplo</p><pre>print(f&quot;Valor de ReLU(-1): {nn.ReLU()(torch.tensor(-1.0))}&quot;)<br>print(f&quot;Valor de ReLU(1): {nn.ReLU()(torch.tensor(1.0))}&quot;)<br>print(f&quot;Valor de GeLU(-1): {GELU()(torch.tensor(-1.0))}&quot;)<br>print(f&quot;Valor de GeLU(1): {GELU()(torch.tensor(1.0))}&quot;)<br><br>#OUTPUT<br># Valor de ReLU(-1): 0.0<br># Valor de ReLU(1): 1.0<br># Valor de GeLU(-1): -0.15880802273750305<br># Valor de GeLU(1): 0.8411920070648193</pre><p>Podemos observar que, diferentemente da ReLU que zera imediatamente qualquer valor negativo, a GeLU apresenta um comportamento mais gradual na transição para zero com valores negativos.</p><p>Podemos ver no gráfico abaixo essa transição mais gradual</p><pre>gelu, relu = GeLU(), nn.ReLU()<br><br>x = torch.linspace(-3, 3, 100)<br>y_gelu, y_relu = gelu(x), relu(x)<br>plt.figure(figsize=(8, 3))<br>for i, (y, label) in enumerate(zip([y_gelu, y_relu], [&quot;GELU&quot;, &quot;ReLU&quot;]), 1):<br>    plt.subplot(1, 2, i)<br>    plt.plot(x, y)<br>    plt.title(f&quot;{label} activation function&quot;)<br>    plt.xlabel(&quot;x&quot;)<br>    plt.ylabel(f&quot;{label}(x)&quot;)<br>    plt.grid(True)<br>plt.tight_layout()<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*HJT0h4ZZlFFuBsqbgMTmXw.png" /></figure><p>Com a função de ativação criada podemos usa-la na nossa FFN</p><h3>3. Camada FeedForward</h3><p>Se o mecanismo de atenção é responsável por capturar relações entre tokens e encontrar dependências no texto, as <strong>camadas FeedForward</strong> têm o papel de processar e refinar essas informações.</p><p>A FeedForward Network (FFN) dentro do Bloco Transformer é uma <strong>MLP (Multi-Layer Perceptron)</strong> simples, aplicada a cada embedding. A estrutura típica da FeedForward é composta por três etapas:</p><ol><li><strong>Expansão dimensional</strong>: a entrada é projetada para um espaço maior (tipicamente 4 vezes o tamanho original).</li><li><strong>Aplicação da ativação não-linear</strong>: geralmente <strong>GeLU</strong>.</li><li><strong>Redução dimensional</strong>: o vetor é projetado de volta ao tamanho original.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CqRqyALV5V5jH0jrHz74uA.png" /></figure><p>A <strong>expansão da dimensionalidade</strong> permite que a rede capture <strong>relações mais ricas</strong> e represente padrões mais complexos. Mesmo que a entrada e a saída tenham o mesmo tamanho, esse aumento temporário de dimensionalidade cria um <strong>espaço de representação mais expressivo</strong>, permitindo que o modelo aprenda transformações mais sofisticadas.</p><p>Esse conceito é semelhante ao que acontece em redes convolucionais, onde camadas intermediárias frequentemente expandem as dimensões antes de reduzi-las para capturar características mais complexas.</p><p>A implementação da camada FeedForward é bem simples e direta:</p><pre>class FeedForward(nn.Module):<br>    def __init__(self, emb_dim):<br>        super().__init__()<br>        self.layers = nn.Sequential(<br>            nn.Linear(emb_dim, emb_dim * 4),<br>            GeLU(),<br>            nn.Linear(emb_dim * 4, emb_dim),<br>        )<br><br>def forward(self, x):<br>        return self.layers(x)</pre><p>Os tensores de entrada (embeddings já enriquecidos com informações da camada de atenção) são expandidos para uma dimensão 4 vezes maior, processados pela função de ativação GeLU e então reduzidos de volta à dimensão original</p><p>Vamos aplicar nossa rede em um exemplo, simulando 3 tokens com embedding de dimensão 5</p><pre>ffn = FeedForward(5)<br>x = torch.rand(1, 3, 5)<br>out = ffn(x)<br><br>print(f&quot;Entrada:\\n{x.shape}:\\n{x}&quot;)<br>print(f&quot;Saida:\\n{out.shape}:\\n{out}&quot;)<br><br>#OUTPUT<br># Entrada:<br># torch.Size([1, 3, 5]):<br># tensor([[[0.8126, 0.8039, 0.8412, 0.3161, 0.8035],<br>#          [0.5878, 0.1089, 0.9980, 0.0460, 0.3832],<br>#          [0.4469, 0.3190, 0.6802, 0.9577, 0.2851]]])<br># Saida:<br># torch.Size([1, 3, 5]):<br># tensor([[[ 0.0742,  0.1719,  0.3859,  0.1599, -0.0456],<br>#          [ 0.0004,  0.1286,  0.3183,  0.1642,  0.0730],<br>#          [ 0.0759,  0.2067,  0.2459,  0.1798,  0.0152]]],<br>#        grad_fn=&lt;ViewBackward0&gt;)</pre><p>Podemos ver que após passar pela FFN nossos tokens mantêm o mesmo tamanho, mas os valores foram modificados, pois a rede agora tem uma nova oportunidade de encontrar relações úteis nos valores para o resultado final.</p><p>Agora falta apenas um detalhe para podermos construir nosso bloco Transformer: vamos falar sobre atalhos!</p><h3>4. Shortcut Connections: Mantendo o Fluxo do Gradiente</h3><p>Modelos de deep learning frequentemente enfrentam um problema que mencionamos antes: o <strong>vanishing gradients</strong>. À medida que o gradiente do erro se propaga de volta pela rede, ele vai diminuindo, o que prejudica o aprendizado das camadas iniciais.</p><p>Para mitigar esse problema, utilizamos <strong>shortcut connections</strong> (também chamadas de <strong>residual connections</strong>). Elas foram introduzidas originalmente na arquitetura <strong>ResNet</strong> e rapidamente adotadas em diversas outras redes por sua eficiência.</p><p>A ideia central das shortcut connections é simples: ao invés de apenas processar a entrada com uma transformação não-linear, adicionamos um <strong>atalho</strong> somando a entrada original à saída da transformação.</p><p>Essa técnica garante que, se a transformação f(x) for ineficaz em algum momento do treinamento, o gradiente <strong>ainda poderá fluir diretamente pela conexão residual</strong>, evitando que desapareça.</p><p>Pense nesses atalhos como empurrões que mantêm o gradiente fluindo — periodicamente, damos um impulso ao sinal, evitando que ele se dissipe.</p><p>Para demonstrar o impacto dos atalhos, vamos criar uma rede neural fictícia com múltiplas camadas lineares, adicionando atalhos a cada 10 camadas.</p><pre>class ExampleDeepNeuralNetwork(nn.Module):<br>    def __init__(self, n_layers, use_shortcut):<br>        super().__init__()<br>        self.use_shortcut = use_shortcut<br>        <br>        self.layers = nn.ModuleList()<br><br>        for i in range(n_layers-1):<br>            self.layers.append(<br>                nn.Sequential(<br>                    nn.Linear(3, 3),<br>                    GeLU()<br>                )<br>            )<br><br>        self.layers.append(nn.Linear(3, 1))<br><br>    def forward(self, x):<br>        shortcut = x  # Initial shortcut connection<br>        for i, layer in enumerate(self.layers):<br>            layer_output = layer(x)<br>            <br>            if self.use_shortcut and i &gt; 0 and (i % 10 == 0) and x.shape == layer_output.shape:<br>                x = layer_output + shortcut<br>                shortcut = x  # Update shortcut for next block<br>            else:<br>                x = layer_output<br>                <br>        return x</pre><p>Agora vamos criar duas redes com 50 camadas, uma adicionaremos o Shortcut e na outra não</p><pre>layer_sizes = 50<br>sample_input = torch.randn(1, 3)<br>torch.manual_seed(123)<br>model_without_shortcut = ExampleDeepNeuralNetwork(layer_sizes, use_shortcut=False)<br>torch.manual_seed(123)<br>model_with_shortcut = ExampleDeepNeuralNetwork(layer_sizes, use_shortcut=True)</pre><p>Agora vamos criar uma função que avalia o fluxo do gradiente através das camadas da rede. A função recebe um modelo e um tensor x como entrada, e retorna a média dos gradientes para cada camada de peso na rede.</p><p>Não precisamos nos aprofundar nos detalhes desta função agora. Ela existe apenas para visualizarmos o efeito dos Shortcuts nos gradientes da rede. Lembre-se: quanto menor o gradiente, mais difícil é para a rede aprender, pois começamos a lidar com valores muito pequenos que podem chegar a zero.</p><pre>def mean_gradients(model, x):<br>    output = model(x)<br>    target = torch.tensor([[0.0]])<br><br>    loss = nn.MSELoss()<br>    loss = loss(output, target)<br><br>    loss.backward()<br><br>    grad_values = []<br><br>    for name, param in model.named_parameters():<br>        if &quot;weight&quot; in name:<br>            mean_grad = param.grad.abs().mean().item()<br>            grad_values.append(mean_grad)<br><br>    return grad_values<br><br>grads_without = mean_gradients(model_without_shortcut, sample_input)<br>grads_with = mean_gradients(model_with_shortcut, sample_input)</pre><p>Vamos visualizar como os gradientes se distribuem ao longo das 50 camadas após calcularmos o erro e sua propagação</p><pre>fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))<br><br>x = list(range(len(grads_without)))<br><br># Plot without shortcut<br>ax1.bar(x, grads_without, color=&quot;lightcoral&quot;)<br>ax1.set_yscale(&#39;log&#39;)<br>ax1.set_ylabel(&#39;Gradient Mean (log scale)&#39;)<br>ax1.set_xlabel(&#39;Layer&#39;)<br>ax1.set_title(&#39;Without Shortcut&#39;)<br><br># Plot with shortcut<br>ax2.bar(x, grads_with, color=&quot;lightblue&quot;)<br>ax2.set_yscale(&#39;log&#39;)<br>ax2.set_ylabel(&#39;Gradient Mean (log scale)&#39;)<br>ax2.set_xlabel(&#39;Layer&#39;)<br>ax2.set_title(&#39;With Shortcut&#39;)<br><br># Add vertical lines and &quot;Shortcut&quot; text for shortcut connections in ax2<br>for i in range(10, len(x), 10):<br>    ax2.axvline(x=i+0.65, color=&#39;green&#39;, linestyle=&#39;--&#39;, alpha=0.5)<br>    ax2.text(i+1.5, ax2.get_ylim()[1] - 0.4, &#39;Shortcut&#39;, rotation=90, verticalalignment=&#39;top&#39;, color=&#39;green&#39;)<br><br># Para cada subplot<br>for ax in [ax1, ax2]:<br>    ax.set_xticks([0, len(grads_without) - 1])<br>    ax.set_xticklabels([&quot;Input&quot;, &quot;Output&quot;])<br><br>plt.tight_layout()<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gfnM1a9XLlquWPFbDIPppA.png" /></figure><p>O gráfico mostra a média absoluta dos gradientes em cada camada, e devemos analisá-lo da direita para a esquerda, acompanhando o fluxo do Backpropagation.</p><p>O Backpropagation é o processo pelo qual a rede neural ajusta seus pesos durante o treinamento. O gradiente indica quanto cada peso contribuiu para o erro, e usamos essa informação para ajustar os pesos — quanto menor o gradiente, menor será o ajuste. Quando o gradiente se torna muito pequeno, a rede deixa de atualizar os pesos e, consequentemente, para de aprender.</p><p>Em redes com muitas camadas, existe uma tendência natural de diminuição dos gradientes, pois os valores pequenos tornam-se ainda menores conforme retrocedem pela rede.</p><p>Na rede com shortcuts, embora essa tendência de diminuição persista, cada atalho oferece um impulso que eleva o gradiente, impedindo sua redução excessiva e mantendo a capacidade de aprendizado da rede.</p><p>No nosso bloco transformers teremos dois atalhos, um que conectará a entrada da camada de atenção com sua saída (após aplicar dropout), e outro que conectará a entrada da camada FeedForward com sua saída (após aplicação novamente do dropout).</p><p>Com isso, temos todas as peças para montarmos nosso Bloco Transformer</p><h3>Finalmente, o Bloco!</h3><p>Agora podemos consolidar todos esses elementos em um <strong>Bloco Transformer</strong> completo. O bloco portante será composto por</p><ol><li><strong>LayerNorm</strong> antes da Multi-Head Attention</li><li><strong>Atenção Multi-Head</strong>.</li><li><strong>Dropout</strong> antes do Shortcut</li><li><strong>Shortcut Connection</strong> (somando a entrada original).</li><li><strong>LayerNorm</strong> antes da FeedForward.</li><li><strong>Camada FeedForward</strong>.</li><li><strong>Dropout</strong> antes do Shortcut</li><li><strong>Shortcut Connection</strong>.</li></ol><pre>class TransformerBlock(nn.Module):<br>    def __init__(self, d_emb, n_heads, context_length, dropout=0.1, qkv_bias=False):<br>        super().__init__()<br>        self.mha = MultiHeadAttention(<br>            d_in=d_emb,<br>            d_out=d_emb,<br>            context_length=context_length,<br>            n_heads=n_heads,<br>            dropout=dropout,<br>            qkv_bias=qkv_bias,<br>        )<br>        self.ff = FeedForward(d_emb)<br>        self.norm1 = LayerNorm(d_emb)<br>        self.norm2 = LayerNorm(d_emb)<br>        self.drop_shortcut = nn.Dropout(dropout)<br><br>    def forward(self, x):<br>        shortcut = x<br>        x = self.norm1(x) #1<br>        x = self.mha(x) #2<br>        x = self.drop_shortcut(x) #3<br>        x = x + shortcut #4<br><br>        shortcut = x<br>        x = self.norm2(x) #5<br>        x = self.ff(x) #6<br>        x = self.drop_shortcut(x) #7<br>        x = x + shortcut #8<br>        return x</pre><p>Como podemos ver, o bloco transformer é simples de criar quando já temos todas as peças criadas. Vamos testar</p><pre>torch.manual_seed(42)<br>x = torch.rand(2, 4, 768)<br>block = TransformerBlock(<br>    d_emb=768, n_heads=12, context_length=4, dropout=0.1, qkv_bias=False<br>)<br>output = block(x)<br><br>print(f&quot;Entrada:\n{x.shape}:\n{x}&quot;)<br>print(f&quot;Saida:\n{output.shape}:\n{output}&quot;)<br><br>#OUTPUT<br># Entrada:<br># torch.Size([2, 4, 768]):<br># tensor([[[0.2961, 0.5166, 0.2517,  ..., 0.9541, 0.8567, 0.4604],<br>#          [0.2238, 0.3047, 0.3019,  ..., 0.5465, 0.4532, 0.7598],<br>#          [0.6945, 0.2478, 0.4111,  ..., 0.8838, 0.4898, 0.5963],<br>#          [0.0890, 0.7804, 0.9223,  ..., 0.4507, 0.6357, 0.5833]],<br># <br>#         [[0.5716, 0.9297, 0.3396,  ..., 0.0477, 0.4564, 0.2797],<br>#          [0.0936, 0.2211, 0.3806,  ..., 0.3948, 0.4545, 0.4536],<br>#          [0.6788, 0.1741, 0.2084,  ..., 0.5557, 0.5930, 0.0959],<br>#          [0.3894, 0.4083, 0.0662,  ..., 0.9861, 0.9341, 0.1319]]])<br># Saida:<br># torch.Size([2, 4, 768]):<br># tensor([[[-0.0056,  0.0972, -0.1122,  ...,  1.2890,  0.2623,  0.6685],<br>#          [ 0.0023, -0.2369,  0.1720,  ...,  0.5952,  0.2497,  0.7447],<br>#          [ 0.4672,  0.4472,  0.1791,  ...,  1.2526,  0.3045,  0.7750],<br>#          [ 0.0662,  0.7224,  0.9206,  ...,  0.4790,  0.7428,  0.7016]],<br># <br>#         [[ 0.3622,  1.2144,  0.5221,  ...,  0.1854,  0.0111, -0.5035],<br>#          [-0.0225,  0.7789,  0.2770,  ...,  0.1734,  0.5419,  0.1143],<br>#          [ 0.7425,  0.4013,  0.3211,  ...,  0.3268,  0.7523, -0.1642],<br>#          [ 0.5745,  0.6241,  0.4410,  ...,  1.1963,  1.2650,  0.2243]]],<br>#        grad_fn=&lt;AddBackward0&gt;)</pre><p>Criamos tensores de entrada que simulam o tipo e formato de dados que nosso bloco encontrará na prática: 2 batches (2 frases) contendo 4 tokens cada, com embedding de 768 dimensões.</p><p>Após o processamento pelo bloco transformer, a saída mantém a mesma estrutura dimensional. Em outras palavras, nossas frases de 4 tokens preservam seu formato original, mas agora contêm representações enriquecidas pelo processamento do bloco transformer.</p><p>Nos modelos GPT, esse bloco é empilhado diversas vezes. Cada um desses blocos irá capturar representações mais profundas e refinadas dos tokens, permitindo que o modelo aprenda a prever a próxima palavra de maneira mais eficiente.</p><h3>Conclusão</h3><p>Neste artigo, concluímos a montagem do Bloco Transformer, explorando seus componentes fundamentais e suas contribuições para o funcionamento do modelo. A <strong>normalização</strong> de camadas provou ser essencial para a estabilidade do treinamento, enquanto a ativação <strong>GeLU</strong> trouxe avanços significativos sobre a tradicional ReLU. A rede <strong>Feed Forward</strong> demonstrou seu papel vital na transformação dos embeddings, identificando relações que o mecanismo de atenção ocasionalmente não detecta.</p><p>As <strong>conexões de atalho</strong> (shortcuts) mostraram-se cruciais para preservar a eficiência do gradiente através das camadas, potencializando o aprendizado do modelo. Esses componentes funcionam em sinergia, formando um bloco de processamento robusto que captura sutilezas nas relações entre palavras e produz representações contextuais sofisticadas.</p><p>Com o Bloco Transformer dominado, estamos preparados para a próxima etapa: no próximo artigo, vamos integrar todas as peças para construir nosso <strong>modelo GPT </strong>e prepará-lo para a fase de pré-treino!</p><p>Você pode acessar e acompanhar os artigos e códigos diretamente no meu github: <a href="https://github.com/z-fab/llm-zero/tree/master">https://github.com/z-fab/llm-zero/tree/master</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72b895feb846" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM do Zero: Atenção é tudo o que precisamos]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-do-zero-aten%C3%A7%C3%A3o-%C3%A9-tudo-o-que-precisamos-ee42e3c42faf?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee42e3c42faf</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Fri, 24 Jan 2025 22:30:10 GMT</pubDate>
            <atom:updated>2025-01-24T22:30:10.013Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MR9grYvyBZ52nelg8Dhj-w.png" /></figure><h4>Entendendo o mecanismo de Atenção: explorando aquilo que revolucionou os Modelos de Linguagem</h4><p>Imagine estar em uma sala cheia de pessoas conversando simultaneamente. Naturalmente, seu cérebro consegue focar na voz da pessoa com quem você está falando, dando mais atenção a ela do que às outras conversas ao redor. É exatamente assim que o mecanismo de atenção funciona em modelos de linguagem — ele permite que o modelo foque em diferentes partes do texto com diferentes níveis de importância, criando uma compreensão mais profunda e contextualizada das relações entre as palavras.</p><p>Vale lembrar que este é o quarto de uma série de oito artigos. Se ainda não conferiu os anteriores, recomendo que veja antes de prosseguir:</p><ol><li><a href="https://blog.zfab.me/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa">Introdução</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-tokeniza%C3%A7%C3%A3o-um-mal-necess%C3%A1rio-dfaab5dc9488">Tokenização</a></li><li><a href="https://blog.zfab.me/construindo-um-llm-do-zero-criando-significado-com-embeddings-3ede12925b79">Embedding</a></li><li><strong>Mecanismo de Atenção </strong>(Você está aqui!)</li><li><em>Arquitetura Transformer</em></li><li><em>Criando um GPT</em></li><li><em>Treinando um Foundational Model</em></li><li><em>Especializando</em></li></ol><h3>Introdução</h3><p>O mecanismo de atenção foi desenvolvido para resolver uma limitação crucial das redes recorrentes (RNNs): o esquecimento gradual das informações inseridas no modelo. Para entender melhor esse problema, vamos analisar um caso clássico de uso dessa solução: a tradução.</p><p>Imagine que queremos desenvolver um modelo que recebe uma frase em português e a traduz para o inglês. Para isso, é comum separarmos a rede em dois módulos: o <strong>encoder</strong> e o <strong>decoder</strong>. O encoder recebe o texto completo de entrada de forma sequencial e o codifica, passo a passo, em algo que chamamos de <strong>estado oculto</strong>. Em seguida, o decoder recebe o último estado oculto criado e começa a gerar o texto traduzido.</p><p>Podemos entender esse estado oculto como um vetor de embedding que contém todo o conteúdo e significado da frase codificados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IRDR_9Vo5T1TXVa2nKCoZQ.png" /></figure><p>Como o decoder tem acesso apenas ao último estado oculto criado, o conteúdo e significado das palavras iniciais tendem a perder relevância no vetor do estado oculto à medida que a sequência codificada se torna mais longa.</p><p>Para tentar contornar esse problema, em 2014 foi introduzido nas RNNs o mecanismo de atenção de Bahdanau, em homenagem ao seu criador. Este mecanismo permitiu que o decoder tivesse acesso a todos os estados ocultos gerados pelo encoder, não apenas ao último, atribuindo diferentes pesos de importância para cada estado durante a geração da tradução. Assim, o modelo podia “prestar atenção” em diferentes partes da sequência de entrada conforme necessário.</p><p>Apesar de solucionar parcialmente o problema do esquecimento nas RNNs, o mecanismo de atenção de Bahdanau ainda apresentava limitações significativas, principalmente em termos de escalabilidade e processamento paralelo.</p><p>Três anos depois, em 2017, pesquisadores demonstraram que a arquitetura RNN era desnecessária e que o Mecanismo de Atenção, por si só, era suficiente para solucionar o problema da tradução — daí o título “<a href="https://arxiv.org/pdf/1706.03762">Attention is all you need</a>” e a introdução dos Transformers.</p><h3>Mecanismo de Auto Atenção</h3><p>Ao ler um texto, quando você vê uma palavra, seu cérebro automaticamente a conecta com outras palavras importantes na frase. O mecanismo de Auto Atenção faz exatamente isso nos Transformers.</p><p>Diferente do sistema de atenção original (criado por Bahdanau), que apenas comparava duas frases distintas, a Auto Atenção analisa como cada palavra se relaciona com todas as outras palavras <strong>do mesmo texto</strong>.</p><p>Por exemplo, quando o modelo lê uma palavra, ele atribui “notas” (chamadas de pesos de atenção) para indicar a importância das outras palavras na compreensão daquela palavra específica. É como quando você lê “o cachorro pegou sua bola” — você naturalmente associa “sua” com “cachorro” para entender quem é o dono da bola.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/793/1*PplexIikFLTF_in9SKIL_g.png" /></figure><p>Para entender melhor, vamos codificar um mecanismo de atenção simples. Usaremos a frase “Atenção é tudo o que precisamos”, considerando cada palavra como um token representado por um embedding de 3 dimensões.</p><p>O mecanismo de auto atenção recebe o embedding como entrada e devolve um vetor de contexto. Esse vetor pode ser considerado um embedding enriquecido, que contém não apenas as informações semânticas e posicionais do token, mas também suas relações com todos os outros tokens.</p><p>Vamos criar esse embedding enriquecido começando pelo token “tudo”.</p><pre>phrase = &quot;Atenção é tudo o que precisamos&quot;<br>tokens = phrase.split()<br># Simulando um embedding de palavras<br>embeds = {<br>    &quot;Atenção&quot;: torch.tensor([0.83, 0.71, 0.6]),<br>    &quot;é&quot;: torch.tensor([0.15, 0.31, 0.12]),<br>    &quot;tudo&quot;: torch.tensor([0.91, 0.81, 0.69]),<br>    &quot;o&quot;: torch.tensor([0.11, 0.23, 0.12]),<br>    &quot;que&quot;: torch.tensor([0.35, 0.41, 0.3]),<br>    &quot;precisamos&quot;: torch.tensor([0.79, 0.92, 0.61])<br>}<br>query = embeds[&quot;tudo&quot;]<br>print(&quot;Embedding do token &#39;tudo&#39;:&quot;, query)<br>print(&quot;Embedding da frase:&quot;, [embeds[token] for token in tokens])<br><br>#OUTPUT<br># Embedding do token &#39;tudo&#39;: tensor([0.9100, 0.8100, 0.6900])<br># Embedding da frase: [<br>#  tensor([0.8300, 0.7100, 0.6000]), -- Embed de &quot;Atenção&quot;<br>#  tensor([0.1500, 0.3100, 0.1200]), -- Embed de &quot;é&quot;<br>#  tensor([0.9100, 0.8100, 0.6900]), -- Embed de &quot;tudo&quot;<br>#  tensor([0.1100, 0.2300, 0.1200]), -- Embed de &quot;o&quot; <br>#  tensor([0.3500, 0.4100, 0.3000]), -- Embed de &quot;que&quot; <br>#  tensor([0.7900, 0.9200, 0.6100])  -- Embed de &quot;precisamos&quot;<br># ]</pre><p>O primeiro passo é calcular um valor intermediário, chamado <strong><em>Attention Score</em></strong><em>, </em>para cada token da frase em relação ao nosso token “tudo” que estamos chamando de query. Para isso basta fazermos o produto escalar (torch.dot) entre query e todos os tokens</p><pre>attention_scores = torch.empty(len(tokens))<br>for i, token in enumerate(tokens):<br>    attention_scores[i] = torch.dot(query, embeds[token])<br><br>print(&quot;Scores de atenção:&quot;, attention_scores)<br><br>#OUTPUT<br># Scores de atenção: tensor([<br>#  1.7444, -- Attention Score entre &quot;tudo&quot; e &quot;Atenção&quot;<br>#  0.4704, -- Attention Score entre &quot;tudo&quot; e &quot;é&quot; <br>#  1.9603, -- Attention Score entre &quot;tudo&quot; e &quot;tudo&quot; <br>#  0.3692, -- Attention Score entre &quot;tudo&quot; e &quot;o&quot; <br>#  0.8576, -- Attention Score entre &quot;tudo&quot; e &quot;que&quot; <br>#  1.8850  -- Attention Score entre &quot;tudo&quot; e &quot;precisamos&quot;<br># ])</pre><p>Podemos ver que, por exemplo, o score de atenção entre “tudo” e “precisamos” é de 1.8850. Utilizamos o produto escalar entre dois vetores porque ele mensura a similaridade entre eles. Um valor grande indica alto alinhamento, ou seja, maior similaridade entre os vetores. Quanto menor o valor, menor a similaridade. É dessa forma que o mecanismo de atenção determina quanto deve &quot;prestar atenção&quot; em cada palavra.</p><p>Agora, com os <em>Scores de Atenção</em> calculados, precisamos normalizá-los usando a função Softmax. Esta normalização permite que a rede processe os valores de forma mais eficiente e facilita os cálculos de gradientes. O resultado são probabilidades cuja soma total é igual a 1 (100%). Após a normalização, estes scores passam a ser chamados de <strong><em>Attention Weights</em></strong> (não confundir com os pesos da rede que veremos adiante).</p><pre>attention_weights = torch.nn.functional.softmax(attention_scores, dim=0)<br>print(&quot;Pesos de atenção:&quot;, attention_weights)<br><br>#OUTPUT<br># Pesos de atenção: tensor([<br>#    0.2306, -- Peso entre &quot;tudo&quot; e &quot;Atenção&quot;<br>#    0.0645, -- Peso entre &quot;tudo&quot; e &quot;é&quot;<br>#    0.2862, -- Peso entre &quot;tudo&quot; e &quot;tudo&quot;<br>#    0.0583, -- Peso entre &quot;tudo&quot; e &quot;o&quot;<br>#    0.0950, -- Peso entre &quot;tudo&quot; e &quot;que&quot;<br>#    0.2654  -- Peso entre &quot;tudo&quot; e &quot;precisamos&quot;<br># ])<br># Soma dos pesos de atenção: tensor(1.)</pre><p>Com os pesos de atenção calculados estamos prontos para calcular o vetor de contexto, o nosso embedding do token “tudo” enriquecido. Para isso basta multiplicarmos os embeddings dos tokens aos respectivos pesos de atenção. Ao final somamos os vetores resultantes e obtemos o resultado final.</p><pre>context_vector = torch.empty(len(query))<br>for i, token in enumerate(tokens):<br>    context_vector += attention_weights[i] * embeds[token]<br><br>print(&quot;Vetor de contexto para o token &#39;tudo&#39;:&quot;, context_vector)<br>print(&quot;Embedding anterior do token &#39;tudo&#39;:&quot;, embeds[&quot;tudo&quot;])<br><br>#OUTPUT<br># Vetor de contexto para o token &#39;tudo&#39;: tensor([0.7108, 0.7121, 0.5410])<br># Embedding anterior do token &#39;tudo&#39;: tensor([0.9100, 0.8100, 0.6900])</pre><p>Agora que temos o vetor contextual para o token ‘tudo’, precisamos aplicar o mesmo processo aos demais tokens. O código a seguir executa o mesmo procedimento, mas em vez de usar for loops, aproveitamos os cálculos matriciais para tornar o processo mais eficiente.</p><pre>attention_scores_all = inputs @ inputs.T<br>attention_weights_all = torch.nn.functional.softmax(attention_scores_all, dim=-1)<br>context_vector_all = attention_weights_all @ inputs<br><br>print(&quot;Scores de atenção entre todos os tokens:&quot;)<br>print(attention_scores_all)<br>print(&quot;\nPesos de atenção entre todos os tokens:&quot;)<br>print(attention_weights_all)<br>print(&quot;\nVetor de contexto para todos os tokens:&quot;)<br>print(context_vector_all)<br><br>#OUTPUT<br># Scores de atenção entre TODOS os tokens:<br># tensor([[1.5530, 0.4166, 1.7444, 0.3266, 0.7616, 1.6749],<br>#         [0.4166, 0.1330, 0.4704, 0.1022, 0.2156, 0.4769],<br>#         [1.7444, 0.4704, 1.9603, 0.3692, 0.8576, 1.8850],<br>#         [0.3266, 0.1022, 0.3692, 0.0794, 0.1688, 0.3717],<br>#         [0.7616, 0.2156, 0.8576, 0.1688, 0.3806, 0.8367],<br>#         [1.6749, 0.4769, 1.8850, 0.3717, 0.8367, 1.8426]])<br># <br># Pesos de atenção entre TODOS os tokens:<br># tensor([[0.2269, 0.0728, 0.2747, 0.0665, 0.1028, 0.2563],<br>#         [0.1845, 0.1390, 0.1947, 0.1348, 0.1509, 0.1960],<br>#         [0.2306, 0.0645, 0.2862, 0.0583, 0.0950, 0.2654],<br>#         [0.1810, 0.1446, 0.1889, 0.1414, 0.1546, 0.1894],<br>#         [0.2002, 0.1160, 0.2204, 0.1107, 0.1368, 0.2159],<br>#         [0.2261, 0.0682, 0.2790, 0.0614, 0.0978, 0.2674]])<br># <br># Vetor de contexto para TODOS os tokens:<br># tensor([[0.6949, 0.6994, 0.5295],<br>#         [0.5738, 0.6051, 0.4428],<br>#         [0.7108, 0.7121, 0.5410],<br>#         [0.5632, 0.5966, 0.4352],<br>#         [0.6148, 0.6368, 0.4721],<br>#         [0.7040, 0.7079, 0.5362]])</pre><p>Se observarmos o terceiro vetor contextual, percebemos que os valores são os mesmos que calculamos anteriormente, demonstrando que através dos cálculos matriciais conseguimos os mesmos resultados, porém de forma mais eficiente.</p><h3>Treinamento da Autoatenção</h3><p>A estrutura que vimos anteriormente funciona porém ainda é muito simples e não é capaz de melhorar durante o treinamento (já que não temos nenhum parâmetro ajustável). Para gerar melhores vetores contextuais, precisamos modificar levemente a estrutura do mecanismo de atenção. A estrutura que implementaremos, introduzida no paper original dos Transformers, é conhecida como <em>scaled dot-product attention</em>.</p><p>A principal diferença é que introduziremos matrizes de pesos que serão ajustados durante o treinamento e servirão para <strong>projetar os embeddings de entrada em um novo espaço amostral</strong>. Assim, o modelo aprenderá os melhores ajustes para capturar as nuances do contexto de entrada e gerar vetores contextuais mais precisos.</p><p>Em vez de usar diretamente os embeddings originais dos tokens, como fizemos antes, vamos criar três novas representações a partir de cada embedding de entrada. Essas novas representações são chamadas de <strong>query</strong>, <strong>key</strong> e <strong>value</strong>. Para criar cada uma delas, multiplicamos o embedding original por diferentes matrizes de pesos (<em>w_query</em>, <em>w_key</em> e <em>w_value</em>) que o modelo aprenderá durante o treinamento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/1*D684oE5NsIu_vrvawCTK4g.png" /><figcaption>Esquema do mecanismo de Atenção Causal. Fonte: <a href="https://arxiv.org/pdf/1706.03762">https://arxiv.org/pdf/1706.03762</a></figcaption></figure><p>Antes de implementar o mecanismo de atenção completo vamos novamente calcular a atenção para o token “tudo” da frase “Atenção é tudo o que precisamos” como exemplo.</p><pre>x2 = inputs[tokens.index(&quot;tudo&quot;)]   # Recuperando o embedding do token &quot;tudo&quot; (Shape: [1,3])<br>d_in = x2.size(0)                   # Dimensão do embedding (Shape: 3)<br>d_out = d_in                        # Dimensão da projeção (Shape: 3)<br><br>torch.manual_seed(42)<br>W_query = torch.nn.Linear(d_in, d_out, bias=False)<br>W_key = torch.nn.Linear(d_in, d_out, bias=False)<br>W_value = torch.nn.Linear(d_in, d_out, bias=False)</pre><p>Vale ressaltar que d_out é a dimensão do espaço vetorial para onde projetaremos nossos “embeddings”. Neste exemplo, mantivemos a mesma dimensão do embedding original (3), o que costuma ser o comum em modelos como GPT.</p><p>Para criar as matrizes de pesos, usamos uma camada Linear do PyTorch sem bias (termo de viés). Sem o bias, essa camada atua como uma matriz de pesos que multiplica os vetores de entrada para gerar novos vetores. A vantagem de usar uma camada linear é que o PyTorch oferece uma inicialização otimizada dos pesos e acelera os cálculos de backpropagation.</p><p>Com as camadas de peso criadas, podemos gerar nossos “embeddings” <strong>query</strong> (apenas do token ‘tudo’), <strong>key</strong> e <strong>values</strong> (de todos os tokens)</p><pre>query_x2 = W_query(x2)         # &quot;Embedding Query&quot; do token &#39;tudo&#39; (Shape: [1,3])<br>keys = W_key(inputs)           # &quot;Embeddings Key&quot; de TODOS tokens  (Shape: [6,3])<br>values = W_value(inputs)       # &quot;Embeddings Value&quot; de TODOS tokens (Shape: [6,3])<br><br>print(&quot;\nEmbedding Query do token &#39;tudo&#39;:&quot;)<br>print(query_x2)<br>print(&quot;\nEmbeddings Key de todos os tokens:&quot;)<br>print(keys)<br>print(&quot;\nEmbeddings Value de todos os tokens:&quot;)<br>print(values)<br><br>#OUTPUT<br># Embedding Query do token &#39;tudo&#39;: <br># tensor([0.6965, 0.4606, 0.3700], grad_fn=&lt;SqueezeBackward4&gt;)<br>#<br># Embeddings Key de todos os tokens:<br># tensor([[0.0696, 0.5766, 0.2995],<br>#         [0.1050, 0.1216, 0.1360],<br>#         [0.0956, 0.6436, 0.3452],<br>#         [0.0818, 0.0983, 0.1036],<br>#         [0.0899, 0.2649, 0.1795],<br>#         [0.1930, 0.5787, 0.3971]], grad_fn=&lt;MmBackward0&gt;)<br>#<br># Embeddings Value de todos os tokens:<br># tensor([[-0.2788,  0.0071, -0.6651],<br>#         [-0.0267, -0.0369, -0.1704],<br>#         [-0.3096,  0.0127, -0.7428],<br>#         [-0.0277, -0.0154, -0.1309],<br>#         [-0.1138, -0.0049, -0.3175],<br>#         [-0.2398, -0.0356, -0.7044]], grad_fn=&lt;MmBackward0&gt;)</pre><p>Agora que temos nossos “embeddings”, podemos calcular os <em>Scores de Atenção</em>. Para obter os <em>Attention Scores</em>, multiplicamos nossa query pela matriz keys (que contém os “embeddings” de todos os tokens). O resultado será um vetor de 6 dimensões (correspondente ao número de tokens da nossa frase), onde cada dimensão representa um score de atenção.</p><pre>attention_scores = query_x2 @ keys.T # Calculando os scores de atenção (Shape: [1,6])<br><br>print(&quot;\nScores de atenção entre o token &#39;tudo&#39; e TODOS os tokens:&quot;)<br>print(attention_scores)<br><br>#OUTPUT<br># Scores de atenção entre o token &#39;tudo&#39; e TODOS os tokens:<br># tensor([0.4249, 0.1795, 0.4907, 0.1406, 0.2511, 0.5479], grad_fn=&lt;SqueezeBackward4&gt;)</pre><p>Finalmente podemos calcular os pesos de atenção. Dessa vez, antes de passarmos os <em>Scores de Atenção</em> pela função softmax vamos normaliza-los dividindo todos pela raiz quadrada do tamanho do embedding <strong>key.</strong></p><p>Quando os <em>Scores de Atenção</em> são muito elevados, a função softmax pode gerar <strong>gradientes extremamente pequenos</strong>durante o backpropagation. Isso faz com que ela funcione quase como uma função binária, atribuindo aproximadamente 1 para um valor e 0 para todos os outros, o que prejudica o treinamento. Para evitar esse problema, normalizamos os valores pela raiz quadrada da dimensão do embedding, mantendo-os em uma escala mais adequada e permitindo um treinamento mais estável e eficiente.</p><pre>attention_weights = torch.nn.functional.softmax(<br>    attention_scores / keys.size(-1)**0.5,<br>    dim=-1<br>)<br><br>print(&quot;\nPesos de atenção entre o token &#39;tudo&#39; e TODOS os tokens:&quot;)<br>print(attention_weights)<br>print(&quot;Soma dos pesos de atenção:&quot;, attention_weights.sum().item())<br><br>#OUTPUT<br># Pesos de atenção entre o token &#39;tudo&#39; e TODOS os tokens:<br># tensor([0.1744, 0.1514, 0.1812, 0.1480, 0.1578, 0.1873], grad_fn=&lt;SoftmaxBackward0&gt;)<br># Soma dos pesos de atenção: 1.0</pre><p>Por fim, calculamos o vetor contextual para o token ‘tudo’. Para isso, multiplicamos os pesos de atenção pelo embedding values, que é o único componente que ainda não havíamos utilizado</p><pre>context_vector = attention_weights @ values<br><br>print(&quot;\nVetor de contexto para o token &#39;tudo&#39;:&quot;, context_vector)<br>print(&quot;Embedding anterior do token &#39;tudo&#39;:&quot;, embeds[&quot;tudo&quot;])<br><br>#OUTPUT<br># Vetor de contexto para o token &#39;tudo&#39;: tensor([-0.1757, -0.0118, -0.4777], grad_fn=&lt;SqueezeBackward4&gt;)<br># Embedding anterior do token &#39;tudo&#39;: tensor([0.9100, 0.8100, 0.6900])</pre><p>Pronto, utilizando esse processo de cálculo, conseguimos obter embeddings contextualizados e permitir que a rede aprenda, durante o treinamento, através das matrizes de peso w, como criar relações entre tokens e “prestar atenção”. Ao final, todo esse processo pode ser resumida na equação que vemos no <a href="https://arxiv.org/pdf/1706.03762">paper</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/427/0*xHG7pSdnOjtyY5HI.png" /></figure><p>Com todo esse conhecimento, podemos agora criar uma classe que executa esses cálculos de forma eficiente para qualquer entrada que recebermos</p><pre>class SelfAttention(torch.nn.Module):<br><br>  def __init__(self, d_in, d_out, qkv_bias=False):<br>        super().__init__()<br>        self.W_query = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br>        self.W_key = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br>        self.W_value = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br><br>    def forward(self, x):<br>        query = self.W_query(x)<br>        keys = self.W_key(x)<br>        values = self.W_value(x)<br>        attention_scores = query @ keys.T<br>        attention_weights = torch.softmax(<br>            attention_scores / keys.size(-1)**0.5,<br>            dim=-1<br>        )<br>        context_vector = attention_weights @ values<br>        return context_vector</pre><p>Com a classe criada, podemos passar nosso input (os embeddings dos tokens da nossa frase) e receber esses embeddings agora enriquecidos — não apenas com a informação semântica e posicional, mas também contextualizados em relação à frase como um todo.</p><pre>torch.manual_seed(42)<br>sa = SelfAttention(d_in, d_out, qkv_bias=False)<br>context_vector = sa(inputs)<br><br>print(&quot;\nVetor de contexto para o token &#39;tudo&#39;:&quot;)<br>print(context_vector)<br><br>#OUTPUT<br># Vetor de contexto para o token &#39;tudo&#39;:<br># tensor([[-0.1747, -0.0118, -0.4754],<br>#        [-0.1678, -0.0121, -0.4594],<br>#        [-0.1757, -0.0118, -0.4777],<br>#        [-0.1675, -0.0121, -0.4586],<br>#        [-0.1701, -0.0120, -0.4645],<br>#        [-0.1747, -0.0119, -0.4754]], grad_fn=&lt;MmBackward0&gt;)</pre><p>Podemos ver que o terceiro embedding, correspondente ao token ‘tudo’, apresenta o mesmo valor que tínhamos obtido no cálculo passo a passo anterior (-0.1757, -0.0118, -0.4777).</p><p>Nosso módulo de atenção está funcionando bem, mas possui uma limitação importante: nosso LLM deveria se basear exclusivamente nos tokens anteriores ao fazer previsões — nunca nos tokens futuros. Se permitíssemos isso, cometeríamos um erro semelhante ao data leakage, usando informações do alvo para prever o próprio alvo.</p><p>Para contornar esse problema, implementaremos a atenção causal</p><h3>Atenção Causal</h3><p>A atenção causal, também conhecida como atenção mascarada (<em>masked attention</em>), é um tipo específico do mecanismo de atenção que limita o fluxo de informação. Durante o cálculo dos <em>Scores de Atenção</em>, ela permite que o modelo considere apenas os tokens anteriores e o atual, bloqueando completamente o acesso aos tokens futuros. Essa restrição previne o problema de leakage mencionado anteriormente.</p><p>Para implementar a atenção causal, utilizamos uma matriz triangular inferior e atribuímos o valor negativo infinito (-inf) aos Scores de Atenção acima da diagonal principal. Quando aplicamos a função softmax para normalização, esses valores -inf são efetivamente zerados na distribuição de probabilidade, garantindo que cada token só possa “prestar atenção” aos tokens anteriores e a si mesmo, mantendo a soma dos pesos de atenção igual a 1 para cada posição.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*_kHes16tMRbrqEWpFxxqBQ.png" /></figure><p>Vamos gerar uma matriz de Scores de Atenção para exemplificar a implementação</p><pre>queries = sa.W_query(inputs)<br>keys = sa.W_key(inputs)<br><br>attention_scores = queries @ keys.T<br><br>mask = torch.triu(torch.ones(inputs.size(0), inputs.size(0)), diagonal=1)<br>masked_attention_scores = attention_scores.masked_fill(mask.bool(), float(&#39;-inf&#39;))<br><br>print(&quot;\nScores de atenção entre todos os tokens:&quot;)<br>print(attention_scores)<br>print(&quot;\nScores de atenção mascarado:&quot;)<br>print(masked_attention_scores)<br><br>#OUTPUT<br># Scores de atenção entre todos os tokens:<br># tensor([[0.3796, 0.1593, 0.4383, 0.1249, 0.2237, 0.4882],<br>#        [0.0823, 0.0443, 0.0968, 0.0344, 0.0545, 0.1190],<br>#        [0.4249, 0.1795, 0.4907, 0.1406, 0.2511, 0.5479],<br>#        [0.0672, 0.0349, 0.0788, 0.0271, 0.0437, 0.0955],<br>#        [0.1768, 0.0794, 0.2050, 0.0620, 0.1073, 0.2343],<br>#        [0.3846, 0.1741, 0.4463, 0.1361, 0.2344, 0.5117]],<br>#       grad_fn=&lt;MmBackward0&gt;)<br>#<br># Scores de atenção mascarado:<br># tensor([[0.3796,   -inf,   -inf,   -inf,   -inf,   -inf],<br>#        [0.0823, 0.0443,   -inf,   -inf,   -inf,   -inf],<br>#        [0.4249, 0.1795, 0.4907,   -inf,   -inf,   -inf],<br>#        [0.0672, 0.0349, 0.0788, 0.0271,   -inf,   -inf],<br>#        [0.1768, 0.0794, 0.2050, 0.0620, 0.1073,   -inf],<br>#        [0.3846, 0.1741, 0.4463, 0.1361, 0.2344, 0.5117]],<br>#       grad_fn=&lt;MaskedFillBackward0&gt;)</pre><p>Agora podemos normalizar os Scores de Atenção, normalizando e aplicando a softmax igual fizemos anteriormente</p><pre>attention_weights = torch.nn.functional.softmax(<br>    masked_attention_scores / keys.size(-1)**0.5,<br>    dim=-1<br>)<br><br>print(&quot;\nPesos de atenção entre todos os tokens:&quot;)<br>print(attention_weights)<br>print(&quot;Soma dos pesos de atenção:&quot;, attention_weights.sum(dim=-1))<br><br>#OUTPUT<br># Pesos de atenção entre todos os tokens:<br># tensor([[1.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],<br>#        [0.5055, 0.4945, 0.0000, 0.0000, 0.0000, 0.0000],<br>#        [0.3440, 0.2986, 0.3574, 0.0000, 0.0000, 0.0000],<br>#        [0.2522, 0.2475, 0.2539, 0.2464, 0.0000, 0.0000],<br>#        [0.2058, 0.1946, 0.2092, 0.1926, 0.1977, 0.0000],<br>#        [0.1730, 0.1532, 0.1792, 0.1499, 0.1586, 0.1861]],<br>#       grad_fn=&lt;SoftmaxBackward0&gt;)<br># Soma dos pesos de atenção: tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000], grad_fn=&lt;SumBackward1&gt;)</pre><p>Dessa forma, podemos observar que o modelo considera a atenção apenas para o token atual e os anteriores, nunca para os tokens futuros.</p><p>Agora vamos introduzir um novo componente muito comum em várias arquiteturas de rede e está presente também nos transformers, dentro dos mecanismos de atenção: a camada de Dropout</p><h3>Evitando overffiting: adicionando Dropout</h3><p>O Dropout é uma técnica de regularização que desativa aleatoriamente um conjunto de neurônios durante cada etapa do treinamento. Durante o treinamento, cada neurônio tem uma probabilidade de ser temporariamente removido da rede, forçando o modelo a aprender padrões mais robustos e distribuídos.</p><p>Essa abordagem <strong>previne o overfitting ao evitar que o modelo se torne excessivamente dependente de neurônios específicos</strong>. É importante ressaltar que o Dropout é ativado apenas durante o treinamento — durante a inferência, todos os neurônios são mantidos ativos para maximizar a capacidade preditiva do modelo.</p><p>Nos modelos como o GPT, o dropout pode ser aplicado em dois pontos estratégicos do mecanismo de atenção: após o cálculo dos pesos de atenção (attention dropout) ou após o cálculo dos vetores contextuais (projection dropout). Em nossa implementação, utilizaremos o attention dropout, por ser a abordagem mais comum nas arquiteturas.</p><pre>dropout = torch.nn.Dropout(0.5)     # Dropout com probabilidade de 50%<br>matriz = torch.ones(6,6)            # Matriz de 1&#39;s (Shape: [6,6])<br><br>print(&quot;Matriz original:&quot;)<br>print(matriz)<br>print(&quot;\nExemplo de dropout:&quot;)<br>print(dropout(matriz))<br><br>#OUTPUT<br># Matriz original:<br># tensor([[1., 1., 1., 1., 1., 1.],<br>#        [1., 1., 1., 1., 1., 1.],<br>#        [1., 1., 1., 1., 1., 1.],<br>#        [1., 1., 1., 1., 1., 1.],<br>#        [1., 1., 1., 1., 1., 1.],<br>#        [1., 1., 1., 1., 1., 1.]])<br>#<br># Exemplo de dropout:<br># tensor([[2., 0., 2., 2., 2., 0.],<br>#        [2., 2., 0., 2., 0., 0.],<br>#        [0., 2., 2., 0., 0., 0.],<br>#        [0., 2., 0., 2., 0., 2.],<br>#        [2., 0., 2., 2., 0., 2.],<br>#        [2., 0., 2., 2., 2., 2.]])</pre><p>No exemplo anterior, implementamos um dropout com taxa de 50%. Isso significa que, durante o treinamento, metade dos neurônios são aleatoriamente desativados (seus valores são zerados).</p><p>Para manter a magnitude dos sinais consistente na rede, os valores dos neurônios ativos são reescalados dividindo-os pelo dropout rate (que no nosso caso é 0,5). Esta compensação é necessária porque, com metade dos neurônios desativados, precisamos dobrar a intensidade dos sinais dos neurônios restantes para manter o mesmo nível de ativação total da camada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/793/1*X1OvP9_7W6h5w7wG3Z1E9Q.png" /></figure><p>Vamos aplicar o dropout na matriz dos pesos de atenção criada anteriormente</p><pre>torch.manual_seed(42)<br>attention_weights_with_dropout = dropout(attention_weights)<br><br>print(&quot;\nPesos de atenção sem dropout:&quot;)<br>print(attention_weights)<br>print(&quot;Pesos de atenção com dropout:&quot;)<br>print(attention_weights_with_dropout)<br><br>#OUTPUT<br># Pesos de atenção sem dropout:<br># tensor([[1.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],<br>#        [0.5055, 0.4945, 0.0000, 0.0000, 0.0000, 0.0000],<br>#        [0.3440, 0.2986, 0.3574, 0.0000, 0.0000, 0.0000],<br>#        [0.2522, 0.2475, 0.2539, 0.2464, 0.0000, 0.0000],<br>#        [0.2058, 0.1946, 0.2092, 0.1926, 0.1977, 0.0000],<br>#        [0.1730, 0.1532, 0.1792, 0.1499, 0.1586, 0.1861]],<br>#       grad_fn=&lt;SoftmaxBackward0&gt;)<br># Pesos de atenção com dropout:<br># tensor([[2.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],<br>#        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],<br>#        [0.0000, 0.0000, 0.7147, 0.0000, 0.0000, 0.0000],<br>#        [0.0000, 0.4951, 0.5077, 0.0000, 0.0000, 0.0000],<br>#        [0.4117, 0.3892, 0.0000, 0.3853, 0.3955, 0.0000],<br>#        [0.3459, 0.3064, 0.3585, 0.2997, 0.0000, 0.0000]],<br>#       grad_fn=&lt;MulBackward0&gt;)</pre><p>Agora que o conceito do dropout e da atenção causal foram explicados vamos modificar nossa classe de atenção para incorporar esses dois mecanismos.</p><pre>class CausalAttention(torch.nn.Module):<br><br>    def __init__(self, d_in, d_out, context_length, qkv_bias=False, dropout = 0.1):<br>        super().__init__()<br><br>        self.W_query = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br>        self.W_key = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br>        self.W_value = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br><br>        self.dropout = torch.nn.Dropout(dropout) #1<br><br>        self.register_buffer( #2<br>            &quot;mask&quot;,<br>            torch.triu(torch.ones(context_length, context_length), diagonal=1)<br>        )<br><br>    def forward(self, x):<br>        n_tokens, _ = x.size()<br><br>        query = self.W_query(x)<br>        keys = self.W_key(x)<br>        values = self.W_value(x)<br><br>        attention_scores = query @ keys.T<br>        attention_scores.masked_fill_(<br>            self.mask.bool()[:n_tokens, :n_tokens], -torch.inf #3<br>        )<br><br>        attention_weights = torch.softmax(<br>            attention_scores / keys.size(-1)**0.5,<br>            dim=-1<br>        )<br>        attention_weights = self.dropout(attention_weights) #4<br><br>        context_vector = attention_weights @ values<br>        return context_vector</pre><p>As únicas mudanças que fizemos foram adicionar uma nova camada de dropout <strong>(1)</strong>, que chamamos antes de calcular o vetor contextual, e adicionar a máscara com os valores infinitos negativos acima da diagonal principal <strong>(4)</strong>.</p><p>Para criar a máscara, usamos a função register_buffer <strong>(2)</strong>, que permite registrar um tensor como parte do estado do módulo sem que ele seja considerado um parâmetro treinável. Isso é útil para valores que precisam ser persistentes durante a execução do modelo mas não devem ser otimizados durante o treinamento, como é o caso da nossa máscara de atenção causal.</p><p>Além disso, ao aplicar a máscara à matriz de Scores de Atenção, garantimos o recorte da máscara para o tamanho equivalente ao número de tokens <strong>(3)</strong>, já que nem todas as entradas terão o mesmo tamanho. Isso é particularmente importante quando processamos sequências que podem ter diferentes comprimentos (podemos ter uma frase com 4 tokens e outra com 20), garantindo que a máscara seja aplicada corretamente, independentemente do tamanho da entrada.</p><pre>torch.manual_seed(42)<br>ca = CausalAttention(d_in, d_out, context_length=6, qkv_bias=False, dropout=0.2)<br><br>ca.eval() #1<br>context_vector = ca(inputs)<br><br>print(&quot;Vetor de contexto para TODOS tokens:&quot;)<br>print(context_vector)<br><br>#OUTPUT<br>#Vetor de contexto para TODOS tokens:<br>#tensor([[-0.2788,  0.0071, -0.6651],<br>#        [-0.1542, -0.0146, -0.4205],<br>#        [-0.2146, -0.0040, -0.5452],<br>#        [-0.1624, -0.0079, -0.4307],<br>#        [-0.1552, -0.0070, -0.4135],<br>#        [-0.1747, -0.0119, -0.4754]], grad_fn=&lt;MmBackward0&gt;)</pre><p>Para utilizar a classe, seguimos o mesmo procedimento anterior, com uma diferença importante: precisamos informar ao PyTorch que não estamos em modo de treinamento <strong>(1)</strong>, desativando assim o dropout. Sem essa configuração, o dropout continuará ativo e poderá gerar vetores contextuais zerados por conta da desativação aleatória dos neurônios.</p><p>Apesar da eficácia do nosso mecanismo de atenção atual, podemos fazer uma alteração para deixa-lo<strong> mais robusto em tarefas mais complexas</strong>. Imagine que ao invés de utilizarmos uma camada de atenção, podemos utilizar múltiplas, em paralelo, cada uma funcionando como um especialista dedicado a detectar padrões específicos nos dados de entrada.</p><p>Para ilustrar, imagine um grupo de especialistas analisando o texto. Enquanto um especialista foca nas relações entre palavras adjacentes, como artigos e substantivos outro observa conexões de média distância, como pronomes e seus referentes e um terceiro analisa o contexto global, identificando o tom e tema geral do texto.</p><p>Esta divisão de responsabilidades permite que o modelo <strong>capture desde detalhes gramaticais sutis até estruturas semânticas complexas</strong> que seriam imperceptíveis com uma única camada de atenção.</p><p>Os vetores contextuais gerados por cada “especialista” (cabeça) são combinados em um único vetor que incorpora todas essas informações, nosso vetor contextual. Essa estrutura é conhecida como <em>Multi-Head Attention</em> (Atenção Multi-Cabeça).</p><h3>De uma Cabeça para Muitas</h3><p>O termo “multi cabeça” (multi-head) refere-se à divisão do mecanismo de atenção em múltiplas cabeças, cada uma operando de forma independente. O que implementamos anteriormente pode ser considerado como uma single-head attention, já que temos apenas um único conjunto de pesos processando os inputs.</p><p>Para implementar nossa camada <em>Multi-head Attention</em>, poderíamos criar várias instâncias da nossa classe CausalAttention e combinar seus resultados. Porém, existe uma abordagem mais eficiente: criaremos as diversas cabeças redimensionando as matrizes <strong>query</strong>, <strong>key</strong> e <strong>value</strong> e, após calcular a atenção, combinaremos os resultados de cada cabeça em uma única matriz</p><p>Antes de implementar uma classe que faça o calculo do Multi-Head Attention, vamos realizar os cálculos novamente passo a passo. Primeiro vamos definir nosso input, que continua sendo a frase “Atenção é tudo o que precisamos” e para cada token, criamos um “embedding” aleatório de dimensão 8</p><pre>torch.manual_seed(42)<br>phrase = &quot;Atenção é tudo o que precisamos&quot;<br>tokens = phrase.split()<br><br># Simulando um embedding de palavras<br>embeds = {<br>    &quot;Atenção&quot;: torch.randn(8),<br>    &quot;é&quot;: torch.randn(8),<br>    &quot;tudo&quot;: torch.randn(8),<br>    &quot;o&quot;: torch.randn(8),<br>    &quot;que&quot;: torch.randn(8),<br>    &quot;precisamos&quot;: torch.randn(8),<br>}<br><br>inputs = torch.stack([embeds[token] for token in tokens])<br><br>d_in = inputs.size(-1)      # Dimensão do embedding<br>d_out = d_in                # Dimensão da projeção<br>n_heads = 2                 # Número de cabeças de atenção<br>d_head = d_out // n_heads   # Dimensão da projeção em cada cabeça<br><br>W_query = torch.nn.Linear(d_in, d_out, bias=False)<br>W_key = torch.nn.Linear(d_in, d_out, bias=False)<br>W_value = torch.nn.Linear(d_in, d_out, bias=False)<br><br>out_proj = torch.nn.Linear(d_out, d_out)<br>mask = torch.triu(torch.ones(len(tokens), len(tokens)), diagonal=1)</pre><p>Além das variáveis já conhecidas, como as matrizes de peso $w$ e a máscara triangular da atenção causal, temos n_heads, que define quantas cabeças de atenção teremos, e d_head, que determina a dimensão das matrizes <strong>query</strong>, <strong>key</strong> e <strong>value</strong> de cada cabeça - sendo esta dimensão o resultado da divisão das dimensões iniciais pelo número de cabeças.</p><p>Outra novidade é uma camada linear chamada out_proj que servirá para projetar o resultado das cabeças no nosso vetor contextual final. Pense nas múltiplas cabeças de atenção como vários especialistas e a camada linear como um &quot;moderador&quot;, combinando as opiniões desses especialistas para produzir uma única decisão ou representação final (vetor contextual).</p><p>Agora vamos gerar as matrizes <strong>query</strong>, key e value multiplicando nosso input pelos respectivos pesos <em>w</em></p><pre>queries = W_query(inputs)<br>keys = W_key(inputs)<br>values = W_value(inputs)<br><br>print(&quot;Shape Queries:&quot;, queries.shape)<br>print(&quot;Shape Keys:&quot;, keys.shape)<br>print(&quot;Shape Values:&quot;, values.shape)<br><br>#OUTPUT<br># Shape Queries: torch.Size([6, 8])<br># Shape Keys: torch.Size([6, 8])<br># Shape Values: torch.Size([6, 8])</pre><p>Podemos ver que as dimensões das nossas matrizes são 6 linhas, uma para cada token, e 8 valores em cada linha — os valores dos embeddings já ponderados pelos pesos w. Vamos agora dividir esses 8 valores entre as duas cabeças utilizando o comando view</p><pre>queries = queries.view(len(tokens), n_heads, d_head)<br>keys = keys.view(len(tokens), n_heads, d_head)<br>values = values.view(len(tokens), n_heads, d_head)<br><br>print(&quot;Shape Queries:&quot;, queries.shape)<br>print(&quot;Shape Keys:&quot;, keys.shape)<br>print(&quot;Shape Values:&quot;, values.shape)<br><br>#OUTPUT<br># Shape Queries: torch.Size([6, 2, 4])<br># Shape Keys: torch.Size([6, 2, 4])<br># Shape Values: torch.Size([6, 2, 4])</pre><p>Vemos que nossas matrizes <strong>query</strong>, <strong>key</strong> e <strong>value</strong> são compostas por 6 tokens, onde para cada um desses tokens temos 2 cabeças com 4 valores cada. Antes de calcular os <em>Scores de Atenção</em> e em seguida os Pesos de Atenção precisamos fazer a transposição dessas matrizes.</p><p>Precisamos reorganizar nossas matrizes de modo que os cálculos sejam feitos por cabeça e não por token. Isso é feito trocando a primeira dimensão (tokens) com a segunda dimensão (cabeças) através da operação de transposição. Dessa forma, poderemos processar as cabeças de atenção de forma independente e paralela.</p><pre># Transpondo as dimensões para que possamos multiplicar as matrizes corretamente (Shape esperado: [n_heads, n_tokens, d_head])<br>queries = queries.transpose(0, 1)<br>keys = keys.transpose(0, 1)<br>values = values.transpose(0, 1)<br><br>print(&quot;Shape Queries:&quot;, queries.shape)<br>print(&quot;Shape Keys:&quot;, keys.shape)<br>print(&quot;Shape Values:&quot;, values.shape)<br><br>#OUTPUT<br># Shape Queries: torch.Size([2, 6, 4])<br># Shape Keys: torch.Size([2, 6, 4])<br># Shape Values: torch.Size([2, 6, 4])</pre><p>Agora os valores estão organizados na ordem correta: primeiro as cabeças, depois os tokens e, por fim, os valores individuais. Com essa estrutura, podemos calcular os <em>Scores de Atenção</em> e aplicar a máscara causal.</p><pre>attention_scores = queries @ keys.transpose(-2, -1) # Fazendo a multiplicação das queries e keys transpondo as últimas duas dimensões<br>mask_bool = mask.bool()[:len(tokens), :len(tokens)]<br>attention_scores.masked_fill_(mask_bool, float(&#39;-inf&#39;))<br><br>print(&quot;Shape Attention Scores:&quot;, attention_scores.shape)<br>print(&quot;Attention Scores:&quot;)<br>print(attention_scores)<br><br>#OUTPUT<br># Shape Attention Scores: torch.Size([2, 6, 6])<br># <br># Attention Scores:<br># tensor([[[-0.7591,    -inf,    -inf,    -inf,    -inf,    -inf],<br>#          [ 0.8709, -0.8787,    -inf,    -inf,    -inf,    -inf],<br>#          [ 0.0184,  0.1349,  0.1138,    -inf,    -inf,    -inf],<br>#          [ 0.0916,  0.1808, -0.0922, -0.0583,    -inf,    -inf],<br>#          [-0.1927,  0.1316,  0.1359, -0.0222,  0.0728,    -inf],<br>#          [ 0.4217, -0.5818, -0.6180, -0.0103, -0.2964, -0.4543]],<br># <br>#         [[-0.0480,    -inf,    -inf,    -inf,    -inf,    -inf],<br>#          [ 0.0837,  0.7436,    -inf,    -inf,    -inf,    -inf],<br>#          [ 0.1602, -0.4546,  1.2174,    -inf,    -inf,    -inf],<br>#          [ 0.1047, -0.3286,  0.7837,  0.1288,    -inf,    -inf],<br>#          [ 0.0237, -0.2529,  0.7510, -0.0975,  0.2896,    -inf],<br>#          [-0.0731,  0.2625, -0.7685,  0.0042, -0.2592, -0.3273]]],<br>#        grad_fn=&lt;MaskedFillBackward0&gt;)</pre><p>Temos agora as nossas <strong>duas matrizes</strong> com os <em>Scores de Atenção</em>, uma para cada cabeça. Vamos achar os <em>Pesos de Atenção</em></p><pre>attention_weights = torch.nn.functional.softmax(<br>    attention_scores / keys.size(-1)**0.5,<br>    dim=-1<br>)<br><br>print(&quot;Shape Attention Weights:&quot;, attention_weights.shape)<br>print(&quot;\nAttention Weights:&quot;)<br>print(attention_weights)<br><br>#OUTPUT<br># Shape Attention Weights: torch.Size([2, 6, 6])<br># <br># Attention Weights:<br># tensor([[[1.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],<br>#          [0.7057, 0.2943, 0.0000, 0.0000, 0.0000, 0.0000],<br>#          [0.3217, 0.3410, 0.3374, 0.0000, 0.0000, 0.0000],<br>#          [0.2574, 0.2691, 0.2348, 0.2388, 0.0000, 0.0000],<br>#          [0.1790, 0.2106, 0.2110, 0.1950, 0.2045, 0.0000],<br>#          [0.2299, 0.1392, 0.1367, 0.1852, 0.1606, 0.1484]],<br># <br>#         [[1.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],<br>#          [0.4183, 0.5817, 0.0000, 0.0000, 0.0000, 0.0000],<br>#          [0.2914, 0.2143, 0.4943, 0.0000, 0.0000, 0.0000],<br>#          [0.2369, 0.1907, 0.3326, 0.2397, 0.0000, 0.0000],<br>#          [0.1854, 0.1615, 0.2668, 0.1745, 0.2118, 0.0000],<br>#          [0.1748, 0.2068, 0.1235, 0.1817, 0.1593, 0.1540]]],<br>#        grad_fn=&lt;SoftmaxBackward0&gt;)</pre><p>Chegamos na última etapa: calcular os <strong>vetores contextuais:</strong></p><pre>context_vector = attention_weights @ values<br>context_vector = context_vector.transpose(0, 1) # Transpondo de volta para o formato original (Shape esperado: [n_tokens, n_heads, d_head])<br>context_vector = context_vector.contiguous().view(len(tokens), d_out) # Remodelando para o formato original (Shape esperado: [n_tokens, d_out])<br>context_vector = out_proj(context_vector)<br><br>print(&quot;Shape Vetor de Contexto:&quot;, context_vector.shape)<br>print(&quot;Vetor de Contexto:&quot;)<br>print(context_vector)<br><br>#OUTPUT<br># Shape Vetor de Contexto: torch.Size([6, 8])<br># <br># Vetor de Contexto:<br># tensor([[ 0.0257,  0.3181, -0.0296,  0.2585, -0.1248,  0.0339, -0.1693,  0.2312],<br>#         [ 0.0084,  0.2291, -0.3647,  0.2155, -0.0515, -0.2924, -0.1800,  0.1574],<br>#         [ 0.1803,  0.2423, -0.3487,  0.1708,  0.2053, -0.0517, -0.1429,  0.3193],<br>#         [ 0.2501,  0.2304, -0.3660,  0.0852,  0.1882, -0.0400, -0.1757,  0.3423],<br>#         [ 0.2623,  0.1995, -0.3935,  0.0788,  0.2488, -0.0262, -0.2089,  0.4014],<br>#         [ 0.1728,  0.2577, -0.4239,  0.1221,  0.2583, -0.0639, -0.1834,  0.3750]],<br>#        grad_fn=&lt;AddmmBackward0&gt;)</pre><p>O cálculo dos vetores contextuais é feito com pequenas diferenças: após a multiplicação dos <strong>Pesos de Atenção</strong> com a matriz <strong>values</strong>, fazemos uma transposição, retornando a dimensão dos tokens para a primeira posição. Em seguida, concatenamos as cabeças usando a função view e, por fim, passamos o resultado pela nossa camada linear.</p><p>Agora temos nossos vetores contextuais resultantes do cálculo de múltiplas cabeças. Estamos prontos para implementar a classe que usaremos no nosso LLM</p><pre>class MultiHeadAttention(torch.nn.Module):<br><br>    def __init__(self, d_in, d_out, context_length, n_heads, qkv_bias=False, dropout = 0.1):<br>        super().__init__()<br><br>        assert d_out % n_heads == 0, &quot;d_out deve ser divisível por num_heads&quot;<br><br>        self.d_out = d_out<br>        self.n_heads = n_heads<br>        self.d_head = d_out // n_heads<br><br>        self.W_query = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br>        self.W_key = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br>        self.W_value = torch.nn.Linear(d_in, d_out, bias=qkv_bias)<br><br>        self.out_proj = torch.nn.Linear(d_out, d_out)<br>        self.dropout = torch.nn.Dropout(dropout)<br><br>        self.register_buffer(<br>            &quot;mask&quot;,<br>            torch.triu(torch.ones(context_length, context_length), diagonal=1)<br>        )<br><br>    def forward(self, x):<br>        n_batch, n_tokens, _ = x.size()<br><br>        queries = self.W_query(x)<br>        keys = self.W_key(x)<br>        values = self.W_value(x)<br><br>        queries = queries.view(n_batch, n_tokens, self.n_heads, self.d_head)<br>        keys = keys.view(n_batch, n_tokens, self.n_heads, self.d_head)<br>        values = values.view(n_batch, n_tokens, self.n_heads, self.d_head)<br><br>        queries = queries.transpose(1, 2)<br>        keys = keys.transpose(1, 2)<br>        values = values.transpose(1, 2)<br><br>        attention_scores = queries @ keys.transpose(-2, -1)<br>        attention_scores.masked_fill_(<br>            self.mask.bool()[:n_tokens, :n_tokens], -torch.inf<br>        )<br><br>        attention_weights = torch.softmax(<br>            attention_scores / keys.size(-1)**0.5,<br>            dim=-1<br>        )<br>        attention_weights = self.dropout(attention_weights)<br><br>        context_vector = (attention_weights @ values).transpose(1, 2)<br>        context_vector = context_vector.contiguous().view(n_batch, n_tokens, self.d_out)<br>        context_vector = self.out_proj(context_vector)<br><br>        return context_vector</pre><p>A classe MultiHeadAttention implementa exatamente o mesmo processo que fizemos anteriormente, com uma única diferença: quando formos treinar nosso LLM não enviaremos apenas uma sequência de texto e sim um conjunto de sequências (os famosos batchs). Essa técnica auxilia melhora a convergência do modelo e o tempo necessário para isso.</p><p>Por conta disso, já construímos a classe preparada para receber uma dimensão extra nos inputs: os batches. Em vez de receber apenas [n_tokens, d_out], receberemos [n_batch, n_tokens, d_out]</p><pre>torch.manual_seed(42)<br>mha = MultiHeadAttention(d_in, d_out, context_length=6, n_heads=2, qkv_bias=False, dropout=0.2)<br><br>mha.eval()<br>inputs_with_batch = inputs.unsqueeze(0) # Adicionando uma dimensão de batch<br>context_vector = mha(inputs_with_batch)<br><br>print(&quot;Vetor de contexto para TODOS tokens:&quot;)<br>print(context_vector.squeeze(0))<br><br>#OUTPUT<br># Vetor de contexto para TODOS tokens:<br># tensor([[ 0.4427, -0.2856,  0.6128,  0.1079,  0.6926,  0.0858,  0.3974, -0.0293],<br>#         [ 0.2974, -0.1247,  0.4476,  0.2000,  0.6202,  0.0128,  0.3492, -0.0699],<br>#         [ 0.2069, -0.1970,  0.1220,  0.1342,  0.2787, -0.1903,  0.2832, -0.2000],<br>#         [ 0.1517, -0.1998,  0.0960,  0.1153,  0.2119, -0.2781,  0.3234, -0.2299],<br>#         [ 0.1197, -0.1825,  0.0191,  0.1142,  0.1672, -0.3232,  0.3075, -0.2100],<br>#         [ 0.0767, -0.1438,  0.0484,  0.1368,  0.2004, -0.3595,  0.3050, -0.1914]],<br>#        grad_fn=&lt;SqueezeBackward1&gt;)</pre><p>Com esses vetores contextuais calculados, podemos considerar nosso <strong>módulo de atenção completo</strong>!</p><h3>Conclusão</h3><p>Neste artigo, exploramos detalhadamente o mecanismo de atenção — um componente revolucionário que transformou a maneira como os modelos de linguagem processam informações. Começamos com a arquitetura básica de atenção e avançamos até a arquitetura de múltiplas cabeças, que permite ao nosso modelo aprender relações complexas entre as palavras.</p><p>No próximo artigo, daremos um passo crucial rumo à conclusão do nosso LLM: implementaremos o <strong>bloco Transformer</strong> completo, combinando o mecanismo de atenção com feed-forward networks e normalização. Isso nos aproximará da conclusão do modelo e do início do momento mais aguardado: o pré-treinamento.</p><p>Você pode acessar e acompanhar os artigos e códigos diretamente no meu github: <a href="https://github.com/z-fab/llm-zero/tree/master">https://github.com/z-fab/llm-zero/tree/master</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee42e3c42faf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM do Zero: criando significado com Embeddings]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-do-zero-criando-significado-com-embeddings-3ede12925b79?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ede12925b79</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Fri, 17 Jan 2025 00:40:52 GMT</pubDate>
            <atom:updated>2025-01-17T00:40:52.905Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2YJx6vGw-_aRzh6q__SqTA.png" /></figure><h4>Transformando texto em números: uma jornada pelos embeddings e codificação posicional</h4><p>Você sabia que as palavras podem ser organizadas em um espaço multidimensional que revela suas relações semânticas e contextuais?</p><p>Imagine uma biblioteca onde nenhum livro possui título ou categoria visível. Para organizá-la, analisamos características como peso, número de páginas e autor, posicionando os livros nas prateleiras de acordo com suas similaridades. É exatamente isso que <strong>embeddings</strong> fazem, transformam palavras, frases ou tokens em representações dentro de um espaço multidimensional — e é esse universo que vamos explorar.</p><p>Vale lembrar que este é o terceiro de uma série de oito artigos. Se ainda não conferiu os anteriores, recomendo que veja antes de prosseguir:</p><ol><li><a href="https://blog.zfab.me/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa">Introdução</a></li><li><a href="https://medium.com/@zfab/construindo-um-llm-do-zero-tokeniza%C3%A7%C3%A3o-um-mal-necess%C3%A1rio-dfaab5dc9488">Tokenização</a></li><li><strong>Embedding </strong>(Você está aqui!)</li><li><em>Mecanismo de Atenção</em></li><li><em>Arquitetura Transformer</em></li><li><em>Criando um GPT</em></li><li><em>Treinando um Foundational Model</em></li><li><em>Especializando</em></li></ol><h3>Representação Vetorial dos Tokens</h3><p>Anteriormente, através do processo de tokenização e do vocabulário, convertemos palavras em identificadores numéricos únicos (IDs). Porém, usar esses IDs diretamente como entrada não é eficaz. Por exemplo, em um vocabulário onde “gato” tem ID 1, “elefante” ID 2 e “cachorro” ID 3, o modelo poderia interpretar erroneamente esses números como valores ordinais, sugerindo que “cachorro” (ID 3) é maior ou tem uma relação quantitativa com “elefante” (ID 2).</p><p>Os IDs são identificadores arbitrários que, sozinhos, não carregam o verdadeiro significado dos tokens que representam. É como um CPF: ele não representa quem você é, apenas serve como um identificador numérico. Para informar melhor ao modelo o que cada ID significa, utilizamos vetores — listas de números — que nos oferecem maior flexibilidade na representação dos tokens. Em vez de um único número, trabalharemos com uma lista deles.</p><p>Surge então um novo desafio: como criar vetores que não sejam apenas listas arbitrárias de números, mas que realmente transmitam o significado das palavras? Para resolver essa questão, foram desenvolvidas várias técnicas que transformam palavras em representações numéricas mais ricas e significativas.</p><p>Uma abordagem fundamental para transformar tokens em vetores é conhecida como <strong>one-hot encoding</strong>. Esta técnica, embora simples, ilustra bem o conceito de representação vetorial: cada palavra é convertida em um vetor binário onde apenas a posição correspondente ao seu ID recebe o valor 1, enquanto todas as outras posições são preenchidas com 0. Por exemplo, em um vocabulário de 1000 palavras, a palavra “gato” poderia ser representada por um vetor de 1000 posições, com um único 1 na posição do seu ID e zeros em todas as outras.</p><pre>vocab_onehot = {<br>    &quot;O&quot;: 1,<br>    &quot;rato&quot;: 2,<br>    &quot;comeu&quot;: 3,<br>    &quot;roeu&quot;: 4,<br>    &quot;roupa&quot;: 5,<br>    &quot;a&quot;: 6,<br>    &quot;rainha&quot;: 7,<br>    &quot;do&quot;: 8,<br>    &quot;roma&quot;: 9,<br>    &quot;de&quot;: 10,<br>    &quot;Roma&quot;: 11,<br>    &quot;Rei&quot;: 12<br>}<br><br>vector_onehot = {<br>    k: [1 if i == v else 0 for i in range(1, len(vocab_onehot))] for k, v in vocab_onehot.items()<br>}<br><br>phrase = &quot;O rato roeu a roupa do Rei de Roma&quot;<br>tokens = phrase.split(&quot; &quot;)<br><br>print(&quot;Frase:&quot;, phrase)<br>print(&quot;Tokens IDs:&quot;, [vocab_onehot[t] for t in tokens])<br>print(&quot;Tokens one-hot:&quot;, [vector_onehot[t] for t in tokens])<br><br>#OUTPUT<br>#Frase: O rato roeu a roupa do Rei de Roma<br>#Tokens IDs: [1, 2, 4, 6, 5, 8, 12, 10, 11]<br>#Tokens one-hot: [<br>#  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], <br>#  [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], <br>#  [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], <br>#  [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], <br>#  [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], <br>#  [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], <br>#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], <br>#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], <br>#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]<br>#]</pre><p>Embora o one-hot encoding represente um avanço em relação ao uso direto de IDs numéricos, pois permite uma representação mais estruturada das palavras, esta técnica ainda apresenta limitações significativas que a tornam inadequada para processamento de linguagem natural moderno:</p><ol><li><strong>Alta Dimensionalidade</strong>: Em vocabulários extensos, que podem conter dezenas ou centenas de milhares de palavras, os vetores tornam-se extremamente longos e esparsos, resultando em uso ineficiente de memória e poder computacional.</li><li><strong>Falta de Relacionamento Semântico</strong>: Assim como os IDs numéricos simples, o one-hot encoding não captura relações semânticas entre palavras. Por exemplo, “gato” e “felino” são representados por vetores completamente diferentes, sem qualquer indicação de sua proximidade conceitual.</li><li><strong>Vetores Esparsos</strong>: Com apenas um valor não-zero em cada vetor, as operações matemáticas tornam-se computacionalmente custosas e ineficientes, especialmente em redes neurais modernas que precisam processar grandes volumes de texto.</li></ol><p>Outras abordagens tradicionais de vetorização, como Bag of Words (BoW) e Term Frequency-Inverse Document Frequency (TF-IDF), tentam resolver algumas dessas questões ao criar representações para frases e documentos inteiros. Contudo, estas técnicas ainda sofrem com problemas de esparsidade, ausência de relações semânticas e, crucialmente, não preservam a ordem das palavras no texto.</p><p>Felizmente, essas limitações fundamentais são superadas, ou pelo menos significativamente reduzidas, através do uso de Embeddings</p><h3>Embeddings</h3><p>Para superar essas limitações, surgiram os embeddings — vetores densos e multidimensionais que capturam propriedades semânticas e contextuais das palavras.</p><p>Para entender melhor, considere uma lista de animais: “gato”, “cachorro”, “cobra”, “águia” e “elefante”. Cada palavra pode ser descrita por características numéricas em uma tabela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dn78UT_RDiCIL5WqZmE7Zw.png" /></figure><p>Podemos representar <strong>Aranha</strong> com o vetor [8, 0, 0.02] e <strong>Cachorro</strong> com o vetor [4, 1, 7]. Esta representação permite que o modelo identifique similaridades entre “gato” e “cachorro” através de suas características compartilhadas, ao mesmo tempo que reconhece as diferenças contextuais entre eles e “cobra”.</p><pre># Dicionário com palavras e vetores de 3 posições<br>dict_animals = {<br>    &quot;Gato&quot;: [4, 1, 4],          # 4 patas, mamífero, 4 kg<br>    &quot;Cachorro&quot;: [4, 1, 7],      # 4 patas, mamífero, 7 kg<br>    &quot;Águia&quot;: [2, 0, 5],         # 2 patas, não mamífero, 5 kg<br>    &quot;Aranha&quot;: [8, 0, 0.02],     # 8 patas, não mamífero, 0.02 kg<br>    &quot;Papagaio&quot;: [2, 0, 1],      # 2 patas, não mamífero, 1 kg<br>    &quot;Cobra&quot;: [0, 0, 15],        # 0 patas, não mamífero, 15 kg<br>}<br><br>words = list(dict_animals.keys())<br>vectors = list(dict_animals.values())<br>x = [vec[0] for vec in vectors]<br>y = [vec[1] for vec in vectors]<br>z = [vec[2] for vec in vectors]<br><br>fig = px.scatter_3d(x=x, y=y, z=z, color=words, text=words)<br><br>fig.update_traces(<br>    marker=dict(size=8), <br>    textposition=&#39;top left&#39;,<br>    textfont_size=12,<br>)<br><br>fig.update_layout(<br>    title=&#39;Embedding de Animais&#39;,<br>    scene = dict(<br>        xaxis_title=&#39;Patas&#39;,<br>        yaxis_title=&#39;Mamífero&#39;,<br>        zaxis_title=&#39;Peso&#39;<br>    ),<br>    scene_aspectratio=dict(x=1.2, y=1, z=.7),<br>    scene_camera_eye=dict(x=1.5, y=1.1, z=1.5),<br>    margin=dict(l=20, r=20, b=50, t=50),<br>    showlegend=False,<br>    width=600,<br>    height=500,<br>)<br>fig.show()</pre><p>Ao plotarmos esses animais em um espaço onde cada eixo representa uma propriedade, notamos que animais similares, como águia e papagaio ou cachorro e gato, ficam próximos uns aos outros, enquanto aranha e cobra se posicionam distantes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HziBSHca9JeC_VE86Hg0_g.png" /></figure><p>Agora imagine que, em vez de animais, temos palavras (ou tokens) e, em vez de 3 características, temos centenas ou milhares. Se pudéssemos visualizar esse espaço (conhecido como espaço latente ou espaço de embedding), veríamos que palavras semelhantes como “rei” e “rainha” ficariam próximas, assim como “Brasília” e “Brasil”. Notaríamos também que “rei” e “rainha” mantêm a mesma relação que “homem” e “mulher”, preservando distâncias equivalentes.</p><p>Os embeddings são, essencialmente, representações vetoriais de elementos não numéricos (como palavras ou frases) em <strong>espaços multidimensionais</strong>. Em vez de definirmos manualmente as features, como fizemos com os animais (número de patas, peso, etc.), os valores e suas propriedades são aprendidos automaticamente durante o treinamento.</p><p>Para criarmos embeddings no PyTorch, basta usarmos o <em>nn.Embedding</em>, informando o tamanho do vocabulário e a dimensão do embedding (número de features). A camada de embedding funciona como uma grande tabela que relaciona cada ID ao seu vetor correspondente.</p><pre>torch.nn.Embedding(<br>  num_embeddings=5000,    # Tamanho do Vocabulário <br>  embedding_dim=300       # Tamanho do Embedding (número de features)<br>)</pre><p>Agora, vamos criar uma camada de Embedding e aplicá-la em um exemplo prático. A partir deste ponto, passaremos a chamar os vetores de tensores. Embora o conceito fundamental seja o mesmo, no contexto de Deep Learning é convenção nos referirmos a vetores e matrizes como tensores.</p><pre>VOCAB = {<br>    &quot;O&quot;: 1,<br>    &quot;rato&quot;: 2,<br>    &quot;comeu&quot;: 3,<br>    &quot;roeu&quot;: 4,<br>    &quot;roupa&quot;: 5,<br>    &quot;a&quot;: 6,<br>    &quot;rainha&quot;: 7,<br>    &quot;do&quot;: 8,<br>    &quot;roma&quot;: 9,<br>    &quot;Roma&quot;: 11,<br>    &quot;de&quot;: 10,<br>    &quot;Rei&quot;: 12<br>}<br><br>VOCAB_SIZE = len(VOCAB) # Tamanho do nosso vocabulário<br>EMBEDDING_DIM = 10 # Dimensão dos vetores de embedding<br><br>torch.manual_seed(42)<br>embedding_layer = nn.Embedding(num_embeddings=VOCAB_SIZE+1, embedding_dim=EMBEDDING_DIM)<br><br>phrase = &quot;O rato roeu a roupa do Rei de Roma&quot;<br>tokens = phrase.split(&quot; &quot;)<br><br>input_ids = torch.tensor([VOCAB[t] for t in tokens])  # IDs dos tokens<br>vectors = embedding_layer(input_ids)<br><br>print(&quot;Frase:&quot;, phrase)<br>print(&quot;Tokens IDs:&quot;, [VOCAB[t] for t in tokens])<br>print(&quot;Tokens embeddings:&quot;, vectors)<br><br>#OUTPUT<br>#Frase: O rato roeu a roupa do Rei de Roma<br>#Tokens IDs: [1, 2, 4, 6, 5, 8, 12, 10, 11]<br>#Tokens embeddings: tensor([[-3.9248e-01, -1.4036e+00, -7.2788e-01, -5.5943e-01, -7.6884e-01,<br>#          7.6245e-01,  1.6423e+00, -1.5960e-01, -4.9740e-01,  4.3959e-01],<br>#        [-7.5813e-01,  1.0783e+00,  8.0080e-01,  1.6806e+00,  1.2791e+00,<br>#          1.2964e+00,  6.1047e-01,  1.3347e+00, -2.3162e-01,  4.1759e-02],<br>#        [-1.5576e+00,  9.9564e-01, -8.7979e-01, -6.0114e-01, -1.2742e+00,<br>#          2.1228e+00, -1.2347e+00, -4.8791e-01, -9.1382e-01, -6.5814e-01],<br>#        [-9.7807e-02,  1.8446e+00, -1.1845e+00,  1.3835e+00,  1.4451e+00,<br>#          8.5641e-01,  2.2181e+00,  5.2317e-01,  3.4665e-01, -1.9733e-01],<br>#        [ 7.8024e-02,  5.2581e-01, -4.8799e-01,  1.1914e+00, -8.1401e-01,<br>#         -7.3599e-01, -1.4032e+00,  3.6004e-02, -6.3477e-02,  6.7561e-01],<br>#        [ 1.0868e-02, -3.3874e-01, -1.3407e+00, -5.8537e-01,  5.3619e-01,<br>#          5.2462e-01,  1.1412e+00,  5.1644e-02,  7.4395e-01, -4.8158e-01],<br>#        [-3.6091e-01, -6.0590e-02, -1.8058e+00,  9.2543e-01, -3.7534e-01,<br>#          1.0331e+00, -6.8665e-01,  6.3681e-01,  2.1755e-01, -4.6655e-02],<br>#        [ 6.4076e-01,  5.8325e-01,  1.0669e+00, -4.5015e-01, -1.8527e-01,<br>#          7.5276e-01,  4.0476e-01,  1.7847e-01,  2.6491e-01,  1.2732e+00],<br>#        [-1.3109e-03, -3.0360e-01, -1.4570e+00, -1.0234e-01, -1.4364e+00,<br>#         -1.1299e+00, -1.3603e-01,  1.6354e+00,  6.5474e-01,  5.7600e-01]],<br>#       grad_fn=&lt;EmbeddingBackward0&gt;)</pre><p>A partir de uma única frase, realizamos um processo básico de tokenização, convertemos os tokens em IDs usando um vocabulário e obtivemos seus respectivos tensores na camada de Embedding.</p><p>É importante destacar que, neste estágio, esses tensores ainda <strong>não têm significado</strong> — são apenas números aleatórios gerados, pois a camada de Embedding ainda não foi treinada. Assim, os valores que deveriam representar o significado de cada token ainda não foram aprendidos.</p><h4>Dimensionalidade e Eficiência</h4><p>A escolha da dimensionalidade dos embeddings é crucial. Dimensões menores processam mais rapidamente, mas podem não capturar nuances suficientes. Já dimensões muito grandes aumentam o custo computacional e o consumo de memória.</p><blockquote><em>O modelo GPT-3 da OpenAI utiliza embeddings com </em><strong><em>12.288 dimensões</em></strong><em>.</em></blockquote><p>O tamanho do vocabulário é fundamental. Vocabulários grandes demandam mais memória para processar embeddings, mas permitem capturar maior diversidade linguística.</p><p>A dimensionalidade também afeta diretamente a capacidade do modelo de capturar relações complexas. O tamanho da camada de embedding é uma decisão crítica que influencia tanto o desempenho quanto o custo computacional do modelo.</p><h3>Codificação Posicional: Incorporando Ordem</h3><p>Modelos baseados em RNNs possuem um viés indutivo natural — suas características estruturais já incluem pressupostos sobre a organização dos dados. Como os tokens são processados sequencialmente, a posição das palavras na frase é naturalmente incorporada ao fluxo de cálculos, eliminando a necessidade de informar explicitamente a ordem temporal do texto.</p><p>Já os Transformers não possuem esse viés indutivo intrínseco. Por processarem todos os tokens simultaneamente, sua arquitetura não captura naturalmente a posição das palavras no texto. Isso representa um desafio significativo, pois a ordem das palavras pode alterar completamente o significado de uma frase — “o cachorro mordeu o homem” tem um significado muito diferente de “o homem mordeu o cachorro”.</p><p>Para que os Transformers compreendam a estrutura do texto, precisamos adicionar informações explícitas sobre a posição de cada token. Isso é feito através do positional encoding, que cria nossos embeddings posicionais.</p><p>Esses embeddings posicionais funcionam de maneira análoga aos embeddings de tokens, mas em vez de codificar o significado da palavra, codificam sua posição na sequência. O processo final envolve somar os dois embeddings: o do token (que carrega o significado) e o posicional (que indica a posição). Esta abordagem permite que os Transformers processem as entradas em paralelo enquanto preservam a compreensão da estrutura sequencial do texto.</p><p>Existem diferentes abordagens para implementar o positional encoding. A técnica original, apresentada no artigo “Attention is All You Need”, utiliza funções trigonométricas (seno e cosseno) para gerar os embeddings posicionais de forma determinística. Esta solução tem a vantagem de não adicionar parâmetros treináveis ao modelo.</p><p>Uma alternativa é utilizar uma camada adicional de embedding que aprende as representações posicionais durante o treinamento. Embora esta abordagem adicione parâmetros ao modelo, ela foi adotada com sucesso em arquiteturas posteriores como BERT e GPT-2, demonstrando resultados equivalentes à solução trigonométrica.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vjEbCuu5k75c-7G7BIYbPg.png" /></figure><p>Para nosso modelo, usaremos os embeddings posicionais treináveis — uma camada adicional que aprende a representar a posição de cada token (0, 1, 2…) durante o treinamento. Isso difere da camada principal de embeddings, que trabalha com os IDs das palavras do vocabulário.</p><h3>Implementando nossa solução</h3><p>Para criarmos a camada de embedding posicional do nosso modelo, podemos utilizar a função disponível na biblioteca Pytorch. Diferentemente da criação de embeddings convencionais, em vez de especificarmos o tamanho do vocabulário, devemos informar a quantidade máxima de tokens que o modelo será capaz de processar, conhecida como <strong>janela de contexto.</strong></p><pre>CONTEXT_LENGTH =  20 # Número máximo de tokens que o modelo pode considerar (Janela de contexto)<br><br># Criando a camada de embedding para posições<br>pos_embedding_layer = torch.nn.Embedding(CONTEXT_LENGTH, EMBEDDING_DIM)<br><br># Recuperando os embeddings posicionais para cada token<br>pos_embeddings = pos_embedding_layer(torch.arange(len(tokens)))<br><br># Somando os embeddings token e posicional para obter o embedding final<br>embedding = vectors + pos_embeddings<br><br>print(&quot;Frase:&quot;, phrase)<br>print(&quot;--- Embedding Token 1:\n&quot;, vectors[0])<br>print(&quot;Shape:&quot;, vectors.size())<br>print(&quot;--- Embedding Posicional 1:\n&quot;, pos_embeddings[0])<br>print(&quot;Shape:&quot;, pos_embeddings.size())<br>print(&quot;--- Embedding Final 1:\n&quot;, embedding[0])<br>print(&quot;Shape:&quot;, embedding.size())<br><br>#OUTPUT<br>#Frase: O rato roeu a roupa do Rei de Roma<br>#--- Embedding Token 1:<br># tensor([-0.3925, -1.4036, -0.7279, -0.5594, -0.7688,  0.7624,  1.6423, -0.1596, -0.4974,  0.4396], grad_fn=&lt;SelectBackward0&gt;)<br>#Shape: torch.Size([9, 10])<br>#--- Embedding Posicional 1:<br># tensor([ 1.3541, -0.0709,  2.1726,  2.2334,  0.2225, -0.9300,  0.3208,  0.0371, 0.5675,  0.8284], grad_fn=&lt;SelectBackward0&gt;)<br>#Shape: torch.Size([9, 10])<br>#--- Embedding Final 1:<br># tensor([ 0.9617, -1.4745,  1.4447,  1.6740, -0.5463, -0.1676,  1.9632, -0.1225, 0.0701,  1.2680], grad_fn=&lt;SelectBackward0&gt;)<br>#Shape: torch.Size([9, 10])</pre><p>No código demonstrado, observamos como os embeddings finais são criados através de um processo de soma entre dois componentes: os embeddings dos tokens e os embeddings posicionais. Esta operação matemática permite que cada token mantenha sua representação semântica original enquanto incorpora informações sobre sua localização na sequência.</p><p>Durante este processo, o modelo mantém a representação original de cada token através do embedding de token, enquanto adiciona uma camada extra de informação posicional através do embedding posicional. Esta combinação resulta em um tensor que carrega tanto o significado quanto a posição da palavra no texto.</p><p>Esta abordagem permite que o modelo processe simultaneamente a semântica e a estrutura da frase, fornecendo uma base sólida para o aprendizado do nosso LLM.</p><h3>Conclusão</h3><p>Os embeddings representam um pilar fundamental no processamento de linguagem natural, transformando texto em representações matemáticas precisas que permitem aos modelos de aprendizado de máquina compreender e processar a linguagem humana. Através dessas estruturas matemáticas, os modelos desenvolvem uma compreensão sofisticada de nuances linguísticas e relações contextuais.</p><p>A integração de embeddings com mecanismos avançados, especialmente os posicionais, impulsiona o desempenho excepcional dos modelos de linguagem modernos. Esta combinação permite que eles compreendam não apenas o significado das palavras, mas também sua posição e relacionamento dentro do texto.</p><p>Em nossa próxima discussão, mergulharemos nos <strong>mecanismos de atenção</strong> — um componente revolucionário dos Transformers que trabalha em harmonia com os embeddings. Exploraremos como esses mecanismos permitem que os modelos focalizem dinamicamente nas partes mais relevantes do texto, possibilitando uma compreensão profunda e uma geração de texto mais coerente.</p><p>Você pode acessar e acompanhar os artigos e códigos diretamente no meu github: <a href="https://github.com/z-fab/llm-zero/tree/master">https://github.com/z-fab/llm-zero/tree/master</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ede12925b79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM do Zero: Tokenização, um mal necessário]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-do-zero-tokeniza%C3%A7%C3%A3o-um-mal-necess%C3%A1rio-dfaab5dc9488?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/dfaab5dc9488</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[ciencia-de-dados]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Mon, 13 Jan 2025 22:46:08 GMT</pubDate>
            <atom:updated>2025-01-13T22:46:08.080Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-DVqBxwiGE5Cdr8TRnQ_Rw.png" /></figure><h4>Iniciando a construção do nosso LLM da base: preparando o texto</h4><p>Redes neurais profundas, e LLMs são redes neurais profundas, não podem processar texto diretamente e por isso precisamos transforma-lo em algo que o modelo possa consumir e aprender É nesse momento que entra uma etapa crucial na criação de um modelo de linguagem: a <strong>tokenização.</strong></p><p>Imagine que você está tentando montar um quebra-cabeça sem saber como a imagem final deveria ser. As peças estão lá, mas sem entender o contexto ou a forma como se encaixam, é difícil formar uma imagem coerente. Da mesma forma, um modelo de linguagem precisa que o texto seja dividido em “peças” menores, ou seja, tokens, para que ele possa começar a construir uma representação significativa do conteúdo.</p><p>Vale lembrar que este é o segundo de uma série de oito artigos. Se ainda não conferiu os anteriores, recomendo que veja antes de prosseguir:</p><ol><li><a href="https://blog.zfab.me/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa">Introdução</a></li><li><strong>Tokenização</strong> (Você está aqui!)</li><li><em>Embedding</em></li><li><em>Mecanismo de Atenção</em></li><li><em>Arquitetura Transformer</em></li><li><em>Criando um GPT</em></li><li><em>Treinando um Foundational Model</em></li><li><em>Especializando</em></li></ol><h3><strong>Preparando o texto para o modelo</strong></h3><p>A criação de um LLM (<em>Large Language Model</em> ou Modelo de Linguagem de Grande Escala) começa pela preparação cuidadosa do texto que será utilizado no treinamento. Esse passo é fundamental para garantir que o modelo seja capaz de compreender o conteúdo, capturar o significado das palavras e reconhecer suas relações semânticas e sintáticas. Para alcançar esse objetivo, todo o conteúdo de treinamento precisa ser convertido em números — um formato que o modelo pode processar e, a partir disso, aprender de forma eficiente.</p><p>A abordagem mais simples e intuitiva para processar texto é atribuir um número único a cada palavra e substituir as palavras por esses identificadores sempre que aparecerem. Por exemplo, uma frase como “Eu adoro ciência de Dados!” poderia ser convertida em “1, 4, 10, 2, 13, 25”, onde o número 1 representa a palavra “eu”, o 13 corresponde a “dados” e o 25 indica o ponto de exclamação.</p><p>Porém para chegarmos nessa lista de palavras e identificadores (o chamado vocabulário) precisamos decidir como dividir nosso texto para identificação das palavras: é nisso que consiste a <strong>Tokenização</strong></p><h4><strong>Tokenização</strong></h4><p>A tokenização pode ser comparada a cortar um grande quebra-cabeça em peças menores. Na prática, trata-se de dividir o texto em unidades chamadas tokens, que podem ser palavras, subpalavras ou até mesmo caracteres individuais. Apesar de a ideia parecer simples, sua implementação pode ser bastante complexa.</p><p>Um dos primeiros pontos que precisamos ponderar é a forma como vamos dividir nosso texto já que isso influenciará diretamente o tamanho do nosso vocabulário e por consequência a eficiência do nosso modelo. Vamos usar um conjunto de textos em português como exemplo:</p><pre>with open(&quot;../data/gigaverbo.txt&quot;, &quot;r&quot;, encoding=&quot;utf-8&quot;) as f:<br>    text_raw = f.read()<br>    <br>print(&quot;Número de Caracteres:&quot;, len(text_raw))<br>print(&quot;Número de Palavras:&quot;, len(re.split(r&quot;(\s)&quot;, text_raw)))<br>print(&quot;Número de Caracteres únicos:&quot;, len(set(text_raw)))<br>print(&quot;Número de Palavras únicas:&quot;, len(set(re.split(r&quot;(\s)&quot;, text_raw))))<br><br>#OUTPUT<br>#Número de Caracteres: 79444559<br>#Número de Palavras: 25644299<br>#Número de Caracteres únicos: 1265<br>#Número de Palavras únicas: 748520</pre><p>Avaliando dois cenários, onde em um quebramos o nosso texto por caractere (cada caractere é um id) e outro separando por palavra (cada palavra única é um id) vemos o impacto no tamanho do vocabulário: no primeiro cenário (separação por caractere) temos um vocabulário com <strong>1265 ids</strong> e no segundo cenário (separação por palavras) temos um vocabulário com <strong>748520 ids</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NdHxoN7qkWVvwbrosJ3dfQ.png" /></figure><p>À primeira vista, a separação por caracteres pode parecer uma abordagem mais vantajosa, já que resulta em um vocabulário significativamente menor — mais de 500 vezes menor em comparação à divisão por palavras — , o que exige menos memória. No entanto, essa escolha traz consigo um impacto negativo, como podemos observar no exemplo abaixo:</p><pre>phrase = &quot;Hoje é um belo dia&quot;<br><br># Criando vocabulario de caracteres<br>vocab_char = sorted(set(text_raw))<br><br># Criando vocabulario de palavras<br>vocab_word = sorted(set(re.split(r&quot;(\s)&quot;, text_raw)))<br><br>print(&quot;Frase:&quot;, phrase)<br>print(&quot;Frase em caracteres:&quot;, [vocab_char.index(c) for c in phrase])<br>print(&quot;Frase em palavras:&quot;, [vocab_word.index(w) for w in re.split(r&quot;(\s)&quot;, phrase)])<br><br>#OUTPUT<br>#Frase: Hoje é um belo dia<br>#Frase em caracteres: [43, 82, 77, 72, 3, 155, 3, 88, 80, 3, 69, 72, 79, 82, 3, 71, 76, 68]<br>#Frase em palavras: [179435, 3, 746180, 3, 724737, 3, 355836, 3, 432683]</pre><p>Podemos reparar que apesar do vocabulário por caracteres ser menor a conversão do conteúdo se torna muito mais extensa em comparação com o vocabulário por palavras. Isso quer dizer que a mesma frase necessitará de muito mais processamento para interpretação e relações entre esses caracteres pelo modelo, o que também não é desejado.</p><p>Um outro problema é o que fazer com palavras desconhecidas. Se tentarmos fazer o encode (converter texto para IDs) de uma frase como “Fui assistir o lançamento de um foguete” com nosso vocabulário, criado com texto de Machado de Assis, não teremos algumas palavras como “lançamento” e “foguete”, ou então nomes próprios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2DyJLnvwrJJGMFc1IvPrLw.png" /></figure><p>Para solucionarmos esses e outros problemas algumas soluções foram e são propostas rotineiramente. Recentemente, a Meta introduziu o<strong> Byte Latent Transformer </strong>(BLT), uma arquitetura que elimina a necessidade da tokenização. O BLT processa diretamente sequências de bytes brutos, agrupando-os dinamicamente em “patches” de tamanhos variados com base na complexidade dos dados.</p><p>Atualmente, a solução padrão ouro na industria, usada na maioria dos modelos comerciais, e que usaremos no nosso modelo, é a técnica de Byte Pair Encoding (BPE).</p><h3><strong>Byte Pair Encoding (BPE)</strong></h3><p>O <strong>BPE</strong> (e suas variações) é uma das técnicas mais usadas para lidar com a tokenização atualmente. Originalmente criado como um algoritmo de compressão em 1994, foi adaptado em 2015 por Sennrich et al. (<a href="https://arxiv.org/abs/1508.07909">https://arxiv.org/abs/1508.07909</a>) para o processamento de linguagem natural para resolver, principalmente, o problema das palavras raras ou completamente desconhecidas.</p><p>Sua solução é relativamente simples mas eficás: encontrar um equilíbrio entre caracteres individuais e palavras completas, criando subpalavras que maximizam a eficiência.</p><p>Imagine que você está tokenizando a palavra “araraquara” usando BPE. No início, o algoritmo simplesmente divide a palavra em seus caracteres individuais:</p><pre>A - R - A - R - A - Q - U - A - R - A</pre><p>A partir daí, começa a analisar o texto como um todo e identificamos os <strong>pares de caracteres mais frequentes</strong>. Nesse caso, o par “ar” é o mais comum. Então, ele o combina em um único token:</p><pre>AR - AR - A - Q - U - AR - A</pre><p>O processo continua. O próximo par mais frequente, “ara”, também é combinado:</p><pre>AR - ARA - Q - U - ARA</pre><p>No final, o que começou como <strong>10 tokens</strong> foi reduzido para <strong>apenas</strong> <strong>5</strong>. É esse tipo de compactação inteligente que torna o BPE tão eficiente. Ele identifica padrões frequentes e cria novos tokens que representam essas combinações, o que economiza espaço e melhora o desempenho do modelo.</p><p>A grande sacada do <strong>BPE</strong> é sua capacidade de representar palavras raras como combinações de subpalavras comuns. Em vez de simplesmente ignorar essas palavras ou tratá-las como completamente desconhecidas, o BPE permite que elas sejam representadas por combinações de tokens que já existem.</p><p>Por exemplo, uma palavra rara como “descentralização” pode ser dividida em subpalavras como “<em>des</em>”, “<em>central</em>” e “<em>ização</em>”. Mesmo que o modelo nunca tenha visto “descentralização” antes, ele ainda pode entender parte de seu significado por reconhecer essas subpartes.</p><p>Essa <strong>flexibilidade</strong> permite reduzir significativamente o tamanho do vocabulário, o que economiza recursos computacionais e facilita o treinamento dos modelos.</p><p>O número de fusões realizadas no Byte Pair Encoding (BPE) é definido por um hiperparâmetro arbitrário, esse número determina o tamanho do vocabulário final e, consequentemente, a granularidade dos tokens. Um vocabulário muito pequeno pode levar a uma divisão excessiva em tokens menores, enquanto um vocabulário muito grande pode resultar em um modelo menos eficiente em termos computacionais.</p><p>Além disso, a capacidade do tokenizador de representar palavras de forma eficiente depende fortemente do conjunto de textos utilizado. Um conjunto diversificado e representativo oferece ao BPE dados suficientes para aprender padrões frequentes e linguísticamente significativos. Por outro lado, um corpus limitado ou enviesado pode levar o tokenizador a priorizar combinações que não refletem bem a estrutura linguística do idioma ou do domínio.</p><h3><strong>Nem tudo são flores…</strong></h3><p>A tokenização, embora essencial para o funcionamento de modelos de linguagem de grande escala (LLMs), carrega consigo uma série de desafios que justificam o título de “mal necessário”.</p><h4><strong>1. A Fragmentação e o Contexto Perdido</strong></h4><p>Um dos maiores problemas da tokenização é a necessidade de fragmentação do texto em unidades menores, como palavras ou subpalavras. Essa divisão, enquanto necessária para o processamento por redes neurais, pode descontextualizar certos elementos linguísticos. Um exemplo clássico são os número, como por exemplo “6773”, que, dependendo do tokenizador, pode ser dividido em dois ou mais tokens, dificultando a capacidade do modelo de lidar com cálculos ou de entender o significado numérico como um todo​</p><p>Esse problema se estende a palavras compostas, gírias e outros elementos linguísticos que, quando quebrados, perdem sua semântica original. A incapacidade de capturar adequadamente esses significados pode levar a previsões imprecisas e dificuldades em tarefas como tradução automática ou compreensão de linguagem natural.</p><h4><strong>2. O Impacto do Vocabulário e da Língua</strong></h4><p>Outro desafio está relacionado ao tamanho do vocabulário e à diversidade linguística. Tokenizadores treinados majoritariamente em textos em inglês, por exemplo, tendem a representar frases nesse idioma com menos tokens em comparação a outras línguas, como o português. Isso ocorre porque o treinamento com dados desbalanceados privilegia a compressão de padrões mais frequentes no idioma dominante​ no texto</p><p>Além disso, vocabulários maiores permitem representar mais informações com menos tokens, mas isso tem um custo: modelos com grandes vocabulários demandam mais memória e poder computacional, além de enfrentarem problemas de subtreinamento em tokens raros, que aparecem com pouca frequência nos dados​</p><h4><strong>3. A Complexidade Matemática e Computacional</strong></h4><p>A tokenização tem um impacto direto no desempenho computacional. Quando o texto é mais fragmentado, o número de tokens a serem processados aumenta, o que eleva tanto o tempo de treinamento quanto os requisitos de memória. Por outro lado, técnicas como o Byte Pair Encoding (BPE) compactam as informações em menos tokens, criando vocabulários mais densos.</p><p>Embora esses vocabulários densos sejam eficientes, eles exigem maior capacidade computacional para gerar embeddings mais complexos. Essa complexidade adicional é um aspecto importante a se considerar no desenvolvimento de modelos de linguagem. No próximo artigo, abordaremos mais detalhadamente o tema dos embeddings.</p><h3><strong>Iniciando nosso LLM</strong></h3><p>Para iniciar o desenvolvimento do nosso LLM, o primeiro passo é construir o <strong>Tokenizador</strong>. Além de escolhermos a técnica que utilizaremos, que será a <strong>BPE</strong> (Byte Pair Encoding), é crucial selecionar o corpus adequado.</p><p>O conjunto de textos escolhido é de extrema importância, pois determinará os tokens que nosso modelo será capaz de reconhecer. Por exemplo, se o corpus não contiver a palavra “foguete”, essa palavra será representada por vários tokens, dificultando a capacidade do nosso LLM de compreender seu significado de forma eficaz.</p><p>Nos treinaremos, tanto nosso tokenizador quanto nosso LLM, em uma parte do dataset chamado <strong>GigaVerbo</strong>. Esse dataset está disponível no <a href="https://huggingface.co/datasets/TucanoBR/GigaVerbo">HuggingFace</a> e contém mais de <strong>200 bilhões de tokens</strong> em português e faz parte do trabalho realizado pelo <em>Nicholas Kluge</em> na criação do modelo <strong>Tucano</strong> (o paper pode ser lido no Arxiv: <a href="https://arxiv.org/abs/2411.07854">https://arxiv.org/abs/2411.07854</a>)</p><p>Para conseguir acesso aos dados, usaremos o link disponibilizado pelo HuggingFace. Faremos o download do arquivo <em>train-00000-of-01573.parquet</em></p><pre># Download primeira parte do dataset<br>df = pl.read_parquet(&#39;hf://datasets/TucanoBR/GigaVerbo/data/train-00000-of-01573.parquet&#39;)<br><br>print(f&quot;{df.shape[0]} linhas e {df.shape[1]} colunas&quot;)<br><br>#OUTPUT:<br>#92372 linhas e 4 colunas (text, label, probs, metadata)</pre><p>Como podemos ver, o dataset contém mais de 92 mil textos (de diversos tamanhos) e todos recebem uma label, a probabilidade do texto pertencer ao label e a origem do conteúdo (metadata). O label indica se o texto foi considerado de boa qualidade ou não.</p><p>Para fazer essa classificação de qualidade o time do Tucano treinou um outro modelo para isso e pode ser visto em detalhes no paper. Para nós o importante aqui é entender que label 1 quer dizer que o texto foi considerado de qualidade e serão esses que usaremos no nosso treinamento.</p><pre># Filtrar apenas textos com label 1 (texto de qualidade) e concatenar em uma única string<br>text_raw = &quot;&lt;|eos|&gt;&quot;.join(<br>    df.filter(<br>        pl.col(&#39;label&#39;) == 1)<br>    .select(<br>        pl.col(&#39;text&#39;))<br>    .to_series()<br>    .to_list()<br>)<br><br>with open(&#39;../data/gigaverbo.txt&#39;, &#39;w&#39;) as f:<br>    f.write(text_raw)</pre><p>Pegamos todos os conteúdos classificados com label 1 (texto de qualidade) e os concatenamos, separando-os por um token especial: &lt;|eos|&gt;.</p><p>Os <em>special tokens</em> (tokens especiais) desempenham um papel crucial na estruturação e compreensão de dados textuais por modelos de linguagem. Esses tokens são elementos simbólicos adicionados à tokenização com funções específicas. Por exemplo, o token &lt;|eos|&gt; (end of sequence) é utilizado para indicar o fim de um segmento de texto, ajudando o modelo a diferenciar entre contextos ou trechos independentes.</p><h4><strong>Treinando nosso Tokenizador</strong></h4><p>Para treinar o Tokenizador usaremos a biblioteca sentencepiece desenvolvida pelo google e que permite a criação de vocabulários a partir de diversas técnicas.</p><pre>VOCAB_SIZE = 4096<br>SPECIAL_TOKENS = [&quot;&lt;|eos|&gt;&quot;]<br><br>spm.SentencePieceTrainer.train(<br>    input=&quot;../data/gigaverbo.txt&quot;,              # Caminho para o arquivo de contendo o conteúdo para treinar o tokenizador<br>    model_prefix=&quot;../models/gigaverbo_tk&quot;,     # Prefixo do nome do arquivo de saída<br>    vocab_size=VOCAB_SIZE,                          # Tamanho do vocabulário<br>    model_type=&quot;bpe&quot;,                               # Tipo do tokenizador<br>    self_test_sample_size=0,                        # Tamanho do conjunto de teste (não utilizaremos)<br>    character_coverage=0.995,                       # Fração de caracteres que devem ser cobertos pelo modelo<br>    input_format=&quot;text&quot;,                            # Formato do arquivo de entrada<br>    num_threads=os.cpu_count(),                     # Número de threads a serem utilizadas<br>    split_digits=True,                              # Separar os dígitos tratando-os como tokens separados<br>    allow_whitespace_only_pieces=True,              # Permitir tokens que representem apenas espaços em branco<br>    byte_fallback=True,                             # Utilizar tokenização de bytes como fallback<br>    unk_surface=&quot;&lt;|unk|&gt;&quot;,                          # Representação do token desconhecido<br>    normalization_rule_name=&quot;identity&quot;,             # Regra de normalização (identity = sem normalização)<br>    user_defined_symbols=SPECIAL_TOKENS             # Adiciona tokens especiais definidos pelo usuário<br>)</pre><p>Após o treinamento, dois arquivos serão gerados: o <strong><em>gigaverbo_tk.model</em></strong> e o <strong><em>gigaverbo_tk.vocab</em></strong> . O arquivo .model contém as informações sobre o modelo, como tipo do tokenizador, forma em que números foram divididos entre outras informações. Já o .vocab é nossa grande lista contendo os tokens.</p><pre>phrase = &quot;Olá Mundo, tudo bem?&lt;|eos|&gt;&quot;<br><br>tk = spm.SentencePieceProcessor(model_file=&quot;../models/gigaverbo_tk.model&quot;) # Instanciando o tokenizador treinado<br><br>phrase_encode = tk.encode(phrase)<br>phrase_tokens = tk.encode_as_pieces(phrase)<br>phrase_decode = tk.decode(phrase_encode)<br><br>print(&quot;Frase Tokenizada:&quot;, phrase_tokens)<br>print(&quot;Frase tokenizada:&quot;, phrase_encode)<br>print(&quot;Frase reconstruída:&quot;, phrase_decode)<br><br>#OUTPUT<br>#Frase Tokenizada: [&#39;▁Ol&#39;, &#39;á&#39;, &#39;▁Mu&#39;, &#39;ndo&#39;, &#39;,&#39;, &#39;▁tudo&#39;, &#39;▁bem&#39;, &#39;?&#39;, &#39;&lt;|eos|&gt;&#39;]<br>#Frase tokenizada: [3188, 4047, 2362, 341, 4040, 1927, 824, 4091, 3]<br>#Frase reconstruída: Olá Mundo, tudo bem?&lt;|eos|&gt;</pre><p>No exemplo acima podemos ver a codificação da frase “Olá Mundo, tudo bem?” onde temos a palavra <em>Olá</em> sendo separada em dois tokens, _Ol (O sinal de _ significa que é um token inicial, ou seja, está no começo de uma palavra) e á. Podemos também ver que _tudo é um único token de ID <strong>1927</strong> enquanto o ? é representado pelo ID <strong>4091</strong>. Nosso token especial, &lt;|eos|&gt; é de ID <strong>3</strong>.</p><p>Vamos agora tokenizar nosso corpus (o conjunto de textos que extraímos do GigaVerbo) para que possamos utiliza-lo sem precisar converte-lo em tokens toda vez que formos iniciar o treinamento do LLM.</p><pre>text_tokenized = tk.encode(text_raw)<br><br># Salvando o texto tokenizado<br>with open(&quot;../data/gigaverbo_tokenized.txt&quot;, &quot;w&quot;, encoding=&quot;utf-8&quot;) as f:<br>    f.write(&quot; &quot;.join([str(t) for t in text_tokenized]))<br><br>print(&quot;Amostra do texto tokenizado:&quot;, text_tokenized[:20])<br><br>#OUTPUT<br># Amostra do texto tokenizado: <br># [&#39;2762&#39;, &#39;1993&#39;, &#39;596&#39;, &#39;900&#39;, &#39;271&#39;, &#39;613&#39;, <br>#&#39;445&#39;, &#39;2710&#39;, &#39;845&#39;, &#39;4002&#39;, &#39;372&#39;, &#39;3651&#39;, <br>#&#39;3479&#39;, &#39;4091&#39;, &#39;14&#39;, &#39;14&#39;, &#39;2385&#39;, &#39;2258&#39;, <br>#&#39;2188&#39;, &#39;269&#39;]</pre><p>Pronto! Nosso corpus está devidamente tokenizado. Agora, o próximo passo é transformar esses identificadores de tokens em algo que vá além de números aleatórios — algo que carregue significado e seja capaz de representar a semântica de cada token. É nesse momento que os <strong><em>Embeddings</em></strong> entram em cena e brilham!</p><h3><strong>Conclusão</strong></h3><p>A tokenização é a ponte que conecta texto a números, mas é uma ponte cheia de buracos e obstáculos. Ela define como os modelos “enxergam” o mundo, mas também podem limitar sua capacidade de entender certos contextos. Apesar de seus problemas a tokenização ainda é indispensável.</p><p>Ao explorarmos as complexidades da tokenização, percebemos uma dança entre precisão semântica e eficiência computacional. A escolha do corpus e técnica de tokenização, assim como o tamanho do vocabulário são passos importantíssimos no caminho para desenvolver um LLM.</p><p>No próximo artigo, exploraremos outra peça fundamental no funcionamento dos grandes modelos de linguagem: os <strong>embeddings</strong>. Se o mecanismo de atenção é o coração dos LLMs, os embeddings são o sangue que flui, carregando os significados e relações complexas que sustentam toda a compreensão linguística do modelo.</p><p>Você pode acessar e acompanhar os artigos e códigos diretamente no meu github: <a href="https://github.com/z-fab/llm-zero/tree/master">https://github.com/z-fab/llm-zero/tree/master</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfaab5dc9488" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um LLM: entendendo os Grandes Modelos de Linguagem]]></title>
            <link>https://zfab.medium.com/construindo-um-llm-entendendo-os-grandes-modelos-de-linguagem-b37884219eaa?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/b37884219eaa</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Tue, 07 Jan 2025 21:26:45 GMT</pubDate>
            <atom:updated>2025-01-07T21:26:45.907Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cwA3TD6mgVnUCxRSo4sQ0w.png" /></figure><h4>Aprendendo como um LLM funciona construindo um do zero!</h4><p>Já se perguntou como o ChatGPT, Gemini, Claude e outros modelos de linguagem funcionam? Onde vivem, do que se alimentam?</p><p>Este é o <strong>primeiro de uma série de posts</strong> em que exploraremos o funcionamento dos Modelos de Linguagem de Grande Escala (LLMs). Para compreender profundamente esses modelos, iremos desenvolver e treinar um do zero usando Pytorch.</p><p>Embora o nosso modelo não chegue nem perto do tamanho dos citados anteriormente, ele será suficiente para compreendermos como a tecnologia funciona.</p><p>Esta série está dividida em <strong>8</strong> <strong>partes</strong>:</p><ol><li><strong>Introdução</strong> <em>(Você está aqui!)</em></li><li><em>Tokenização</em></li><li><em>Embedding</em></li><li><em>Mecanismo de Atenção</em></li><li><em>Arquitetura Transformer</em></li><li><em>Criando um GPT</em></li><li><em>Treinando um Foundational Model</em></li><li><em>Especializando</em></li></ol><h3><strong>O que é um Modelo de Linguagem de Grande Escala (LLM)?</strong></h3><p>Os LLMs têm revolucionado o campo do processamento de linguagem natural (NLP), demonstrando uma notável versatilidade — desde a composição de ensaios e poemas até a elaboração de códigos de computador.</p><p>São Modelos por que conseguem, com base em informações fornecidas, emular a realidade; são de Linguagem já que o que emulam é a escrita humana e são de grande escala porque contêm bilhões de parâmetros — números que dizem “para onde” o modelo deve ir. Tudo isso para atingir um simples objetivo: dado uma sequencia de palavras, qual a próxima mais provável baseado em todos os exemplos vistos durante o treinamento.</p><p>Durante muito tempo, diversas técnicas foram criadas para resolver o problema de gerar texto de forma sintética; no entanto, todas apresentavam alguns problemas que dificultavam a resolução de maneira satisfatória.</p><p>O grande salto no desenvolvimento desse tipo de modelo ocorreu a partir de uma nova arquitetura de redes neurais, introduzida no artigo de 2017 intitulado “<a href="https://arxiv.org/abs/1706.03762">Attention is All You Need</a>”. Essa nova forma de organizar as camadas e neurônios foi chamada de <strong>Transformers</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pOU0bG7ZDTnPJpNvgAP6Bg.png" /><figcaption>Fonte: Harnessing the Power of LLMs in Practice: A Survey on ChatGPT and Beyond (<a href="https://arxiv.org/pdf/2304.13712">https://arxiv.org/pdf/2304.13712</a>)</figcaption></figure><p>As redes Transformers são uma arquitetura de aprendizado profundo que utiliza <strong>mecanismo de autoatenção</strong>, o que permite ao modelo pesar a importância de diferentes palavras em uma frase, tornando-o excepcionalmente bom em entender contextos. Essa inovação revolucionou o campo do processamento de linguagem natural, superando as limitações das redes neurais recorrentes (RNNs) e das redes neurais convolucionais (CNNs), usadas anteriormente.</p><blockquote>A palavra banco pode significar diferentes coisas dependendo do contexto em que ela está sendo usada: “Fui ao banco sacar dinheiro” é diferente de “Me sentei no banco da praça” que por sua vez não tem nada a ver com “Meu barco encalhou em um banco de areia”</blockquote><p>Uma das principais vantagens dos Transformers é sua capacidade de <strong>processar, de forma paralelizável, longas sequências de texto</strong>. Como resultado, podemos manter informações contextuais relevantes, melhorando significativamente a compreensão e a geração dos texto.</p><p>Essa combinação de processamento paralelo (em GPUs) e capacidade de lidar com sequências longas torna as Transformers particularmente eficazes para tarefas de processamento de linguagem em larga escala. Isso explica por que essa arquitetura se tornou a base para muitos dos modelos mais avançados e bem-sucedidos da atualidade.</p><h3><strong>Arquitetura Transformer</strong></h3><p>A arquitetura clássica proposta no paper de Vaswani et al., que introduziu os Transformers, é caracterizada por uma estrutura em camadas composta por dois módulos principais: o <strong>codificador</strong> (encoder) e o <strong>decodificador</strong> (decoder). O <strong>codificador</strong> é responsável por processar a entrada e gerar representações contextuais ricas, capturando as relações entre os elementos da sequência de entrada. Já o <strong>decodificador</strong> utiliza essas representações para gerar a sequência de saída, seja traduzindo textos, gerando texto ou realizando outras tarefas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9vwasDQPfd44PM0Ql7S0AQ.png" /><figcaption>Arquitetura Transformer apresentada no paper Attention is All you Need</figcaption></figure><p>Um dos aspectos mais revolucionários dessa arquitetura é o mecanismo de <strong>autoatenção</strong> (self-attention), presente em ambos os módulos. Esse mecanismo permite que o modelo avalie, de forma dinâmica e simultânea, as relações entre todas as palavras na sequência de entrada. Em vez de processar as palavras de maneira isolada ou sequencial, como em modelos tradicionais baseados em RNNs, a autoatenção possibilita que cada palavra “observe” todas as outras, capturando nuances contextuais essenciais. Isso é particularmente importante para entender palavras que possuem múltiplos significados, cuja interpretação depende de seu contexto.</p><p>Outro avanço notável dos Transformers é a substituição das conexões sequenciais, típicas em arquiteturas como <strong>LSTMs</strong>, por um <strong>processamento paralelo</strong>, possibilitado pelo mecanismo de autoatenção. Isso aumenta significativamente a eficiência computacional, permitindo o treinamento de modelos em grandes conjuntos de dados e em menor tempo.</p><p>Além disso, a adoção de embeddings posicionais permite que a arquitetura codifique informações sobre a posição dos tokens na sequência, compensando a ausência de uma estrutura sequencial explícita no design do Transformer (viés indutivo). Essa combinação de atenção e posição reforça a capacidade do modelo de capturar padrões linguísticos complexos.</p><p>A invenção dos Transformers trouxe significativos avanços no campo do processamento de linguagem, além de dar origem a diversas variações da arquitetura, cada uma voltada para problemas específicos. Exemplos incluem o <strong>BERT</strong>, que se especializa em tarefas de compreensão de conteúdo, e o <strong>GPT</strong>, otimizado para a geração de texto. Esses modelos continuam a evoluir, consolidando o Transformer como uma das inovações mais impactantes na história recente da inteligência artificial.</p><h3><strong>Um Olhar Mais Atento aos Modelos GPT</strong></h3><p>A série <strong>GPT</strong> (Generative Pre-trained Transformer), ou Transformador Pré-treinado Generativo, representa uma das maiores inovações no campo do processamento de linguagem natural (NLP), tornando-se a arquitetura que melhor resolveu o problema da geração de texto e estabelecendo a base para os atuais Modelos de Linguagem de Grande Escala (LLMs).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XBvqLrR5z2kZJVUTpbzTxQ.png" /><figcaption>Arquitetura GPT baseada no modelo GPT-2 da OpenAI</figcaption></figure><p>Os modelos GPT utilizam exclusivamente a parte do <strong>decodificador</strong> da arquitetura Transformer, explorando ao máximo suas capacidades para gerar texto de maneira sequencial e contextualizada. O processo de geração ocorre uma palavra por vez, em um fluxo conhecido como <strong>geração autorregressiva</strong>. Nesse método, cada palavra gerada é condicionada pelo contexto formado pelas palavras anteriores, permitindo que o modelo produza textos coerentes, fluídos e contextualmente relevantes, mesmo em tarefas complexas.</p><p>O que torna os modelos GPT verdadeiramente notáveis são seus <strong>comportamentos emergentes</strong> — habilidades que não foram explicitamente programadas, mas que surgem como subprodutos do treinamento em larga escala. Por exemplo, o GPT-3, projetado para prever a próxima palavra em uma sequência, demonstrou capacidades surpreendentes em tarefas como tradução automática, geração de código, resposta a perguntas, resumo de textos e até mesmo raciocínio lógico básico.</p><p>Esses comportamentos <strong>emergem porque o treinamento em grandes volumes de texto</strong> permite ao modelo capturar padrões linguísticos e semânticos de forma incrivelmente rica.</p><h3><strong>Construindo um Modelo: O Processo</strong></h3><p>Diferentemente do que muitos imaginam, a construção de um modelo de linguagem de grande porte (LLM, na sigla em inglês) é um processo complexo que envolve várias etapas de treinamento, cada uma com objetivos e métodos específicos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GdgL7qR19_4MP6pjeCskGg.png" /></figure><h4><strong>1. Pré-treinamento: Construindo a base do modelo</strong></h4><p>A primeira fase, chamada de <strong>pré-treinamento</strong>, é o alicerce da modelagem de um LLM, como o GPT (Generative Pre-trained Transformer). Nessa etapa, o modelo é treinado em uma vasta quantidade de texto proveniente de diversas fontes, como livros, sites, artigos científicos, fóruns e outros materiais textuais. Essa exposição massiva permite que o modelo aprenda com trilhões de palavras e, com isso, desenvolva uma compreensão profunda das estruturas linguísticas, relações semânticas e contextuais, além de um conhecimento geral abrangente sobre inúmeros temas.</p><p>Por exemplo, o GPT-3 da OpenAI foi treinado em centenas de bilhões de palavras, utilizando uma ampla diversidade de dados para alcançar uma versatilidade única. Esse treinamento é essencial para garantir que o modelo possa lidar com diferentes estilos de escrita, tópicos e contextos, tornando-o capaz de gerar textos coesos e informativos sobre praticamente qualquer assunto.</p><p>O produto dessa etapa são os <strong>Modelos Fundacionais</strong>, que possuem um elevado nível de entendimento da linguagem e das estruturas textuais. No entanto, nesta fase, suas capacidades são limitadas: eles podem completar frases e gerar textos com qualidade impressionante, mas ainda carecem de habilidades especializadas. Para torná-los ferramentas úteis e adaptadas a tarefas específicas, é necessário avançar para a próxima etapa.</p><h4><strong>2. Fine-tuning: Especialização do modelo</strong></h4><p>O <strong>fine-tuning</strong>, ou ajuste fino, é a etapa em que o modelo fundacional é refinado para desempenhar funções específicas. Nesta fase, ele é treinado novamente, mas agora com conjuntos de dados menores e cuidadosamente selecionados, que atendem a objetivos específicos. Esses dados podem ser anotados por especialistas, garantindo que o modelo adquira um entendimento mais profundo de tarefas como classificação de sentimentos, análise de dados ou geração de conteúdo especializado.</p><p>Por exemplo, se o objetivo é transformar o modelo em um chatbot, é durante o fine-tuning que ele aprende padrões de conversação, bem como o comportamento esperado em interações humanas. O modelo é ensinado a responder perguntas, resolver problemas e seguir instruções, sempre priorizando a coerência e a utilidade.</p><p>Essa etapa é especialmente importante porque ajusta o modelo para aplicações práticas, tornando-o apto a lidar com demandas específicas de diferentes área.</p><h4><strong>3. Alinhamento: Garantindo segurança e ética</strong></h4><p>A terceira etapa, presente em muitos dos modelos conversacionais em uso atualmente, como o ChatGPT, é o <strong>alinhamento</strong>. Após o fine-tuning, o modelo já é capaz de realizar tarefas específicas e interagir em conversas, mas suas respostas podem não ser ideais em termos de segurança, ética ou relevância.</p><p>O alinhamento tem como objetivo principal ajustar o comportamento do modelo para que suas respostas sejam “alinhadas com as expectativas” humanas. Para tanto as resposta devem ser seguras, evitando a geração de conteúdos prejudiciais ou enganosos, éticas, respeitando valores sociais e culturais, bem como direitos humanos, e contextualmente adequadas, garantindo que as respostas estejam alinhadas ao que o usuário espera ou precisa.</p><p>Essa etapa utiliza técnicas como o aprendizado por reforço com feedback humano (<strong>RLHF</strong> — Reinforcement Learning with Human Feedback) e a Otimização Direta de Preferência (<strong>DPO</strong> — Direct Preference Optimization). Essas abordagens permitem que os modelos sejam ajustados com base nas preferências humanas, promovendo uma interação mais intuitiva e natural entre o usuário e a inteligência artificial.</p><h3><strong>Conclusão</strong></h3><p>Explorar o universo dos Modelos de Linguagem de Grande Escala (LLMs) é um convite para <strong>desvendar uma das tecnologias mais revolucionárias da inteligência artificial dos últimos anos</strong>. Os Transformers nem de longe inventaram a área de IA ou Machine Learning, mas sem dúvidas são os responsáveis pela explosão de produtos e soluções que estamos assistindo nos últimos anos.</p><p>Neste artigo demos o primeiro passo em uma jornada que nos permitirá compreender os fundamentos desses modelos. Nos próximos posts dessa série criaremos e treinaremos nosso próprio modelo, obviamente de maneira simplificada e limitada mas que nos ajudará a entender conceitos como <strong>tokenização</strong>, <strong>embeddings</strong> e <strong>autoatenção</strong> que colaboram para formar as bases de sistemas tão poderosos.</p><p>Mais do que aprender sobre os aspectos técnicos, este projeto é uma oportunidade de reconhecer como os LLMs impactam a sociedade — desde suas capacidades emergentes até os desafios de <strong>alinhamento ético e de segurança</strong>. À medida que avançamos nos próximos capítulos, mergulharemos em cada camada dessa tecnologia fascinante, desmistificando o que está por trás dos produtos que já fazem parte do nosso cotidiano.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b37884219eaa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Governança de TI no Ciclo de Vida de Modelos de Machine Learning]]></title>
            <link>https://zfab.medium.com/governan%C3%A7a-de-ti-no-ciclo-de-vida-de-modelos-de-machine-learning-f03ed8a21ead?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f03ed8a21ead</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[governance]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Fri, 20 Dec 2024 20:45:29 GMT</pubDate>
            <atom:updated>2024-12-20T20:45:29.865Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NiPNAS8KS4VuD3C7W2gG5g.png" /></figure><h4>A ascensão do Machine Learning (ML) e da Inteligência Artificial (IA) transformou setores inteiros e trouxe novos desafios para segurança, privacidade e ética.</h4><p>Modelos de ML não são neutros. Desde a coleta de dados até sua implementação em ambientes de produção, existem decisões e variáveis que podem introduzir vieses, comprometer a privacidade ou simplesmente gerar resultados imprecisos. A falta de governança pode amplificar esses problemas, resultando em violações de privacidade, decisões enviesadas e até danos à reputação das organizações.</p><p>Governança de TI aplicada ao ciclo de vida do ML é sobre mitigar riscos e maximizar benefícios. Desde a concepção até a descontinuação de um modelo, é essencial garantir que cada etapa esteja alinhada com padrões éticos, regulatórios e organizacionais.</p><h3>Os pilares do ciclo de vida do ML e seus desafios</h3><p>Cada fase do ciclo de vida de um modelo de Machine Learning carrega suas particularidades e desafios específicos, mas é a abordagem integrada e estratégica que garante o sucesso do projeto como um todo. Ignorar ou subestimar uma única etapa pode comprometer os resultados esperados, criando um efeito dominó que afeta tanto os objetivos de negócio quanto a confiança na tecnologia.</p><blockquote>É importante entender que o ciclo de vida não é linear. Muitas vezes, insights obtidos na operação podem demandar ajustes no design, e novas exigências regulatórias podem forçar uma reavaliação total dos modelos.</blockquote><h4>Design: Onde tudo começa</h4><p>O design é a base sobre a qual todo o modelo de Machine Learning será construído. É nesta fase que decisões estratégicas são tomadas, definindo o sucesso ou o fracasso do projeto. A escolha do algoritmo, da arquitetura do modelo e a curadoria dos dados são elementos críticos que influenciam diretamente na eficiência, interpretabilidade e confiabilidade do sistema.</p><p>Um dos maiores desafios do design é garantir que os dados sejam representativos e livres de vieses. Isso significa avaliar a origem dos dados, identificar possíveis lacunas ou desbalanceamentos. Bases de dados historicamente enviesadas, por exemplo, podem reforçar preconceitos raciais, de gênero ou socioeconômicos, gerando sistemas que perpetuam discriminações.</p><p>Além disso, o design precisa considerar a explicabilidade e a segurança do modelo. Decisões sobre como o modelo tomará decisões (e como essas decisões serão explicadas) são fundamentais, especialmente em áreas sensíveis como saúde ou finanças. Arquiteturas mais complexas, como redes neurais profundas, exigem um cuidado redobrado, pois podem se tornar verdadeiras “caixas-pretas” difíceis de auditar.</p><h4>Desenvolvimento: O coração do processo</h4><p>O desenvolvimento é a fase onde a teoria encontra a prática. Aqui, os dados são preparados, o modelo é treinado e ajustado, e seu desempenho é testado rigorosamente. Esta etapa demanda atenção minuciosa para assegurar que o modelo atenda às expectativas técnicas e éticas.</p><p>A qualidade dos dados é o fator mais crítico nesta fase. Dados inconsistentes, com valores ausentes ou ruidosos, podem comprometer a eficácia do modelo.</p><p>Outro aspecto crucial é a validação do modelo. Testes rigorosos devem ser conduzidos para avaliar a capacidade do modelo de generalizar para novos dados. Isso inclui o uso de técnicas como validação cruzada, testes de desempenho em cenários adversos e análises de sensibilidade para verificar se pequenas alterações nos dados de entrada impactam de forma inesperada os resultados.</p><h4>Operação: Onde a mágica acontece (ou não)</h4><p>A operação é o momento da verdade. Após o modelo ser implantado, ele passa a interagir com dados reais, fornecendo insights ou automatizando processos. No entanto, este é também o estágio mais dinâmico e imprevisível, onde o monitoramento contínuo se torna indispensável.</p><p>Mudanças nos dados de entrada, como alterações em padrões de consumo ou contexto de mercado, podem comprometer a precisão e a relevância do modelo. Por isso, é fundamental implementar ferramentas de monitoramento que identifiquem anomalias, degradação de desempenho ou desvios de comportamento. Quando necessário, o modelo deve ser reavaliado, ajustado ou até mesmo substituído.</p><p>A operação também exige atenção especial à segurança. O modelo e seus dados estão expostos a possíveis ataques ou violações, como tentativas de manipular previsões ou explorar vulnerabilidades em APIs.</p><p>Além do desempenho técnico, é essencial garantir que as pessoas que utilizam o modelo compreendam seus resultados e limitações. Modelos de IA que geram decisões sem transparência podem causar resistência ou desconfiança, prejudicando a adoção da tecnologia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*kgh5f5mlrJtKDdZfx-QEGQ.gif" /></figure><h3>Governança na prática: como fazer funcionar?</h3><p>A governança de TI no ML não é apenas uma boa prática — é essencial — e requer foco em estrutura, processos e cultura organizacional. Algumas ações podem ser tomadas, como:</p><ol><li><strong>Estratégia e Política: </strong>Ter padrões claros desde o início, desde a escolha dos dados até a definição de métricas de desempenho, tudo deve ser documentado e seguir diretrizes bem estabelecidas para coleta, uso e proteção de dados, alinhadas a regulamentações como LGPD e GDPR.</li><li><strong>Monitoramento Contínuo:</strong> Não basta lançar um modelo e esperar o melhor. Ele precisa ser avaliado e ajustado constantemente. Implementar ferramentas para acompanhar o desempenho dos modelos em tempo real, detectando desvios e prevenindo obsolescência é importante. Realizar auditorias regulares para garantir conformidade também é recomendado.</li><li><strong>Explicabilidade:</strong> Modelos que atuam como “caixas-pretas” são uma receita para a desconfiança. Priorize modelos interpretáveis e forneça explicações claras sobre suas decisões. Isso aumenta a confiança e facilita o alinhamento com objetivos éticos e regulatórios.</li><li><strong>Estrutura Organizacional</strong>: Formar comitês multidisciplinares e estabeleça papéis específicos para supervisão e accountability. Grupos especializados podem compartilhar melhores práticas e garantir a conformidade. Crie canais para coletar feedback de usuários e stakeholders, utilizando essas informações para aprimorar os processos e os modelos.</li></ol><p>A governança de TI não é apenas sobre resolver problemas imediatos. Trata-se de construir um futuro onde ML e IA sejam ferramentas confiáveis, éticas e transformadoras. Com frameworks sólidos e foco na transparência, podemos transformar preocupações em oportunidades.</p><p>O papel das organizações, pesquisadores e legisladores é central. Afinal, o que está em jogo é mais do que eficiência operacional — é a confiança na tecnologia e sua capacidade de servir a sociedade de maneira justa e responsável.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f03ed8a21ead" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Detecção de Anomalias utilizando DBScan e XGBoost]]></title>
            <link>https://zfab.medium.com/detec%C3%A7%C3%A3o-de-anomalias-utilizando-dbscan-e-xgboost-939236a8e64b?source=rss-3efc579adea5------2</link>
            <guid isPermaLink="false">https://medium.com/p/939236a8e64b</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Fabricio Zillig]]></dc:creator>
            <pubDate>Mon, 02 Dec 2024 22:52:51 GMT</pubDate>
            <atom:updated>2024-12-02T22:52:51.208Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xmKKULPSOoI3fNt-Ua6tCQ.png" /></figure><h4>Utilizando técnicas de aprendizado de máquina para identificar comportamentos suspeitos em redes de computadores.</h4><p>Na era da informação, a detecção de invasões em redes de computadores é uma tarefa fundamental e desafiadora. A identificação precoce de comportamentos anômalos pode ser a diferença entre um sistema seguro e uma brecha que compromete informações críticas.</p><p>Neste artigo, exploramos a aplicação de técnicas de aprendizado de máquina, especificamente o algoritmo DBScan para detectar anomalias e o XGBoost para classificação, no contexto de comportamentos suspeitos.</p><blockquote>Você pode acessar o notebook com o código no <a href="https://github.com/z-fab/ppgca/blob/master/machine-learning/projeto/notebook/anomalia.ipynb"><strong>Github</strong></a></blockquote><h3>O Problema</h3><p>Os dados utilizados simulam um ambiente de rede militar típico da Força Aérea dos Estados Unidos, onde múltiplas conexões TCP/IP são submetidas a ataques simulados. Cada conexão recebe um rótulo indicando se é normal ou anômala. O objetivo é identificar padrões de comportamento suspeito que possam indicar potenciais invasões.</p><p>O conjunto de dados contém 41 variáveis por conexão — 3 qualitativas e 38 quantitativas — fornecendo uma visão abrangente das características do protocolo e dos serviços utilizados.</p><p>Nosso objetivo é identificar conexões suspeitas e treinar um modelo para classificar esses tipos de conexões.</p><blockquote><strong>Link do dataset:</strong> <a href="https://www.kaggle.com/datasets/sampadab17/network-intrusion-detection">https://www.kaggle.com/datasets/sampadab17/network-intrusion-detection</a></blockquote><h3>Construção da Solução</h3><p>A construção da solução envolve uma série de etapas, desde o pré-processamento dos dados até a implementação do algoritmo de classificação.</p><p>Nossa abordagem combina dois modelos: o <strong>DBScan</strong> para identificar outliers (possíveis anomalias) e o <strong>XGBoost para classificar</strong> esses tipos de conexões anômalas, criando assim um sistema de detecção de invasões.</p><h3>Pré Processamento dos Dados</h3><p>O primeiro passo para a construção do modelo é o pré-processamento dos dados. Carregamos o dataset, realizamos a normalização dos valores numéricos e transformamos as variáveis categóricas em variáveis dummy para assegurar que possam ser utilizadas pelos algoritmos.</p><p>A normalização é uma etapa crucial, pois o DBScan utiliza distâncias euclidianas em seus cálculos e diferentes escalas podem prejudicar o algoritmo. O MinMaxScaler garante que todas as features fiquem na mesma escala (entre 0 e 1), impedindo que features com valores maiores dominem o cálculo das distâncias em relação às features com valores menores.</p><pre>import polars as pl<br>from sklearn.preprocessing import MinMaxScaler<br><br># Carregando o dataset<br>df_raw = pl.read_csv(&#39;../data/data.csv&#39;)<br>df_raw.sample(5)<br><br># Normalização dos dados<br>scaler = MinMaxScaler().set_output(transform=&quot;polars&quot;)<br>df_scaled = scaler.fit_transform(df_raw.drop([&quot;protocol_type&quot;, &quot;service&quot;, &quot;flag&quot;, &quot;class&quot;]))<br><br># Criando variáveis dummies<br>df_dummies = df_raw.select([&quot;protocol_type&quot;, &quot;service&quot;]).to_dummies()<br><br># Transformando target em variável binária<br>df_target = df_raw.select(<br>    pl.when(df_raw[&quot;class&quot;] == &quot;anomaly&quot;).then(1).otherwise(0).alias(&quot;target&quot;)<br>)<br><br># Concatenando todos os dados processados<br>df_processed = pl.concat([df_scaled, df_dummies, df_target], how=&quot;horizontal&quot;)<br>df_processed.sample(5)p</pre><p>Um passo crucial foi a criação de <strong>variáveis dummy</strong> para as variáveis categóricas e a conversão da target para formato binário.</p><p>Essa transformação garante que as variáveis <strong>possam ser processadas por algoritmos de aprendizado de máquina</strong> de maneira adequada. A técnica de <em>One-Hot Encoding</em> é particularmente útil para representar variáveis categóricas sem introduzir ordens arbitrárias que poderiam afetar a interpretação do modelo.</p><h3>Detecção de Anomalias com DBScan</h3><p>O <a href="https://scikit-learn.org/stable/auto_examples/cluster/plot_dbscan.html">DBScan</a> (Density-Based Spatial Clustering of Applications with Noise) é um algoritmo de clustering que detecta anomalias ao considerar pontos que não pertencem a grupos densos como ruídos.</p><p>Diferente de algoritmos como o K-means, o DBScan não requer que o número de clusters seja pré-definido, o que o torna ideal para a detecção de anomalias em um contexto onde não se conhece a quantidade de clusters e outliers previamente.</p><h4>Definindo Atributos e Variáveis Alvo</h4><p>Inicialmente, definimos nosso conjunto de atributos (<em>X</em>) e nossa variável alvo (<em>y</em>).</p><p>É importante destacar que, embora utilizemos os rótulos para validar os melhores hiperparâmetros, isso não é necessário, já que o DBScan é um algoritmo não supervisionado.</p><blockquote>Em um cenário real, essa abordagem não seria realizada, pois não teríamos as anomalias rotuladas.</blockquote><pre>X = df_processed.drop(&quot;target&quot;).to_numpy()<br>y = df_processed[&quot;target&quot;].to_numpy()</pre><p>Para determinar os melhores parâmetros do DBScan, realizamos uma busca em grade (Grid Search), variando o número mínimo de pontos (<em>min_samples</em>) e a distância máxima entre os pontos (<em>eps</em>). Como nosso objetivo é identificar ataques, focamos em maximizar o <em>recall</em>, garantindo a minimização dos falsos negativos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VqQBNHYafu9J4I-b.png" /><figcaption>Fonte: Wikipédia — <a href="https://en.wikipedia.org/wiki/Hyperparameter_optimization">https://en.wikipedia.org/wiki/Hyperparameter_optimization</a></figcaption></figure><p>Minimizar falsos negativos é especialmente relevante neste contexto de segurança, uma vez que ataques não detectados podem comprometer seriamente a integridade do sistema. O uso do Grid Search nos permite testar múltiplas combinações de hiperparâmetros para garantir que estamos otimizando o modelo para o cenário desejado.</p><pre>from sklearn.metrics import precision_score, recall_score<br>from sklearn.cluster import DBSCAN<br><br>def grid_search_dbscan(X, y, min_samples_range, eps_range):<br>    results = []<br>    for min_samples in min_samples_range:<br>        for eps in eps_range:<br>            dbscan = DBSCAN(eps=eps, min_samples=min_samples, n_jobs=-1)<br>            labels = dbscan.fit_predict(X)<br>            labels_anomaly = np.where(labels == -1, 1, 0)<br>            precision = precision_score(y, labels_anomaly)<br>            recall = recall_score(y, labels_anomaly)<br>            f1 = 2 * (precision * recall) / (precision + recall)<br>            accuracy = (labels_anomaly == y).mean()<br>            results.append({<br>                &quot;min_samples&quot;: min_samples,<br>                &quot;eps&quot;: eps,<br>                &quot;precision&quot;: precision,<br>                &quot;recall&quot;: recall,<br>                &quot;f1&quot;: f1,<br>                &quot;accuracy&quot;: accuracy<br>            })<br>    return results<br>grid_search_results = grid_search_dbscan(<br>    X, y, min_samples_range=[5, 100, 500, 1000, 2000, 5000], eps_range=[0.1, 0.3, 0.5, 0.7, 1.0, 1.5]<br>)</pre><p>Com os resultados da busca em grade, selecionamos os parâmetros que proporcionam o <strong>maior <em>recall</em></strong>. Além disso, transformamos o resultado do agrupamento (labels) em uma variável binária, sinalizando os registros marcados como outlier (label igual a -1)</p><pre># Seleção dos melhores parâmetros<br>dbscan = DBSCAN(eps=0.5, min_samples=5000, n_jobs=-1)<br>labels = dbscan.fit_predict(X)<br>labels_anomaly = np.where(labels == -1, 1, 0)</pre><h3>Treinando um Modelo de Classificação</h3><p>Com os registros classificados entre anomalia e não anomalia, podemos desenvolver um modelo supervisionado para predizer futuros registros nessas categorias.</p><blockquote>É importante ressaltar que consideramos um cenário <strong>sem dados previamente anotados</strong> (variável target) — este é o motivo pelo qual utilizamos o DBScan para realizar essa anotação inicial.</blockquote><p>Para a classificação, escolhemos o <strong>XGBoost</strong> (eXtreme Gradient Boosting), o queridinho dos dados tabulares. Ele é uma implementação otimizada do <strong>Gradient Boosting</strong>, destacando-se pela eficiência computacional e capacidade de lidar com dados desbalanceados — característica comum em problemas de detecção de anomalias.</p><p>O XGBoost constrói <strong>árvores de decisão de forma iterativa</strong>, onde cada nova árvore <strong>corrige os erros das anteriores</strong>. Este processo de “boosting” permite que o modelo aprenda padrões complexos e seja mais robusto a outliers. O algoritmo também inclui técnicas de regularização que previnem overfitting.</p><h4>Divisão dos Dados e Busca de Hiperparâmetros</h4><p>Dividimos o conjunto de dados em treino e teste, realizando a normalização dos atributos novamente para assegurar a consistência dos dados:</p><pre>scaler = MinMaxScaler().set_output(transform=&quot;polars&quot;)<br>df_scaled = scaler.fit_transform(<br>    df_raw.drop([&quot;protocol_type&quot;, &quot;service&quot;, &quot;flag&quot;, &quot;class&quot;])<br>)<br><br>df_dummies = df_raw.select([&quot;protocol_type&quot;, &quot;service&quot;]).to_dummies()<br><br>df_processed = pl.concat([df_scaled, df_dummies], how=&quot;horizontal&quot;)<br><br>X = df_processed.to_numpy()<br><br>X_train, X_test, y_train, y_test = train_test_split(<br> X, labels_anomaly, test_size=0.2, random_state=13<br>)</pre><p>Para encontrar os melhores hiperparâmetros do XGBoost, utilizamos o <a href="https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html"><strong>GridSearchCV</strong></a> com 3 folds de validação cruzada. Esta técnica divide o conjunto de dados em 3 subconjuntos (folds) de tamanho igual. A cada iteração, 2 folds são usados para treinar o modelo, enquanto o terceiro é usado para validação. O processo se repete 3 vezes, alternando o fold de validação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/0*ReY2w8OoZDHZp5ik.png" /><figcaption>Fonte: Scikit Learn — <a href="https://scikit-learn.org/1.5/modules/cross_validation.html">https://scikit-learn.org/1.5/modules/cross_validation.html</a></figcaption></figure><p>Esta abordagem proporciona uma avaliação mais robusta do modelo, pois cada observação participa tanto do treino quanto da validação. Isso reduz o viés que poderia surgir de uma única divisão treino-teste.</p><p>Com 3 folds, cada observação é usada duas vezes para treino e uma vez para validação, resultando em uma estimativa mais confiável dos hiperparâmetros ideais.</p><pre>from xgboost import XGBClassifier<br>from sklearn.model_selection import GridSearchCV<br><br># Definindo o modelo<br>xgb = XGBClassifier(eval_metric=&#39;logloss&#39;)<br><br># Definindo os parâmetros para a busca em grade<br>param_grid = {<br>    &#39;n_estimators&#39;: [100, 200, 300],<br>    &#39;learning_rate&#39;: [0.01, 0.1, 0.2],<br>    &#39;max_depth&#39;: [3, 5, 7],<br>    &#39;subsample&#39;: [0.8, 1.0],<br>    &#39;colsample_bytree&#39;: [0.8, 1.0]<br>}<br><br># Configurando o GridSearchCV<br>grid_search = GridSearchCV(estimator=xgb, param_grid=param_grid, scoring=&#39;accuracy&#39;, cv=3, n_jobs=-1, verbose=2)<br><br># Executando o Grid Search<br>grid_search.fit(X_train, y_train)<br><br># Exibindo os melhores parâmetros<br>print(&quot;Melhores parâmetros encontrados: &quot;, grid_search.best_params_)<br>print(&quot;Melhor pontuação: &quot;, grid_search.best_score_)</pre><h4>Treinamento e Avaliação do Modelo</h4><p>Com os melhores parâmetros definidos, treinamos o modelo final e avaliamos suas métricas no conjunto de teste</p><pre>from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score<br><br># Usando os melhores parâmetros encontrados para treinar o modelo<br>best_params = grid_search.best_params_<br>xgb_best = XGBClassifier(**best_params, eval_metric=&#39;logloss&#39;)<br><br># Treinando o modelo com os melhores parâmetros<br>xgb_best.fit(X_train, y_train)<br><br># Fazendo previsões no conjunto de teste<br>y_pred = xgb_best.predict(X_test)<br><br># Calculando métricas de desempenho<br>accuracy = accuracy_score(y_test, y_pred)<br>precision = precision_score(y_test, y_pred)<br>recall = recall_score(y_test, y_pred)<br>f1 = f1_score(y_test, y_pred)<br>print(f&quot;Accuracy: {accuracy}&quot;)<br>print(f&quot;Precision: {precision}&quot;)<br>print(f&quot;Recall: {recall}&quot;)<br>print(f&quot;F1 Score: {f1}&quot;)</pre><p>Em nosso conjunto de teste, alcançamos resultados excepcionais, com <strong>métricas superiores a 0,99</strong>. Isso demonstra que nosso modelo desenvolveu uma excelente capacidade de diferenciar anomalias.</p><h3>Na prática</h3><p>No mundo real, o sistema descrito neste artigo poderia ser implementado para monitorar redes corporativas ou governamentais, onde a segurança dos dados é crítica.</p><p>O sistema funcionaria coletando dados em tempo real das conexões de rede, aplicando um pré-processamento semelhante ao descrito, e então utilizando o modelo XGBoost treinado para identificar anomalias em tempo real, sinalizando eventos que poderiam representar ameaças.</p><p>Para tornar a implementação viável em um ambiente de produção, algumas adaptações seriam necessárias:</p><ol><li><strong>Coleta de Dados em Tempo Real</strong>: Seria necessário configurar uma infraestrutura para coleta contínua de dados, como logs de rede, que alimentariam o sistema de detecção.</li><li><strong>Pipeline Automatizado</strong>: O pré-processamento dos dados, incluindo a normalização e transformação de variáveis categóricas, precisaria ser automatizado para permitir uma resposta rápida às novas entradas de dados.</li><li><strong>Integração com Sistemas de Segurança</strong>: A integração com sistemas de resposta a incidentes permitiria que as ameaças identificadas fossem tratadas de forma automatizada ou semiautomatizada, minimizando os riscos e o tempo de resposta.</li><li><strong>Escalabilidade</strong>: Garantir que o sistema seja escalável para lidar com grandes volumes de dados em redes de larga escala, utilizando técnicas como paralelismo e distribuição de processamento.</li><li><strong>Coleta e Rotulação de Ataques</strong>: É fundamental manter um processo contínuo de coleta e rotulação de novos ataques identificados, permitindo o retreinamento periódico do modelo XGBoost para mantê-lo atualizado com as mais recentes ameaças.</li></ol><p>Dessa forma, o sistema teria a capacidade de monitorar continuamente a rede, identificar e classificar anomalias e gerar alertas ou tomar ações corretivas de maneira eficaz, contribuindo para a segurança de ambientes críticos.</p><h3>Conclusão</h3><p>Neste artigo, exploramos como o DBScan pode ser utilizado para detectar anomalias em acessos de rede e como utilizar uma XGBoost para prever futuros registros.</p><p>Podemos ainda explorar outras técnicas e algoritmos de aprendizado de máquina para comparar os resultados e buscar uma solução que maximize tanto a precisão quanto o <em>recall</em>. Exemplos incluem o uso de redes neurais, como redes neurais recorrentes (RNNs) ou redes neurais convolucionais (CNNs).</p><p>A aplicação de técnicas mais sofisticadas e o ajuste fino dos parâmetros dos modelos também são caminhos promissores para futuras melhorias e aperfeiçoamento dos sistemas de detecção de intrusões.</p><p>É fundamental nesse cenário manter um processo contínuo de coleta e rotulação de novos ataques, permitindo o <strong>retreinamento periódico do modelo</strong> para mantê-lo atualizado.</p><p><em>Este artigo foi desenvolvido e criado como parte da disciplina de Aprendizado de Máquina no Mestrado em Computação Aplicada</em></p><p><em>Realizado em conjunto com </em><a href="https://medium.com/@danmangabeira"><em>Daniel Mangabeira</em></a><em> e Beatriz Bonanno</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=939236a8e64b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>