Jev: o modelo de classificação definitivo?

Autoria: Sam Witteveen · 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: Jev - The Ultimate Classification Model? · Canal: Sam Witteveen · 16:01 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Inferência e otimização de modelos, Modelos de IA

Resumo

O vídeo apresenta Jev, um modelo da Typesafe AI voltado a decisões rápidas e tarefas de classificação, em contraste com LLMs focados em raciocínio longo. Em vez de gerar texto, Jev recebe dados e perguntas tipadas — escolha, pontuação ou sim/não — e retorna respostas estruturadas com probabilidades. Demonstrações mostram usos como classificação de mensagens, análise de sentimento, detecção de dados pessoais e seleção de ferramentas, com baixa latência e custo. A arquitetura e o método de treinamento RLCD ainda não são explicados em detalhe, e o apresentador ressalta que o modelo pode errar mesmo quando respeita o formato solicitado.

Pontos-chave

Jev é apresentado como um modelo System 1 para decisões rápidas, não como um chatbot de uso geral.
O modelo recebe dados não estruturados e perguntas tipadas de escolha, pontuação ou sim/não.
As respostas incluem probabilidades, sem depender de texto gerado para preencher um JSON.
As demonstrações incluem roteamento de chamados, análise de sentimento, detecção de PII, spam e seleção de ferramentas.
O modelo pode ser rápido e barato em tarefas de classificação, mas suas respostas continuam sujeitas a variação e erro.
A Typesafe AI cita uma nova arquitetura, um amostrador paralelo e o método de treinamento RLCD, mas não divulga detalhes técnicos.
O apresentador considera Jev uma alternativa a avaliar para tarefas hoje executadas com modelos BERT menores ajustados para classificação.

Capítulos

Início	Capítulo	Resumo
00:00	Por que decisões simples não precisam de raciocínio longo	O vídeo contrapõe o raciocínio demorado dos modelos de fronteira a tarefas de classificação simples que aparecem em softwares.
03:13	Como Jev recebe perguntas e retorna decisões	O apresentador explica os tipos de entrada e saída de Jev e demonstra escolhas, pontuações e respostas de sim ou não.
05:23	Demonstrações de classificação e exemplos práticos	Testes mostram Jev classificando idiomas e sentimentos, avaliando mensagens e lidando com tarefas como roteamento e detecção de conteúdo.
09:08	Roteamento, segurança e seleção de ferramentas	O vídeo testa chamados ambíguos, urgência, injeção de prompt, sarcasmo, revisão de código, PII, spam e seleção de ferramentas.
12:49	Arquitetura, velocidade e limitações	O apresentador discute as informações limitadas sobre a arquitetura e o RLCD, a rapidez das respostas e a possibilidade de escolhas incorretas.
15:31	Usos potenciais e próximos passos	O vídeo considera Jev para automatizar decisões, compara seu potencial ao ajuste de modelos BERT e convida o público a compartilhar testes.

Citações

O chat é a interface errada para software. O software não quer um parágrafo; quer um valor que possa usar imediatamente. — 02:41

Pense neste modelo como uma instrução condicional inteligente. — 04:16

Tudo retorna em uma única passagem. — 13:54

Ele ainda pode escolher a opção errada e, portanto, dar uma resposta errada. — 14:24

Conceitos e entidades

Jev (modelo): Modelo apresentado como uma solução de baixa latência para decisões estruturadas e tarefas de classificação.
TypeSafe AI (empresa): Empresa que desenvolveu Jev e que, segundo o vídeo, passou dois anos trabalhando no modelo em sigilo.
Diogo Almeida (pessoa): Fundador da Typesafe AI, anteriormente ligado à OpenAI e um dos principais autores do artigo InstructGPT.
InstructGPT (modelo): Trabalho de pesquisa mencionado como parte do desenvolvimento de modelos capazes de seguir instruções.
System 1 (conceito): Modo de pensamento rápido e intuitivo usado no vídeo para caracterizar o tipo de decisão que Jev busca automatizar.
System 2 (conceito): Modo de pensamento lento e deliberado associado no vídeo aos modelos que realizam cadeias longas de raciocínio.
RLCD (conceito): Sigla de reinforcement learning for calibrated decisions, método de treinamento citado pela Typesafe AI sem explicação detalhada.
OpenRouter (ferramenta): Serviço por meio do qual o apresentador acessa Jev nas demonstrações.
Cactus (modelo): Modelo citado como comparação para a seleção de ferramentas, embora Jev não extraia os argumentos a serem enviados à ferramenta.
BERT (modelo): Família de modelos mencionada como exemplo de alternativa usada em tarefas de classificação.

