Safetensors, CKPT, ONNX, GGUF e Outros Formatos Essenciais de Modelos de IA [2025]

O crescimento da inteligência artificial e da aprendizagem automática (machine learning) criou uma necessidade crítica de métodos para armazenar e distribuir modelos que sejam eficientes, seguros e compatíveis com diferentes sistemas. À medida que os modelos se tornam mais complexos e são utilizados em contextos mais diversos, a escolha do formato de serialização é uma decisão fundamental. Esta escolha afeta o desempenho, o uso de recursos e a segurança dos sistemas de IA.

Este relatório analisa os principais formatos de serialização de modelos, incluindo Safetensors, CKPT, ONNX e GGUF. Destaca as suas características únicas, utilizações comuns e como se comparam entre si.

1. Introdução à Serialização de Modelos em IA/Aprendizagem Automática

A serialização de modelos é o processo de guardar um modelo de aprendizagem automática treinado num ficheiro. Este ficheiro pode ser armazenado, partilhado ou recarregado para uso posterior, como para fazer previsões, continuar o treino ou realizar análises. Esta capacidade é essencial para todo o ciclo de vida da IA/aprendizagem automática, desde a investigação e desenvolvimento até à implementação em larga escala.

O Papel Crítico dos Formatos de Modelos no Ciclo de Vida de IA/Aprendizagem Automática

Guardar modelos num formato padrão é crucial por várias razões:

• Reprodutibilidade: Permite que experiências de investigação sejam replicadas e validadas com precisão.
• Colaboração: Formatos padrão facilitam a partilha de modelos entre equipas, permitindo que trabalhem em conjunto e integrem modelos em sistemas maiores.
• Implementação: A serialização transforma um modelo treinado num ficheiro portátil que pode ser carregado e executado em vários ambientes, desde servidores na nuvem a dispositivos de edge.
• Aprendizagem por Transferência: Permite o uso de modelos pré-treinados como base para novas tarefas, o que poupa tempo de treino e dados significativos.

Visão Geral dos Desafios Abordados pelos Formatos Modernos

Com o avanço da aprendizagem automática, os formatos de serialização modernos evoluíram para resolver vários desafios importantes:

• Segurança: Uma grande preocupação é o risco de segurança nos métodos tradicionais, especialmente os que utilizam o módulo pickle do Python. Estes métodos podem permitir a execução de código malicioso quando um modelo é carregado, criando uma grave ameaça de segurança se o modelo vier de uma fonte não fidedigna.
• Desempenho: Os modelos atuais, grandes e complexos, exigem um carregamento muito rápido e uma gestão de memória eficiente. Isto é especialmente importante para dispositivos com recursos limitados, como telemóveis, e para aplicações que necessitam de respostas imediatas.
• Portabilidade e Interoperabilidade: O mundo da aprendizagem automática utiliza muitas frameworks diferentes (como PyTorch, TensorFlow e JAX). São necessários formatos que permitam que os modelos se movam facilmente entre estas frameworks e sejam executados em hardware diferente (GPUs, TPUs) sem grandes retrabalhos.

Nos últimos anos, a comunidade de IA tem-se movido em direção a formatos mais eficientes e seguros como GGUF e Safetensors, refletindo um esforço coletivo para resolver estas questões.

Os primeiros métodos para guardar modelos de aprendizagem automática, como o uso do módulo pickle do Python pelo PyTorch para os seus ficheiros .pt e .pth, foram escolhidos pela sua facilidade de uso. Conseguiam guardar facilmente objetos Python complexos, incluindo tanto a arquitetura do modelo como o seu estado de treino (como o otimizador). Embora isto fosse conveniente para a investigação num ambiente Python, criou uma falha de segurança grave. O módulo pickle está desenhado de forma a permitir a execução de qualquer código incorporado num ficheiro durante o processo de carregamento. Isto significa que carregar um modelo aparentemente inofensivo de uma fonte não fidedigna pode comprometer um sistema inteiro.

