Julia: 144 milhões de parâmetros, escolhe respostas em 44 ms na CPU (vs. Jev)

Autoria: Prompt Engineer 48 · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Julia: 144M Parameters, Picks Answers in 44 ms on a CPU (vs Jev) · Canal: Prompt Engineer 48 · 05:12 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Inferência e otimização de modelos, Modelos de IA, Modelos locais e open source

Resumo

O vídeo apresenta Julia 1, um decision model com 144,3 milhões de parâmetros que escolhe entre opções e roda na CPU em cerca de 44 ms por chamada. O apresentador compara seus resultados com referências de Jev e demonstra usos multilíngues, múltiplas perguntas por chamada e diferentes tipos de resposta. Os testes também expõem falhas sensíveis à formulação da pergunta, além de limites como a necessidade de sempre escolher uma opção. Julia pode ser baixada e executada localmente, enquanto Jev é oferecido por API em acesso antecipado; o vídeo recomenda testar qualquer um deles com os próprios dados antes de confiar nos resultados.

Pontos-chave

Julia 1 tem 144,3 milhões de parâmetros, checkpoint de 550 MB e licença Apache 2.0.
O modelo recebe um estado, uma pergunta e de duas a 20 opções, e retorna uma opção com probabilidades.
Em uma CPU, 100 chamadas curtas levaram 4,4 segundos, cerca de 44 ms por chamada.
Julia oferece respostas do tipo escolha, pontuação em escala ordenada e sim ou não com probabilidade.
O modelo aceita entradas em diferentes idiomas e pode responder a várias perguntas sobre um mesmo estado em uma chamada.
Os resultados de referência comparam Julia e Jev em conjuntos de classificação, mas não são uma nova execução de Jev.
A redação da pergunta pode alterar significativamente a resposta; alguns erros persistem mesmo após reformulações.
Julia precisa escolher uma opção mesmo diante de entradas irrelevantes e aceita apenas de duas a 20 opções.
O vídeo sugere usos como triagem de tickets, sinalização de urgência, pontuação de respostas e avaliação por rubricas.

Capítulos

Início	Capítulo	Resumo
00:00	Julia 1 e a comparação com Jev	O vídeo apresenta o tamanho, a velocidade e a proposta de Julia, e compara o modelo com Jev e resultados de referência.
01:34	Tipos de resposta e testes locais	O apresentador explica os formatos de resposta de Julia, mostra como carregá-lo e testa velocidade, idiomas e múltiplas perguntas.
03:07	Falhas e limitações do modelo	Exemplos mostram que a formulação da pergunta pode mudar a resposta e que o modelo pode errar ou ser inadequado para certas tarefas.
04:10	Versão GGUF e usos possíveis	O vídeo menciona arquivos GGUF e possíveis aplicações de Julia, contrapondo a execução local ao serviço de Jev por API.

Citações

Ele escolhe a resposta certa em cerca de 44 milissegundos. — 00:00

Não é um modelo de chat. Ele apenas compara as respostas que você fornece. — 00:31

Mesmo modelo, mesmo texto, formulação diferente. — 03:07

De todo modo, teste com suas próprias perguntas e opções antes de confiar nele. — 04:41

Conceitos e entidades

Julia 1 (modelo): Modelo de decisão da família Julia, apresentado como capaz de escolher entre opções e executado localmente na CPU.
Supersonic Labs (empresa): Empresa responsável pela família de modelos Julia.
Jev (modelo): Sistema de decisão oferecido por API em acesso antecipado e comparado com Julia no vídeo.
TypeSafe (empresa): Empresa associada ao sistema Jev.
mm bird small (modelo): Encoder multilíngue no qual Julia 1 é baseado.
Hugging Face (empresa): Plataforma mencionada como origem para baixar o repo do modelo.
GGML (empresa): Organização mencionada como distribuidora de uma versão GGUF de Julia.
llama.cpp (ferramenta): Projeto citado para executar a versão GGUF de Julia por meio do endpoint indicado.
Apache License 2.0 (conceito): Licença indicada para Julia 1.

Tradução completa (pt-BR)

00:00 Certo. Neste vídeo, vamos conhecer Julia, um decision model com apenas 144 milhões de parâmetros. Dá para ver que estou executando-o aqui na CPU do meu laptop, e ele escolhe a resposta certa em cerca de 44 milissegundos. Mas atenção: ele não consegue escrever uma única frase. Vamos ver por que esse é justamente o objetivo. Julia vem da Supersonic Labs, e Julia 1 é o primeiro modelo da família Julia. Ele é construído com base no mmBERT small, um encoder multilíngue, e tem ao todo 144,3 milhões de parâmetros. O checkpoint tem 550 megabytes, e a

