A Apple ainda não colocou um LLM no seu relógio. Então eu coloquei.

Ver no idioma original →

Autoria: Better Stack · 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: Apple Hasn’t Put an LLM on Your Watch. So I Did. · Canal: Better Stack · 11:27 · Assistir no YouTube

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

Resumo

O vídeo demonstra um LLM executado totalmente offline em um Apple Watch Series 6, com inferência local e geração de texto em velocidade que chega a cerca de 24 tokens por segundo. O apresentador explica por que Core ML não é adequado para esse modelo e como adaptar llama.cpp para watchOS. Também aborda a arquitetura arm64_32 e o limite de memória imposto pelos endereços de 32 bits. Na demonstração, dois modelos pequenos usam chamadas de ferramentas para responder perguntas, embora respostas longas fiquem mais lentas. O vídeo termina questionando por que fabricantes ainda hesitam em oferecer LLMs locais de uso geral em seus dispositivos.

Pontos-chave

• Um Apple Watch Series 6 executa um modelo de IA localmente, sem depender de streaming pela nuvem.
• O modelo Falcon H1 tem 90 milhões de parâmetros e combina camadas de atenção com Mamba 2.
• Core ML não oferece um componente adequado para a parte de espaço de estados usada pelo Falcon H1.
• Foi possível compilar llama.cpp para watchOS com algumas flags de compilação e uma alteração pequena no código-fonte.
• arm64_32 mantém o conjunto completo de instruções ARM de 64 bits, mas usa endereços de memória de 32 bits.
• O limite de endereçamento de memória impede o Apple Watch de executar modelos grandes, mesmo com quantização agressiva.
• A demonstração compara Falcon H1, de 90 milhões de parâmetros, com um modelo Small M2 de 135 milhões.
• Chamadas de ferramentas, como Wikipedia e clima, funcionam no app; a localização do exemplo de clima foi fixada em Ottawa.
• A velocidade de geração cai em respostas longas, provavelmente por causa dos limites de memória do relógio.

Capítulos

Início	Capítulo	Resumo
00:00	LLM offline no Apple Watch	O apresentador mostra um modelo local funcionando no Apple Watch Series 6 e apresenta o objetivo do experimento.
02:04	Por que Core ML não serve para este modelo	A explicação apresenta a arquitetura híbrida do Falcon H1 e os obstáculos de Core ML para executar Mamba 2.
04:09	Compilação para watchOS e limites de memória	O vídeo mostra a adaptação de llama.cpp e explica as características de arm64_32 e seu limite de endereçamento.
06:43	Configuração do app e demonstração	O apresentador mostra os modelos e ferramentas adicionados ao projeto e testa perguntas por voz, incluindo chamadas de ferramentas.
09:51	Resultados e adoção de LLMs locais	O vídeo avalia o desempenho dos modelos e questiona por que fabricantes ainda não oferecem LLMs locais de uso geral.

Citações

Tudo está funcionando no dispositivo, gerando texto a cerca de 15 tokens por segundo, em média. — 00:00

Mil tokens depois, ele está usando exatamente a mesma quantidade de memória que no primeiro token. — 03:05

O desempenho matemático real é tão rápido quanto seria em qualquer outro chip ARM. — 05:10

Estou surpreso que a Apple ainda não tenha lançado um modelo local de uso geral que você possa usar livremente no dispositivo. — 10:23

Conceitos e entidades

• Apple Watch Series 6 (ferramenta): Relógio de 2020 usado para demonstrar a execução local de modelos de IA.
• Falcon H1 (modelo): Modelo com 90 milhões de parâmetros, executado no relógio e composto por camadas de atenção e Mamba 2.
• Small M2 (modelo): Modelo de 135 milhões de parâmetros usado para comparação com Falcon H1.
• Core ML (ferramenta): Framework de machine learning da Apple para executar modelos nos dispositivos, mas que não oferece o componente de espaço de estados necessário neste caso.
• llama.cpp (repo): Projeto adaptado no vídeo para compilar e executar modelos no watchOS.
• Mamba 2 (conceito): Modelo de espaço de estados que mantém um estado de memória de tamanho fixo e o atualiza a cada token.
• arm64_32 (conceito): Alvo de arquitetura usado pelo watchOS, com conjunto de instruções ARM de 64 bits e endereços de memória de 32 bits.
• Andras (pessoa): Apresentador do vídeo, que demonstra o app e explica como adaptou llama.cpp para o relógio.
• Better Stack (empresa): Canal responsável pelo vídeo.