A criação de formatos como Safetensors, juntamente com o uso crescente de ONNX e GGUF, é uma resposta direta a este risco de segurança, bem como à necessidade de melhor desempenho e portabilidade. O Safetensors, por exemplo, foi construído especificamente para impedir a execução de código malicioso. Isto mostra que, à medida que o campo da aprendizagem automática amadurece e a IA passa da investigação para aplicações do mundo real, a segurança e a eficiência já não são considerações secundárias, mas sim princípios centrais no desenvolvimento de novos formatos. Esta mudança representa uma transição necessária da flexibilidade focada na investigação para a segurança e robustez de nível de produção, corrigindo a "dívida técnica" dos métodos mais antigos e permissivos.

Os formatos nativos das frameworks, como .pt/.pth para PyTorch e .ckpt/.h5 para TensorFlow/Keras, estão firmemente integrados nas suas frameworks específicas. Embora isto os torne eficientes dentro de um único ecossistema, causa problemas significativos de interoperabilidade. Um modelo treinado numa framework não pode ser facilmente usado noutra sem conversões complexas ou a manutenção de sistemas separados para cada framework. Isto leva a fluxos de trabalho de desenvolvimento e implementação desconexos.

O formato Open Neural Network Exchange (ONNX) foi criado para quebrar estas barreiras. Ele fornece um padrão "multiplataforma" e "neutro em relação ao fornecedor" para modelos. Consegue isto ao definir a estrutura do modelo (o seu grafo computacional) de uma forma abstrata que é independente de qualquer framework individual. Da mesma forma, o GGUF, embora originalmente criado para o projeto llama.cpp, também se foca em melhorar a compatibilidade para modelos de linguagem grandes (large language models - LLMs) em diferentes plataformas.

A variedade de formatos atuais reflete uma tensão central na indústria de aprendizagem automática: o desejo por funcionalidades específicas da framework durante o desenvolvimento (por exemplo, o grafo dinâmico do PyTorch para flexibilidade na investigação) versus a necessidade de uma implementação universal, eficiente e segura. Esta tensão significa que múltiplos formatos continuarão a existir, tornando as ferramentas de conversão e os pipelines avançados de MLOps cada vez mais vitais para ligar o desenvolvimento de modelos à implementação. Diferentes formatos continuarão a ser usados para fases específicas do ciclo de vida da aprendizagem automática com base nas suas forças únicas.

2. Compreender o Safetensors

O Safetensors representa um grande avanço na serialização de modelos, concebido especificamente para corrigir os problemas de segurança e eficiência dos métodos tradicionais de armazenamento de modelos.

Definição e Princípios Fundamentais de Design

Safetensors é um formato de serialização moderno, seguro e rápido para modelos de deep learning, criado pela Hugging Face. O seu principal objetivo é fornecer uma forma segura de armazenar e partilhar tensores — as matrizes multidimensionais que são os blocos de dados fundamentais da aprendizagem automática. O formato foi desenhado para ser mais seguro e rápido do que formatos mais antigos como o pickle.

Um princípio fundamental do Safetensors é a sua separação estrita entre os pesos do modelo (tensores) e qualquer código executável. Este design aborda diretamente as falhas de segurança encontradas em métodos de serialização mais antigos.

Funcionalidades Principais

• Zero-copy e Lazy Loading: Uma chave para o desempenho do Safetensors é a sua capacidade de zero-copy (cópia zero). Isto permite que os dados do modelo sejam mapeados diretamente do disco para a memória sem criar cópias extra, o que poupa memória e acelera o carregamento. Também suporta lazy loading (carregamento diferido), o que significa que apenas as partes necessárias de um modelo grande são carregadas para a RAM quando necessário. Isto é muito útil para modelos extremamente grandes ou sistemas com memória limitada.
• Gestão Estruturada de Metadados: Cada ficheiro Safetensors inclui uma secção de metadados separada em formato JSON. Esta secção lista todos os tensores no modelo com detalhes como a sua forma, tipo de dados e nome. Os metadados apontam para onde os dados reais do tensor estão armazenados separadamente no ficheiro, o que melhora tanto a legibilidade como a segurança.
• Armazenamento Exclusivo de Dados de Tensores: A funcionalidade de segurança mais importante do Safetensors é que foi desenhado para conter "apenas dados brutos de tensores e metadados associados". Pela sua arquitetura, "não permite a serialização de código Python arbitrário". Esta escolha de design fundamental elimina o risco de executar código malicioso ao carregar um modelo.
• Suporte à Quantização: O Safetensors consegue lidar com tensores quantizados, o que ajuda a tornar os modelos mais pequenos e a usar menos memória. No entanto, o seu suporte à quantização "não é tão flexível como o do GGUF" porque depende das funcionalidades fornecidas pela framework PyTorch.

