A suposição da LoRA que quebra a produção | NeuralNet IA

🇧🇷 O Que Isso Significa para o Brasil?

Com o crescimento do ecossistema de IA no país e discussões sobre regulação (PL 2338/2023), avanços em inteligência artificial, machine learning e automação impactam diretamente profissionais, startups e empresas brasileiras. Fique atento a:

• 🎓 Capacitação profissional: Demanda por habilidades em IA cresce 3x ao ano no mercado brasileiro
• ⚖️ Marco Regulatório: Proposta de lei sobre IA pode afetar desenvolvimento e uso de ferramentas
• 🏢 Adoção empresarial: Setores como saúde, jurídico e financeiro lideram implementação de IA no Brasil

LoRA é amplamente utilizado para ajustar modelos grandes porque é eficiente, mas assume silenciosamente que todas as atualizações de um modelo são semelhantes. Na realidade, eles não são. Quando você ajusta o estilo (como tom, formato ou personalidade), as mudanças são simples e concentradas em apenas algumas dimensões – que ela lida bem com atualizações de baixa classificação. Mas quando se tenta ensinar ao modelo novos conhecimentos factuais (como dados médicos ou estatísticas), a informação é espalhada por muitas dimensões. Uma configuração de classificação baixa (como classificação 8) não pode capturar tudo isso, então o modelo pode parecer correto, mas fornecer respostas erradas ou incompletas.

Tentar consertar isso aumentando a classificação introduz outro problema: instabilidade. À medida que a classificação aumenta, a escala padrão usada faz com que o sinal de aprendizagem enfraqueça, tornando o treinamento ineficaz. RS-LoRA resolve isso ajustando ligeiramente a fórmula de escala (alterando de divisão por R à divisão por √r), o que estabiliza a aprendizagem mesmo em níveis mais elevados. Essa pequena mudança permite que o modelo retenha melhor informações complexas e de alta dimensão sem interromper o treinamento.

No passo a passo do código abaixo, demonstramos essa falha desde os primeiros princípios usando NumPy – sem loops de treinamento, sem estruturas. Simulamos dois tipos de atualizações de peso, medimos exatamente quanta informação sobrevive em cada classificação e expomos a falha secundária: aumentar ingenuamente a classificação para compensar desencadeia um colapso de escala que mata totalmente o sinal de aprendizagem. Em seguida, mostramos a correção – escala estabilizada de classificação do RS-LoRA – e por que uma única mudança de caractere no denominador (r → √r) é o que torna a adaptação de classificação alta estável.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
 
np.random.seed(42)

Nesta configuração, estamos simulando como o ajuste fino afeta a matriz de pesos de um modelo, criando um ambiente simplificado. Assumimos uma matriz de pesos pré-treinada de tamanho 64×64 e introduzimos dois tipos de atualizações: mudanças de “estilo” de baixa classificação (como tom ou formatação) e mudanças de “fatos” de alta classificação (como estatísticas detalhadas de críquete). Em seguida, definimos duas configurações de LoRA – uma classificação pequena (r=4), que representa o uso típico de LoRA, e uma classificação maior (r=32), que é mais adequada para capturar informações complexas como no RS-LoRA. Isso nos permite comparar quão bem diferentes classificações podem recuperar essas atualizações simuladas e destacar onde o LoRA padrão tem dificuldades.

d, k = 64, 64          # weight matrix dimensions
r_low  = 4             # LoRA rank -- small (standard choice)
r_high = 32            # LoRA rank -- large (RS-LoRA compatible)
 
print(f"Weight matrix shape : ({d} x {k})")
print(f"Low  rank (standard): r = {r_low}")
print(f"High rank (RS-LoRA) : r = {r_high}")
print(f"Max possible rank   : {min(d, k)}")

Aqui, simulamos os dois tipos fundamentalmente diferentes de atualizações de ajuste fino. A atualização de estilo é intencionalmente construída como de classificação baixa: apenas alguns valores singulares são grandes e o restante desaparece rapidamente, o que significa que a maioria das informações importantes está concentrada em apenas algumas dimensões. Isso reflete o comportamento do mundo real, onde as alterações de tom ou formatação não exigem modificação generalizada do modelo.