Tradução completa (pt-BR)

00:00 Certo, se você observar, de modo geral, o que todos os laboratórios de ponta vêm fazendo nos últimos dois anos, tudo tem seguido uma única direção. Todos têm se concentrado em raciocínio e, para obter esse raciocínio, têm se dedicado principalmente a cadeias de pensamento mais longas e a orçamentos de pensamento. E, embora esses modelos sejam ótimos, eles ficam ali, tranquilamente, por vários minutos antes mesmo de responder. E, claro, se você quiser ver essa cadeia de pensamento, os laboratórios de ponta não vão deixar, mesmo que você esteja pagando por isso. Então, se você leu o livro de Daniel Kahneman, Thinking Fast and Slow, você

00:32 sabe que todo esse tipo de raciocínio é pensamento do Sistema 2. É lento, deliberado e exige esforço, enquanto o Sistema 1, por outro lado, é rápido, intuitivo, como uma decisão instintiva que você toma muito depressa, sem deliberar. E é aqui que o tema do vídeo de hoje fica realmente interessante, na minha opinião. A maioria das decisões que existem dentro de softwares não são problemas do Sistema 2. Muitas vezes, são apenas problemas bem simples de classificação. Que tipo de chamado de suporte é este? Esta mensagem é urgente? A saída de um agent realmente violou alguma regra?

01:04 Você nem deveria precisar de 30 segundos para esse tipo de pensamento, muito menos dos minutos que alguns modelos acabam levando. E, embora seja ótimo poder pedir a um desses modelos de raciocínio uma resposta de uma palavra e depois envolvê-la em JSON, você paga um custo enorme de latência para gerar todo aquele texto antes de receber o rótulo de uma palavra. Então, nesta semana, um novo laboratório que acabou de sair do modo furtivo seguiu exatamente o caminho oposto ao dos modelos de raciocínio. Eles criaram um modelo com o qual você não pode conversar, muito menos fazê-lo raciocinar e

01:35 deliberar sobre as coisas por muito tempo. Ele simplesmente não gera texto da maneira autoregressiva padrão. E o mais curioso é que, por ser assim, os tokens de saída desse modelo são gratuitos. Mas entender por que esses tokens são gratuitos pode ser justamente o que nos diz muito sobre como essa coisa foi construída. Certo, a empresa se chama Typesafe AI, e o modelo se chama Jev. O fundador é Diogo Almeida, que trabalhou na OpenAI por bastante tempo. E, curiosamente, foi um dos principais autores do artigo do InstructGPT.

02:08 Esse foi o artigo que levou a todo o processo de ajuste de instruções dos modelos, que desde então avançou até os modelos de raciocínio que vemos hoje. Então, se você não sabe, esse artigo basicamente pegou um modelo de linguagem bruto, mais ou menos o que hoje chamaríamos de modelo base, e fez com que ele seguisse instruções. E toda essa pesquisa levou ao ChatGPT. Ou seja, estamos falando de alguém que claramente ajudou a tornar os modelos bons em conversar com as pessoas. E a pergunta que, segundo ele, vem incomodando há quatro anos é: à medida que os modelos se tornaram sobre-humanos em conversação, onde está toda a automação?

02:41 E, curiosamente, ele diz que a conversa é a interface errada para software. O software não quer um parágrafo. Quer um valor que possa usar imediatamente. Diogo e o restante da equipe da TypeSafe AI passaram os últimos dois anos trabalhando em sigilo nesse modelo chamado Jev. Certo. Então, o que é o Jev? Eles se referem especificamente a ele como um modelo do Sistema 1. E provavelmente a maneira mais fácil de entendê-lo é como uma espécie de chamada de função. Você passa duas coisas. A primeira é o que eles chamam de estado, que é simplesmente o seu

03:13 texto ou dado não estruturado. Pode ser qualquer coisa que você queira classificar. Pode ser um chamado de suporte, um registro de atividade de um agent, um arquivo de log etc. E a segunda coisa que você passa é um conjunto de perguntas tipadas. Há apenas três tipos de pergunta que você pode fazer. Há a escolha, em que você fornece uma lista de opções e o modelo escolhe uma. Há a pontuação, em que ele avalia algo em uma escala definida por você. E há uma chamada noul, que é uma pergunta de sim ou não, cuja resposta vem na forma de uma probabilidade de que a resposta seja sim.