Benefícios Principais

• Segurança Reforçada (Mitigação da Execução de Código Arbitrário): Esta é a maior vantagem do Safetensors. Por design, impede completamente que código Python seja guardado no ficheiro. Isto elimina o risco de segurança mais sério encontrado nos formatos baseados em pickle: a execução de código malicioso quando um modelo é carregado. Isto torna o Safetensors a melhor escolha para partilhar e usar modelos de fontes públicas ou não fidedignas. O formato também inclui outras funcionalidades de segurança como "técnicas de encriptação avançadas" e controlos de acesso para prevenir a adulteração de dados.
• Otimização de Desempenho: O uso de zero-copy e lazy loading resulta em "tempos de carregamento mais rápidos e menor uso de memória". Testes de desempenho mostram que é muito "mais rápido" que o pickle e pode ser "76.6 vezes mais rápido em CPU e 2 vezes mais rápido em GPU em comparação com o método de gravação tradicional do PyTorch".
• Portabilidade: O formato foi desenhado para ser portátil, o que significa que funciona em diferentes linguagens de programação. Isto torna mais fácil partilhar e usar modelos em vários sistemas de software.
• Integração Transparente: O Safetensors "integra-se perfeitamente com as frameworks e bibliotecas de aprendizagem automática existentes". Isto permite que os programadores adotem este formato mais seguro facilmente, sem fazer grandes alterações nos seus fluxos de trabalho atuais.

Comparação com a Serialização Tradicional (p. ex., Pickle)

O módulo pickle do Python, que é usado para os ficheiros .pt e .pth do PyTorch, é inerentemente inseguro. Permite que qualquer código seja escondido dentro de um ficheiro serializado e executado automaticamente quando o ficheiro é carregado. Esta é uma vulnerabilidade bem conhecida e severa, especialmente ao usar modelos descarregados de sites públicos. Embora ferramentas como o picklescan possam detetar alguns padrões maliciosos, não são infalíveis e não podem garantir a segurança.

O Safetensors foi criado especificamente para resolver este problema de segurança. Ao permitir apenas dados brutos de tensores e metadados estruturados no ficheiro, elimina a possibilidade de executar código malicioso. Além da segurança, o Safetensors também oferece um desempenho muito superior. O seu design para mapeamento de memória e lazy loading leva a um carregamento significativamente mais rápido e a um uso de memória mais eficiente em comparação com o pickle, que normalmente carrega o modelo inteiro para a memória de uma só vez.

A falha de segurança no pickle do Python significa que descarregar um ficheiro .pt ou .pth de uma fonte não fidedigna não é apenas descarregar dados; é como executar um programa potencialmente perigoso. Sabe-se que "não existe uma solução 100% à prova de bala para verificar a segurança de um ficheiro pickle sem execução". Isto coloca o fardo de verificar a segurança do ficheiro no utilizador, o que é difícil e pouco fiável.

O Safetensors muda esta dinâmica ao redesenhar o próprio formato para impedir a inclusão de código malicioso em primeiro lugar. Ele transfere a responsabilidade da segurança do difícil processo de verificação do utilizador para a segurança integrada do formato. Isto marca uma mudança importante na comunidade de IA de código aberto de uma abordagem de "verificar, depois confiar" para um modelo de "confiança por design". Esta mudança reconhece que é quase impossível procurar todas as ameaças possíveis em ficheiros complexos. Ao bloquear o vetor de ataque (execução de código arbitrário), o Safetensors torna mais seguro partilhar modelos amplamente, incentivando a colaboração e facilitando o uso de modelos pré-treinados por mais pessoas. Este princípio de "confiança por design" é essencial para o crescimento e segurança de todo o ecossistema de IA.

Embora o Safetensors tenha sido criado principalmente por razões de segurança (para corrigir as vulnerabilidades do pickle), também proporciona grandes melhorias de desempenho, como carregamento mais rápido, menor uso de memória e operações de zero-copy. Estes ganhos de desempenho não são apenas um efeito secundário; são um resultado direto do design otimizado do Safetensors, que usa mapeamento de memória e lazy loading para gerir os dados eficientemente. Isto torna-o naturalmente mais eficiente para modelos grandes.

