# Apresentando Julia 1

Nosso modelo de decisão que roda em quase tudo.

![Arte geométrica monocromática do Julia 1](/images/julia-banner.webp)

Julia 1 abre nossa pesquisa em modelos compactos de decisão. Ele parte do [mmBERT-small](https://huggingface.co/jhu-clsp/mmBERT-small), um encoder multilíngue, e escolhe entre respostas oferecidas a uma pergunta. São 144,3 milhões de parâmetros, com execução em CPU.

Nossa pergunta: um único modelo consegue classificar, ordenar níveis e responder sim ou não quando as opções mudam? Julia 1 é o primeiro resultado dessa investigação. Aqui estão os acertos, as falhas e os métodos usados para medi-los. **Em breve, esta página terá mais exemplos, testes e informações úteis sobre a Julia 1.**

## A pergunta por trás de Julia

### Uma interface, várias formas de decidir.

O modelo recebe um contexto, uma pergunta e de 2 a 20 respostas possíveis. Ele escolhe uma delas e devolve pontuações na ordem das opções recebidas. Esse formato nos permite estudar tarefas diferentes com o mesmo modelo e uma medida direta: quantas escolhas ele acertou?

Pense na mensagem “Fui cobrado duas vezes pelo mesmo pedido”. Entre Cobrança, Entrega e Acesso à conta, Julia escolhe o destino. A pergunta seguinte pode ser “Qual é a prioridade?”, com baixa, média e alta como opções. O exemplo mostra a interface; os resultados abaixo mostram como ela se saiu em testes definidos.

![Formas entram continuamente na trilha de decisão; apenas as azulroxas seguem até o fim](/images/julia-decision-flow.svg)

## Os primeiros resultados

### Acertos em quatro tarefas, com uma falha importante.

Na avaliação de 24 de setembro de 2026, Julia 1 ficou acima das referências Jev fornecidas em três das quatro tarefas abaixo. Acertou **1.463 de 2.000 decisões tipadas (73,15%)**, uma diferença de 0,45 ponto percentual sobre a referência. Nos pilotos de 100 exemplos, classificou corretamente **94 notícias** e **86 emoções**. Em emoções, a diferença foi de **38 pontos percentuais** sobre a referência.

O piloto bancário foi mais difícil. Com 72 categorias e uma etapa que reduz a lista antes da decisão final, Julia acertou 64 de 100 exemplos; a referência Jev é 87%. Listas extensas e categorias parecidas são uma frente concreta para melhorar.

```chart
{
  "type": "bar",
  "title": "Julia 1 em quatro tarefas",
  "description": "Acurácia em 2.000 decisões tipadas e três pilotos de 100 exemplos. A série Jev reproduz os valores de referência do protocolo.",
  "labelKey": "task",
  "series": [
    { "key": "julia", "label": "Julia 1" },
    { "key": "reference", "label": "Referência Jev" }
  ],
  "unit": "%",
  "min": 0,
  "max": 100,
  "data": [
    { "task": "Decisões tipadas", "julia": 73.15, "reference": 72.70 },
    { "task": "AG News", "julia": 94, "reference": 91 },
    { "task": "DAIR Emotion", "julia": 86, "reference": 48 },
    { "task": "Banking77", "julia": 64, "reference": 87 }
  ],
  "source": "Avaliação do Julia 1, 24 de setembro de 2026; referências Jev do protocolo de comparação"
}
```

| Tarefa | Acertos do Julia 1 | Julia 1 | Referência Jev |
| --- | ---: | ---: | ---: |
| Decisões tipadas | 1.463 / 2.000 | 73,15% | 72,70% |
| AG News, 4 classes | 94 / 100 | 94% | 91% |
| DAIR Emotion, 6 classes | 86 / 100 | 86% | 48% |
| Banking77, lista reduzida de 72 classes | 64 / 100 | 64% | 87% |

### O mesmo modelo em 52 localidades.

Também avaliamos Julia no [MASSIVE](https://huggingface.co/datasets/AmazonScience/massive), escolhendo um entre 18 cenários para cada exemplo. Foram **110.573 acertos em 154.648 casos (71,50%)** distribuídos por 52 localidades. O teste inclui português de Portugal e inglês dos Estados Unidos.

| Classificação de cenários MASSIVE | Acertos / total | Acurácia |
| --- | ---: | ---: |
| Todas as 52 localidades | 110.573 / 154.648 | 71,50% |
| Português (pt-PT) | 2.565 / 2.974 | 86,25% |
| Inglês (en-US) | 2.580 / 2.974 | 86,75% |

O teste mede a escolha de um entre 18 cenários. Português brasileiro, classificação de intenção e preenchimento de campos ficam para avaliações futuras.

### Uma nova medição em CPU.

Em uma execução em CPU registrada em 25 de setembro de 2026, Julia 1 acertou **1.451 de 2.000 decisões tipadas (72,55%)**. Nos pilotos de 100 exemplos, foram 94 acertos em AG News e 86 em DAIR Emotion. No piloto bancário de 72 categorias, foram 60 acertos e três abstenções. As abstenções entram no total de 100 casos.

| Tarefa na execução em CPU | Acertos / decisões | Acurácia | Cobertura |
| --- | ---: | ---: | ---: |
| Decisões tipadas | 1.451 / 2.000 | 72,55% | 100% |
| AG News, 4 classes | 94 / 100 | 94% | 100% |
| DAIR Emotion, 6 classes | 86 / 100 | 86% | 100% |
| Banking77, lista reduzida de 72 classes | 60 / 100 | 60% | 97% |

Esta execução usou PyTorch 2.14.0+cpu, codificação estrita e limite de 1.024 tokens. O registro identifica os pesos pelo SHA-256 iniciado em `df853bf7fe42` e traz as [contagens completas e a identificação dos dados](/data/julia-1-cpu-20260925.json). O pacote registra o dispositivo como CPU.

### Julia 1 em diferentes dispositivos.

Há medições em um Mac com Apple M4, em um computador com Intel Core i5-1235U e no tablet Samsung SM-X510. As entradas e os caminhos de execução estão descritos logo abaixo da tabela.

| Equipamento e teste | Decisões | Tempo mediano | p95 | Decisões/s |
| --- | ---: | ---: | ---: | ---: |
| Apple M4, uma por chamada | 128 | 33,15 ms | 44,23 ms | 28,01 |
| Apple M4, lotes de 16 | 128 | 312,11 ms por lote | 313,44 ms por lote | 51,20 |
| Samsung SM-X510, ONNX Runtime | 40 | 203 ms | 205 ms | 5,0 |
| Intel Core i5-1235U, decisões tipadas | 2.000 | 294,81 ms | 428,49 ms | — |
| Intel Core i5-1235U, AG News | 100 | 107,83 ms | 142,89 ms | — |
| Intel Core i5-1235U, DAIR Emotion | 100 | 89,83 ms | 118,95 ms | — |
| Intel Core i5-1235U, Banking77 | 100 | 3.713,54 ms | 5.125,10 ms | — |

No Mac, cada pedido tinha 100 palavras de contexto e quatro opções. Usamos o checkpoint `df853bf7fe42`, o runtime Python local, o tokenizer público do mmBERT-small e quatro threads de CPU. No teste de 16, cada tempo representa um lote completo; o processo ocupava 370,6 MiB de RAM ao fim dessa rodada.

No Samsung SM-X510, a execução informada processou **40 decisões em 8 segundos** (5 por segundo, ou 300 por minuto), com 3.693 tokens ao todo, cerca de 92 por decisão e uma taxa efetiva de 462 tokens/s. A latência variou de 193 a 205 ms por decisão. O tablet usou Android 16, Python 3.13.13, ONNX Runtime 1.27.0 e tokenização nativa em Rust. O ONNX Runtime listou NNAPI e CPU; o driver recorreu à CPU por operador nessa execução. O pico de memória residente do processo foi **393,1 MB**. O arquivo de pesos de 550,1 MB foi mapeado em memória. XNNPACK compila incorretamente um `Reshape` nesse grafo e ficou fora da execução.

No i5, os tempos vêm dos 2.300 registros de `predictions.jsonl` no pacote da avaliação de 25 de setembro. Essa execução usou PyTorch 2.14.0+cpu, codificação estrita e o runtime identificado no pacote. O teste Banking77 inclui a redução de 72 categorias antes da escolha. O pacote registra o dispositivo como CPU; a identificação do processador foi informada junto à avaliação. As cargas variam entre os dispositivos; veja os [dados e condições de cada medição](/data/julia-1-hardware-20260926.json).

## O que construímos

### Do encoder multilíngue a um modelo de decisão.

O mmBERT-small fornece a base de linguagem e o tokenizer. Julia 1 adapta essa base para pontuar alternativas apresentadas junto do contexto e da pergunta. O checkpoint, com 144,3 milhões de parâmetros, produz uma escolha para tarefas de classificação, roteamento, escalas ordenadas e respostas de sim ou não. Os pesos ocupam **550,5 MiB**.

![Formas passam por uma comparação com o quadrado azul de referência e recebem porcentagens ilustrativas](/images/julia-similarity-flow.svg)

O runtime Python 3.11+ executa o modelo em CPU. A configuração avaliada aceita até **1.024 tokens** para contexto, pergunta e opções. Listas maiores podem passar por um Router que reduz candidatos em grupos; o teste Banking77 mostra que essa redução pode perder a resposta correta. Para planejar uma integração, meça latência e memória com as entradas e o equipamento que pretende usar.

## Por que usamos mmBERT-small

Nosso time inicial trabalha com orçamento e capacidade computacional limitados. Treinar um modelo multilíngue desde o início exigiria muito mais dados, infraestrutura, tempo e dinheiro do que tínhamos para esta primeira versão. O [mmBERT-small](https://huggingface.co/jhu-clsp/mmBERT-small) já oferecia um encoder e um tokenizer multilíngues. Partimos desses pesos, desenvolvemos os componentes de decisão e treinamos Julia 1 para escolher entre respostas fornecidas com a pergunta. **Julia 1 não é um fine-tuning de Qwen.**

Essa escolha nos permitiu testar o modelo, o treinamento e a avaliação com um orçamento pequeno. Julia 1 é nossa primeira validação pública dessa abordagem. Os resultados mostram onde ela funciona e onde precisamos avançar, especialmente em listas longas de opções e tarefas que exigem conhecimento externo ou raciocínio em várias etapas.

## O desafio de construir com poucos recursos

O gasto total com GPUs na nuvem para o treinamento e os experimentos da Julia 1 ficou em cerca de **R$ 540 (US$ 104,08)**. Esse orçamento permitiu colocar a abordagem à prova, medir os resultados e encontrar falhas concretas. Treinar uma base multilíngue do zero exigiria um investimento muito maior.

Para Julia 2, planejamos desenvolver uma arquitetura fundacional própria, sem mmBERT. O trabalho parte do que aprendemos com Julia 1 e das limitações que os testes já revelaram. Julia 2 ainda está em desenvolvimento.

A Supersonic Labs está totalmente aberta a investimentos e financiamento para avançar essa pesquisa. Para conversar, envie uma DM para [@supersonicai no X](https://x.com/supersonicai).

## Como medimos

O teste [Typed Decisions](https://huggingface.co/datasets/LocalLLaMA/typed-decisions) reúne 400 casos, com cinco decisões por caso: escolha, pontuação ordenada e sim ou não. Julia acertou 428/600 em Choice, 484/600 em Noul e 551/800 em Score. Os três pilotos de classificação seguem esta versão do [protocolo Jev](https://github.com/AbdelStark/jev-benchmarks/tree/0d610cc53e79bcbec691312b0c4adb4a0e371642). Avaliamos Julia com inferência H200 BF16 e codificação estrita; a coluna Jev usa os resultados de referência do protocolo. Abstenções entram como erro. O repositório do modelo inclui os [resultados completos](https://huggingface.co/SupersonicLabs/Julia-1/blob/main/metrics/accuracy-20260924.json) e a [proveniência do checkpoint](https://huggingface.co/SupersonicLabs/Julia-1/blob/main/provenance.json).

Os resultados cobrem decisões entre respostas fornecidas junto da pergunta. Conhecimento externo e cálculos em várias etapas pedem outros testes. Para aplicar Julia a um domínio novo, avalie perguntas e opções reais desse domínio. Decisões de maior consequência precisam de revisão humana.

## Explore o modelo

O [Julia 1 no Hugging Face](https://huggingface.co/SupersonicLabs/Julia-1) reúne os pesos, a interface Python, as métricas, a proveniência e as instruções para baixar e executar o modelo. Os artefatos têm licença Apache 2.0.

Também estamos construindo uma API própria para Julia 1. Vamos abrir o acesso em breve para quem quiser integrar o modelo. O preço de lançamento será **US$ 0,025 por milhão de tokens de entrada** e **US$ 0,00 por milhão de tokens de saída**.

[Voltar ao laboratório](/)