Em contraste, a atualização dos fatos é de alto nível: os valores singulares decaem lentamente, indicando que muitas dimensões contribuem com informações significativas. Isto reflete como o conhecimento factual (como estatísticas ou dados de domínio) é distribuído no modelo. Os valores singulares impressos deixam isso claro: as atualizações de estilo mostram uma queda acentuada após os primeiros valores, enquanto as atualizações de fatos permanecem consistentemente grandes em muitas dimensões, provando que não podem ser facilmente compactadas em uma aproximação de classificação inferior.

def make_low_rank_delta(d, k, true_rank, noise=0.01):
    """Simulates a style update -- low intrinsic rank."""
    U = np.random.randn(d, true_rank)
    S = np.linspace(5, 0.5, true_rank)   # fast-decaying singular values
    V = np.random.randn(k, true_rank)
    U, _ = np.linalg.qr(U)
    V, _ = np.linalg.qr(V)
    delta = (U[:, :true_rank] * S) @ V[:, :true_rank].T
    delta += noise * np.random.randn(d, k)
    return delta
 
def make_high_rank_delta(d, k, noise=0.01):
    """Simulates a fact/knowledge update -- high intrinsic rank."""
    U = np.random.randn(d, d)
    S = np.linspace(3, 0.5, min(d, k))   # slow-decaying -- many dimensions matter
    V = np.random.randn(k, k)
    U, _ = np.linalg.qr(U)
    V, _ = np.linalg.qr(V)
    delta = (U[:, :min(d,k)] * S) @ V[:, :min(d,k)].T
    delta += noise * np.random.randn(d, k)
    return delta
 
delta_style = make_low_rank_delta(d, k, true_rank=4)
delta_facts = make_high_rank_delta(d, k)
 
print("\nStyle  update -- top 10 singular values:", np.linalg.svd(delta_style, compute_uv=False)[:10].round(2))
print("Facts  update -- top 10 singular values:", np.linalg.svd(delta_facts,  compute_uv=False)[:10].round(2))
print("\nNotice: Style decays fast → low-rank. Facts decay slowly → high-rank.")

Esta parte compara quão bem o LoRA padrão e o RS-LoRA podem reconstruir as atualizações originais usando diferentes classificações. Ambos os métodos usam primeiro SVD para obter a melhor aproximação possível de classificação r (ou seja, compactar a atualização em r dimensões), mas diferem na forma como dimensionam o resultado: LoRA padrão divide por r, enquanto RS-LoRA divide por √r. A tabela mostra o erro de reconstrução – menor significa melhor.

A principal conclusão é clara: para atualizações de estilo, mesmo classificações pequenas (como 4 ou 8) funcionam bem porque a informação é naturalmente de classificação baixa, então o erro cai rapidamente. Mas para atualizações de fatos, o erro permanece alto em níveis baixos, provando que informações importantes estão sendo perdidas. Aumentar a classificação ajuda, mas o LoRA padrão torna-se instável devido ao excesso de escala (o erro não melhora consistentemente). O RS-LoRA, com sua escala √r, lida com classificações mais altas com mais elegância e reduz erros de forma mais constante, tornando-o mais adequado para capturar conhecimento complexo e de alta dimensão.

def lora_approx_standard(delta, r, alpha=16):
    """Approximate delta using rank-r LoRA with standard alpha/r scaling."""
    U, S, Vt = np.linalg.svd(delta, full_matrices=False)
    # Truncate to rank r
    B = U[:, :r] * S[:r]          # shape (d, r)
    A = Vt[:r, :]                  # shape (r, k)
    scaling = alpha / r
    delta_approx = scaling * (B @ A)
    error = np.linalg.norm(delta - delta_approx, 'fro') / np.linalg.norm(delta, 'fro')
    return delta_approx, error
 
def lora_approx_rslora(delta, r, alpha=16):
    """Approximate delta using rank-r LoRA with RS-LoRA sqrt(r) scaling."""
    U, S, Vt = np.linalg.svd(delta, full_matrices=False)
    B = U[:, :r] * S[:r]
    A = Vt[:r, :]
    scaling = alpha / np.sqrt(r)   # <-- the key change
    delta_approx = scaling * (B @ A)
    error = np.linalg.norm(delta - delta_approx, 'fro') / np.linalg.norm(delta, 'fro')
    return delta_approx, error
 
ranks = [2, 4, 8, 16, 32, 48]
 
style_errors_standard, facts_errors_standard = [], []
style_errors_rslora,   facts_errors_rslora   = [], []
 