00:31 licença é Apache 2.0. A ideia é a seguinte: você fornece três coisas — um estado, uma pergunta e de duas a 20 respostas possíveis. Ele devolve uma resposta com uma probabilidade para cada opção. Não é um modelo de chat. Ele apenas compara as respostas que você fornece. Essa ideia não é nova. E é aqui que Jev entra. Jev é o primeiro modelo de sistema 1 da empresa Typesafe. A proposta deles é: estado não estruturado na entrada, decisões probabilísticas tipadas na saída. Eles dizem que uma resposta leva de 70 a 500 milissegundos e que a entrada custa 4,2 centavos

01:03 por milhão de tokens. A saída é gratuita. A diferença está no acesso: Jev está em acesso antecipado por meio de uma API, enquanto Julia pode ser baixado. Empresas diferentes, mesmo tipo de problema; e o próprio model card de Julia coloca os números de Jev ao lado dos seus, para que possamos compará-los. Então, vamos olhar o teste de decisões tipadas do model card. Julia alcança 73,15%, e a referência de Jev é 72,7%. No AG News, com quatro rótulos, 94 contra 91. No conjunto de emoções, 86 contra 48. Mas, no Banking77, Julia chega a

01:34 64, e Jev fica em 87. Mas atenção: os números de Jev são referências fornecidas, não o resultado de uma nova execução de Jev. Os testes de classificação têm apenas 100 exemplos cada, e o Banking77 usa uma lista curta, não uma chamada nativa com 72 opções. Então, é um bom começo, não uma garantia. Julia responde a três tipos de pergunta. Choice escolhe uma opção de uma lista; score dá um número em uma escala ordenada; e null é a opção de sim ou não, com uma probabilidade de que a resposta seja sim. É simples obtê-lo. Baixamos o repo do Hugging Face,

02:05 que tem cerca de 550 megabytes. Instalamos com PIP e chamamos load model na minha máquina. O carregamento leva cerca de 20 segundos e, depois disso, o modelo permanece na memória. Vamos fazer uma pergunta. O estado é: “Fui cobrado duas vezes pelo mesmo pedido.” A pergunta é: “Qual equipe deve cuidar disso: cobrança, envio ou acesso?” E dá para ver que ele responde “cobrança”, com 85%. Quanto à velocidade, executei 100 chamadas seguidas. Foram 4,4 segundos no total, cerca de 44 milissegundos por chamada, na CPU, sem GPU. Mas atenção: estas são entradas curtas, então um

02:36 estado longo levará mais tempo. O modelo também é multilíngue. Escrevi a mesma reclamação em português, e ele respondeu “cobrança”, com mais de 99%. Depois, em hindi, escrevi que meu pacote não tinha chegado, e ele respondeu “envio”, novamente com mais de 99%. Você também pode fazer várias perguntas sobre um único estado em uma só chamada. O cliente diz que foi cobrado duas vezes, que ninguém está respondendo e que quer um reembolso hoje. Uma chamada, três respostas. A equipe é cobrança. Urgente é verdadeiro, com 99,8%, e a pontuação de raiva fica em torno de 1,1, o que significa irritado. Agora, vamos ver onde ele

03:07 falha, porque falha. O estado: “Nosso banco de dados de produção está fora do ar e os clientes não conseguem finalizar a compra.” Perguntei: “É uma emergência que exige atenção humana imediata?” E ele respondeu que não. 84% de probabilidade de falso. Está errado. Então, reformulei a pergunta e dei descrições reais para verdadeiro e falso: “Isso deve chamar o engenheiro de plantão agora? Não é urgente ou é uma interrupção urgente?” E agora ele responde verdadeiro, com praticamente 100%. Mesmo modelo, mesmo texto, formulação diferente. Não consegui corrigir o segundo caso. Um cliente diz que a comida estava fria e que o garçom o ignorou

03:38 por 40 minutos. Em uma escala de cinco pontos, o modelo respondeu neutro, com 99,97%. Com uma formulação melhor, ainda respondeu neutro, com 76%. E, como escolha entre negativo, neutro e positivo, respondeu neutro, com 100%. Então, esse é um erro real. Mais algumas limitações. Se você perguntar algo sem relação, como apenas “olá”, ele ainda precisa escolher uma opção, e respondeu “cobrança”, com 70%. Se você der uma opção ou 21, ele gera um erro, porque aceita apenas de 2 a 20. E não foi feito para matemática. Perguntei 17 * 23, e ele acertou, com 59% de probabilidade. Mas

04:10 o model card diz que essa capacidade não foi comprovada. Há também uma versão GGUF da GGML ORG. Ela vem em dois arquivos: Q8, com 168 MB, e BF16, com 303 megabytes. O card diz para executá-la com llama serve e o nome do modelo. E ela precisa do novo endpoint /v1/system em llama.cpp. Ainda não testei esse caminho. Então, experimente e me conte como foi. Então, onde você usaria algo assim? Em ifs inteligentes: escrever um ticket de suporte, sinalizar algo