Tradução completa (pt-BR)

00:00 Este é um modelo de IA LLM rodando completamente offline em um Apple Watch Series 6, um relógio de 6 anos que foi lançado em 2020. Não há transmissão pela nuvem envolvida. Tudo funciona na borda, gerando texto a cerca de 15 tokens por segundo, em média. Então, alguns dias atrás, me desafiei a descobrir se os Apple Watches conseguem mesmo executar modelos de IA localmente. E, para minha surpresa, conseguem. E, com alguns truques, dá para deixá-los bem eficientes também. Agora, o motivo de isso funcionar é que, nos bastidores, ele executa um modelo de 90 milhões de parâmetros chamado Falcon H1. E, por ser tão pequeno, o desempenho é surpreendentemente bom. Ele até oferece suporte a chamadas de ferramentas e, graças à entrada de voz do próprio relógio, é muito fácil enviar um prompt para ele também. Então, no vídeo de hoje, vamos ver como compilar e executar localmente um modelo de IA em um Apple Watch. Vamos falar sobre por que isso funciona e quais são as melhores práticas ao

00:32 implantar esses modelos. Depois, faremos uma demonstração rápida para ver como ele se sai e onde ainda tem dificuldades. Vai ser muito divertido, então vamos começar. >> [música] >> Há alguns meses, fiz outro vídeo em que testei se um Raspberry Pi de primeira geração conseguiria executar um modelo de IA completamente offline. E descobri que consegue, mas, no meu teste, ele tinha dificuldades para chegar a cerca de 0,3 token por segundo. Então, funcionava, mas não era

01:02 realmente utilizável. Mas isso me fez pensar: e se eu colocasse o mesmo modelo no meu Apple Watch de 6 anos? Que desempenho eu teria com um wearable da Apple de verdade? A resposta acabou sendo cerca de 50 vezes mais rápido. O Raspberry Pi 1 tinha um único núcleo de 700 MHz e 512 MB de RAM, enquanto o Series 6 tem dois núcleos de 1,8 GHz e um gigabyte inteiro. Então, no papel, essa configuração sempre seria mais potente, mas eu

01:32 não esperava que fosse muito melhor. Agora, se você está pensando em como executar inference em um dispositivo com watchOS, a primeira coisa que vem à mente naturalmente é o Core ML da própria Apple. É o framework de machine learning da Apple para execução no dispositivo, e a ideia é converter um modelo para o formato da Apple, entregá-lo ao sistema e deixar que ele cuide do resto. Mas isso não funciona bem com todos os modelos, e Falcon H1 é um deles, porque metade da arquitetura não usa camadas de atenção.

02:04 O funcionamento do Falcon é assim: junto com a atenção convencional, cada camada também executa um modelo de espaço de estados chamado Mamba 2. Ele mantém um bloco de memória de tamanho fixo e o atualiza um token de cada vez, decidindo o que manter e o que substituir à medida que cada novo token chega. Essa sequência de atualizações é chamada de varredura e, como cada etapa depende da anterior, ela precisa ser executada em ordem. Nada é armazenado em cache nem guardado para depois, porque tudo é

02:34 compactado nesse estado. Então, é menos preciso do que a atenção, mas consome memória com muita eficiência. Mesmo depois de mil tokens, ele usa exatamente a mesma quantidade de memória que usava no primeiro token. E o Falcon executa as duas coisas ao mesmo tempo, a camada de atenção e a camada Mamba, e soma os resultados, o que é ótimo para dispositivos pequenos. O problema é que o Core ML não tem um bloco básico para espaço de estados. Ele só sabe converter camadas de atenção, então não há nada em que converter a camada Mamba. E o