Esta combinação de segurança reforçada e melhorias significativas de desempenho tem sido um fator chave para a sua adoção generalizada. Se o Safetensors tivesse oferecido apenas melhor segurança, a sua adoção poderia ter sido mais lenta, particularmente entre utilizadores não focados imediatamente na segurança. No entanto, os benefícios de desempenho claros e mensuráveis fornecem uma forte razão para todos mudarem, acelerando a sua integração em grandes plataformas como a Hugging Face. Isto mostra que, na engenharia de IA, uma tecnologia muitas vezes precisa de oferecer vantagens tanto de segurança como de desempenho para ser rápida e amplamente aceite pela indústria.

3. Visão Geral dos Principais Formatos de Modelos

Além do Safetensors, vários outros formatos são importantes no mundo da aprendizagem automática, cada um com as suas próprias características e casos de uso.

3.1. CKPT (Checkpoints)

Um checkpoint de IA não é um tipo de ficheiro único, mas sim um instantâneo do estado de um modelo guardado num ponto específico durante o treino. Os checkpoints são essenciais para guardar o progresso durante longos processos de treino.

Características e Casos de Uso Típicos

Um checkpoint normalmente contém os parâmetros aprendidos de um modelo, como os seus pesos e biases. Também pode armazenar outras informações importantes necessárias para retomar o treino, como o estado do otimizador, o número da epoch atual e o cronograma da taxa de aprendizagem. As extensões de ficheiro para checkpoints variam por framework. Para o PyTorch, são geralmente .pt ou .pth, enquanto para o TensorFlow/Keras, são .ckpt ou .h5.

Os principais benefícios dos ficheiros CKPT incluem:

• Reprodutibilidade: Garantem que um modelo se comporta de forma consistente quando recarregado, o que é vital para validar a investigação e manter um desempenho fiável.
• Colaboração: São fáceis de partilhar, permitindo que os programadores repliquem resultados ou construam sobre trabalho existente.
• Flexibilidade: Os formatos .pt/.pth do PyTorch são particularmente flexíveis, tornando simples guardar e carregar modelos para fins de investigação.

Os casos de uso comuns para ficheiros CKPT incluem:

• Retomar o Treino: Continuar uma sessão de treino que foi interrompida, o que poupa tempo e recursos computacionais significativos.
• Fine-Tuning: Usar um modelo pré-treinado como ponto de partida para treinar num novo conjunto de dados mais específico.
• Avaliação de Modelos: Testar o desempenho de um modelo em diferentes fases do treino sem ter de o treinar novamente.
• Inferência: Carregar um modelo totalmente treinado para um sistema de produção para fazer previsões.
• Investigação e Experimentação: Analisar como um modelo evolui ao longo do tempo e ajustar sistematicamente os seus parâmetros.
• Aprendizagem por Transferência: Servir como um ponto de partida poderoso para tarefas relacionadas, o que reduz o tempo de treino e as necessidades de dados.
• Recuperação de Desastres: Atuar como uma cópia de segurança para retomar o trabalho após uma falha durante um longo processo de treino.

Considerações de Segurança

O maior risco de segurança com os ficheiros CKPT, especialmente os formatos .pt e .pth do PyTorch, vem da sua dependência do módulo pickle do Python. Isto significa que estes ficheiros podem ser concebidos para conter e executar código Python malicioso quando carregados (se a função torch.load for usada sem a configuração weights_only=True). Esta vulnerabilidade (CWE-502: Desserialização de Dados Não Fidedignos) pode ter consequências graves, como roubo de dados, comportamento alterado do modelo ou até mesmo o controlo total do sistema.

A indústria reconheceu este risco, e o Safetensors surgiu como uma opção mais segura. Como referido, "A maioria dos checkpoints de IA de Stable Diffusion são guardados em formatos como .ckpt ou .safetensors... .safetensors é uma alternativa mais segura, concebida para prevenir a execução de código malicioso." Isto mostra uma clara tendência para formatos mais seguros para a partilha de modelos.

Os CKPTs, particularmente no formato .pt/.pth do PyTorch, são conhecidos por serem "altamente flexíveis". Esta flexibilidade permite-lhes guardar não apenas os pesos do modelo, mas também o estado do otimizador e até mesmo classes Python personalizadas, o que é muito útil para retomar o treino com precisão.

