Finalmente dá para usar IA local no dia a dia?

Autoria: AI ProgBr · 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: português

Vídeo original: Finalmente dá para usar IA Local no dia a dia? · Canal: AI ProgBr · 22:13 · Assistir no YouTube

Tópicos: Engenharia de software com IA, Inferência e otimização de modelos, Infraestrutura e hardware de IA, Modelos locais e open source

Resumo

O vídeo mostra como melhorias recentes em hardware e engines de inferência aumentaram bastante o desempenho de modelos locais. Em testes com o Qwen 3.8 Flash Next e o Qwen 27B, o apresentador observa velocidades próximas ou superiores a 100 tokens por segundo em geração e cerca de 1.000 tokens por segundo no processamento de prompt. Ele ressalta que IA local ainda não é a melhor opção para a maioria das pessoas, mas pode ser útil para quem precisa de privacidade, quer aprender sobre IA ou executa agentes continuamente. A conclusão é que modelos locais começam a ser viáveis para algumas tarefas, embora o custo do hardware continue sendo uma barreira.

Pontos-chave

Em um mês, a velocidade observada para o Qwen 3.8 Flash Next no Mac Studio M3 Ultra aumentou de cerca de 30–35 para mais de 60 tokens por segundo em geração.
Em um teste com um livro de 47 mil tokens, o processamento de prompt chegou a aproximadamente 1.000 tokens por segundo.
O apresentador recomenda IA local principalmente para quem prioriza privacidade, quer aprender sobre IA ou tem workloads contínuos que podem justificar o custo.
A quantidade de VRAM ou de memória unificada determina quais modelos podem ser carregados, mas carregar um modelo não significa que ele será rápido o bastante para ser útil.
Engines especializadas para determinado hardware ou modelo podem aumentar bastante o desempenho, embora possam demorar a oferecer suporte a novos modelos.
TensorFold e MLX são apresentados como parte das melhorias recentes para rodar modelos em hardware da Apple; o vídeo também demonstra speculative decoding com MTP.
No teste de geração de código com o Qwen 27B, o apresentador mediu uma média de 71,9 tokens por segundo, acima do teto teórico estimado pela calculadora que criou.
O apresentador considera que cerca de 1.000 tokens por segundo no processamento de prompt e 100 tokens por segundo na geração já tornam alguns usos locais práticos.
O cache pode reduzir bastante o tempo de processamento quando uma sessão reutiliza o mesmo contexto.
A evolução combinada de hardware e software deve continuar ampliando as possibilidades da IA local.

Capítulos

Início	Capítulo	Resumo
00:00	A evolução da inferência local	O apresentador compara o desempenho atual do Qwen 3.8 Flash Next com os resultados obtidos um mês antes.
03:39	Quando a IA local pode fazer sentido	São discutidos os casos de uso, os limites de desempenho e a importância da memória para carregar modelos.
07:17	TensorFold, MTP e testes de velocidade	O vídeo demonstra TensorFold, explica MTP e mede a geração de texto e código.
11:27	Calculadora de desempenho e teste com Qwen 27B	O apresentador mostra uma calculadora de velocidade e compara a estimativa teórica com a geração real.
16:02	Hardware Apple e ganhos de desempenho	São comparados os chips M3 e M5 e explicadas as diferenças entre geração e processamento de prompt.
18:06	O futuro da IA local	O apresentador relaciona a evolução do hardware e do software à possibilidade de modelos locais mais rápidos.
20:11	Viabilidade no dia a dia e conclusão	O vídeo conclui que alguns modelos locais já podem ser úteis, mas que hardware local não é necessário para todo mundo.

Citações

Hoje eu só indico ir para IA local se você precisar de privacidade ou se quiser aprender sobre IA, especificamente. — 03:39

Eu diria que 35 tokens por segundo é o mínimo dos mínimos para você conseguir extrair utilidade. — 05:11

71 tokens por segundo num modelo tão bom quanto Qwen 27B é excelente. — 16:02

1.000 tokens por segundo de processamento de prompt e 100 tokens por segundo de geração é extremamente utilizável. — 19:40

Se você só usa os modelos, você não precisa ainda. — 20:43

Conceitos e entidades

Qwen3.8 Flash Next (modelo): Modelo usado para demonstrar o aumento de desempenho da inferência local no Mac Studio M3 Ultra.
Qwen 27B (modelo): Modelo de 27 bilhões de parâmetros usado nos testes de geração e na calculadora de velocidade.
TensorFold (ferramenta): Engine de inferência apresentada no vídeo para rodar modelos com foco em desempenho em hardware específico.
MLX (ferramenta): Tecnologia mencionada para executar modelos em hardware da Apple e aproveitar sua arquitetura.
llama.cpp (ferramenta): Engine citada como uma das opções comuns para rodar modelos localmente.
vLLM (ferramenta): Engine citada como uma opção comum para executar modelos em hardware Nvidia.
MTP (conceito): Técnica descrita como uma forma de prever vários tokens para que o modelo principal os verifique e possa acelerar a geração.
speculative decoding (conceito): Método usado nos testes para acelerar a geração por meio da previsão e verificação de tokens.
Mac Studio M3 Ultra (ferramenta): Computador usado pelo apresentador para testar o desempenho dos modelos locais.
Apple (empresa): Empresa cujos chips e memória unificada são discutidos como opções para executar modelos localmente.

Tradução completa (pt-BR)

00:00 A velocidade com que as coisas acontecem na inteligência artificial às vezes é até difícil de acompanhar. Eu sinto que, se fico dois ou três dias um pouquinho mais desligado do que está acontecendo, já fico meio perdido. Toda semana é um modelo novo, uma técnica nova, uma arquitetura nova. É uma loucura. E hoje eu quero falar exatamente sobre isso, só que do ponto de vista da inteligência artificial rodando localmente. O que acontece? No último mês, fiz um vídeo sobre o Qwen 3.8 Flash Next, um modelo com mais de 100 bilhões de parâmetros, rodando aqui no meu Mac Studio M3 Ultra. E, naquela época

00:32 a gente conseguiu os seguintes dados. Este aqui é o meu vídeo. Eu o publiquei há mais ou menos um mês e a gente conseguiu 35 tokens por segundo nesse modelo, com um pouco de variação. Às vezes era um pouquinho mais, às vezes um pouquinho menos. E uma média de 548 tokens por segundo no processamento de prompt. Essas duas pontas vão ser importantes. Basicamente, processamento de prompt é a rapidez com que o modelo consegue processar seus arquivos, os documentos que você passar para ele, coisas que ele precisa saber antes de começar a responder. Isso vai

01:03 definir quanto tempo você vai esperar até o primeiro token aparecer, quando ele começar a responder. E aqui embaixo, a geração de tokens vai ser a velocidade com que o modelo responde. Então, quão rápido cada token chega depois que ele começa a responder? Um mês atrás, para esse modelo, a resposta era de 30 a 35 tokens por segundo e o processamento de prompt era de mais ou menos 550 tokens por segundo. E, assim como a gente vê uma evolução muito grande nos modelos que rodam na nuvem, principalmente nos modelos dos laboratórios de fronteira, a gente tem uma comunidade

