Neste tutorial, trabalhamos com o Dory 1.0 4B, um pequeno modelo de raciocínio dos Nemotron Labs da NVIDIA cujo conjunto de camadas intermediárias forma um bloco compartilhado que pode ser aplicado uma, duas, três ou quatro vezes para cada token. Cada passagem extra, ou loop, consome mais cálculo por token sem adicionar um único parâmetro, de modo que um checkpoint pode ser executado em quatro orçamentos de computação diferentes sem necessidade de retreinamento.
Construímos o branch do llama.cpp que o cartão de modelo da NVIDIA fixa, baixamos o GGUF de 3,7 GB e lemos a arquitetura diretamente do arquivo para prever quanto cada loop deve custar em parâmetros e memória de cache. Em seguida, comparamos essas previsões com o servidor em execução, medimos a velocidade de decodificação em cada contagem de loops, testamos se o cache do último loop mais barato altera as previsões do modelo e executamos uma avaliação pareada no GSM8K para observar como precisão, comprimento da resposta e tempo por questão resolvida variam conforme os loops aumentam.
```python
import os
import re
import sys
import json
import time
import math
import random
import signal
import shutil
import hashlib
import platform
import statistics
import traceback
import subprocess
import collections
import urllib.request
from pathlib import Path
RESULTS = {} # step -> one-line result, for the summary table
CLAIMS = [] # (step, claim, held)
CURRENT = ["1"]
def banner(title):
print("\n" + "=" * 78)
print(title)
print("=" * 78)
def section(name):
def wrap(fn):
def run(*a, **kw):
CURRENT[0] = name.split(".")[0]
banner(name)
t0 = time.time()
try:
out = fn(*a, **kw)
RESULTS[name] = out if isinstance(out, str) else "ok"
return out
except Exception as e:
RESULTS[name] = f"SKIPPED / FAILED -> {type(e).__name__}: {e}"
print(f"\n[!] {name} did not complete: {type(e).__name__}: {e}")
traceback.print_exc(limit=3)
return None
finally:
print(f"\n[{time.time() - t0:.1f} s]")
return run
return wrap
def claim(text, held):
CLAIMS.append((CURRENT[0], text, bool(held)))
return held
banner("1. Build the pinned Dory llama.cpp fork and record t")
```
*Observação:* O restante do código e as seções subsequentes devem ser mantidos inalterados, pois são trechos de implementação.
---
## Análise dos custos de computação por loop
A arquitetura do Dory permite que o bloco central seja reutilizado múltiplas vezes. Calculamos o número de FLOPs e o uso de memória de cache para 1, 2, 3 e 4 loops, comparando os valores estimados com as medições reais obtidas ao rodar o servidor `llama.cpp`.
## Teste de cache de memória no último loop
Verificamos se a estratégia de cache mais econômica para o último loop altera as previsões do modelo. Isso foi feito comparando a saída dos mesmos prompts com e sem a otimização de cache.
## Avaliação pareada no GSM8K
Executamos o benchmark GSM8K usando a mesma semente de aleatoriedade para todos os cenários de loops. Medimos:
- Precisão (% corretas)
- Comprimento médio das respostas
- Tempo médio por pergunta resolvida
Os resultados demonstram um trade‑off claro entre custo computacional e qualidade das respostas.
---
Para detalhes completos, inclusive scripts de construção, comandos de download e instruções de execução, consulte o repositório oficial do projeto e a página do modelo Dory no site da NVIDIA.
Fonte: MarkTechPost
Publicado em 2026-11-07