03:05 problema mais profundo é que o Core ML exige um grafo fixo definido de antemão, enquanto a varredura é um loop cujo comprimento depende da duração da conversa. Então, suas opções são desenrolá-lo para um comprimento fixo, o que limita você a um único tamanho de contexto, ou carregar o estado por conta própria e passá-lo por um pipeline de conversa que falha ao converter tudo perfeitamente e depois fornece números sutilmente incorretos. Então, o Core ML não funciona para o nosso caso específico, mas há outra opção que podemos usar: o

03:37 llama.cpp. Mas ele tem outro problema. Ele vem com um script que compila para macOS, iOS, tvOS e visionOS, mas watchOS não está nessa lista. Porém, em nenhum lugar do projeto está escrito que ele não oferece suporte aos Apple Watches, e também não há muitas informações na internet sobre esse caso de uso específico. Então, decidi testar e ver se conseguimos fazer o llama.cpp funcionar no watchOS. Felizmente, conseguimos. Tudo de que ele

04:09 precisa é de algumas flags de compilação e de uma condição de proteção de uma linha no código-fonte. É aqui que surge a confusão. Todo mundo presume que o impedimento está na arquitetura. O watchOS não usa o arm64 padrão. Ele usa algo chamado arm64_32. E esse nome dá a impressão de que se trata de uma versão reduzida de 32 bits do arm, que funcionaria pela metade da velocidade, mas não é esse o caso. O conjunto de instruções está completamente intacto.

04:39 É o mesmo arm completo de 64 bits. Nada foi removido, incluindo o neon, que é a unidade vetorial do arm que permite agrupar operações matemáticas. Então, o desempenho matemático real é exatamente o mesmo que seria em qualquer outro chip arm. O que muda, no entanto, é a forma como o chip se refere à memória. Cada posição na memória tem um endereço, que é basicamente um número, e, em um sistema normal de 64 bits, esses números têm 64 bits. Mas, no relógio, eles têm apenas 32

05:10 bits. E a Apple fez isso porque, de qualquer forma, um relógio só tem um gigabyte de RAM. Portanto, fazer cada um desses endereços ter esse tamanho libera memória em todo o sistema. Mas isso estabelece um limite rígido, porque um número menor só consegue contar até certo valor. 32 bits permitem chegar a cerca de 2 GB, e só. Um relógio não consegue endereçar fisicamente mais memória do que isso, o que significa que nunca poderá executar um modelo grande, por mais agressivamente que ele seja quantizado. Mas o Falcon

05:42 tem apenas 57 MB, então estou bem longe desse limite. Mas você deve ter isso em mente se quiser implantar outros modelos de IA maiores no Apple Watch. E o bom é que nada disso exige portar ou alterar qualquer coisa. ARM64 32 é apenas um alvo que você informa ao compilador para o qual compilar. Basta passar flags diferentes. Então, para compilar o llama.cpp corretamente e especificamente para watchOS, você precisa usar este comando. Mas, no projeto do app para o relógio com que vamos trabalhar, ele já está

06:13 compilado. E vou deixar na descrição um link para o repo no GitHub, que você pode clonar e executar por conta própria. E, como você pode ver no Xcode, o projeto é bem simples. Temos apenas uma pasta models, na qual você pode importar diferentes arquivos GGML do modelo que quiser. Só tenha em mente que este é um dispositivo vestível muito pequeno e você não vai conseguir executar nele um modelo com vários bilhões de parâmetros. Mas, para esta demonstração específica, adicionei dois modelos de IA aqui. Um deles é o Falcon H1, mencionado

06:43 antes, que tem 90 milhões de parâmetros. Também adicionei um modelo small M2 um pouco maior, com 135 milhões de parâmetros, só para ver como eles se comparam no mesmo conjunto de tarefas. E, na seção de ferramentas, também há um arquivo de exemplos de ferramentas, onde você pode conferir algumas das ferramentas adicionais que adicionei para este app. Se você simplesmente renomear esse arquivo para tools, essas chamadas de ferramentas específicas serão registradas na hora. Você também pode modificar esse arquivo para adicionar ou remover quaisquer outras