01:33 muito dedicada a melhorar a inferência, que é rodar os modelos localmente. Então, aqui estou com a mesma aplicação que vimos um mês atrás, exatamente o mesmo modelo, só que numa versão mais nova. Naquele vídeo, eu estava rodando a versão 0.6.3; agora estamos rodando a versão 0.7.0. E muita coisa mudou de lá para cá. Isso foi só em um mês, tá? Mas vou dar um oi aqui só para a gente entender mais ou menos do que estou falando. Então, olha só: só nesse pequeno “oi”, a gente já consegue enxergar uma diferença de basicamente o dobro da velocidade quando

02:05 a gente fala de geração de tokens. Há um mês, a gente rodava esse modelo a 35 tokens por segundo. Agora já está a mais de 60 tokens por segundo. Mas a gente pode ver aqui que o processamento de prompt parece extremamente baixo: dois tokens por segundo. Pois é, porque o nosso prompt foi “oi”, muito pequeno. Se a gente tiver um prompt maior, consegue uma velocidade melhor. Deixa eu limpar aqui. E vou fazer o seguinte: vou pegar um livro aqui, de domínio público, Romeu e Julieta, e vou pedir para o nosso chat, que vou criar agora, fazer um resumo para a gente.

02:35 Esse livro é relativamente grande, tá? A gente vai ver quantos tokens ele tem, mas é uma quantidade bem mais considerável do que um “oi”, né? Vou dar um Enter aqui. E ele começa a processar. A gente consegue ver aqui. E aqui vamos acompanhando o perfil enquanto ele está processando. Olha, 1.000 tokens por segundo. Ele chegou a isso aqui. Vamos ver como vai ficar a média. A gente vai conseguir ver aqui. Então, olha só: ele começou a responder e a gente já consegue ter uma prévia. Nosso perfil ficou, em média, em 1.000 tokens por segundo. Então, para processar 47.000 tokens a 1.000 tokens por segundo, levou mais ou menos 47 segundos até o primeiro

03:07 token, até ele começar a responder. E a gente pode ver aqui que o tempo total para gerar esse resumo para a gente — o resumo teve 1.500 tokens — foi de 70 segundos, dando uma média de 60 tokens por segundo. Isso numa context window de 48.000 tokens. Então, em apenas um mês, a performance desse modelo dobrou. Por que estou fazendo este vídeo? Porque acredito que, com esses números, a gente está começando a chegar a um patamar em que usar modelos locais começa a ser possível. Eu não

03:39 acho que ainda seja a hora de a grande maioria das pessoas seguir por esse caminho. Hoje, só indico usar IA local se você precisar de privacidade ou se quiser aprender sobre IA especificamente. Se você for um dev que quer se especializar em IA, precisa, de alguma forma, partir para a IA local e entender como funciona um modelo de IA de fato. Se você for qualquer outro tipo de dev, um dev web etc., provavelmente esse investimento ainda não faz sentido. Outro caso talvez sejam empresas que rodam um agent 24 horas por dia. Nesse

04:10 caso, pode haver alguns cenários em que a conta fecha. Mas vamos ignorar agora a parte econômica e focar na parte didática e em imaginar as possibilidades, porque estamos chegando a um nível em que talvez até programar comece a ser possível. Se você não fizer coisas muito complexas, não precisa de modelos muito capazes. Então, nesse caso, programar começa a ser viável, porque até ontem a gente tinha um grande problema de performance. Quando falamos de rodar modelos locais, temos, a princípio, dois gargalos. O primeiro é a VRAM ou a memória unificada, dependendo do seu hardware,

04:41 né? Placas de vídeo usam VRAM. Hardwares como os da Apple usam memória unificada, mas, basicamente, você precisa fazer com que o modelo caiba totalmente na memória para ter o máximo de performance. Então, a quantidade de memória vai definir quais modelos você consegue carregar. Por que digo “carregar”? Porque há uma pequena diferença entre carregar e ser útil. Num Mac Studio com 512 GB, você consegue carregar um modelo de 1 trilhão de parâmetros se ele estiver em Q4 ou menos, mas muitas vezes vai conseguir apenas 10 tokens por segundo. E

05:11 aí fica muito difícil usar 10 tokens por segundo para algo útil. E, a não ser que você tenha um grande problema de privacidade, provavelmente vai desistir e acabar voltando a usar alguma coisa na nuvem. Eu diria que 35 tokens por segundo é o mínimo dos mínimos para conseguir extrair alguma utilidade. Mas, mesmo assim, tentei usar esse modelo a 35 tokens por segundo e fiquei com a sensação de que estava perdendo tempo. Acabei não usando tanto assim. Na última semana, com as evoluções das engines, comecei a usar

05:44 ele de novo e agora acho que estamos chegando ao ponto ideal. E uma das frentes é essa: a melhoria das engines que já existiam. Hoje em dia, temos várias formas de rodar modelos locais, né? Se você tiver um hardware da Nvidia, por exemplo, como uma 5090, pode rodar o llama.cpp ou o vLLM. Esses são os mais comuns hoje. Se você tiver um hardware da Apple, também pode rodar o llama.cpp, mas pode usar outros motores de inferência que utilizam MLX. MLX é um formato específico para o hardware da Apple, com o qual

06:15 você consegue extrair um pouco mais de performance. E esse é exatamente o ponto. O que aconteceu nos últimos meses? Temos visto surgir cada vez mais engines, ou seja, motores de inferência, que são a parte de software que roda os modelos. E essas novas engines que temos visto são feitas especificamente para um hardware e, às vezes, até especificamente para um modelo. Então, quando você tem essa camada de software feita para extrair o máximo daquele hardware e daquele modelo, temos o melhor dos mundos. É claro que, por um lado, isso

06:46 limita um pouco, né? Sai um modelo novo, e essa engine não consegue rodá-lo; ela precisa de toda uma adaptação e, às vezes, leva um pouco mais de tempo até chegar o suporte a novos modelos. Por outro lado, algumas empresas já se adiantam. É o caso da Qwen, da Alibaba. O Qwen 3.8 Flash Next já tem a arquitetura do Qwen 4, então, teoricamente, quando o Qwen 4 sair, vai ser muito mais fácil para os motores de inferência se adaptarem e rodarem o Qwen 4 mais rapidamente. E, na verdade, minha motivação para gravar este vídeo nem foi mostrar esse ganho

07:17 do OMLX. A gente começou por aqui porque eu rodei o OMLX no último vídeo. Neste vídeo, quero te mostrar exatamente isso de que estou falando. O motor de inference, que inicialmente tinha como foco os computadores Apple Mac, agora está se expandindo um pouco e já dá suporte ao DGX Spark, etc. E o foco é extrair o máximo de um pequeno grupo de modelos. Estou falando aqui do Tensor Fold. Cara, instalei isso esta semana e, para mim, mudou completamente o jogo. Aqui estou rodando a versão 0.6.0 do Tensor Fold, e vamos rodar o Qwen Flash de 4 bits, que

