Explore os LLMs (grandes modelos de linguagem) no Apple Silicon com o MLX

Olá! Meu nome é Angelos. Sou engineer da equipe MLX. Hoje, mostrarei como o MLX é perfeito para grandes modelos de linguagem no Apple Silicon. Com ele, você pode fazer inferências e ajustar modelos enormes diretamente do Mac. E você pode fazer tudo isso com apps de CLI, no Python ou no Swift. Caso não conheça, o MLX é uma biblioteca de código aberto desenvolvida para aprendizado de máquina no Apple Silicon. Ele utiliza Metal para aceleração na GPU e aproveita a memória unificada para que as operações na CPU e GPU possam funcionar nos mesmos dados simultaneamente. Você pode usar o MLX na sua linguagem favorita, pois ele fornece APIs em Python, Swift, C++ e até C. Para saber mais, confira a sessão "Introdução ao MLX para Apple Silicon". Quando o assunto é executar grandes modelos de linguagem no Apple Silicon, o MLX tem novos recursos robustos, permitindo executar os modelos mais avançados e atuais no Mac com um comando de linha única. Vamos carregar o modelo mais recente do DeepSeek AI, que tem 670 bilhões de parâmetros.

Mesmo quando quantificados para 4,5 bits por peso, os pesos do modelo sozinhos ainda requerem cerca de 380 GB de memória. Para processar isso, usamos um M3 Ultra com seus 512 GB de memória unificada, mais que qualquer outro dispositivo de consumo. Agora que o modelo está carregado, podemos começar a interagir com ele. Podemos fazer perguntas como "Qual é o lago mais profundo dos Estados Unidos?"

ou pedir para que escreva um código.

Como pode ver, o MLX permite interação e geração fáceis em tempo real com velocidades mais rápidas do que a leitura, mesmo com modelos contendo centenas de bilhões de parâmetros, todos em execução localmente no seu Mac. Agora que você já viu o que é possível, vamos ver como pode usar o MLX para executar esses modelos robustos no seu Mac. Começaremos com o MLX LM, uma biblioteca de Python e um conjunto de apps de linha de comando que atende a todos os seus requisitos de grandes modelos de linguagem, fornecendo uma solução robusta e versátil para vários apps.

Depois, vamos nos aprofundar na geração de texto com o MLX LM e mostrar como é fácil gerar texto no Python ou no terminal. Além disso, vamos baixar modelos do Hugging Face e quantificá-los para uma inferência mais rápida no dispositivo.

Mas o MLX pode fazer muito mais do que apenas inferência. Em seguida, usaremos o MLX LM para ajustar um modelo de linguagem nos nossos dados. Treinaremos um adaptador de baixa classificação, que podemos integrar ao modelo para facilitar a implantação e agilizar a inferência. Por fim, abordaremos o uso do MLX do Swift, onde veremos como integrar um grande modelo de linguagem ao seu app do Swift com algumas linhas de código.

O jeito mais fácil de começar a usar modelos de linguagem no MLX é com o MLX LM. O MLX LM é um pacote Python criado com base no MLX, projetado para executar e testar grandes modelos de linguagem. Ele fornece um conjunto de ferramentas de linha de comando que permitem gerar texto ou ajustar modelos sem escrever código. Se você quiser ter mais controle, ele também fornece uma API Python para personalizar o processo de geração ou treinamento. Ele também é totalmente integrado ao Hugging Face. Portanto, você pode baixar rapidamente milhares de modelos da Internet e fazer o upload do seu próprio para compartilhar com a comunidade. É fácil começar. Basta executar pip install mlx-lm. Vamos ver mais detalhes do caso de uso mais comum para modelos de linguagem: gerar texto. É uma ferramenta de linha de comando que permite gerar texto usando um modelo de linguagem direto do terminal, sem necessidade de código. Veja como funciona. Você fornece um modelo do Hugging Face, um caminho local ou um prompt de texto, e ele faz o resto. Ele baixa o modelo, se necessário, executa o prompt por ele e imprime a resposta gerada. Em vez de só falar sobre isso, vamos executar esse comando.

Em segundos, temos uma implementação do Swift de classificação rápida.

Ajuste o comportamento do modelo adicionando sinalizadores para itens como temperatura de amostragem, tokens top-p ou max, como em qualquer configuração de geração de texto padrão. Se quiser conhecer as opções disponíveis, execute mlx_lm.generate --help. Ao criar protótipos de ideias, gerar código ou explorar o que o modelo pode fazer, esse é o lugar mais simples para começar. Acabamos de ver como é fácil gerar texto com a linha de comando usando mlx_lm.generate. Mas um dos pontos fortes reais do MLX LM é que ele não se limita às ferramentas de terminal. Ele também fornece uma API Python limpa e flexível, ideal quando você quer um controle mais refinado ou precisa integrar a geração a um fluxo de trabalho maior. Vamos ver como podemos fazer a mesma coisa, gerando texto, usando apenas algumas linhas de Python.