07:14 ferramentas que queira neste projeto. Certo, agora vamos ver como funciona. Certo, vamos abrir o app. Aqui você pode escolher para qual modelo queremos enviar um prompt. Primeiro, vamos testar com o Falcon H1. Podemos simplesmente tocar neste botão para começar a falar. Qual é a capital da França? Quando terminarmos, podemos tocar em Concluído e, em seguida, apertar o botão Perguntar. E, como você pode ver, ele está usando a chamada de ferramenta da Wikipedia e respondeu quase instantaneamente que

07:46 ferramentas que você talvez queira neste projeto. Certo, agora vamos ver como funciona. Certo, vamos abrir o app, e aqui você pode escolher qual modelo queremos usar no prompt. Primeiro, vamos testar com o Falcon H1, e podemos simplesmente apertar este botão para começar a falar. Qual é a capital da França? Quando terminarmos, basta clicar em Concluído e depois apertar o botão Perguntar. E, como você pode ver, ele está usando uma chamada de ferramenta da Wikipedia e respondeu quase instantaneamente que

08:17 Paris é a capital da França, o que está correto, e ele fez isso a uma velocidade de 24 tokens por segundo. Agora vamos tentar a mesma coisa com o modelo pequeno. Podemos fazer a mesma pergunta. Ele está usando a Wikipédia de novo, e este foi um pouco mais lento: 14 tokens por segundo, porque este é um modelo maior, então isso era esperado. Agora também adicionei uma chamada de ferramenta de clima. Qual é a temperatura atual? Vamos perguntar isso e, como você pode ver, ele está usando a ferramenta de clima, e

08:49 a temperatura atual é de 14,5 graus Celsius. E preciso dizer que, para essa chamada de ferramenta, deixei a localização fixa como Ottawa, só porque não queria adicionar a permissão de localização neste app. Mas, se você usar isso no seu próprio aplicativo, vai querer configurá-lo para usar a localização atual, em vez de deixá-la fixa. Agora vamos perguntar algo mais difícil. Você pode me explicar o algoritmo de busca em profundidade? Uau, ele me deu a resposta quase

09:19 imediatamente, e olha só: está transmitindo a resposta muito rápido. E, quanto mais a resposta continua, mais lento fica, porque acho que estamos chegando ao limite da memória que o relógio consegue comportar. Acho que começamos com cerca de 20 tokens por segundo, e agora caiu para cerca de 10. Sim, dá para ver como a contagem de tokens por segundo está caindo. Então, provavelmente, não é ideal para respostas muito longas ou perguntas difíceis que exigem vários parágrafos de

09:51 explicações. Então, como você pode ver, nenhum dos dois modelos tem problemas para responder a perguntas com respostas detalhadas, e eles fazem isso em um ritmo relativamente rápido para um dispositivo vestível tão pequeno. Estou muito feliz com esses resultados. E é isso, pessoal. Agora temos um aplicativo de inference funcional. Isso significa que até dispositivos antigos de 2020, como o Apple Watch Series 6, são potentes o bastante para executar modelos de IA localmente. A Apple lançou recentemente seu novo relógio Series 12 e, embora ele tenha um mecanismo neural no dispositivo capaz de realizar algumas tarefas leves de IA, fico surpreso que a Apple ainda não tenha lançado um modelo local de uso geral que você possa promptar livremente no dispositivo. Acho que testes como o que acabei de fazer e experimentos semelhantes mostraram que o setor já está em um estado estável o bastante para ter capacidade de executar LLMs localmente. Então, minha pergunta sincera é: por que os fabricantes de dispositivos ainda hesitam em dar

10:23 o salto para LLMs na borda? Você tem alguma opinião sobre isso? Conte o que você acha nos comentários abaixo. E, pessoal, se vocês gostam desse tipo de análise técnica detalhada, mostrem isso clicando no botão de curtir abaixo do vídeo e não se esqueçam de se inscrever no nosso canal. Aqui foi Andras, da Better Stack, e vejo vocês nos próximos vídeos. >> [música] [música]

10:53 [música]

11:27 [música]

Transcrição original