07:49 é bem parecido com o que a gente estava rodando no MLX. Estou configurando aqui para o MTP ter três drafts, tá? O MTP também vai ser muito importante nisso. Estou preparando outro vídeo só para explicar como funciona o local, para a gente entender largura de banda, processamento de prompt, MTP, tudo que influencia a capacidade de rodar um modelo e de rodá-lo bem. Mas, basicamente, o MTP é como se um modelo bem menor previsse vários tokens ao mesmo tempo, ou numa velocidade muito rápida, e assim o modelo grande, em vez de gerar um token a cada passada,

08:22 só verifica se aceita ou não aqueles tokens. E se, por exemplo, você previu quatro tokens e ele aceitou os quatro — o que nem sempre acontece, tá? —, você teria uma velocidade quatro vezes maior. Então dá para multiplicar bastante a velocidade do modelo usando isso. Aqui estou com o OpenCode aberto, e ele já está conectado ao meu Qwen, rodando no Tensor Fold. Vamos começar com o clássico “oi”, só para ter uma ideia se está tudo funcionando direitinho. Beleza? Aqui embaixo temos um resumo do que aconteceu. Na verdade, deixa eu aumentar esta parte,

08:52 que é a mais importante. Então, se olharmos aqui, nossa context window tem 95,55 mil tokens, tá? Por quê? Porque, quando mandamos uma mensagem para o OpenCode, não vai só o nosso “oi”: vai todo o system prompt, todos os cabeçalhos de skills, tudo isso vai junto. E, no nosso caso, tudo isso dá mais ou menos 9.500 tokens. Para ser mais exato, 9.510 tokens, que o nosso modelo levou 10 segundos para processar. Isso dá em torno de 950 tokens por segundo de processamento. Mas a parte mais legal é

09:23 que a resposta dele veio aqui, a 77,5 tokens por segundo, ainda mais do que a gente tinha visto antes com o OMLX. Deixa eu fazer outro pedido para ele. Vou pedir o seguinte: “Crie uma calculadora do teto de velocidade de um modelo de LLM em determinado hardware usando HTML”. Basicamente, o usuário vai inserir a largura de banda daquele hardware, a quantidade de parâmetros do modelo e a quantização. E a nossa aplicação precisa fornecer uma estimativa da velocidade que dá para atingir. Até esqueci de

09:53 colocar aqui “velocidade em tokens por segundo”. Beleza? Vamos lá. Ele vai processar nosso prompt rapidamente e continuar criando aqui para a gente. Neste momento, conseguimos ver uma prévia, tá? Olha só esta prévia. Ele está gerando em tempo real a mais de 100 tokens por segundo. Não sei se vai conseguir manter isso até o final. No final, vamos conseguir ver qual foi a média, mas chegar perto de 100 tokens por segundo é simplesmente absurdo. Então, ele terminou de criar para a gente, e aqui do lado conseguimos ver o que aconteceu. Vamos pegar aqui. A gente

10:24 começou com o nosso prompt, que tinha 9.000 tokens. Ele usou o cache, primeiro de tudo. Por isso começou a responder tão rápido. Levou um segundo para começar a responder, porque a maioria dos tokens bateu no cache. Aí ele gerou em torno de 2.900 tokens. Desses 2.900 tokens, usou speculative decoding e MTP para prever múltiplos tokens numa só passada. Dos múltiplos tokens que previu, 2.000 foram aceitos, tá? De 2.900 que gerou, 2.000 foram aceitos. Por isso tivemos uma velocidade tão alta,

10:56 uma média de 104 tokens por segundo neste trecho. Depois, ele fez mais algumas requisições. Na próxima requisição, por exemplo, ele já tinha 12.000 tokens de entrada, com 9.000 já carregados. Levou 3 segundos para processar o restante. Ou seja, aqui temos uma diferença de 3.000 tokens, que levou 3,5 segundos. Então, é uma taxa de aproximadamente 900 tokens por segundo de processamento, e ele gerou 184 tokens a 103 tokens por segundo. Basicamente, levou um segundo para responder e, aqui embaixo, mais uma vez, 92 tokens por

11:27 segundo, desta vez com 309 tokens. Então, na média, ficou muito perto de 100 tokens por segundo para gerar essa pequena aplicação. A propósito, olha só que interessantes a inteligência e a capacidade deste modelo. O prompt que eu dei não foi superespecífico; não seria um prompt que você usaria na vida real. Na vida real, provavelmente, você criaria uma especificação para dizer exatamente como quer que as coisas funcionem, né? E, a partir daí, o modelo seguiria as instruções e teria um resultado mais certeiro. Inclusive, esse é o módulo em que estou trabalhando neste momento para

11:57 o nosso curso IA para Devs. É um módulo que vai sair muito em breve e é uma parte extremamente importante desta nova forma de desenvolver com IA. Mas aqui a gente fez um prompt bem simples. Mesmo assim, ele foi além e fez alguns ajustes no que pedimos. Primeiro, ele já traz alguns exemplos do que seria esperado de largura de banda de alguns hardwares. Esse 273, por acaso, é exatamente a largura de banda do DGX Spark. Ele também adicionou aqui uma eficiência real da banda. Por quê? Porque nem sempre o hardware entrega a banda que

12:28 diz que entrega. O M3 Ultra, por exemplo, tem 800 GB/s de largura de banda, mas nem sempre você vai conseguir isso. Às vezes, vai conseguir menos: 650, 700, depende bastante. Teria que medir. Neste caso, a nossa calculadora permite levar isso em consideração. Tamanho do modelo. Então, o modelo aqui no DGX Spark: se a gente colocar um Qwen 27B e selecionar Q4, vamos calcular o teto. O teto seria de 14 tokens por segundo. Obviamente, este é o teto do hardware, sem considerar as melhorias que a gente vem

12:59 tendo. Exatamente. Aqui não estamos considerando MTP, por exemplo. Então, se eu pegar aqui e colocar 800 GB/s, que é aproximadamente a largura de banda do meu Mac M3 Ultra, e considerar uma eficiência de 100%, que seria o máximo teórico, vamos calcular: teríamos um máximo de 59,3 tokens por segundo neste computador. Mas, como falei, o software, neste momento da história, muda completamente o jogo. E é aí que está acontecendo a

13:30 maioria das evoluções que a gente vê. Então, aqui, por exemplo, vou voltar ao OMLX. Tenho aqui um modelo 27B Q4, que é exatamente este que a gente estava calculando. Na verdade, não: o modelo que estamos carregando é o OQ4. O OQ4 não é exatamente o Q4 básico, tá? A maioria das camadas vai estar em 4 bits, mas algumas das mais importantes vão estar numa precisão maior, de 5 até 8 bits. Ou seja, este vai ser um modelo mais pesado, então deveria ser mais lento

14:00 do que o Q4, que é o que temos na calculadora. Mas vamos conferir agora se isso vai acontecer ou não. Vamos voltar ao vídeo. Vou selecionar aqui o Lightning MTP com três tokens por passada. Agora, com o modelo carregado, vou dar o nosso clássico “oi”. E temos aqui 55,8 tokens por segundo. Vamos pedir para ele criar um pouco mais de texto para conseguirmos ver se esse número aumenta ou diminui. Vou até zerar aqui antes. Pedi para ele criar um HTML de uma padaria. A gente nem vai olhar esse código em si.