Primeiro, importamos dois utilitários: Load e Generate. Load, como o nome sugere, lida com tudo relacionado ao carregamento do modelo. Ele busca o modelo solicitado, do disco local ou direto do Hugging Face, e configura o objeto de modelo junto com o tokenizador. Então, chamamos Generate. Essa função executa um loop de geração de tokens e retorna o texto de saída, que podemos processar ainda mais em Python, log ou feed em outros sistemas.

Com apenas essas duas etapas, de carregamento e geração, obtemos a mesma funcionalidade da CLI, mas com total controle e flexibilidade em Python. Veja outro aspecto incrível da API Python do MLX LM. O modelo que você obtém do carregamento não é um objeto opaco com o qual você só pode interagir por uma interface fixa. É uma rede neural MLX totalmente estruturada, ou seja, você pode inspecioná-la, explorar sua arquitetura e até modificá-la. Vou fazer uma breve demonstração.

Podemos começar imprimindo a lista de camadas que compõem o modelo.

Isso nos dá uma divisão completa da pilha de transformadores, camada por camada. Também podemos ver os parâmetros do modelo, essencialmente os pesos e vieses que o modelo aprendeu.

Também podemos nos aprofundar em uma parte específica da rede, como o módulo de autoatenção na primeira camada.

Esse nível de transparência é útil, não apenas para depuração ou aprendizado, mas também se você quiser testar algo como troca de camadas, rotinas personalizadas de ajuste ou cirurgia de modelo de baixo nível.

Até agora, vimos como gerar texto com um único prompt. E se você quiser manter uma conversa ou gerar respostas em vários turnos em que cada novo prompt se baseia no anterior? É aí que entra o cache de valor de chave, ou cache KV. Os modelos de linguagem usam mecanismos de atenção para processar tokens de entrada e, na geração, computam repetidamente a atenção nos tokens já gerados. Isso pode ficar caro, especialmente para prompts longos ou cenários de vários turnos. Um cache KV resolve isso armazenando resultados intermediários de etapas anteriores, especificamente as chaves e os valores.

Em vez de recalcular tudo do zero, o modelo reutiliza esse cache, economizando tempo e computação. No MLX LM, usar um cache KV é algo simples.

Vamos atualizar o exemplo anterior do Python com um cache KV criado explicitamente que podemos reutilizar para várias gerações.

Primeiro criamos o objeto de cache usando a função make_prompt_cache. Podemos usá-lo para editar o histórico no local, salvá-lo para uso posterior ou alternar facilmente entre conversas. Então, passamos para a função de geração. E à medida que novos tokens são gerados, o cache é atualizado. Cada chamada continua de onde a última parou, mantendo o contexto ao longo dos turnos. Isso é útil ao criar chatbots, assistentes virtuais ou qualquer app interativo em que é importante acompanhar o histórico. Agora vamos falar sobre quantificação de modelo. Vimos como gerar texto e trabalhar com modelos de forma interativa. Para a implantação no mundo real, a eficiência é tão importante quanto a funcionalidade. Os modelos geralmente são lançados na mesma precisão com que foram treinados, como float32 ou float16. Há precisão, mas isso os torna grandes e lentos, especialmente em dispositivos menores. É aí que entra a quantificação. Ela reduz o modelo para menor precisão, como Int8 ou 4-bit, o que reduz o uso de memória e acelera a inferência, com pouco impacto na qualidade. Geralmente, a quantificação envolve outras ferramentas, scripts de conversão e problemas de compatibilidade. No MLX, é muito mais simples. A quantificação é integrada. Você pode compactar modelos em vários níveis e usá-los imediatamente para inferência ou treinamento sem configuração extra. Vamos ver como funciona. Para quantificar ou converter um modelo com o MLX, use o comando mlx_lm.convert. Essa ferramenta baixa um modelo do Hugging Face, converte-o em uma precisão diferente e o salva localmente em uma única etapa. Neste exemplo, estamos buscando o modelo Mistral original de 16 bits e quantificando-o para cerca de 4 bits por peso. O resultado é um modelo significativamente menor, mais rápido de executar e que requer menos memória. Após a conversão, o modelo é salvo na pasta especificada e pode ser usado imediatamente para inferência ou treinamento com as mesmas ferramentas MLX LM. E se quiser compartilhar seu modelo de quantificação com outras pessoas, faça upload dele de volta para o Hugging Face passando um nome de repositório. Se você está otimizando a velocidade, economizando espaço ou contribuindo para a comunidade, só precisa deste comando.