[00:00] This is an LLM AI model running completely offline on an Apple Watch Series 6, which is a 6-year-old watch that came out back in 2020. There’s no streaming over the cloud involved here. Everything is working on edge and streaming text at around 15 tokens per second on average. So, a few days ago, I challenged myself to see if Apple Watches can actually run AI models locally. And to my surprise, yes, they can. And with a few tricks, you can make

[00:32] them pretty efficient as well. Now, the reason this works is because behind the scenes, it’s running a 90 million parameter model called Falcon H1. And because it’s so small, it’s surprisingly performant. It even supports tool calls, and thanks to the watch’s own voice input, it’s really easy to prompt it as well. So, in today’s video, we’re going to take a look at how to compile and run an AI model on an Apple Watch locally. We’ll talk about why this works and what the best practices are when you’re

[01:02] deploying these models, and then we’ll run a quick demo to see how it performs and where it still struggles. It’s going to be a lot of fun, so let’s dive into it. >> [music] >> So, a few months ago, I did another video where I tested whether a first generation Raspberry Pi could run an AI model completely offline. And it turns out that it can, but in my test, it was struggling at around 0.3 tokens a second. So, it worked, but it wasn’t

[01:32] really usable. But that got me thinking, what if I put the same model on my 6-year-old Apple Watch? What kind of performance would I get out of a proper Apple wearable? And the answer turned out to be about 50 times faster. The Raspberry Pi 1 had a single 700 MHz core and 512 MB of RAM, while the Series 6 has two cores at 1.8 GHz and a full gigabyte. So, on paper, this was always going to be a more powerful setup, but I

[02:04] didn’t expect it to be better by such a long shot. Now, if you’re thinking about how to run inference on a watchOS device, the first thing that naturally comes to mind is Apple’s own Core ML. It is Apple’s on-device machine learning framework, and the idea is that you convert a model into Apple’s format, hand it over, and let the system deal with it. But, that doesn’t work well with every model, and Falcon H1 is one of those models because half of its architecture doesn’t use attention

[02:34] layers. The way Falcon works is that alongside the usual attention, every layer also runs a state space model called Mamba 2. It keeps one fixed-size chunk of memory and updates it one token at a time, deciding what to keep and what to override as each new token comes in. And that sequence of updates is called a scan, and because each step depends on the one before it, it has to run in order. And nothing gets cached or stored for later because it all gets

[03:05] compressed into that state. So, it’s less precise than attention, but it’s very memory efficient. And a thousand tokens in, it’s using exactly the same amount as it was at token one. And Falcon runs both of these at once, the attention layer and the Mamba layer, and adds the results together, which is great for small devices. The problem is that Core ML has no state space building block. It only knows how to convert attention layers, so there’s nothing for the Mamba layer to convert into. And the

[03:37] deeper issue is that Core ML wants a fixed graph decided up front, while the scan is a loop whose length depends on how long your conversation is. So, your options are to unroll it at a fixed length, which locks you into one context size, or carry the state yourself and thread it through a conversation pipeline that fails by converting perfectly and then giving you subtly wrong numbers. So, Core ML doesn’t work for our specific case, but there’s another option we can use, which is

[04:09] llama.cpp. But, that one has another problem on its own. It ships with a script that builds for macOS, iOS, tvOS, and visionOS, but watchOS is not on that list. But, nowhere in the project does it say that it doesn’t support Apple watches, and there’s not a lot of information about this specific use case on the web, either. So, I decided to test it and see if we can actually get llama.cpp to work on watchOS. And fortunately for us, it does work. All it

[04:39] needs is a handful of build flags and a one-line guard in the source. So, here’s where the confusion arises. Everyone assumes the blocker here is the architecture. watchOS doesn’t use standard arm64. It uses something called arm64_32. And that name makes it sound like it uses some kind of 32-bit cut-down, half-speed variant of arm, which is not actually the case. Because the instruction set is completely intact.

[05:10] It’s the same full 64-bit arm. Nothing is removed, including neon, which is the arm’s vector unit that allows batching math operations. So, the actual math performance runs exactly as fast as it would on any other arm chip. The one thing that is different, however, is how the chip refers to memory. So, every location in memory has an address, which is really just a number, and on a normal 64-bit system, those numbers are 64 bits long. But, on the watch, they’re only 32