03:46 Então, se você observar o que retorna, não há texto para analisar. Para a pergunta de escolha, você recebe a opção escolhida e também a probabilidade de cada uma das outras opções. E acho isso realmente interessante, porque é uma das coisas que muitos de nós temos tentado imitar com JSON: pedimos aos modelos que façam algo e retornem uma saída em JSON. Mas, em muitos casos, o número que você recebe ali é apenas texto gerado. E, se você observar coisas como LLM as a judge, muitas vezes vai perceber que esse texto tende a se inclinar de uma maneira bem específica.

04:16 Ou seja, é apenas um modelo escrevendo os caracteres 0.9, em vez de uma representação real de probabilidade. A maneira como eles querem que você use esse modelo é pensar nele como uma instrução if inteligente. Você não faz uma pergunta ampla e vaga, como “Avalie esta proposta de startup”. Você faz pequenas perguntas instintivas. Qual é a viabilidade disso? Que tipo de mercado eles estão buscando? E, claro, se você fizer uma pergunta de escolha, precisa fornecer as opções entre as quais o modelo deve escolher. Aí, o mais legal é que você pode combinar

04:47 tudo isso em código comum. Então, quando algo muda, você pode simplesmente alterar um número no seu código. Não precisa ajustar nenhum prompt nem nada. Certo, o que fiz foi basicamente programar um pequeno aplicativo de demonstração para testar isso. Estou usando o modelo na OpenRouter. Então, este é um modelo de preços meio maluco, né? Estamos falando de 4.20 centavos por milhão de tokens de entrada e zero centavos por milhão de tokens de saída. E, se entrarmos aqui, dá para ver que eles têm um código mostrando como chamá-lo usando os endpoints de API da OpenAI. E tenho experimentado

05:23 por algumas horas, com diferentes tipos de demonstrações e testando coisas variadas. Então, o primeiro ponto importante é que há três tipos de coisas que você pode fazer, certo? Uma delas é uma escolha. Aqui dá para ver que tenho um texto que vou analisar, e há cinco classes diferentes para escolher. E o modelo é muito bom em detectar qual delas é a correta. Se olharmos a saída bruta, veremos que ela basicamente tem o tipo choice. Neste caso, a escolha foi francês, e depois ele nos dá as probabilidades,

05:56 de cada uma delas e uma pontuação de confiança. E dá para ver que ele fez isso bem rápido. Provavelmente estou no lado oposto do mundo em relação ao lugar onde o modelo está hospedado. Mas você vai notar que ele responde muito rápido. Até em casos como este, em que quis testá-lo em tailandês, usando os caracteres tailandeses, ele identifica de imediato que é o idioma tailandês. Então pedi que fizesse uma versão romanizada do texto. E dá para ver que ele também não tem dificuldade nenhuma em acertar isso.

06:27 A segunda coisa que você pode fazer é pedir que ele dê uma pontuação. Aqui dá para ver que estamos dando uma pontuação entre zero e dois. Estamos avaliando o sentimento e, mais uma vez, fazendo uma tarefa de classificação. O resultado é o sentimento. Se escolhermos sentimento positivo, dá para ver que ele retorna dois de dois. Se escolhermos negativo, zero. Se escolhermos misto, ele também se sai muito bem. E dá para ver que, a cada vez, isso está me custando zero vírgula zero zero

06:58 um quatro de centavo aqui, certo? Se você conseguir dividir o que está tentando fazer em várias classificações diferentes, dá para fazer muita coisa com isso por um custo extremamente baixo. E dá para ver que, neste caso, quando tentei deixá-lo um pouco mais positivo do que no meio, ele mudou a resposta a cada vez. Então, ainda há um processo estocástico em andamento, e dá para ver que a confiança é menor do que antes. A cada vez que faço uma chamada, recebo algo ligeiramente diferente, mas bem próximo de

07:31 as mesmas pontuações, mais ou menos nessa faixa. Quando olhamos para a API disso, dá para ver as probabilidades que ela retorna. Neste caso, passamos uma pontuação e ela nos devolveu esse resultado. Então, a pontuação é uma função bem útil. Por fim, temos aqui probabilidades de verdadeiro ou falso, ou de sim ou não. Então, este é um modelo de classificação e, basicamente, ele retorna uma probabilidade para o que inserimos. Se eu perguntar algo simples assim, ele responde “sim” com 87% de probabilidade,