14:30 A gente só quer ter uma ideia. Olha, aqui a gente consegue ver um pouco da velocidade que ele está gerando em tempo real. E, se eu expandir aqui, olha, a gente consegue ver que ele está gerando por volta de 49 tokens por segundo. No final, a gente vai ver aqui a média total. Uma coisa importante também é que esses modelos novos, principalmente com o speculative de Code ligado, vão ter uma velocidade diferente quando a gente fala de texto ou de código. Código é algo mais previsível. Então, quando o modelo menor gera os tokens que vão

15:01 ser verificados pelo modelo maior, normalmente há uma aceitação maior no código, porque ele é mais previsível. Então, nesse caso, a gente aumenta um pouco a velocidade. Provavelmente, quando ele começar a escrever código aqui, vamos ter esse aumento. Inclusive, vou fazer o seguinte: vou parar por enquanto, tá? Parei aqui. Vou diminuir o limite de pensamento para 1.000 tokens. Ele só pode pensar por 1.000 tokens, porque a gente quer ver aqui a velocidade, não a qualidade. Isso aqui não faz muita diferença pra gente; está mais atrapalhando do que ajudando a gente a

15:31 conseguir ver o máximo que a gente consegue atingir. Então, nesse texto aqui, em que ele basicamente estava pensando, a gente conseguiu uma média de 55 tokens por segundo. Agora vou pedir para ele gerar novamente com o nosso limite de 1.000 tokens de pensamento. E olha só: agora ele está escrevendo código e a gente está passando dos 70 tokens por segundo. 68, 69, chegando a 70 de vez em quando. Vamos ver como vai ficar a média no final, e aí falamos um pouco sobre a conclusão disso. Então, beleza, ele terminou aqui e a média foi de 71,9

16:02 tokens por segundo. Se a gente trouxer nossa calculadora de novo, tínhamos visto que, para esse hardware, o limite seria de 59 tokens por segundo se ele tivesse 100% de eficiência. Como conseguimos 71,9? Exatamente por conta do software, que tem evoluído bastante, muito graças à comunidade. 71 tokens por segundo em um modelo tão bom quanto o Qwen 27B é excelente. Então, aqui a gente conseguiu 20% a mais do que o limite teórico. E o que é interessante aqui? O Mac M3 Ultra tem 800 GB/s de largura de

16:34 banda, mas o M5 Max, que tem versões com menos memória, com 64 GB, por exemplo, e que conseguiria rodar esse modelo tranquilamente, tem 614 GB/s. Então, não é tão menos do que o M3 Ultra. Se a gente calcular aqui o limite teórico, seriam 45 tokens. Se aplicarmos a mesma taxa de 20%, conseguimos aumentar isso aqui para cerca de 55 tokens. Só que tem um porém: o M5 Max e o M5 Ultra vêm com um acelerador neural que o M3 não tem. Isso

17:05 faz com que o processamento de prompt seja muito mais rápido. Olha só, estamos falando aqui de valores em torno de 120 tokens por segundo de velocidade de decoding no M5 Ultra — no M5 Max, desculpa. O M5 Ultra é ainda melhor do que o M5 Max, mas estou falando do M5 Max porque é uma máquina que tem versões de 64 GB que conseguiriam rodar o Qwen 3.8 27B tranquilamente. O M5 Max e o M5 Ultra também têm mais capacidade de processamento. Isso quer dizer que eles

17:35 processam prompt muito mais rápido. Para você ter uma ideia, a gente conseguiu aqui, então, no Qwen 3.8 Flash Next, cerca de 1.000 tokens por segundo, né? No M3 Ultra. No M5 Ultra, esse valor sobe para 2.500. Isso acontece por conta dos novos processadores, mas também porque as GPUs do M5 Ultra têm um hardware específico para matrizes que o M3 Ultra não tem. Isso faz com que elas consigam processar muito mais rápido. Se você comparar os tokens por segundo de geração do M3 Ultra com o M5 Ultra, vai

18:06 ter um aumento também, mas por conta da largura de banda. Já o processamento de prompt se deve ao novo hardware. Estou extremamente empolgado porque acho que o futuro da IA local está chegando, e está chegando bem rápido, por dois motivos. Primeiro, a melhoria de hardware, tá? A gente já viu uma grande melhoria do M3 Ultra para o M5, e também uma melhoria de software. Neste momento, inclusive, tem muito mais gente engajada no DGX Spark, por exemplo, que é da Nvidia, do que no hardware da Apple. O lançamento do M5 Ultra, na verdade, mexeu com as coisas, porque a galera começou a ficar de olho e começou a aparecer

18:36 uma galera criando esse tipo de coisa, como o TensorFold. A gente começou a ver essas melhorias no MLX, então isso deu um impulso legal na comunidade para a gente ver melhorias do lado da Apple também. Mas o mais curioso é que a Apple acertou por acaso na IA quando fez um chip com memória unificada, né? O M1 e, depois, os outros foram só evoluções simples, não focadas em IA. A mudança começa agora. O M5 dá um pequeno passo na direção certa. O M6, que já existe e que, segundo os rumores, só vai ter a versão básica, já traz suporte de hardware a FP8, o

19:09 que é importantíssimo para IA. No M5, eles precisam emular isso e acabam perdendo desempenho. Então, se tivéssemos um M6 Max ou um M6 Ultra, ele seria ainda melhor do que o M5 para IA. Só que provavelmente não vamos ter isso, porque a Apple resolveu pular o M6 e concentrar os esforços em fazer do zero um M7 feito para IA, e esse vai ser um monstro. Então, o que temos visto é uma evolução acontecendo no hardware e, principalmente, no software. E a junção das duas coisas faz com que tudo evolua

19:40 muito rápido. Provavelmente, daqui a um mês, vou voltar aqui falando desse modelo ou do sucessor dele, com velocidades ainda mais interessantes e, provavelmente, modelos mais inteligentes. Mas eu diria que, nesse nível, a gente já chegou ao mínimo utilizável, com 1.000 tokens por segundo de processamento, principalmente levando em consideração que, depois que você processa isso, fica em cache. E, se precisar processar esse prompt exato de novo, vai ser muito rápido. 1.000 tokens por segundo de processamento de prompt e 100 tokens por segundo de geração é extremamente utilizável, principalmente

20:11 se você considerar que, normalmente, em uma sessão, se entregar muitos dados de uma vez, só vai processá-los uma vez. Depois, vai reutilizar o cache, e a leitura do cache é muito rápida. Então, eu diria que, para o uso no dia a dia, esse modelo aqui, o Qwen 3.8 Flash Next, já é bem utilizável. Quero, inclusive, fazer um experimento para criar algumas coisas só com ele, tá? E trazer os resultados aqui para vocês. Na verdade, tenho feito isso sem mostrar, mas quero fazer algo exclusivo aqui para o canal. Para muitos dos meus projetos, esse modelo me atende, mas, como falei, hardware não é para todo mundo. Se