No entanto, esta mesma flexibilidade é o que cria a vulnerabilidade de segurança. Como o formato pode guardar qualquer objeto Python, um atacante pode esconder código malicioso dentro de um ficheiro de modelo. Quando o ficheiro é carregado sem as devidas precauções, esse código é executado. Isto ilustra um compromisso fundamental no design de sistemas: mais flexibilidade muitas vezes leva a uma maior superfície de ataque e a maiores riscos de segurança.

A solução da indústria é adotar formatos como o Safetensors para a distribuição de modelos, mesmo que os formatos mais flexíveis .pt/.pth ainda sejam usados para treino em ambientes controlados. Isto mostra uma compreensão crescente de que diferentes fases do ciclo de vida da aprendizagem automática requerem diferentes níveis de segurança. O poder de guardar o estado completo do treino é melhor mantido dentro de um ambiente de desenvolvimento fidedigno, enquanto a partilha e a implementação exigem formatos com garantias de segurança integradas.

3.2. ONNX (Open Neural Network Exchange)

ONNX, que significa Open Neural Network Exchange, é um formato de padrão aberto para modelos de aprendizagem automática. Foi concebido para permitir que os modelos funcionem em diferentes frameworks de deep learning.

Características e Casos de Uso Principais

Um ficheiro ONNX contém a estrutura completa de um modelo, incluindo a sua sequência de operações (o grafo computacional), os seus pesos aprendidos e outros metadados. Uma grande força do ONNX é que atua como um tradutor universal. Modelos treinados em frameworks como PyTorch, TensorFlow ou scikit-learn podem ser convertidos para o formato ONNX, permitindo uma abordagem de "treinar uma vez, implementar em qualquer lugar".

Ao contrário de formatos que armazenam apenas os pesos do modelo (como Safetensors ou GGUF), o ONNX inclui o grafo computacional do modelo. Esta estrutura baseada em grafos proporciona "mais flexibilidade ao converter modelos entre diferentes frameworks". O ONNX oferece uma excelente portabilidade em muitas plataformas, dispositivos e aceleradores de hardware (CPUs, GPUs, chips de IA). Os modelos são armazenados no formato Protobuf, que é uma forma eficiente e neutra em termos de plataforma para guardar dados estruturados.

Os principais casos de uso do ONNX incluem:

• Implementação Multi-Framework: Executar um modelo numa framework ou ambiente diferente daquele em que foi treinado.
• Inferência de Alto Desempenho: O ONNX Runtime é um motor de inferência que otimiza automaticamente os modelos para hardware específico, resultando frequentemente num desempenho mais rápido.
• Implementação em Edge e Dispositivos Móveis: A sua pegada reduzida e o runtime otimizado tornam o ONNX uma boa escolha para executar modelos em dispositivos com recursos limitados.
• Sistemas de Produção: A sua robustez e portabilidade tornam-no popular para implementar modelos em ambientes de produção exigentes.

Considerações de Segurança

Um risco de segurança subtil mas sério com os modelos ONNX é o potencial para backdoors arquitetónicas. Um atacante poderia modificar o grafo computacional de um modelo para incluir um caminho oculto que é ativado apenas por entradas específicas. Quando ativado, este backdoor poderia fazer com que o modelo produzisse resultados maliciosos ou inesperados, enquanto se comporta normalmente com entradas padrão, tornando-o difícil de detetar. Outros riscos incluem ataques de inversão de modelo (extração de dados de treino sensíveis) e ataques adversariais (uso de entradas maliciosas para enganar o modelo).

Para reduzir estas ameaças, são recomendadas várias práticas:

• Assinar digitalmente os modelos ONNX para garantir que não foram adulterados.
• Implementar modelos em ambientes isolados, como contentores Docker, com forte segurança de rede.
• Usar ferramentas de monitorização para acompanhar o comportamento do modelo e detetar anomalias.
• Seguir as melhores práticas de segurança gerais, como higienizar as entradas e manter o software atualizado.

O ONNX é geralmente mais seguro do que os formatos baseados em pickle porque não executa código arbitrário quando carregado. No entanto, se um modelo ONNX usar camadas personalizadas implementadas externamente, essas camadas poderiam potencialmente conter código Python malicioso se não forem geridas com cuidado.