08:01 “Este texto está fazendo uma pergunta?” A resposta aqui seria não. Dá para ver que a probabilidade de “sim” é de 2%, então, basicamente, é “não”, certo? Dá para pensar nisso como algo achatado por uma função sigmoide: o resultado fica entre zero e um. Mesmo se fizermos algo como uma pergunta sem ponto de interrogação, ele tem muita confiança de que ainda é uma pergunta, mesmo sem o ponto de interrogação. Então, não é como se ele estivesse simplesmente procurando um ponto de interrogação. E dá para ver que diferentes tipos de pergunta recebem respostas diferentes. Curiosamente, se eu simplesmente perguntar “Você pode ajudar?”, ele tem bem menos certeza se

08:35 pode, porque não fui específico. Mas, se eu perguntar “Você pode ajudar a encontrar meu gato?”, ele tem 95% de certeza de que consegue. E, se eu mudar apenas uma palavra e perguntar “Você pode me ajudar a alimentar meu gato?”, a confiança cai um pouco. Então, é interessante como ele faz isso. Dá para ver que, novamente, ainda é um processo estocástico. O resultado muda um pouco a cada vez, mas é bem consistente quando se trata de dizer que algo é uma coisa ou outra. E dá para ver que, se eu der apenas duas palavras, ele começa

09:08 a perder a confiança nisso. Então, parece que, quanto mais longo o texto de entrada, mais confiança ele tem nas respostas. Certo, agora vamos ver algumas aplicações mais práticas que podemos fazer aqui. Dá para inserir uma mensagem como “Fui cobrado duas vezes por um pedido. Por favor, reembolse a cobrança duplicada…” e pedir que ele determine para qual equipe encaminhá-la. Aqui, a categoria de cobrança é bem óbvia. Para vendas, ele retorna 100% de confiança. E se fizermos algo um pouco mais ambíguo?

09:39 Agora dá para ver que ele não tem muita confiança. Na verdade, ele retorna que a categoria não está clara, mas ainda considera que se trata mais de uma questão técnica. E dá para ver que, cada vez que executamos isso, obtemos uma resposta um pouco diferente. Agora, além dessas tarefas, estamos fazendo várias coisas ao mesmo tempo. Dá para ver que também temos aqui um modelo de classificação para identificar se foi solicitado um reembolso. Obviamente, se eu selecionar isso, a resposta é sim. O caso é sensível ao tempo? Certo? Neste caso, ele indica que há 7% de chance de ser sensível ao tempo.

10:11 Se eu mudar para “Por favor, reembolse a cobrança duplicada agora mesmo”, em vez de apenas “agora mesmo”, dá para ver que a probabilidade de ser sensível ao tempo sobe para algo em torno de 60% ou 70%, neste caso. Também podemos tentar coisas como inserir instruções, por exemplo, testar casos em que alguém tenta fazer uma prompt injection ou algo assim. Parece que ele lida muito bem com isso. O sarcasmo também parece ser algo com que ele se sai razoavelmente bem. Também seria interessante testá-lo com humor e outras coisas do tipo.

10:44 Mas é bom que ele não seja enganado por várias coisas diferentes que normalmente enganariam esse tipo de sistema. Outras tarefas que podemos pedir que ele execute incluem revisões de código, por exemplo, perguntar se algo é seguro ou não. Parece que ele faz um bom trabalho nisso. Classificar diferentes tipos de conteúdo também parece funcionar muito bem. Dá para ver aqui que ele consegue detectar informações de identificação pessoal, ou PII. Ele faz um bom trabalho com esse tipo de coisa. Também se sai bem na detecção de spam.

11:16 O quarto exemplo aqui é a seleção de ferramentas por um agent. Isso é um pouco parecido com o modelo Cactus, que vimos há algum tempo, no sentido de que envolve algum tipo de chamada de função. Mas é importante entender que ele não extrai nada para passar à ferramenta, certo? Ele apenas nos diz qual ferramenta usar, em vez de obter os argumentos corretos para passar à ferramenta. Nesse sentido, os modelos de chamada de função ainda conseguem basicamente