20:43 você quer saber mais sobre esse tipo de coisa de que estamos falando aqui, eu só consigo saber porque me envolvo com hardware local; senão, não saberia nada disso. Quem usa só o ChatGPT, o Claude etc. não lida muito com largura de banda, né? Nem sabe muito sobre quantização — até sabe o que é, porque às vezes o modelo fica tão ruim que a gente acha que quantizaram tudo —, mas, de forma geral, para ter esse contato mais de perto, entender e testar, aí você precisa partir para o hardware local. Se você só usa os modelos, ainda não precisa. Mas eu

21:13 acho que estamos vivendo um momento incrível e talvez o futuro da carreira seja a gente se envolver mais com IA, né? E, nesse caso, sim, ter hardware local é uma grande vantagem. Se quiser ver o primeiro vídeo que gravei sobre o Qwen 3.8 Flash, dá uma olhada neste vídeo aqui. Se quiser aprender a extrair mais de modelos menores, mesmo de modelos na nuvem, com planos como OpenCode Go, MiniMax, GLM etc., dá uma olhada neste link aqui, que é o link do meu curso. Lá você vai entender mais sobre harness e desenvolvimento com IA. Não é sobre modelos locais, tá? Não

21:43 É um curso sobre modelos locais ainda. Se você tiver interesse nisso, deixa aqui embaixo nos comentários, só para eu saber, ter uma ideia. Mas eu acho que é nichado demais, não sei. Agora, se você quiser se desesperar um pouco, dá uma olhada neste vídeo aqui, porque eu falo do aumento de preço dos planos da Open AI. Isso é um pouco preocupante, porque eu sei que hardware local é caro e, como eu falei, não é para todo mundo. Eu preciso reforçar isso toda hora, senão vai vir alguém comentar: “Ah, mas no Brasil não, não é para você comprar, não, não compre. É para… eu tô fazendo este vídeo para você entender onde estamos hoje em hardware local. Se você é essa pessoa que vai

22:13 deixar esse comentário, você pode escolher olhar este vídeo aqui e pagar os seus 500 por mês em assinatura da Open AI.

Transcrição original

[00:00] A velocidade que as coisas acontecem na inteligência artificial, às vezes é até difícil de acompanhar. Eu sinto que se eu fico dois ou três dias um pouquinho mais desligado do que que tá acontecendo, eu já fico um pouco meio perdido. Toda semana é um modelo novo, uma técnica nova, uma nova arquitetura. É uma loucura. E hoje eu quero falar exatamente sobre isso, só que do ponto de vista de inteligência artificial rodando localmente. Que que acontece? No último mês, eu fiz um vídeo sobre o Quen 3.8 Flash Next, um modelo de mais de 100 bilhões de parâmetros, rodando aqui no meu Mac Studio M3 Ultra. E naquela época

[00:32] a gente conseguiu os seguintes dados. Esse aqui é o meu vídeo. Eu subi ele há mais ou menos um mês atrás e a gente conseguiu 35 tokens por segundo nesse modelo com um pouco de variação. Às vezes era um pouquinho mais, às vezes um pouquinho menos. E uma média aqui, ó, de 548 tokens por segundo em processamento de prompt. Aqui as duas pontas vão ser importantes e basicamente processamento de prompt é o quão rápido o modelo vai ser capaz de processar seus arquivos, os documentos que você passar para ele, coisas que ele precisa saber antes de começar a responder. Isso daqui vai

[01:03] definir o quanto tempo você vai esperar pro primeiro token ali aparecer para quando ele começa a responder. E aqui embaixo, tokenation, vai ser a velocidade que o modelo responde. Então, quão rápido cada token chega depois que ele começa a responder? Então, um mês atrás para esse modelo era de 30 a 35 tokens por segundo pra resposta e mais ou menos 550 tokens por segundo para processamento de prompt. E assim como a gente vê uma evolução muito grande nos modelos que rodam na nuvem, né, os modelos principalmente dos laboratórios Frontier, a gente tem uma comunidade

[01:33] muito dedicada a melhorar a inferência, que é rodar os modelos localmente. Então aqui eu tô com a mesma aplicação que a gente viu um mês atrás, exatamente o mesmo modelo, só que uma versão mais nova. Lá naquele vídeo eu tava rodando a versão 0.6.3, agora a gente tá rodando a versão 0.7.0. E muita coisa mudou de lá para cá. Isso foi só em um mês, tá? Mas eu vou dar um oi aqui só pra gente entender mais ou menos do que que eu tô falando. Então, olha só, só nesse pequeno Oi a gente já consegue enxergar uma diferença de basicamente o dobro de velocidade quando

[02:05] a gente fala de geração de tokens. Há um mês atrás, a gente rodava esse modelo a 35 tokens por segundo. Agora já tá mais de 60 tokens por segundo. Mas a gente pode olhar aqui que o processamento de prompt parece extremamente baixo. Dois tokens por segundo. Pois é, porque o nosso prompt foi oi, muito pequeno. Se a gente tiver um prompt maior, a gente consegue uma velocidade melhor. Deixa eu limpar aqui. E eu vou fazer o seguinte, eu vou pegar um livro aqui, ó, que é domínio público, Romeu e Julieta, e eu vou pedir pro nosso chat, que eu vou criar um novo aqui, resumir pra gente.

[02:35] Esse livro é um livro relativamente grande, tá? A gente vai ver quantos tokens ele tem, mas é uma quantidade mais considerável do que um oi, né? Vou dar um enter aqui, ó. E ele começa a processar. A gente consegue ver aqui. E aqui a gente vai vendo o prefil enquanto ele tá processando. Ó, 1000 tokens por segundo. Ele bateu aqui. Vamos ver como é que vai ficar a média. A gente vai conseguir ver aqui. Então, olha só, ele começou a responder aqui e a gente já consegue ter uma prévia aqui. Nosso perfil ficou em média em 1000 tokens por segundo. Então, 1000 tokens por segundo para processar 47.000 tokens, levou mais ou menos 47 segundos até o primeiro

[03:07] token, até ele começar a responder. E a gente pode ver aqui então que o tempo total para dar esse resumo pra gente, o resumo dele teve 1500 tokens, o tempo total foi de 70 segundos, dando uma média de 60 tokens por segundo. Isso numa janela de contexto de 48.000 tokens. Então, em apenas um mês, a gente teve um dobro na performance desse modelo aqui. Por que que eu tô fazendo esse vídeo? Porque eu acredito que com esses números a gente está começando a chegar num patamar onde usar modelos locais começa a ficar possível. Eu não

[03:39] acho que ainda é a hora da grande maioria das pessoas ir por esse caminho. Hoje eu só indico ir a local se você precisar de privacidade ou se você quiser aprender sobre IA, especificamente. Se você for um dev que quer se especializar em IA, você precisa de alguma forma ir para IA local, entender como funciona o modelo de A de fato. Se você é qualquer outro tipo de dev, dev web, etc. Provavelmente não faz sentido esse investimento ainda. Um outro caso talvez seja para empresas que rodam um agente 24 horas por dia. Nesse