Assim como na geração de texto, usar a API Python para converter e quantificar modelos oferece mais flexibilidade sem aumentar a complexidade. O MLX LM facilita a aplicação de diversos ajustes de quantificação a diferentes partes do modelo ou no Python.

Por exemplo, é prática comum manter as camadas de incorporação e projeção final em maior precisão, pois elas tendem a ser mais sensíveis à quantificação. Neste exemplo, quantificamos essas camadas para 6 bits, enquanto o resto do modelo usa 4 bits, atingindo um ótimo equilíbrio entre qualidade e eficiência. Isso é feito passando uma função de predicado de quantificação, que recebe cada camada e retorna os parâmetros de quantificação a serem usados para ela. Todo o resto funciona da mesma forma. Chamamos a conversão. Passamos o caminho do Hugging Face e o diretório de saída local. O MLX lida com o resto, incluindo baixar o modelo e salvar o resultado quantificado. Esse controle refinado é especialmente útil quando você está testando a compactação de modelos ou tentando encontrar a melhor compensação entre desempenho e precisão.

Até agora, vimos como gerar texto usando grandes modelos de linguagem e como quantificá-los para inferência mais rápida e implantação mais leve. Mas o MLX pode fazer mais, especialmente quando se trata de treinamento. Com o MLX LM, você pode ajustar um grande modelo de linguagem com base nos seus dados diretamente no Mac e, principalmente, sem que esses dados saiam do seu dispositivo. E o melhor: você pode fazer isso sem escrever uma única linha de código. Vamos ver como o ajuste funciona.

Grandes modelos de linguagem geralmente são treinados em conjuntos de dados enormes e de uso geral de toda a Internet. Isso dá a eles amplo conhecimento, mas eles também podem não ter profundidade em domínios especializados ou perder o tom e a linguagem de uma tarefa específica. O ajuste é como adaptamos esses modelos a novos contextos. Ao treiná-los ainda mais em um conjunto de dados menor e específico do domínio, podemos dar a eles novos recursos ou adaptar suas respostas a necessidades específicas. Tradicionalmente, esse processo é feito na nuvem, o que pode ser caro e muitas vezes não é o ideal quando você está trabalhando com dados privados ou confidenciais. Com o MLX, você pode ajustar grandes modelos de linguagem localmente no Mac sem precisar de nuvem, e nenhum dado sai da máquina. Ele é eficiente, seguro e perfeitamente integrado ao fluxo de trabalho do MLX.

O MLX LM permite dois tipos de ajustes prontos para uso: ajuste do modelo completo e treinamento de adaptadores de baixa classificação. No ajuste, atualizamos todos os parâmetros do modelo pré-treinado. Isso oferece flexibilidade máxima, mas também consome mais recursos. Por outro lado, o treinamento de adaptadores, especificamente adaptadores de baixa classificação, adiciona alguns novos parâmetros ao modelo e treina só esses, mantendo a rede original congelada. Isso torna o treinamento mais rápido, leve e eficiente em termos de memória, especialmente em hardware local. Vejamos como podemos aplicar isso na prática ajustando o modelo Mistral em um conjunto de dados personalizado. Vamos ver como é fácil iniciar um trabalho de ajuste com o MLX LM. Basta um único comando e alguns argumentos principais. Especificamos o modelo que queremos ajustar, o caminho para o conjunto de dados e por quanto tempo queremos treinar. Como a quantificação está profundamente integrada ao MLX, o comando mlx_lm.lora pode até treinar adaptadores sobre modelos quantificados. Isso reduz drasticamente o uso da memória sem sacrificar a capacidade de ajuste de forma eficaz.

Neste exemplo, estamos treinando em uma versão quantificada de 4 bits do Mistral, que reduz o uso de memória para os pesos do modelo em cerca de 3,5x em comparação com a versão de precisão completa. Por isso, mesmo com modelos grandes, o ajuste continua sendo prático e eficiente no seu Mac. Esse comando de linha única é perfeito para um treinamento rápido, especialmente quando você está começando. Mas se você quiser ajustar o desempenho, é provável que precise de mais controle sobre o processo de treinamento. É aí que entra o arquivo de configuração de treinamento. O MLX LM aceita arquivos de configuração com controle refinado sobre todos os aspectos do treinamento, incluindo tamanho do caminho, cronogramas de taxa de aprendizado, ajustes do otimizador, intervalos de avaliação, etc. Isso permite personalizar a configuração de treinamento para seu conjunto de dados, hardware ou metas de otimização e aproveitar ao máximo seu adaptador. Vamos ver o ajuste em ação e como ele pode atualizar o conhecimento de um modelo. Começamos perguntando ao Mistral 7b quem venceu o último Super Bowl.