11:46 gerar o que deve ser enviado como entrada para a função. Por último, uma das coisas que achei muito interessante testar foi encadear ações, certo? Ou seja, damos algo a ele e depois queremos executar várias tarefas diferentes sobre isso para ver quanto tempo leva e como ele processa tudo. Aqui estão 20 tarefas diferentes sendo executadas, e dá para ver que ele está avançando rapidíssimo. Eu poderia ter executado algumas delas em paralelo, pelo menos.

12:17 Mas dá para ver que, apenas fazendo isso, passamos por todas as 20 tarefas, obtivemos as respostas e recebemos os resultados. E custou pouco mais de 1/20 de centavo. Acho mesmo que é aqui que vamos encontrar coisas realmente interessantes, certo? Quando você consegue encadear várias classificações diferentes para obter algum tipo de resposta, isso é muito valioso e rápido. Certo, então como tudo isso funciona?

12:49 Bem, eles não nos contam muita coisa. Não há artigo nem diagrama da arquitetura. Não fornecem muitas informações, mas mencionam três elementos: uma nova arquitetura de modelo, um amostrador paralelo e, talvez o mais interessante, estão treinando com um novo método que chamam de RLCD. Isso significa aprendizado por reforço para decisões calibradas. Eles não explicam exatamente como o RLCD funciona, mas comparam o método com LLMs existentes que usam tanto RLHF, ou seja, aprendizado por reforço com feedback humano, quanto aprendizado por reforço com recompensas verificáveis,

13:22 que abrange todo o GRPO e muitas das maneiras pelas quais os modelos modernos estão sendo treinados atualmente. Então, parece provável que seja algum tipo de transformer, mas talvez o que ele esteja fazendo de fato seja usar a etapa de prefill para calcular as heads, etc. Depois, faz uma previsão que é simplesmente uma classificação ou uma regressão, dependendo das diferentes tarefas em questão. Uma das coisas legais aqui é, sem dúvida, a velocidade. Como não são gerados tokens um após o outro,

13:54 tudo retorna em uma única passagem. Isso significa que a resposta chega em cerca de 70 a 500 milissegundos. Somando o tempo da ida e volta, continua sendo extremamente rápido para esse tipo de tarefa. Uma das coisas que acho fascinantes é a afirmação de que ele não pode alucinar. E parece que o que estão realmente dizendo é que ele não vai sair do schema que você fornece para retornar os resultados. Ou seja: nada de JSON inválido, nada de nomes de ferramentas inventados. Ele só consegue lidar com aquilo que você realmente forneceu.

14:24 Ele não vai gerar nada de novo. Ainda assim, parece que pode escolher a opção errada e dar uma resposta incorreta. Isso significa que pode identificar corretamente o tipo de pergunta, mas ainda assim fornecer uma resposta errada. E parece que é aqui que eles contam com o RLCD para fornecer respostas de alta qualidade. Não sabemos se é apenas um LLM menor, treinado de outra maneira, ou se é realmente uma arquitetura diferente, etc. Mesmo assim, é meio incrível que ele consiga fazer coisas como jogar Doom, em que pode

14:58 fazer isso tão rapidamente, que você basicamente consegue fazê-lo responder a essas entradas. E o que acho fascinante aqui é que fazer isso e executar cerca de 10 consultas por segundo, mesmo nessa taxa, acaba custando apenas cerca de US$ 7 por hora. Então, no geral, eu diria que, se você está fazendo qualquer tipo de classificação com algum modelo BeRT ou coisas assim, definitivamente vale a pena experimentar para ver como funciona nos seus casos de uso específicos. E fico pensando se isso realmente entrega o que promete: será que isso significa o fim do fine-tuning de modelos BeRT pequenos para tarefas exclusivamente de classificação? É

15:31 que eles ressaltam aqui que ainda é cedo e que estão realmente focados em qualquer tipo de decisão que você precise conseguir automatizar. E meu palpite é que eles provavelmente deram início a uma onda de pessoas tentando criar versões open source disso. Então, no próximo mês ou algo assim, talvez vejamos alguns modelos open source muito interessantes que sigam ideias semelhantes a esta. Enfim, me contem nos comentários se vocês já experimentaram o Jev e onde

16:01 conseguiriam se imaginar usando-o. E eu adoraria ouvir quem já o testou e descobriu que não funcionava para certas coisas. Quais foram os casos de uso em que não funcionou? E, como sempre, se você achou o vídeo útil, clique em gostei e inscreva-se no canal. Até o próximo vídeo. Tchau por enquanto.

Transcrição original