04:41 como urgente, dar uma pontuação a uma resposta, verificar se uma resposta atende a uma rubrica — coisas para as quais normalmente você escreveria um monte de regras de palavras-chave e ficaria corrigindo-as. Jev aposta na mesma ideia, em escala de API. Julia é a opção que você pode baixar, ler o código e executar na sua própria CPU. Jev é a opção hospedada, em acesso antecipado. De qualquer forma, teste com suas próprias perguntas e opções antes de confiar no modelo. Neste vídeo, vimos Julia 1, um decision model com 144 milhões de parâmetros, e como ele se compara a Jev. Se tiver interesse, você também pode experimentar isso no seu próprio

05:12 sistema e me contar como foi. O modelo é Julia 1, da Supersonic Labs. Vejo você em outro vídeo. Confira o próximo vídeo.

Transcrição original

[00:00] All right. In this video, we will see Julia, a decision model with just 144 million parameters. You can see that I’m running it here on my laptop CPU and it picks the right answer in about 44 milliseconds. Now, mind you, it cannot write a single sentence. Let’s go ahead and see why that’s actually the point. So, Julia comes from Supersonic Labs and Julia 1 is the first model in the Julia family. It’s built on mm bird small, which is a multilingual encoder and the whole thing is 144.3 million parameters. The checkpoint is 550 megabytes and the

[00:31] license is Apache 2.0. Here’s the idea. You give it three things, a state, a question, and two to 20 possible answers. And it gives you back one answer with a probability for every option. It’s not a chat model. It only compares the answers that you hand it. Now, this idea is not new. And this is where Jev comes in. Jev is the first system one model from a company called Typesafe. Their line is unstructured state in typed probabilistic decisions out. They say a response takes 70 to 500 milliseconds and input costs 4.2 cents

[01:03] per million tokens. Output is free. The difference is access Jev is an early access behind an API and Julia as a download. Different companies same shape of problem and Julia’s own model card puts Jev numbers right next to its own so we can compare them. So let’s look at the card on their type decisions test. Julia gets 73.15% and the Jev reference is 72.7. on AG news with four labels 94 against 91. On the emotion set 86 against 48 but on banking 77 Julia gets

[01:34] 64 and Jeff is at 87. Now mind you the Jeff numbers are supplied references not a fresh Jeff run. The classification tests are just 100 examples each and banking 77 uses a short list not a native 72 option call. So this is a good start not a guarantee. Julia answers three kinds of question. Choice picks one option from a list score gives you a number on an ordered scale and null is the yes or no one with a probability that it’s yes. Getting it is simple. We download the repo from hugging face

[02:05] which is about 550 megbytes. PIP install it and call load model on my machine. It takes about 20 seconds to load and after that it stays in memory. Let’s go ahead and ask it something. The state is I was charged twice for the same order. The question is which team should handle this billing, shipping or access? And you can see it says billing with 85%. Now the speed I ran 100 calls in a row. That’s 4.4 seconds in total about 44 milliseconds each on a CPU no GPU. Mind you these are short inputs so a long

[02:36] state will take longer. It’s also multilingual. I wrote the same complaint in Portuguese and it says billing over 99%. Then in Hindi I wrote that my package has not arrived and it says shipping again over 99%. You can also ask several questions about one state in a single call here. The customer says they were charged twice, nobody’s answering, and they want a refund today. One call, three answers. The team is billing. Urgent is true at 99.8% and the anger score comes out around 1.1, which is annoyed. Now, let’s see where it

[03:07] breaks because it does. The state, our production database is down and customers can’t check out. I asked, is this an emergency needing immediate human attention? And it says no. 84% false. That’s wrong. So what I did is I rewrote the question and gave true and false real descriptions. Should this page the on call engineer right now, not urgent or urgent outage? And now it says true with basically 100%. Same model, same text, different wording. The second one I could not fix. A customer says the food was cold and the waiter ignored

[03:38] them for 40 minutes. On a fivepoint scale, it said neutral 99.97% with better wording. It still said neutral 76%. and as a choice between negative neutral and positive neutral at 100. So that’s a real miss. A few more limits. If you ask it something unrelated like just hello, it still has to pick one and it said billing at 70%, give it one option or 21 and it throws an error because it only takes 2 to 20 and math is not what it’s for. I asked 17 * 23 and it got it right at 59%. But

[04:10] the model card says that ability is not established. Now there’s also a GVUF version from GGML ORG. It comes as two files Q8 at 168 MGB and BF16 at 303 mgabytes. The card says to run it with llama serve and the model name. And it needs the new /v1/system on endpoint in llama.cpp. I haven’t run this path yet. So go ahead and try it and let me know how it goes. So where would you use something like this? Smart if statements wrote a support ticket. flag something

[04:41] as urgent, score a reply, check if an answer fits a rubric, things where you’d normally write a pile of keyword rules and keep fixing them. Jev is the same bet at API scale. Julia is the one you can download, read the code off, and run on your own CPU. Jev is the hosted one in early access. Either way, test it on your own questions and options before you trust it. So, in this video, we have seen Julia A1 144 million parameter decision model and how it lines up against Jev. If you’re interested, you can go ahead and try this on your own

[05:12] system as well and let me know how it goes. The model is Julia 1 from Supersonic Labs. I’ll see you in another one. Check out the next video.