Desvantagens

Embora o ONNX suporte modelos quantizados, "não suporta nativamente tensores quantizados" de forma tão transparente como o GGUF. Ele decompõe-nos em tensores de inteiros e fatores de escala separados, o que "pode levar a uma redução da qualidade". Converter modelos com camadas complexas ou personalizadas que não são padrão no ONNX também pode ser difícil e pode exigir trabalho personalizado que poderia diminuir o desempenho.

Formatos tradicionais baseados no pickle do Python (como ficheiros .pt) guardam objetos Python, que podem incluir código executável. Isto trata o modelo como um programa. Em contraste, o ONNX foca-se em guardar o "grafo computacional" do modelo — uma representação mais abstrata das suas operações e fluxo de dados, em vez de uma implementação de código específica.

Esta abordagem centrada no grafo é o que confere ao ONNX a sua excelente portabilidade entre frameworks e permite que seja otimizado para diferentes hardwares. Ao definir a lógica do modelo a um nível mais alto, ele torna-se independente da framework em que foi treinado. Esta é uma mudança conceptual significativa, passando de uma implementação específica da framework para uma representação computacional portátil. Embora isto melhore muito a flexibilidade de implementação, também cria novas preocupações de segurança, como backdoors arquitetónicas, que exigem estratégias de segurança diferentes das usadas para formatos baseados em pickle.

3.3. GGUF (GPT-Generated Unified Format)

GGUF (GPT-Generated Unified Format) é um formato de ficheiro concebido especificamente para armazenar e executar modelos de linguagem grandes (LLMs) de forma eficiente. É uma versão melhorada do seu antecessor, GGML, e visa tornar os LLMs mais fáceis de usar, especialmente em computadores pessoais.

Características e Casos de Uso Principais

O GGUF foi desenhado para tornar os LLMs mais pequenos e muito mais rápidos de carregar. Isto é crucial para executar modelos localmente, onde o espaço de armazenamento e a RAM são frequentemente limitados. O formato usa "técnicas de compressão avançadas" para alcançar este objetivo. Também fornece uma maneira padrão de empacotar os pesos, arquitetura e metadados de um modelo, garantindo que funcione de forma consistente em diferentes softwares, especialmente com motores de inferência baseados no llama.cpp.

Uma característica fundamental do GGUF é o seu excelente suporte à quantização. A quantização reduz a precisão numérica dos pesos de um modelo (por exemplo, de números de 16 bits para 4 bits), o que reduz drasticamente o tamanho do ficheiro e a computação necessária para o executar. Os modelos GGUF estão disponíveis em vários níveis de quantização (de Q2 a Q8), oferecendo uma gama de compromissos entre tamanho e qualidade.

• Níveis de quantização mais baixos (como Q2 ou Q3) resultam em ficheiros muito pequenos que podem ser executados em hardware com menos RAM, mas podem ter uma ligeira queda na qualidade do modelo.
• Níveis de quantização mais altos (como Q6 ou Q8) mantêm uma melhor qualidade, mas exigem mais armazenamento e RAM.

Os principais casos de uso do GGUF incluem:

• Implementação Local de LLMs: Ferramentas como o Ollama usam GGUF para facilitar aos utilizadores a execução de LLMs poderosos nos seus próprios computadores.
• Assistentes de IA Offline: Muitas aplicações usam modelos GGUF para fornecer alternativas locais e privadas a ferramentas de IA baseadas na nuvem.
• Assistência de Código: IDEs e editores de código estão a começar a usar modelos GGUF para completação de código inteligente.
• Chatbots Locais: Os modelos GGUF são frequentemente usados para sistemas de IA conversacional privados e responsivos.
• Investigação em IA: A sua flexibilidade e suporte à quantização tornam-no popular entre os investigadores para experimentar LLMs em hardware acessível.

Considerações de Segurança

Ao contrário da crença popular, a biblioteca subjacente GGML (na qual o GGUF se baseia) teve vulnerabilidades documentadas relacionadas com a "validação insuficiente do ficheiro de entrada". Estas falhas podem levar a "vulnerabilidades de corrupção de memória potencialmente exploráveis durante a análise". Foram identificados problemas de segurança específicos onde a entrada do utilizador não verificada poderia causar heap overflows, permitindo potencialmente a um atacante executar código malicioso.