[00:00] Okay, so if you pretty much look at what every frontier lab has been doing over the past two years. It’s all been in one direction. They’ve all been focused on reasoning and to get that reasoning, mostly they’ve been focused on longer chains of thought and thinking budgets. And while those models are great, they’ll happily sit there for multiple minutes before they even give you an answer back. And of course, if you wanted to see that chain of thought the frontier labs are not gonna let you see it even though you’re paying for it. So if you read Daniel Kahneman’s book, Thinking Fast and Slow, you

[00:32] know that all this kind of reasoning stuff is system two thinking. It’s slow, deliberate, effortful whereas System 1 on the other hand is fast, intuitive, sort of like a gut call that you make really quickly without any deliberation. And here’s where the subject of today’s video I think is really interesting. Most decisions that actually sit inside of software aren’t system two problems. They’re often just really simple classification problems. What kind of support ticket is this? Is this message urgent? Did an agent’s output actually break a rule?

[01:04] You shouldn’t even need 30 seconds for that kind of thinking let alone the sort of minutes that some of the models end up taking. And while It’s great that you can ask one of these reasoning models for a one-word answer and then wrap it in JSON, you’re paying a huge latency cost for generating all that text before you get your one-word label back. so this week a new lab that’s just come out of stealth has gone the complete opposite way of the reasoning models. They’ve built a model that you can’t chat with at all, let alone have it reason and

[01:35] deliberate over things for a long time. It just doesn’t generate text in the standard autoregressive way. And the funny thing actually enforcing that is that the output tokens of this model are actually free. But actually working out why those tokens are free might be the thing that actually tells us a lot about how this thing is built. All right, so the company is called Typesafe AI, and the model is called Jev. So the founder is Diogo Almeida, and actually he was at OpenAI for quite a while before. And funnily enough was one of the top authors on the InstructGPT paper.

[02:08] That was the paper that actually led to the whole sort of instruction tuning of models, which has just progressed onwards from that to the reasoning models that we see today. So if you don’t know, that paper basically took a raw language model, basically like what we would call a base model now, and actually made it follow instructions. And out of all that research came ChatGPT. So this is someone who clearly helped make models good at talking to people. And the question that he says that’s been bugging him for the last four years is that as models have become superhuman at chat, where’s all the automation here?

[02:41] And interestingly, he’s saying that chat is the wrong interface for software. Software doesn’t want a paragraph. It wants a value that it can basically use straight away. Now, Diogo and the rest of the team at TypeSafe AI have spent the last two years in stealth working on this model called Jev. Alright. So what is Jev? so they specifically refer to this as a system one model. And probably the easiest way of looking at this is it’s kind of like a function call. You pass in two things. the first is what they call the state, which is just your

[03:13] unstructured text or data. And that could be anything that you want classified. It could be a support ticket, could be an agent trace, it could be a log file, et cetera. And then the second thing that you pass in is a set of typed questions. And there are only three kinds of questions that you can ask here. There’s choice, where you give it a list of options and it picks one. There’s score, where it rates something on a scale that you defined. And then there’s one called noul, which is a yes or no question, where it basically comes back with a probability that the answer is yes.

[03:46] So if you look at what comes back here, there’s no text to parse. For the choice question, you get the option it picked and also a probability of every other option. And I think this is really kind of interesting because this is one of the things that a lot of us have kind of been trying to fake with JSON, where we ask models to do stuff and return JSON output. But in many ways, the number that you’re getting back there is just generated text. And if you look at things as LLM as a judge, you’ll often see that that text skews in a very certain way.

[04:16] I.e., it’s just a model writing the character 0.9 rather than actually a real representation of probability. The way they want you to use this model is to think about it as being a smart if statement. You don’t ask one big fuzzy question like, “Rate this startup pitch.” you ask small gut questions in there. What’s the feasibility of this? What type of market are they going after? And of course, if you’re asking a choice question, you have to actually give it the options to choose from. Then the cool thing is that you can actually combine

[04:47] all of those in normal code. So when something changes, you can just change a number in your code. you don’t need to go and tweak any prompts or anything All right, so what I’ve done is basically just code up a, little demo app to try this out. I’m using the model on OpenRouter. So This is a crazy sort of price model, right? You’re looking at 4.20 cents per million tokens in and zero, cents per million tokens out and you can see if we come in here, they’ve got some code to actually how to call it on, using the OpenAI, API endpoints, And so I’ve been playing around