for r in ranks:
    _, e = lora_approx_standard(delta_style, r);  style_errors_standard.append(e)
    _, e = lora_approx_standard(delta_facts, r);  facts_errors_standard.append(e)
    _, e = lora_approx_rslora(delta_style, r);    style_errors_rslora.append(e)
    _, e = lora_approx_rslora(delta_facts, r);    facts_errors_rslora.append(e)
 
print("Rank | Style Err (std) | Facts Err (std) | Facts Err (RS-LoRA)")
print("-" * 60)
for i, r in enumerate(ranks):
    print(f"  {r:2d} |      {style_errors_standard[i]:.3f}      |      {facts_errors_standard[i]:.3f}      |      {facts_errors_rslora[i]:.3f}")

Esta seção explica por que o LoRA padrão tem dificuldades em cargos mais elevados. À medida que a classificação r aumenta, o LoRA padrão dimensiona a atualização em α / r, que diminui rapidamente – você pode vê-la cair de 16 (em r=1) para apenas 0,25 (em r=64). Isso significa que mesmo que você adicione mais dimensões (tentando capturar mais informações), a atualização geral fica cada vez mais fraca, suprimindo efetivamente o sinal de aprendizagem. O otimizador então tem que compensar forçando os pesos com mais força, o que muitas vezes leva à instabilidade ou à convergência deficiente.

RS-LoRA corrige isso alterando a escala para α/√r. Em vez de encolher de forma demasiado agressiva, a escala diminui mais gradualmente – permanecendo suficientemente forte mesmo em níveis mais elevados (por exemplo, ainda 2,0 em r=64). Isso mantém a magnitude efetiva da atualização significativa, permitindo que o modelo realmente se beneficie de representações de classificação mais alta sem eliminar o sinal. Em termos simples: o LoRA padrão adiciona capacidade, mas elimina seu impacto, enquanto o RS-LoRA preserva ambos.

alpha = 16
rs = np.arange(1, 65)
standard_scale = alpha / rs
rslora_scale   = alpha / np.sqrt(rs)
 
print("\nRank | Standard Scale (alpha/r) | RS-LoRA Scale (alpha/sqrt(r))")
print("-" * 55)
for r in [1, 4, 8, 16, 32, 64]:
    print(f"  {r:2d} |         {alpha/r:.4f}          |         {alpha/np.sqrt(r):.4f}")
 
print("\nStandard scaling vanishes as rank grows.")
print("RS-LoRA scaling stays meaningful at high ranks.")

Esta seção mostra a principal diferença em como as informações são distribuídas entre atualizações de estilo e factuais. Por estilo, a maior parte do sinal importante está concentrada em apenas algumas dimensões – você pode ver que com a classificação 4, mais de 99% da informação já foi capturada. É por isso que métodos de baixo escalão, como LoRA, funcionam tão bem para mudanças de tom, formato ou personalidade. Há um claro “cotovelo” nos valores singulares – depois de alguns componentes, o resto não importa muito.

Para os fatos, é o oposto. A informação está espalhada por muitas dimensões – mesmo na classificação 8, você captura apenas cerca de 28% do sinal total, o que significa que a maior parte do conhecimento ainda está faltando. Este é o problema da “cauda longa”: cada dimensão adicional contribui com algo importante. Quando o LoRA é truncado para uma classificação baixa, ele corta essa cauda, ​​levando a um conhecimento incompleto ou incorreto. É por isso que o modelo pode parecer confiante, mas ainda assim errar nos detalhes factuais.

sv_style = np.linalg.svd(delta_style, compute_uv=False)
sv_facts  = np.linalg.svd(delta_facts,  compute_uv=False)
 
print("Cumulative variance captured by top-r components:\n")
print(f"{'Rank':>5} | {'Style (%)':>10} | {'Facts (%)':>10}")
print("-" * 32)
total_style = np.sum(sv_style**2)
total_facts  = np.sum(sv_facts**2)
for r in [2, 4, 8, 16, 32]:
    cs = 100 * np.sum(sv_style[:r]**2) / total_style
    cf = 100 * np.sum(sv_facts[:r]**2)  / total_facts
    print(f"  {r:3d} | {cs:9.1f}% | {cf:9.1f}%")
 
print("\nWith r=8, style is nearly fully captured.")
print("With r=8, facts are still poorly captured -- the tail matters!")

📚 Leia Também no NeuralNet:

• 👉 Guia de Inteligência Artificial para Iniciantes
• 👉 Melhores Ferramentas de IA para Aumentar sua Produtividade
• 👉 Ética e Regulação de IA no Brasil: O Que Você Precisa Saber