A tese desta página: um System One é um leitor que aponta em vez de escrever, e a probabilidade que ele devolve só vale alguma coisa porque o treino puniu a mentira. A página anterior mediu o comportamento de um System One fechado e se recusou, de propósito, a adivinhar como ele era por dentro. A Laya é outro modelo, da Convai Innovations, licença Apache 2.0, com pesos, código e configuração publicados. Então aqui dá para abrir: como a pergunta vira uma fila de tokens, por que o encoder precisa ler nos dois sentidos, como uma nota por marcador vira resposta, de onde sai a decisão de agir ou chamar gente, e que regra de treino faz um número entre 0 e 1 significar o que parece.
Explore cada etapa →
As contas, num só lugar
As 7 contas desta página. Clique em qualquer uma para pular direto para a etapa que a explica.
O que foi publicado, e o que medimos aqui
Sem ajuste → ajustada
0,362 → 0,766
ECE de fábrica → com temperatura
0,466 → 0,081
Treino do multilíngue
4,97 h
Por mensagem, RTX 3060
23 ms
RAM acordada
1,8 GB
Para acordar
8,2 s
A primeira linha é citada: acurácia no benchmark de decisões tipadas antes e depois do fine-tuning, e ECE do checkpoint em inglês antes e depois do ajuste de temperatura, do cartão do modelo em convaiinnovations/laya; as 4,97 horas estão no rl_agent_config.json que vem junto com os pesos. A segunda linha é medição própria, em 26/09/2026: uma RTX 3060 de 12 GB, laya 0.3.20, torch 2.14, o checkpoint multilíngue em fp16 servido pelo laya-serve.
Honestidade, antes de começar: esta página não chama modelo nenhum. O que roda de verdade: toda a aritmética que você vê, os orçamentos da sequência reproduzem os de build_sequence, as regras de pontuação e o TD(λ) são as mesmas fórmulas do código, o ECE usa as mesmas 15 faixas, e o ajuste de temperatura é uma busca real pelo mínimo da log-verossimilhança. O que é brinquedo declarado: as contagens de token são sliders, não um tokenizador; o treino da etapa 6 tem um parâmetro, e não 322 milhões; as populações das etapas 6 e 8 são sorteadas por um gerador determinístico, com a semente impressa; e o portão da etapa 4 é a regra de custo mínimo, não a rede treinada. O que não é público: os dados de treino e o custo total do treinamento. E a fronteira da página anterior continua de pé: a Laya não é o Jev, e nada aqui diz como o Jev é por dentro.
A Laya não recebe "um prompt". Cada pergunta vira uma fila de tokens com formato fixo, montada pelo código antes de o modelo ver qualquer coisa: o tipo e as instruções, depois um marcador [MASK] na frente de cada opção, e por último o texto. Os marcadores são o truque todo: é no vetor que sai de cada um deles que o modelo vai dar a nota daquela opção.
espaço = max(0, max_len − |cabeça| − 1) · texto = min(pedido, espaço), cortado pelo fim
Leia assim:max_len é o teto da fila inteira, 1.024 tokens no checkpoint multilíngue, 512 no de inglês. A cabeça é tudo até o segundo separador: tipo, instruções, marcadores e opções, com teto próprio (head_max_len, 256 ou 192). Dentro da cabeça as opções têm prioridade: cada uma leva até 48 tokens, e se sobrar menos de 16 para as instruções, todas as opções encolhem por igual. O texto fica com o que sobra, e quando não cabe, perde o fim.
o que você manda, e a fila que isso vira
import laya
agente = laya.load("convaiinnovations/laya", subfolder="multilingual")
perguntas = {
"setor": {
"type": "choice",
"instructions": "Qual setor deve atender?",
# a descrição é o que o marcador lê: rótulo solto é palavra solta"criteria": {"financeiro": "cobrança, boleto, reembolso",
"suporte": "erro, sistema fora do ar"},
},
"cancelar": {"type": "noul", "instructions": "O cliente ameaça cancelar?"},
}
r = agente.system_one("Fomos cobrados duas vezes, estornem ou cancelamos.", perguntas)
# {'setor': {'choice': 'financeiro', 'probabilities': {...}, 'action': {'act_probability': 1.0}},# 'cancelar': {'noul': 0.9482, ...}} ← medido aqui, fp16, RTX 3060
# laya-serve expõe o mesmo formato de pedido da TypeSafe
POST /v1/systemone
{
"state": "Fomos cobrados duas vezes, estornem ou cancelamos.",
"questions": {
"cancelar": {"type": "noul", "instructions": "O cliente ameaça cancelar?"}
}
}
# a fila que o noul acima vira (as opções do noul são fixas no código):# [CLS] noul question: O cliente ameaça cancelar? [SEP]# [MASK] false: no, the statement does not hold# [MASK] true: yes, the statement holds [SEP]# Fomos cobrados duas vezes, estornem ou cancelamos. [SEP]
Uma pergunta, uma fila, e o texto se repete em cada uma. Duas perguntas sobre o mesmo documento viram duas sequências, cada uma com o documento inteiro no fim. O código tokeniza o texto uma vez só e reaproveita os ids em todas as filas, mas o encoder atravessa cada uma delas. É o contrário do LLM, que lê o documento uma vez e escreve todas as respostas: aqui cada pergunta custa uma passada, e as passadas vão em lote, lado a lado na mesma chamada.
A fila da etapa anterior tem uma consequência que passa despercebida: os marcadores vêm antes do texto. Num modelo que escreve isso seria fatal, porque a atenção dele é causal: cada token enxerga só quem veio antes, para não espiar a resposta que ainda vai escrever. A Laya lê com um encoder bidirecional (mmBERT no multilíngue, ModernBERT no de inglês): não há o que esconder, porque nada vai ser escrito, e todo token enxerga todos.
causal: i enxerga j ⇔ j ≤ i · bidirecional: i enxerga j para todo j
Leia assim: a máscara de atenção é uma matriz de sim e não, linha é quem olha, coluna é para quem. A causal é um triângulo: o token 10 enxerga do 0 ao 10 e mais nada. A bidirecional é o quadrado cheio. Clique em qualquer token para ver o que ele enxerga, e troque a ordem para ver por que um prompt de LLM põe o documento primeiro. A matriz abaixo é a mesma conta para a fila inteira; o Transformer por dentro mostra o que acontece com o peso de cada casa.
Clique num token: apagado é o que ele não enxerga
A máscara inteira: linha é quem olha, coluna é para quem; a linha destacada é o token escolhido
O preço da leitura nos dois sentidos: um encoder não sabe escrever. Não há cabeça de vocabulário para gerar a palavra seguinte, e nem faria sentido: ele enxerga o futuro. É exatamente o que a Laya quer: ela nunca vai escrever, então troca a capacidade de gerar pela de ler cada opção à luz do documento inteiro. É a mesma família de modelo do BERT de 2018, e é por isso que ela cabe em 322 milhões de parâmetros.
Depois do encoder, a Laya soma a cada posição um vetor que diz o tipo da pergunta (escolha, nota ou sim/não), passa tudo por duas camadas de transformer próprias, treinadas do zero, e então faz a coisa que dá nome a esta etapa: pega o vetor que saiu em cada marcador e o passa pelo mesmo pontuador: uma rede pequena que devolve um número. Um número por opção. O softmax desses números é a resposta.
Leia assim:h[marcador_i] é o vetor que sai da posição do marcador da opção i, 768 números no multilíngue, 1.024 no de inglês. O pontuador é o mesmo para todas as opções e para todas as perguntas: ele não sabe quantas opções existem, só dá nota a um vetor. Posições de enchimento recebem −10.000 antes do softmax, o que as zera. No brinquedo abaixo a opção certa tem nota m e as outras k − 1 têm nota 0: a fórmula mostra quanto de vantagem é preciso para uma certeza dada, e por que ela cresce com o logaritmo do número de opções.
Por que isso é "apontar" e não "escrever": um LLM escolhe a próxima palavra entre as dezenas de milhares do vocabulário, e a resposta "financeiro" precisa sair letra a letra, ou token a token, com a chance de sair "financeira" ou "é financeiro, porque…". Aqui o espaço de respostas é a sua lista, e a resposta é um índice nela. Não existe resposta fora da lista, o que existe é pouca certeza dentro dela, e a etapa seguinte transforma essa pouca certeza em decisão.
A Laya tem uma segunda cabeça, pequena, que não olha para as opções: ela olha para o formato da distribuição que acabou de sair, quanto a líder levou, quanto ela ganhou da segunda, quão espalhado está o resto e quantas opções existiam, junto com o vetor do início da fila. O que sai é a probabilidade de agir contra escalar, ou seja, chamar uma pessoa.
Leia assim:p é a chance de a resposta estar certa. Agir custa c_erro quando ela está errada, o que acontece com chance 1 − p. Escalar custa c_escalar sempre, o tempo da pessoa. A fronteira é onde as duas retas se cruzam. A configuração publicada com os pesos traz cost_wrong_act = 3,0 e act_costs.escalate = 0,5: com eles, agir só compensa acima de 0,833. A distribuição vem da etapa anterior: mexa em k e na vantagem aqui mesmo.
As duas retas de custo: rosa é agir, azul é escalar; verde é o p atual, âmbar é a fronteira
O que a página calcula e o que a Laya calcula: a reta e a fronteira são a regra de custo mínimo, o que um decisor perfeito faria sabendo p. A cabeça de agir da Laya é uma rede treinada que recebe os quatro números da tabela mais o vetor inteiro do início da fila, e devolve a probabilidade de agir. O treino a empurra para essa regra, mas ela não é essa regra, e a gente não tem como abrir o que ela aprendeu além do que ela devolve. Na prática, em todas as mensagens do nosso teste ela respondeu act_probability 1,0, inclusive onde a resposta estava errada. Quem garante o corte, então, é você, com a probabilidade calibrada da etapa 8 e os seus custos.
Aqui está a peça que dá sentido às outras. A Laya não é treinada para acertar: é treinada para reportar a probabilidade certa. O método se chama RLCD, aprendizado por reforço para decisões calibradas, e o prêmio de cada resposta é uma regra de pontuação estritamente própria: uma função que só atinge o máximo esperado quando o número reportado é a frequência verdadeira.
R = ln p_certa + ½ · p_certa ÷ ‖p‖ − RPS (só nas notas) · RPS = Σ (F_relato − F_verdade)² ÷ (k − 1)
Leia assim:ln p_certa é a regra logarítmica, reportar pouca chance para o que aconteceu custa caro, e reportar zero custa infinito (o código põe um piso em −9,21). O segundo termo é a regra esférica, com peso ½: a probabilidade da certa dividida pelo tamanho do vetor de probabilidades. O RPS compara as distribuições acumuladas e só entra nas perguntas de nota. Abaixo, uma pergunta de sim ou não cuja resposta verdadeira é "sim" com frequência q: a curva é o prêmio médio de cada relato possível. Troque a regra e veja onde fica o topo.
Prêmio esperado por relato: verde é a verdade, rosa é o que o modelo reporta
Notas e distância
proper_reward, como está no pacote (Apache 2.0)
defproper_reward(q, target, qtype, mask, w_sph=0.5, w_rps=1.0, log_floor=-9.21):
q = q * mask
# logarítmica, com piso: reportar zero para o que aconteceu não vira −∞
logq = torch.log(q.clamp_min(1e-12)).clamp_min(log_floor)
log_score = (target * logq).sum(-1)
# esférica: a da certa sobre o tamanho do vetor inteiro
sph = (target * q).sum(-1) / q.norm(dim=-1).clamp_min(1e-9)
r = log_score + w_sph * sph
is_score = (qtype == QTYPES["score"]).float()
if is_score.any():
# RPS só nas notas: errar por dois degraus custa mais que por um
k = mask.sum(-1).clamp(min=2).float()
cdf_q = torch.cumsum(q, -1)
cdf_t = torch.cumsum(target, -1)
rps = (((cdf_q - cdf_t) ** 2) * mask).sum(-1) / (k - 1)
r = r - w_rps * rps * is_score
return r
Por que isso importa mais que a acurácia: a página anterior terminou dizendo que o corte de confiança é o botão que decide quanto você automatiza, e que ele só significa alguma coisa se a confiança for calibrada. Esta etapa é de onde a calibração vem. Um modelo treinado só para acertar, ou avaliado por preferência humana, não tem motivo para que o 0,7 dele queira dizer 70%. Um treinado com regra própria tem: qualquer outro número dá prejuízo esperado.
Falta o como. Não existe "probabilidade certa" rotulada para o modelo copiar: os dados têm respostas, não frequências. O treino faz o que o cartão do modelo descreve: sacode os logits com ruído gaussiano, calcula o prêmio de cada tentativa com a regra própria, e usa a média do grupo de tentativas como régua: quem ganhou mais que a média puxa o parâmetro na sua direção, quem ganhou menos empurra para longe.
Leia assim:θ é o parâmetro, e o modelo reporta σ(θ). Cada passo sorteia um rótulo, sim com frequência q, e G tentativas, cada uma com o logit sacudido por ruído de tamanho σ. A_g é a vantagem: o prêmio da tentativa menos a média do grupo. Somar vantagem vezes ruído estima para que lado o prêmio sobe, sem derivar nada: é o REINFORCE, e usar a média do grupo como linha de base é a ideia do GRPO. Rode com cada regra e compare onde o número para.
O número reportado ao longo do treino: a linha verde é a verdade
Por que exploração e não gradiente direto: com a regra logarítmica pura daria para derivar e descer o gradiente como em qualquer classificador, é a entropia cruzada. O cartão do modelo descreve o ruído nos logits e a média do grupo, mas não explica a escolha. Uma leitura plausível: a Laya treina também a decisão, e a cabeça de agir e os custos da etapa 4 dependem de escolhas discretas, que se treinam tentando, medindo e comparando. O que dá para afirmar é o papel da régua do grupo: ela tira do sinal o que é sorte do rótulo, se todas as tentativas ganharam, nenhuma aprendeu nada.
Uma pergunta como "este cliente vai cancelar?" é feita a cada mensagem de uma conversa, mas a resposta só se sabe no fim. Os turnos do meio não têm rótulo. O treino da Laya empresta o do fim com TD(λ): andando de trás para a frente, o alvo de cada turno mistura o alvo do turno seguinte com a previsão que o próprio modelo fez ali.
Leia assim:p_(j+1) é o que o modelo previu no turno seguinte, e G é o alvo. Com λ = 1 a previsão não entra e todo turno aprende direto com o desfecho: é o valor que a Laya usa. Com λ = 0 cada turno aprende só com a previsão seguinte, sem nunca ver o desfecho a não ser pelo último. Mexa nas previsões dos turnos e no λ, e veja o alvo de cada um.
Por turno: a barra é a previsão, o traço é o alvo do treino
O que isso muda para quem usa: a probabilidade que a Laya dá no turno 2 de uma conversa foi treinada para prever o desfecho, não o humor daquela mensagem. É por isso que "vou pensar" pode sair com risco de cancelamento alto: em conversas parecidas, "vou pensar" terminou em cancelamento. É útil e é perigoso pelo mesmo motivo, o número carrega o padrão das conversas de treino, que não são as suas.
A regra própria deixa a probabilidade honesta na distribuição em que o treino rodou. Na sua, outros clientes, outra língua, outras perguntas, ela sai torta, quase sempre confiante demais. O conserto é o mais simples da área: dividir os logits por uma temperatura T ajustada nos seus exemplos rotulados. Um número por tipo de pergunta e por faixa de opções: é a faixa choice:3-5 que apareceu na etapa 3.
p = softmax(z ÷ T) · T* = argmin_T −Σ ln p_T(rótulo) · T preso em [0,5 ; 5]
Leia assim:T maior que 1 achata a distribuição e tira confiança; menor que 1 afia e dá confiança. T* é a que maximiza a probabilidade dos rótulos que você tem: ajustar isso não muda a resposta escolhida, só o quanto ela diz ter certeza. A biblioteca prende T entre 0,5 e 5, e a etapa mostra por quê. Abaixo, uma população simulada confiante demais: arraste T, ou clique em ajustar e deixe a página achar o mínimo.
Diagrama de confiabilidade: a barra é o acerto real, o traço é o prometido
Duas coisas que o arquivo publicado conta: o checkpoint em inglês traz temperaturas ajustadas, 1,98 para sim/não, 1,25 para notas, 1,76 para escolhas de 3 a 5 opções, as três acima de 1, ou seja, o modelo saía confiante demais. E traz 0,1006 para escolhas com 11 opções ou mais, que é o contrário: afiar dez vezes. A biblioteca recusa esse valor, usa 0,5 e escreve no log que aquela confiança não está calibrada. O checkpoint multilíngue, o que atende português, traz 1,0 em tudo: sem ajuste nenhum. Se você vai cortar por confiança em português, a temperatura é sua para ajustar.
Sem ajuste, a Laya acerta 0,362 no benchmark de decisões tipadas; ajustada nele, 0,766. É a diferença entre inútil e útil, e o projeto publica o caminho: um notebook que faz o ciclo inteiro, montar o conjunto, treinar, ajustar a temperatura, avaliar, publicar, em duas GPUs T4 gratuitas do Kaggle, em cerca de quatro horas. A pergunta que sobra é a de sempre na página de fine-tuning: quanto custa, e quando se paga.
rotular = N · s ÷ 3600 · preço_hora · empate = custo_inicial ÷ (LLM_mês − Laya_mês)
Leia assim:N é quantos exemplos rotulados, s quantos segundos uma pessoa leva em cada um. O custo mensal da Laya inclui, além do servidor, uma suposição declarada: a cada rodada de retreino, 20% dos exemplos precisam de rótulo novo, porque o problema muda. Do outro lado, um LLM por API resolvendo a mesma decisão, chamada por chamada. O empate é quando a economia mensal paga o começo.
O atalho que quase todo mundo toma, e o cuidado que ele pede: pré-rotular com um LLM e deixar a pessoa só corrigir. Os segundos por rótulo caem para um terço, e a conta acima muda de figura. O cuidado: o que a Laya aprende a imitar passa a ser o LLM, com os vieses dele, e a calibração da etapa 8 precisa ser ajustada em rótulos que uma pessoa conferiu, senão a temperatura aprende a concordar com o professor, e não com o mundo.
Por último, a pergunta prática: o que custa deixar isso rodando. Medimos numa placa de consumidor, e a primeira surpresa é que o modelo é a menor parte da memória. Em fp16 os pesos ocupam 0,63 GB na placa de vídeo; na RAM, o que pesa é a pilha em volta, o PyTorch, o contexto de CUDA e um tokenizador de 256 mil palavras. A segunda é que ela não precisa estar acordada o tempo todo.
Leia assim:λ é quantas chamadas chegam por minuto, em média e ao acaso; W é quantos minutos sem chamada até a Laya dormir. Um porteiro de 70 MB fica escutando no lugar dela e a acorda quando precisa. Ela está acordada quando houve ao menos uma chamada nos últimos W minutos, para chegadas ao acaso, isso tem probabilidade exata 1 − e−λW, e uma chamada a encontra dormindo quando os W minutos anteriores foram de silêncio. Cada acordada custa ~8,2 s.
O que medimos: RTX 3060 12 GB, laya 0.3.20, torch 2.14, 26/09/2026
Onde estão os 1,8 GB, somando degrau por degrau
um checkpoint só, em fp16, atrás de um porteiro
import laya.serve as serve
# sem isto o roteador escolhe por mensagem e carrega o checkpoint em inglês# (mais ~1 GB) sempre que um texto parece inglês
serve._resolve_model = lambda _model: "multilingual"
_build_router = serve.build_router
defbuild_router():
router = _build_router()
if router.device andstr(router.device).startswith("cuda"):
import torch
for agent in router._agents.values():
agent.model.half() # 1,25 GB → 0,63 GB de vídeo, 0,948 contra 0,947
torch.cuda.empty_cache()
return router
serve.build_router = build_router
serve.main()
module.exports = { apps: [
{
// porteiro de 70 MB na porta pública: acorda a Laya e a põe para dormir
name: "laya", script: "repouso.mjs",
env: { PORT: "8100", BACKEND_PORT: "8101", IDLE_MIN: "10" },
},
{
name: "laya-serve", script: "serve_multilingual.py",
interpreter: ".venv/bin/python",
env: {
LAYA_HOST: "127.0.0.1", LAYA_PORT: "8101", LAYA_DEVICE: "cuda",
LAYA_MODELS: "multilingual", // não os três: 3,2 GB → 1,8 GB
MALLOC_ARENA_MAX: "2", // devolve ao sistema o que o carregamento soltou
MALLOC_MMAP_THRESHOLD_: "131072", MALLOC_TRIM_THRESHOLD_: "131072",
},
},
]};
O que tentamos e não valeu: carregar os pesos direto na placa, sem passar pela RAM, não baixou nada. Montar o tokenizador sem a camada da biblioteca de transformers economizou 80 MB num processo isolado e quase nada com o servidor inteiro. O ONNX em CPU tira o PyTorch da GPU mas não do processo, o pacote ainda o importa, e fica seis vezes mais lento. O int8 cortou 150 MB e errou com confiança. Para descer muito abaixo de 1,8 GB acordada seria preciso reescrever o pré-processamento sem PyTorch. O repouso resolveu mais que tudo isso junto: a memória que importa é a média, não o pico.
As dez, de um relance
Armadilhas de produção
O que está no arquivo e ninguém lê, o que degrada em silêncio e o que só aparece quando ela sai do notebook.
No fim: abrir um System One mostra que não há mágica nenhuma na velocidade, é um leitor de 2018 com uma cabeça que aponta em vez de uma que escreve. O que é novo, e o que faz a diferença em produção, está no treino: uma recompensa em que mentir sobre a própria certeza dá prejuízo. Todo o resto, o corte, a cascata, a triagem da página anterior, depende desse número querer dizer o que parece. E o arquivo publicado lembra que ele só quer dizer isso depois que você ajusta a temperatura nos seus dados.