[05:23] for a couple of hours with different kinds of demos and trying out different things. so the first key thing here is that there are three kinds of things that you can do, right? One of them, is a choice. So you can see here I’ve got some text that I’m gonna parse in, and then it’s got a choice of five different classes out here. and it’s very good at being able to detect, which of these is the right one. And so what it will do if we look at the raw output here is that it basically has a type choice. in this case, the choice was French, and then it gives us the probabilities,

[05:56] for each of these and a confidence score And you can see that it did that, pretty quickly. So I’m probably on the opposite side of the world to where the model is actually being hosted. but you’ll see that it’s very quick at being able to respond. even for things like this where, I wanted to try it on Thai, but using the Thai characters, it’s gonna give it its way straight away that it’s the Thai language. So I asked it to basically make like a Romanized version of that. and you could see that even that has no problems being able to get that right.

[06:27] The second thing that you can do with this, is you can get it to give a score. So here you can see that we’re giving a score between zero and two, We’re sort of doing sentiment here, and we’re doing a classification task again. we’ve got sentiment coming out, and if we go for positive sentiment, you’ll see it comes out two of two. If we go for negative, zero. If we go for mixed, it’s pretty good at being able to do that. And you can see each time this is costing me, zero point zero zero

[06:58] one four of a cent right, in here. if you can break down what you’re trying to do to lots of different, classifications, you really can extremely cheaply, do a lot of stuff with this And you can see in this case where I tried to make it a little bit more positive than in the middle, I… It does change coming back each time. So It still is a stochastic process going on here, and we can see, the confidence, is less than before. each time I ping it, I’m getting something slightly different, but pretty close to

[07:31] the same sort of, ballpark scores there. when we look at the API for that, you can see that, okay, the probabilities that it’s coming back. So you can see in this case, we’ve passed in a score. We’ve got that back, coming out of there So scoring is a really nice, function in there. And then lastly, we’ve got the true or false or the yes, no, kind of probabilities here. So this is a noul, and It’s basically gonna give back a probability for, what we put in. Now, if I ask it, something simple like that, it comes back 87% yes,

[08:01] Is this text asking a question? Okay, the answer would be no here. So you can see that it’s 2% yes, so basically it’s no, right? You could kind of think of this as being flattened out by a sigmoid function, so you’ve got zero to one coming out of this and even if we do things like where, okay, we’ve got a question, but we’ve got no question mark, it’s very confident that that is still a question without a question mark. So it’s not like it’s just looking for a question mark there And you can see different kinds of questions will get different, responses. So interestingly, if I just ask it, “Can you help?” it’s a lot less sure if

[08:35] it can ’cause I haven’t been specific. But if I ask it, “Can you help find my cat?” Well, then it’s 95% sure, that it can do it And if I just change one word in there to, “Can you help me feed my cat?” it goes back down a bit. So, it is interesting, how it actually does this. you will see that, like, again, this is still a stochastic process. It comes back, slightly different each time, but it is pretty consistent of you either being able to say one thing or the other thing And you can see if I just give it two words, then it starts

[09:08] losing its confidence, about this. so it does seem to me the longer the, the input that you put in, the more confident it gets with its responses out All right, now looking at some sort of more practical kinds of things, that we could do here. you can see that we can put in like a message of, “I was charged twice for an order. please refund the duplicate-” get it to work out which team it’s gonna route it to. here it’s billing kind of obvious sales one. It gets, 100% sales. What if we do something a little bit more ambiguous?

[09:39] You can see now it’s not very confident. it’s actually coming back that it’s unclear, as, as the class, but it’s still thinking that this is more of a technical kind of thing. And you can see that each time we run that, we do get a slightly different response, you know, going through this now on top of these, we’re actually doing multiple things at the same time. So you can see, that we’ve also got a noul in here for was a refund requested. Obviously, if I, select this, the answer is yes. is it sort of time sensitive? Right? I- in this case, it’s saying, time sensitive 7%.

[10:11] if I change that to, “Please refund the duplicate charge right now,” instead of just right now, you can see the time sensitive is jumping up to sort of like 60, 70%, in this case. We can even try it with things like, injecting stuff in there, so doing any sort of thing where, someone’s trying to do a prompt injection or something like that, this seems to do pretty well at being able to, get that kind of thing. Sarcasm is also something that it seems to be doing an okay job at it. it would be interesting also to test it on humor and other kind of things.