[04:10] caso pode ter alguns cenários onde a conta fecha. Mas vamos ignorar agora a parte econômica, vamos focar na parte didática e na parte de imaginar as possibilidades, porque a gente tá chegando num nível onde começa a ficar possível talvez até código. Se você não fizer coisas muito complexas, você não precisa de modelos muito capazes. Então, nesse caso, código começa a ficar viável, porque até ontem a gente tinha um grande problema de performance. Quando a gente fala de rodar modelos locais, a gente tem, a princípio dois gargalos. O primeiro é Vran ou memória unificada, dependendo do seu hardware,

[04:41] né? placas de vídeos of run. Hardwers como o MAC usam memória unificada, mas basicamente você precisa fazer com que o seu modelo caiba totalmente na memória para você ter o máximo de performance. Então a quantidade de memória, ela vai definir quais modelos você consegue carregar. Por que que eu digo carregar? Porque entre carregar e ser útil tem uma pequena diferença. Num Mac Studio de 512 GB você consegue carregar um modelo de 1 trilhão de parâmetros se ele for Q4 ou menos, mas muitas vezes você vai conseguir ali 10 tokens por segundo. E

[05:11] aí é muito difícil você usar para algo útil 10 tokens por segundo. E a não ser que você tenha um grande problema de privacidade, você provavelmente vai desistir e vai acabar voltando para usar alguma coisa na nuvem. Eu diria que 35 tokens por segundo é o mínimo dos mínimos para você conseguir extrair utilidade. Mas mesmo assim eu tentei usar esse modelo a 35 tokens por segundo e eu me vi com sentimento de que eu tava perdendo tempo e eu acabei não usando tanto ele assim. Na última semana com as evoluções das engines, eu comecei a usar

[05:44] ele de novo e agora eu acho que a gente tá chegando no suit spot. E uma das frentes é essa, melhoria das engines que já existiam. Hoje em dia a gente tem várias formas de rodar modelos locais, né? Se você tiver um hardware da Nvidia, por exemplo, como a 5090, você pode rodar o Lama CPP, você pode rodar o VLLM. Esses são os mais comuns hoje. Se você tiver um hardware da Apple, você pode também rodar o Lama CPP, mas você pode rodar outros motores de inferência que utilizam MLEX. MLEX é um formato específico pro hardware da Apple, onde

[06:15] você consegue extrair um pouco mais de performance. E esse é exatamente o ponto. O que que aconteceu nos últimos meses? A gente tem visto surgir cada vez mais engines, ou seja, motores de inferência, que são ali a parte de software que rodam os modelos. E essas novas engines que a gente tem visto, elas têm sido feitas especificamente para um hardware e às vezes até especificamente para um modelo. Então, quando você tem essa camada de software que foi feita para extrair o máximo daquele hardware, extrair o máximo daquele modelo, a gente tem o melhor dos mundos. É claro que por um lado isso

[06:46] limita um pouco, né? sai um modelo novo, essa não consegue rodar, ela precisa de toda uma adaptação e às vezes leva um pouco mais de tempo pro suporte chegar para novos modelos. Por outro lado, algumas empresas já se adiantam, é o caso do Quen, da Alibaba. O Quen 3.8 Flash Next, ele já tem a arquitetura do Quen 4, então teoricamente quando Quen 4 sair, vai ser muito mais fácil pr os motores de inferência se adaptarem e rodarem o Coin 4 mais rapidamente. E na verdade a minha motivação para gravar esse vídeo nem foi te mostrar esse ganho

[07:17] do OMLX. A gente começou por aqui porque eu rodei ox no último vídeo. Nesse vídeo aqui eu quero te mostrar exatamente isso que eu tô falando. O motor de inferência que inicialmente o foco era computadores da Apple Mac, agora ele tá expandindo um pouco, já dá suporte a DDX Park, etc. E com foco a extrair o máximo de um pequeno grupo de modelos. Eu tô falando aqui do Tensor Fold. Cara, eu instalei essa semana isso daqui e para mim mudou completamente o jogo. Aqui eu tô rodando a versão 0.6.0 do Tensor Fold e a gente vai rodar o Quent. flash de 4 bits, que

[07:49] é bem parecido com o que a gente estava rodando MLX. Tô configurando aqui pro MTP ter três drafts, tá? O MTP vai ser muito importante nisso também. Eu tô preparando um outro vídeo só para explicar como que a local funciona, pra gente entender largura de banda, processamento de prompt, MTP, tudo que influencia você conseguir rodar um modelo e você conseguir rodar um modelo bem. Mas basicamente o MTP é como se um modelo bem menor fosse prever vários tokens ao mesmo tempo ou numa velocidade muito rápida e assim o modelo grande em vez dele gerar um token na cada passada

[08:22] ele só verifica ali se aqueles tokens ali ele aceita ou não. E se, por exemplo, você preveu quatro tokens e ele aceitou os quatro, o que nem sempre acontece, tá? você teria aí quatro vezes mais velocidade. Então, dá para multiplicar bastante a velocidade do modelo usando isso. Então, aqui eu tô com o meu open aberto, ele tá conectado já o meu quint. Rodando aqui no tensor fold. E a gente vai começar com o clássico oi, só pra gente ter uma ideia se tá tudo funcionando direitinho. Beleza? Aqui embaixo a gente tem um resumão do que que aconteceu. Na verdade, deixa eu aumentar essa parte

[08:52] aqui que ela é a mais importante. Então, se a gente olhar aqui, ó, nossa janela de contexto tem 95.55 tokens, tá? Por quê? Porque quando a gente manda uma mensagem pro Pencode, não vai só o nosso Oi, vai todo o system prompt, todos os cabeçalhos de skills, tudo isso vai junto. E no nosso caso aqui, tudo isso dá mais ou menos 9.500 tokens. Para ser mais exato, 9.510 tokens, que o nosso modelo levou 10 segundos para processar. Isso daqui dá em torno de 950 tokens por segundo de processamento. Mas a parte mais legal é

[09:23] que a resposta dele veio aqui, ó, a 77.5 tokens, ainda mais do que a gente tinha visto anteriormente com OMLX. Deixa eu fazer um outro pedido para ele aqui. Eu vou pedir para ele o seguinte: cria uma calculadora de teto de velocidade modelo de LLM em determinado hardware usando HTML. Basicamente, o usuário vai entrar com a largura de banda daquele hardware ali, a quantidade de parâmetros do modelo e a quantização. E a nossa aplicação, ela precisa entregar uma estimativa de quanto dá para atingir em questão de velocidade. Esqueci até de

[09:53] colocar aqui de velocidade em tokens por segundo. Beleza? Vamos lá. Ó, ele vai processar o nosso prompt rapidamente e vai continuar criando aqui pra gente. Nesse momento a gente consegue ver aqui uma prévia, tá? Olha essa prévia aqui. Ele tá gerando em tempo real a mais de 100 tokens por segundo. Eu não sei se ele vai conseguir manter isso aqui até o final. No final a gente vai conseguir ver a média que ficou, mas bater por volta dos 100 tokens por segundo é simplesmente absurdo. Então aqui ele terminou de criar pra gente e aqui do lado a gente consegue ver o que que aconteceu. Vamos pegar aqui. A gente

