Close Menu
    Trending
    • Implementing IBCS rules in Power BI
    • What comes next for AI copyright lawsuits?
    • Why PDF Extraction Still Feels LikeHack
    • GenAI Will Fuel People’s Jobs, Not Replace Them. Here’s Why
    • Millions of websites to get ‘game-changing’ AI bot blocker
    • I Worked Through Labor, My Wedding and Burnout — For What?
    • Cloudflare will now block AI bots from crawling its clients’ websites by default
    • 🚗 Predicting Car Purchase Amounts with Neural Networks in Keras (with Code & Dataset) | by Smruti Ranjan Nayak | Jul, 2025
    AIBS News
    • Home
    • Artificial Intelligence
    • Machine Learning
    • AI Technology
    • Data Science
    • More
      • Technology
      • Business
    AIBS News
    Home»Machine Learning»Construindo um LLM do Zero: Bloco Transformer | by Fabricio Zillig | Feb, 2025
    Machine Learning

    Construindo um LLM do Zero: Bloco Transformer | by Fabricio Zillig | Feb, 2025

    Team_AIBS NewsBy Team_AIBS NewsFebruary 21, 2025No Comments4 Mins Read
    Share Facebook Twitter Pinterest LinkedIn Tumblr Reddit Telegram Email
    Share
    Facebook Twitter LinkedIn Pinterest Email


    Redes neurais profundas enfrentam dois grandes desafios durante o treinamento: Gradientes Explosivos (Exploding Gradient) — quando os pesos são atualizados de forma exponencial, desestabilizando o treinamento, e Gradientes Desaparecendo (Vanishing Gradient) — quando os gradientes se tornam tão pequenos que as camadas iniciais da rede praticamente param de aprender.

    Para evitar principalmente o problema do Vanishing Gradient, os Transformers utilizam Layer Normalization (LayerNorm), 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.

    Na equação do LayerNorm mostrada, temos:

    • x: é o valor de entrada a ser normalizado
    • μ (mu): é a média do vetor de entrada
    • σ² (sigma²): é a variância do vetor
    • ε (epsilon): é um pequeno valor para evitar divisão por zero

    Além disso, LayerNorm possui dois parâmetros treináveis:

    • γ (gamma): é um parâmetro treinável que ajusta a escala da normalização
    • β (beta): é um parâmetro treinável que adiciona um deslocamento para preservar a expressividade

    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.

    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.

    torch.manual_seed(42)

    inp = torch.randn(3, 6)
    layer = nn.Linear(6, 4)
    out = layer(inp)

    print(f"Entrada:n{inp}")
    print(f"Saida:n{out}")

    #OUTPUT
    # Entrada:
    # tensor([[ 1.9269, 1.4873, -0.4974, 0.4396, -0.7581, 1.0783],
    # [ 0.8008, 1.6806, 0.3559, -0.6866, 0.6105, 1.3347],
    # [-0.2316, 0.0418, -0.2516, 0.8599, -0.3097, -0.3957]])
    # Saida:
    # tensor([[ 0.3800, -0.5400, 0.5123, -0.4735],
    # [ 0.2889, -0.6716, 0.1246, 0.0287],
    # [ 0.6655, -0.0524, -0.1044, -0.1135]], grad_fn=)

    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.

    mean_out = out.imply(dim=-1, keepdim=True)
    var_out = out.var(dim=-1, keepdim=True, unbiased=False)

    print(f"Média:n{mean_out}")
    print(f"Variância:n{var_out}")
    #OUTPUT
    # Média:
    # tensor([[-0.0303],
    # [-0.0574],
    # [ 0.0988]], grad_fn=)
    # Variância:
    # tensor([[0.2297],
    # [0.1344],
    # [0.1076]], grad_fn=)

    É 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)

    out_norm = (out - mean_out) / torch.sqrt(var_out)
    mean_norm = out_norm.imply(dim=-1, keepdim=True)
    var_norm = out_norm.var(dim=-1, keepdim=True, unbiased=False)

    torch.set_printoptions(sci_mode=False) # Desabilita a notação científica

    print(f"Saida normalizada:n{out_norm}")
    print(f"Média:n{mean_norm}")
    print(f"Variância:n{var_norm}")

    #OUTPUT
    #Saida normalizada:
    #tensor([[ 0.8560, -1.0633, 1.1320, -0.9247],
    # [ 0.9444, -1.6753, 0.4963, 0.2346],
    # [ 1.7277, -0.4610, -0.6194, -0.6473]], grad_fn=)
    #Média:
    #tensor([[ -0.0000],
    # [ 0.0000],
    # [ 0.0000]], grad_fn=)
    #Variância:
    #tensor([[1.0000],
    # [1.0000],
    # [1.0000]], grad_fn=)

    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.

    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.

    Vamos agora criar uma classe de LayerNorm usando a fórmula que vimos acima e adicionando os dois parâmetros treináveis

    class LayerNorm(nn.Module):
    def __init__(self, embedding_size):
    tremendous().__init__()
    self.eps = 1e-6 # Epsilon para evitar divisão por zero
    self.scale = nn.Parameter(torch.ones(embedding_size)) # Gamma - Inicializando com 1 para não alterar a escala
    self.shift = nn.Parameter(torch.zeros(embedding_size)) # Beta - Inicializando com 0 para não alterar o deslocamento

    def ahead(self, x):
    imply = x.imply(dim=-1, keepdim=True)
    var = x.var(dim=-1, keepdim=True, unbiased=False)
    norm_x = (x - imply) / torch.sqrt(var + self.eps)
    return self.scale * norm_x + self.shift # Gamma * x_norm + Beta

    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.

    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.

    Vamos passar pela nossa camada de normalização o mesmo tensor que obtivemos anteriormente (3 tensores de tamanho 4)

    ln = LayerNorm(embedding_size=4)

    out_ln = ln(out)
    mean_ln = out_ln.imply(dim=-1, keepdim=True)
    var_ln = out_ln.var(dim=-1, unbiased=False, keepdim=True)

    print(f"Saida normalizada:n{out_ln}")
    print(f"Média:n{mean_ln}")
    print(f"Variância:n{var_ln}")

    #OUTPUT
    # Saida normalizada:
    # tensor([[ 0.8560, -1.0633, 1.1320, -0.9247],
    # [ 0.9444, -1.6753, 0.4963, 0.2346],
    # [ 1.7277, -0.4610, -0.6194, -0.6473]], grad_fn=)
    # Média:
    # tensor([[ -0.0000],
    # [ 0.0000],
    # [ 0.0000]], grad_fn=)
    # Variância:
    # tensor([[1.0000],
    # [1.0000],
    # [1.0000]], grad_fn=)

    Como podemos observar, o resultado foi exatamente o esperado: média zero e variância unitária, exatamente igual nossa conta anterior.

    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



    Source link

    Share. Facebook Twitter Pinterest LinkedIn Tumblr Email
    Previous ArticleAI Data Center Workaround? Startups Pursue Networked Aggregation of Idle GPUs
    Next Article Costco Shoppers Love Deals on Luxury Items: Gold Bars, Dom P
    Team_AIBS News
    • Website

    Related Posts

    Machine Learning

    Why PDF Extraction Still Feels LikeHack

    July 1, 2025
    Machine Learning

    🚗 Predicting Car Purchase Amounts with Neural Networks in Keras (with Code & Dataset) | by Smruti Ranjan Nayak | Jul, 2025

    July 1, 2025
    Machine Learning

    Reinforcement Learning in the Age of Modern AI | by @pramodchandrayan | Jul, 2025

    July 1, 2025
    Add A Comment
    Leave A Reply Cancel Reply

    Top Posts

    Implementing IBCS rules in Power BI

    July 1, 2025

    I Tried Buying a Car Through Amazon: Here Are the Pros, Cons

    December 10, 2024

    Amazon and eBay to pay ‘fair share’ for e-waste recycling

    December 10, 2024

    Artificial Intelligence Concerns & Predictions For 2025

    December 10, 2024

    Barbara Corcoran: Entrepreneurs Must ‘Embrace Change’

    December 10, 2024
    Categories
    • AI Technology
    • Artificial Intelligence
    • Business
    • Data Science
    • Machine Learning
    • Technology
    Most Popular

    Empty shelves but Co-op says payments fixed after cyber attack

    May 6, 2025

    ‘4-Hour Workweek’ Led to a $600,000 Side Hustle in 16 Months

    February 8, 2025

    Meerkat Substation Security: Protecting Energy Networks from Threats

    June 23, 2025
    Our Picks

    Implementing IBCS rules in Power BI

    July 1, 2025

    What comes next for AI copyright lawsuits?

    July 1, 2025

    Why PDF Extraction Still Feels LikeHack

    July 1, 2025
    Categories
    • AI Technology
    • Artificial Intelligence
    • Business
    • Data Science
    • Machine Learning
    • Technology
    • Privacy Policy
    • Disclaimer
    • Terms and Conditions
    • About us
    • Contact us
    Copyright © 2024 Aibsnews.comAll Rights Reserved.

    Type above and press Enter to search. Press Esc to cancel.