[10:44] but it is good that it’s not being tricked by a lot of different things that normally would trick this kind of thing Other tasks that you can get it to do is things like, code reviews, like where you can basically ask it, Is something safe? Is something not safe?” it seems to do a good job at that Doing things like classification on, different types of content, that seems to work really well. you can see here it’s able to discover PII information, personal identifiable information here. it does a good job with that kind of thing. it does a good job at sort of spam detection as well.

[11:16] So the fourth example here is looking at agent tool selection. So this is a little bit like the Cactus model, that we looked at a while ago, in that it’s doing some kind of sort of function calling. But it’s important to understand here that it’s not actually extracting anything out and passing it to the tool, right? It’s just telling us which tool to use, as opposed to, getting the right arguments out to pass to the tool. So in that sense, function calling models are still able to basically

[11:46] generate out what should be the input going to the function Last up, one of the things that I thought was really interesting to test it is stringing actions together, right? So where we basically give it something and we then want to basically run, a number of different tasks over this, to see how long does it take, how does it actually process these. so here’s 20 different tasks going through, and you can see that it’s flying along. Now, I could have done them in parallel, for some of them at least.

[12:17] but you can see that just going through it like that, we’ve gone through, all different 20 tasks in here, gotten the answers out, gotten the results back, for these, And it’s cost just over 1/20 of 1 cent I really feel like this is where you’re going to find really interesting things, right? When you can string lots of different classifications together to be able to get some kind of response out, That’s really valuable for you in a really quick time Okay, so how does this all actually work?

[12:49] Well, they don’t really tell us a lot here. There’s no paper, there’s no architecture diagram. They don’t give us a lot of information, but what they do give us is three pieces, that they mention that there’s a new model architecture, a parallel sampler, and then perhaps the most interesting bit is that they’re training with a new method they’re calling RLCD. This is reinforcement learning for calibrated decisions. Now how RLCD actually works, they don’t really tell us, but they compare that to the existing LLMs using both, RLHF, so that’s reinforcement learning from

[13:22] human feedback, and also, reinforcement learning from, verifiable rewards, which is your whole sort of GRPO and a lot of the ways that the modern models are being trained at the moment. So it does seem probable to me that this is some kind of transformer, but perhaps what it’s actually doing is just using the prefill stage to calculate heads, et cetera, And then doing a prediction out which is just a classification or a regression depending on the different tasks that you’ve got there. One of the cool things here is definitely the speed. Because there are no tokens being generated one after another,

[13:54] everything comes back in a single pass. And that means you’re done in about 70 to 500 milliseconds, which you can add to the basically round trip time and it’s still extremely fast for doing these kinds of tasks. Now, one of the things I find fascinating is that they claim it can’t hallucinate. And it seems what they’re really saying there is that this is not gonna break the schema that you give it to basically come back with things. So like no broken JSON, no invented tool names. it can only deal with what you’ve actually given it.

[14:24] It’s not gonna actually generate sort of anything new there. Now it does seem that it can still pick the wrong option and like a wrong answer, meaning that it could have the right type of question, but actually give you a wrong answer for that. And it seems that this is where they’re relying on that RLCD to be able to deliver high-quality answers back. Now, we don’t know if this is just like a smaller LLM that’s been trained in a different way or if this is actually a different architecture, et cetera. It is kind of amazing though that it can do things like play Doom where it can

[14:58] do it so quickly, that you can basically have it responding, to these inputs And the thing that I find fascinating here is that doing that and running sort of 10 queries per second, even in that rate ends up only costing about $7 per hour. So overall, I would say if you’re doing any kind of classification with, any kind of BeRT model or things like that, this is definitely worth trying out to see how it goes for your particular use cases. And I do wonder if this really delivers like they say it does, is

[15:31] this going to be the end of sort of fine-tuning small BeRT models for doing purely classification tasks. Anyway, they make the point here that this is early days, that they’re really focused on any sort of decision that you need to be able to automate. And my guess is that they’ve probably kicked off a whole bunch of people trying to make open source versions of this. So over the next month or so, we might see some really interesting open source models that come along with similar ideas to this. Anyway, let me know in the comments if you’ve actually tried Jev, where you

[16:01] could see yourself actually using it. And I’d love to hear from people who’ve actually tested it and found that it didn’t work for certain things. What were those use cases that it didn’t work for? and as always, if you found the video useful, please click like and subscribe, and I will talk to you in the next video. Bye for now