[05:42] bits. And Apple did that because a watch only has a gigabyte of RAM, anyway. so making every one of those addresses have the size is freeing up memory across the whole system. But that does put a hard ceiling on things because a smaller number can only count so high. 32 bits gets you to about 2 GB, and that’s it. A watch physically cannot address more memory than that, which means it can never run a large model no matter how aggressively it’s quantized. But Falcon

[06:13] is only 57 MB, so I’m not remotely close, but this is something you should keep in mind if you want to deploy other bigger AI models on the Apple Watch. And the nice part is that none of this requires porting anything or changing anything. ARM64 32 is just a target you tell the compiler to build for. You just need to pass different flags. So, to compile llama.cpp correctly specifically for watchOS, you need to use this command. But in the watch app project we’ll be working with, it is already

[06:43] compiled. And I’ll leave a link down in the description below to the GitHub repo that you can clone and run it for yourself. And as you can see on Xcode, the project is quite simple. We just have a models folder where you can import different GGML files of whichever model you want. Just be aware that it is a very small wearable device and you won’t be able to successfully run a multi-billion parameter model on it. But for this specific demo, I have two AI models added here. One is the previously

[07:14] mentioned Falcon H1, which has 90 million parameters. And I also added a slightly bigger 135 million parameter small M2 model just to see how they compare on the same set of tasks. And then in the tools section, there’s also a tools samples file where you can check out some of additional tools that I’ve added for the use of this app. And if you just rename this file to tools, it will register these specific tool calls instantly and you can also modify this file to add or remove any other specific

[07:46] tools that you might want in this project. All right, so now let’s see how it works. All right, so let’s open the app, and here you can choose which model we want to prompt. So first, let’s try it with the Falcon H1, and we can just push this button to start speaking. What is the capital of France? And when we’re done, we can just click done, and then press the ask button. And as you can see, it’s using the Wikipedia tool call, and it answered almost instantly that

[08:17] Paris is the capital of France, which is correct, and it did it with a speed of 24 tokens per second. Now let’s try the same thing with the small model. We can ask the same question. It’s using Wikipedia again, and this one was a bit slower, 14 tokens per second, because this is a bigger model, so that is expected. Now I also added a weather tool call. What is the current temperature? So let’s ask that, and as you can see, it’s using the weather tool call, and

[08:49] the current temperature is 14.5 degrees Celsius. And I do have to say that for this tool call, I hardcoded the location as Ottawa, just because I didn’t want to add the location permission on this app, but if you use this in your own application, you would want to set it to reference the current location rather than hardcoding it. Now let’s ask it something more difficult. Can you explain the depth-first search algorithm to me? Wow, it gave me the answer almost

[09:19] immediately, and look at that, it is streaming so quickly. And the longer it goes, the slower it becomes, because I guess we’re pushing the boundaries of the memory the watch can hold. So I think we started off at like 20 tokens per second, and now it has dropped to like 10. Yeah, you can see how the token count per second is dropping. So, it’s probably not ideal for very long responses or difficult questions that require multiple paragraphs of

[09:51] explanations. So, as you can see, both of the models have no problems answering questions with detailed responses, and they’re doing it at a relatively quick pace for such a small wearable device. So, I’m super happy about these results. So, there you have it, folks. We now have a functional inference application. This means that even old devices from 2020, like the Apple Watch Series 6, are powerful enough to run AI models locally. Apple recently came out with

[10:23] their new Series 12 watch, and although it does have an on-device neural engine that can perform certain light AI tasks, I’m surprised that Apple still hasn’t shipped a general-purpose local model you can prompt freely on the device. I think tests like I just did and similar experiments have shown that the industry is now in a stable enough state to actually have the capacity to run LLMs locally. So, my honest question is, why are device makers still hesitant to make

[10:53] the jump to on-edge LLMs? Do you have any thoughts on that? Let me know what you think in the comment section down below. And folks, if you like these types of technical breakdowns, please let me know by smashing that like button underneath the video, and also don’t forget to subscribe to our channel. This has been Andras from Better Stack, and I will see you in the next videos. >> [music] [music]

[11:27] [music]