Existe uma ideia errada comum de que um ficheiro GGUF "não pode conter código" e é "apenas um ficheiro de modelo". No entanto, um relatório de segurança da Databricks mostrou que, embora o ficheiro GGUF em si não contenha código Python executável, um ficheiro especialmente criado pode explorar falhas no parser (o software que lê o ficheiro) para causar corrupção de memória e alcançar a execução de código.

Para reduzir estes riscos, é melhor:

• Usar modelos e ferramentas de fontes bem conhecidas e reputadas (como Koboldcpp).
• Executar LLMs em ambientes isolados (como contentores Docker).
• Para tarefas altamente sensíveis, considerar o uso de uma máquina dedicada sem acesso à internet.

Desvantagens

Uma grande desvantagem do GGUF é que a maioria dos modelos é primeiro desenvolvida noutras frameworks (como PyTorch) e deve ser convertida para o formato GGUF. Este processo de conversão nem sempre é fácil, e alguns modelos podem não ser totalmente suportados por ferramentas compatíveis com GGUF. Além disso, modificar ou fazer fine-tuning de um modelo depois de estar no formato GGUF geralmente "não é simples".

Embora o GGUF seja concebido para um carregamento rápido e um uso eficiente de VRAM, a velocidade de inferência real (a rapidez com que o modelo gera respostas) pode por vezes ser mais lenta do que a de modelos não quantizados. Isto pode acontecer com níveis de quantização mais baixos devido ao trabalho extra necessário para desquantizar os pesos durante a inferência. O principal benefício de desempenho do GGUF é que ele permite que modelos grandes sejam executados em hardware de consumo ao poupar VRAM, não que necessariamente os torne mais rápidos.

A característica definidora do GGUF é a sua profunda integração com a quantização, o que permite que LLMs poderosos sejam executados em "hardware de consumo" com VRAM limitada. Isto ajuda a democratizar o acesso à IA. No entanto, esta eficiência envolve compromissos. Embora a quantização torne os modelos mais pequenos, níveis mais baixos podem reduzir ligeiramente a qualidade do modelo. Além disso, a velocidade de inferência pode por vezes ser mais lenta do que com modelos não quantizados, especialmente se a versão não quantizada couber inteiramente na VRAM.

O benefício de "velocidade" do GGUF refere-se geralmente a um carregamento mais rápido e à capacidade de executar um modelo maior em hardware limitado, em vez de desempenho bruto. O GGUF capta perfeitamente a tendência de "democratização da IA" ao tornar modelos avançados acessíveis a mais pessoas. Isto exige que os utilizadores equilibrem a qualidade do modelo com as limitações do seu hardware. A disponibilidade de múltiplos níveis de quantização permite que os utilizadores adaptem os modelos às suas necessidades específicas, o que é fundamental para a popularidade do formato na comunidade de IA local.

4. Análise Comparativa dos Formatos

A seleção de um formato de serialização de modelo apropriado é uma decisão estratégica que depende do equilíbrio de vários fatores, incluindo segurança, desempenho, eficiência de recursos, interoperabilidade e o contexto específico da aplicação. A tabela abaixo fornece uma visão geral comparativa do Safetensors, CKPT, ONNX e GGUF nestas dimensões críticas.