[10:24] começou lá com o nosso prompt que tinha 9.000 tokens. Ele usou o cash, primeira coisa. Então por isso que ele começou a responder tão rápido. Levou um segundo para começar a responder porque a maioria dos tokens bateram no cash. E aí ele gerou em torno de 2.900 tokens. desses 2900 tokens, ele usou speculative decode, ele usou o MTP para prever, né, múltiplos tokens numa passada só. Desses múltiplos tokens que ele previu, 2.000 foram aceitos, tá? De 2900 que ele gerou, 2.000 foram aceitos. Por isso que a gente teve uma velocidade tão alta,

[10:56] uma média de 104 tokens por segundo nesse trecho aqui. Depois ele fez mais algumas requisições. Na próxima requisição, por exemplo, ele já tinha agora 12.000 tokens de entrada com 9.000 1000 jáados, levou 3 segundos ali para processar o restante. Ou seja, aqui a gente tem uma diferença de 3.000 tokens, levou 3.5 segundos. Então, é uma taxa de aproximadamente 900 tokens por segundo de processamento e gerou 184 tokens a 103 tokens por segundo. Basicamente, levou um segundo ali para responder e aqui embaixo, mais uma vez 92 tokens por

[11:27] segundo, dessa vez 309 tokens. Então, na média, ele ficou muito próximo aos 100 tokens por segundo para gerar essa pequena aplicação. A propósito, olha só que interessante a inteligência e a capacidade desse modelo. O prompt que eu dei, ele não foi super específico, não seria um promptia na vida real. Na vida real, provavelmente, você vai criar uma especificação para você dizer exatamente como que você quer que as coisas funcionem, né? E a partir daí o modelo ele vai seguir e vai ter um resultado mais certeiro. Inclusive esse é o módulo que eu tô trabalhando nesse momento pro

[11:57] nosso curso IA para Devs. É um módulo que vai sair muito em breve lá e é uma parte extremamente importante dessa nova forma de desenvolver com IA. Mas aqui a gente fez um prompt bem simplão. Mesmo assim ele foi além e ele fez alguns ajustes no que a gente pediu. Então primeiro que ele já traz aqui alguns exemplos, né, do que que seria esperado de largura de banda de alguns hardwares. Esse 273 por acaso, é exatamente a largura de banda do DJX Park. Ele também adicionou aqui um eficiência real da banda. Por quê? Porque nem sempre o hardware ele entrega a banda que ele

[12:28] fala que ele entrega. O M3 Ultra, por exemplo, tem 800 GB/sundo de largura de banda, mas nem sempre tu vai conseguir isso. Às vezes tu vai conseguir menos, 650, 700, depende bastante. Teria que medir. Nesse caso aqui, a nossa calculadora permite que a gente leve isso em consideração. Tamanho do modelo. Então, modelo aqui no DJX Spark, se a gente colocar um Quin 27B e vamos colocar ele aqui, ó, Q4, tá? Vamos calcular o teto. O teto seria de 14 tokens por segundo. Obviamente esse daqui é o teto de hardware, sem considerar as melhorias que a gente vem

[12:59] tendo. Exatamente. Aqui a gente não tá considerando MTP, por exemplo. Então se eu pegar aqui, ó, e colocar 800 GB/sund, que é aproximadamente do meu Mac M3 Ultra aqui, e eu colocar, vamos botar que fosse uma eficiência de 100%, tá? Que seria ali a teoria máxima, vamos calcular, a gente teria ali uma máxima de 59.3 três tokens por segundo nesse computador aqui. Mas como eu falei, software nesse momento da história muda completamente o jogo. E é aí que tá acontecendo a

[13:30] maioria das evoluções que a gente vê. Então aqui, por exemplo, vou voltar no OMLX. Eu tenho aqui um modelo de 27BQ4, que é exatamente esse daqui que a gente estava calculando. Exatamente. Não, esse modelo que a gente tá carregando é o OQ4. O OQ4 ele não é exatamente o Q4 básico, tá? A maioria das camadas vai est em 4 bits, mas algumas delas que são mais importantes vão estar numa precisão maior 5 bits até 8 bits. Ou seja, esse vai ser um modelo mais pesado, aí deveria ser mais lento

[14:00] do que o Q40, que é o que a gente tem lá na calculadora. Mas vamos conferir agora se isso vai acontecer ou não. Vamos de volta pro vídeo. E eu vou colocar aqui, ó, Lightning MTP com três tokens por passada. E agora com modelo carregado aqui, vou dar o nosso clássico oi. E a gente tem aqui, ó, 55.8 oito tokens por segundo. Vamos pedir para ele criar um pouquinho mais de texto pra gente conseguir ver se esse número aumenta ou diminui. Vou até zerar aqui antes. Pedi aqui para criar um HTML de uma padaria. A gente nem vai olhar esse código em si.

[14:30] A gente só quer ter uma ideia. Ó, aqui a gente consegue ver um pouco da velocidade que ele tá gerando em tempo real. E se eu expandir aqui, ó, a gente consegue ver aqui que ele tá gerando por volta de 49 tokens por segundo. No final, a gente vai ver aqui a média total. Uma coisa importante também é que esses modelos novos, principalmente com speculative de Code ligado, eles vão ter uma velocidade diferente quando a gente fala de texto assim ou código. Código é algo mais previsível. Então, quando o modelo menor ele gera os tokens que vão

[15:01] ser verificados pelo modelo maior, normalmente você tem uma aceitação maior em código porque é mais previsível. Então, nesse caso, a gente aumenta um pouco a velocidade. Provavelmente, quando ele começar a escrever código aqui, a gente vai ter esse aumento. Inclusive, vou fazer o seguinte, eu vou parar por enquanto, tá? Parei aqui. Eu vou diminuir aqui o limite de pensamento para 1000 tokens. Ele só pode pensar por 1000 tokens, porque como que a gente quer ver aqui a velocidade, não a qualidade? Isso aqui não faz muita diferença pra gente, tá mais atrapalhando do que ajudando a gente

[15:31] conseguir ver o máximo que a gente consegue atingir. Então, nesse texto aqui, que foi basicamente ele pensando, a gente conseguiu ali uma média de 55 tokens por segundo. Agora eu vou pedir para ele gerar novamente com o nosso limite de 1000 tokens de pensamento. E olha só, agora ele tá escrevendo código e a gente tá passando dos 70 tokens por segundo. 68, 69, batendo ali 70 de vez em quando. Vamos ver como é que vai ficar a média aqui no final e a gente fala um pouco sobre a conclusão disso. Então, beleza, ele acabou aqui e a média foi de 71.9