Como esperado, a resposta está correta, mas desatualizada. O corte de conhecimento do modelo significa que ele não tem acesso a eventos recentes. Com o ajuste, podemos corrigir isso em poucos minutos. Ao treinar com um conjunto de dados com perguntas e respostas sobre o último Super Bowl, atualizamos o conhecimento do modelo e fazemos com que responda corretamente.

Depois de poucos minutos de ajuste, o modelo é capaz de dar respostas atualizadas sobre times, jogadores, resultados e muito mais.

Agora que treinamos nossos adaptadores, podemos usar o MLX LM para integrá-los de volta ao modelo base. Isso é útil para implantação e compartilhamento porque produz um modelo independente único fácil de distribuir e usar.

O processo de fusão combina o adaptador com os pesos originais, resultando em um modelo que tem a mesma arquitetura e número de parâmetros da versão pré-treinada, apenas com recursos atualizados. Então, de fora, ele se comporta como qualquer outro modelo, mas com seu conhecimento refinado integrado.

Para integrar o adaptador ao modelo, usamos o comando mlx_lm.fuse. Ele calcula os pesos integrados e salva os resultados no caminho especificado em uma única etapa. Não há necessidade de desquantificar ou requantificar nada manualmente. O MLX lida com isso automaticamente e preserva a mesma quantificação usada durante o treinamento. E se você pode compartilhar facilmente seu modelo recém-ajustado com outras pessoas. Basta fornecer um nome de repositório do Hugging Face para o modelo integrado ser enviado e ficar pronto para uso. Até agora, usamos Python para gerar texto e ajustar grandes modelos de linguagem. Mas um dos recursos de destaque do MLX é que ele traz a mesma simplicidade e flexibilidade para o Swift. Vamos ver como é fácil usar um grande modelo de linguagem no Swift com o MLX.

Veja um exemplo completo de como carregar um modelo Mistral quantificado e gerar texto no Swift. E tudo cabe em apenas 28 linhas de código. Começamos importando o MLX e as bibliotecas de modelos de linguagem. Criamos um contêiner de modelo, um agente que gerencia com segurança o acesso simultâneo ao modelo e ao tokenizador. Em seguida, preparamos a inserção. Nós tokenizamos o prompt, convertendo-o no formato numérico que o modelo entende. Por fim, executamos o loop de geração e imprimimos o resultado, assim como já vimos em Python. É o mesmo fluxo de trabalho, os mesmos recursos, mas agora totalmente nativos no Swift. Vamos ver o que é preciso para reter o histórico de uma conversa em várias interações com um modelo, assim como já fizemos em Python. Em Swift, são necessárias apenas algumas linhas extras. A ideia principal é a mesma: precisamos criar explicitamente um cache de valor chave para reutilizá-lo de em várias gerações. Isso é feito com uma única linha adicional de código. Sem complexidade extra. Para gerenciar a interação com mais precisão, também usamos um iterador de token, que nos permite definir o valor da chave diretamente e controlar as gerações passo a passo. Essa configuração nos dá flexibilidade para lidar com conversas em vários turnos e solicitações avançadas, tudo do Swift. Ao longo desta sessão, vimos como é simples realizar inferência, treinamento e quantificação com o MLX, seja por meio de código ou comandos de terminal. Tudo que usamos, das APIs avançadas de modelo de linguagem aos kernels do Metal que as viabilizam, é totalmente de código aberto. O MLX fornece operações principais em C, C++, Python e Swift, com APIs avançadas em Python e Swift, fornecendo flexibilidade e controle em toda a pilha. Isso torna o MLX muito poderoso para executar modelos de linguagem e fluxos de trabalho de aprendizado de máquina no hardware da Apple. Vamos dar uma olhada nos próximos passos. Exploramos alguns dos principais recursos do MLX LM, mas você pode fazer muito mais. A documentação detalha recursos avançados, como inferência e treinamento distribuídos, quantificação aprendida e ciclos de treinamento personalizados. Para começar rápido, os repositórios de exemplo MLX e MLX Swift têm projetos prontos para execução para tarefas como geração de imagens com modelos de difusão, reconhecimento de fala e treinamento completo de modelos de linguagem. Esteja você criando seu próprio app de IA ou explorando o que acontece nos bastidores, você só precisa de alguns cliques para começar. Queremos ver as experiências incríveis que você criará no hardware da Apple usando o MLX e o poder de grandes modelos de linguagem.