Característica / Formato	Safetensors	CKPT (.pt/.pth)	ONNX	GGUF
Propósito Principal	Armazenamento seguro e rápido de tensores para modelos de deep learning	Checkpoints de treino, parâmetros de modelo, preservação de estado	Interoperabilidade entre frameworks, implementação em hardware diverso	Armazenamento eficiente de LLMs, inferência local otimizada em hardware de consumo
Perfil de Segurança	Elevado (sem execução de código arbitrário por design)	Baixo (execução de código arbitrário via desserialização Pickle)	Moderado (sem execução de código arbitrário, mas possíveis backdoors arquitetónicas)	Moderado (vulnerabilidades da biblioteca subjacente, mas o ficheiro em si não é código Python executável)
Velocidade de Carregamento	Muito Rápido (zero-copy, lazy loading)	Varia (pode ser mais lento que o Safetensors devido ao carregamento completo)	Rápido (runtime otimizado, otimizações de grafo)	Rápido (mmap, eficiente para LLMs)
Uso de Memória	Eficiente (lazy loading, carregamento parcial)	Pode ser elevado (carrega o grafo completo de objetos)	Eficiente (otimizações de runtime)	Muito Eficiente (quantização, poupança de VRAM)
Espaço em Disco	Eficiente (compressão, apenas tensores)	Varia (pode ser grande, inclui estado completo)	Eficiente (formato Protobuf)	Muito Eficiente (quantização, compressão avançada)
Suporte à Quantização	Sim, mas menos flexível que o GGUF (dependente do PyTorch)	Sim (dependente da framework)	Suporte nativo limitado (decompõe tensores)	Robusto (múltiplos níveis, Q2-Q8, variantes especializadas)
Portabilidade	Elevada (entre diferentes linguagens de programação)	Baixa (fortemente acoplado a frameworks específicas)	Muito Elevada (multi-framework, multiplataforma, hardware diverso)	Elevada (especialmente para o ecossistema llama.cpp)
Aplicações Principais	Partilha segura de modelos, padrão da Hugging Face	Treino, fine-tuning, investigação, gravação de modelos	Implementação em produção, móvel/edge, interoperabilidade	Inferência local de LLMs, hardware de consumo, aplicações de conversação
Vantagem Principal	Segurança por design, carregamento rápido, baixa pegada de memória	Preservação do estado de treino, reprodutibilidade detalhada	Implementação universal, otimização de runtime, agnóstico em relação à framework	Eficiência de LLMs em hardware de consumo, quantização flexível
Desvantagem Principal	Requer um parser JSON para metadados em C++	Risco de execução de código arbitrário, ficheiros de grande dimensão	Complexidade para camadas personalizadas, quantização nativa limitada	Conversão frequentemente necessária, potencial abrandamento da inferência com quantizações mais baixas

5. Conclusão

O mundo dos formatos de modelos de aprendizagem automática está em constante evolução, impulsionado pela necessidade de maior segurança, desempenho e interoperabilidade. Os formatos tradicionais, como os ficheiros CKPT baseados em pickle, eram flexíveis para a investigação, mas introduziam sérios riscos de segurança ao permitir a execução de código arbitrário. Isto levou ao desenvolvimento e adoção de formatos mais novos e seguros.

O Safetensors é um exemplo principal desta mudança. Ao separar dados de código e usar técnicas de carregamento eficientes, oferece uma alternativa segura e de alto desempenho para partilhar modelos de deep learning, especialmente no ecossistema da Hugging Face. Os seus duplos benefícios de segurança e velocidade tornaram-no uma escolha popular nos fluxos de trabalho modernos de IA.

O ONNX resolve o grande problema da incompatibilidade entre frameworks. Ao representar modelos como grafos computacionais abstratos, permite que sejam implementados em diferentes hardwares e softwares. Embora o ONNX impeça a execução de código arbitrário vista no pickle, tem as suas próprias preocupações de segurança, como backdoors arquitetónicas, que exigem medidas de proteção diferentes.

O GGUF é uma solução especializada para executar modelos de linguagem grandes em hardware de consumo. As suas poderosas funcionalidades de quantização reduzem drasticamente o tamanho do modelo e o uso de memória, tornando os LLMs poderosos acessíveis a mais pessoas. No entanto, esta eficiência pode por vezes resultar em velocidades de inferência mais lentas, e as suas bibliotecas subjacentes mostraram vulnerabilidades que exigem que os utilizadores sejam cautelosos.

Em última análise, o melhor formato depende do contexto específico.

• Safetensors é a melhor escolha para partilhar modelos de deep learning de forma segura e eficiente.
• ONNX é ideal para implementar modelos em diferentes frameworks e hardwares.
• GGUF oferece uma eficiência inigualável para executar modelos de linguagem grandes em dispositivos locais com recursos limitados.

Embora os formatos CKPT tradicionais ainda sejam úteis para guardar o progresso do treino em ambientes controlados, estão a ser substituídos por alternativas mais seguras para distribuição pública. À medida que o campo da IA amadurece, o desenvolvimento contínuo destes formatos especializados será essencial para avançar o poder e o alcance da aprendizagem automática.