[16:02] tokens por segundo. Se a gente trouxer de novo aqui a nossa calculadora, a gente tinha visto que para esse hardware o limite seria 59 tokens por segundo se ele tivesse 100% de eficiência. Como que a gente conseguiu 71.9? exatamente por conta do software e o software tem evoluído bastante, muito graças à comunidade. 71 tokens por segundo no modelo tão bom quanto Quen 27B é excelente. Então aqui a gente conseguiu 20% a mais do que o limite teórico. E o que que é interessante aqui? O Mac M3 Ultra tem 800 GB/sund de largura de

[16:34] banda, mas o M5 Max que tem versões com menos memória, com 64 GB, por exemplo, que conseguiria rodar esse modelo tranquilamente, ele tem 614 GB/sundo, então não é tão menos do que o M3 Ultra. Se a gente calcular aqui o limite teórico, seria 45 tokens. Se a gente aplicar a mesma taxa de 20%, a gente consegue aumentar isso aqui para em torno de 55 tokens. Só que tem um porém o M5 Max e o M5 Ultra, eles vêm com um acelerador neural que o M3 não tem. Isso

[17:05] faz com que o processamento de prompt seja muito mais rápido. Olha só, a gente tá falando aqui de valores em torno de 120 tokens por segundo de velocidade de decoding no M5 Ultra, no M5 Max, desculpa. M5 Ultra é ainda melhor do que o M5 Max, mas eu tô falando do M5 Max porque ele é uma máquina que tem versões de 64 GB que conseguiriam rodar o Quen 3.827B tranquilamente. O M5 Max e o M5 Ultra eles também tm mais capacidade de processamento. Isso quer dizer que eles

[17:35] processam prompt muito mais rápido. Para você ter uma ideia a gente conseguiu aqui então no Quint. 8 Flash Next em torno de 1000 tokens por segundo, né? No M3 Ultra. No M5 Ult, esse valor sobe para 2.500. Isso por conta dos novos processadores, mas também porque as GPUs do M5 Ultra elas têm um hardware específico para matrizes que o M3 Ultra não tem. Isso faz com que elas consigam processar muito mais rápido. Se você comparar os tokens por segundo de geração do M3 Ultra com M5 Ultra, vai

[18:06] ter um up também, mas por conta da largura de banda. Agora o processamento de prompt é por conta do novo hardware. Eu tô extremamente empolgado porque eu acho que o futuro da IA local tá chegando e tá chegando bem rápido por dois motivos. Primeiro, melhoria em hardware, tá? A gente já viu uma melhoria grande do M3 Ultra pro M5 e melhoria de software também. Nesse momento, inclusive, tem muito mais gente engajada no DJX Park, por exemplo, que é da Nvidia, do que no hardware da Apple. O lançamento da M5 Ultra, na verdade, deu uma mexida aí porque a galera começou a ficar de olho, começou a vir

[18:36] uma galera criar esse tipo de coisa, como tensor fold, a gente começou a ver essas melhorias no MLX, então deu um amp legal na comunidade pra gente ver melhorias do lado da Apple também. Mas o mais curioso é que a Apple ela acertou por acaso na IA quando ela fez um chip com memória unificada, né, o M1 e depois os outros foram só evoluções simples não focadas em Ia. A mudança começa agora. O M5 ele dá um pequeno passo na direção certa. O M6 que já existe, que rumores dizem que só vai ter a versão básica, ele já traz suporte de hardware a FP8, o

[19:09] que é importantíssimo para IA. O M5 eles precisam emolar, acabam perdendo performance nisso. Então se a gente tivesse um M6 Max, o M6 Ultra, ele seria melhor ainda do que o M5 para IA. Só que provavelmente a gente não vai ter porque a Apple resolveu focar os esforços em polar o M6 e fazer do zero um M7 feito para IA e esse vai ser um monstro. Então, o que a gente tem visto é uma evolução que tá acontecendo no hardware e principalmente no software. E a junção das duas coisas faz com que tudo evolua

[19:40] muito rápido. Provavelmente daqui a um mês eu vou voltar aqui falando desse modelo ou do sucessor dele com velocidades ainda mais interessantes e provavelmente modelos mais inteligentes. Mas eu diria que nesse nível aqui a gente já tá na base do utilizável com 1000 tokens por segundo de processamento, principalmente levando em consideração que depois que você processa isso vai ser casado. E se você precisar processar esse exato prompt de novo, vai ser muito rápido. 1000 tokens por segundo de processamento de prompt e 100 tokens por segundo de geração é extremamente utilizável, principalmente

[20:11] se você considerar que normalmente numa sessão, se você entregar muitos dados de uma vez, você só vai processar aquilo uma vez. Depois você vai reutilizar o cash e a leitura do cash é muito rápida. Então eu diria que para uso no dia a dia, esse modelo aqui, Quen 3.8 Flash Next, ele já tá bem utilizado. Eu quero fazer inclusive um experimento de criar algumas coisas só com ele, tá? E trazer aqui para vocês os resultados. Eu tenho feito isso, na verdade, em off, mas eu quero fazer algo exclusivo aqui pro canal. Pra muitos dos meus projetos, esse modelo me atende, mas como eu falei, hardware não é pr todo mundo. Se

[20:43] você quer saber mais sobre esse tipo de coisa aqui, esse tipo de coisa que a gente tá falando aqui, eu só consigo saber porque eu me envolvo com hardware local, senão não saberia nada disso. Quem usa só o chatpt, o cloud, etc. Não, não lida muito com largura de banda, né? Com end, quanto, até sabe o que que é quantização, porque às vezes o modelo fica tão ruim lá que a gente acha que quantizaram tudo, mas de forma geral, para você ter esse contato mais de perto, entender, testar, aí você precisa ir pro hardware local. Se você só usa os modelos, você não precisa ainda. Mas eu

[21:13] acho que a gente tá vivendo um momento incrível e talvez o futuro da carreira seja a gente ter esse envolvimento com IA mais, né? E nesse caso sim, ter um hardware local é uma grande vantagem. Se você quiser ver o primeiro vídeo que eu gravei sobre o Quintos. Flash, dá uma olhada nesse vídeo aqui. Se você quiser aprender a extrair mais de modelos menores, mesmo modelos na nuvem, planos como Opent Code Go, mini Max, GLM, etc., dá uma olhada nesse link aqui que é o link do meu curso. Lá você vai entender mais sobre harness e desenvolvimento com IA. Não é sobre modelos locais, tá? Não

[21:43] é um curso sobre modelos locais ainda. Se você tiver interesse sobre isso, deixa aqui embaixo nos comentários, só para eu saber, ter uma ideia. Mas eu acho que é meio nichado demais, não sei. Agora se você quiser se desesperar um pouco, dá uma olhada nesse vídeo aqui, porque eu falo do aumento de preço dos planos da Open AI. Isso é um pouco preocupante, porque eu sei que hardware local é caro e como eu falei, não é para todo mundo. Eu preciso reforçar isso toda hora, senão vai vir alguém comentar: “Ah, mas no Brasil não, não é para você comprar, não, não compre. É para, eu tô fazendo esse vídeo para você entender onde estamos hoje em hard local. Se você é essa pessoa que vai

[22:13] deixar esse comentário, você pode escolher olhar esse vídeo aqui e pagar os seus 500 por mês em assinatura da Open AI.