Minha Jornada: Ajustando & Implantando Modelos de IA Menores

Olá a todos, Nina aqui, de volta ao agntbox.com! Hoje, quero falar sobre algo que tem movimentado meus canais do Slack e me acompanhado nas minhas sessões de programação noturnas: frameworks de IA. Especificamente, quero explorar um canto específico que costuma ser ignorado quando todos estão ocupados correndo atrás do último LLM: as ferramentas em torno do ajuste fino e implementação para modelos menores e mais especializados.

Todos conhecemos os grandes nomes – TensorFlow, PyTorch. Eles são os gigantes, os players estabelecidos. E por boas razões! Eles são incrivelmente poderosos e versáteis. Mas sejamos realistas, às vezes você não precisa de um navio de guerra para atravessar um lago. Às vezes, você precisa de um barco rápido e ágil, especialmente quando está trabalhando com um prazo apertado, um conjunto de dados específico e um objetivo claro em mente. É aí que eu quero falar sobre algo com que tenho me familiarizado bastante ultimamente: Hugging Face Optimum para ONNX Runtime.

Agora, antes que seus olhos se percam em siglas, deixe-me explicar. Hugging Face, é claro, é o darling do mundo de NLP, tornando modelos pré-treinados acessíveis a todos. ONNX (Open Neural Network Exchange) é um padrão aberto para representar modelos de aprendizado de máquina, o que basicamente significa que você pode converter modelos treinados em um framework (como PyTorch) e executá-los em outro (como TensorFlow, ou, no nosso caso, ONNX Runtime). E o ONNX Runtime? É o motor de inferência de alto desempenho da Microsoft.

Então, o que o Hugging Face Optimum faz para o ONNX Runtime? É basicamente uma ponte, um otimizador e um assistente de implementação tudo em um. Ele ajuda você a pegar seus modelos do Hugging Face, otimizá-los para a inferência no ONNX Runtime e, muitas vezes, obter um aumento de velocidade significativo sem sacrificar muito (ou qualquer) precisão. E isso, meus amigos, é ouro.

Por que Estou Obcecada pelo Optimum ONNX Runtime Agora

Minha jornada no Optimum ONNX Runtime começou, como a maioria das minhas obsessões tecnológicas, com um problema. Eu estava trabalhando em um projeto para um cliente que envolvia implementar um modelo relativamente pequeno baseado no BERT para classificação de texto em tickets de suporte ao cliente. O modelo foi treinado em um conjunto de dados customizado e, embora tivesse um bom desempenho, o tempo de inferência era um pouco lento demais para interações em tempo real com os clientes. Estávamos falando de talvez 150-200ms por inferência em uma GPU potente, o que não é terrível, mas para aplicações de alto volume e em tempo real, cada milissegundo conta.

Eu tentei todos os suspeitos habituais: agrupamento, otimização de pipelines de entrada, até uma quantização básica. Conseguimos algumas melhorias, mas nada dramático. Então, um colega mencionou o Optimum, e especificamente, sua integração com o ONNX. Eu estava cética a princípio. Mais uma camada de abstração? Mais dependências? Mas eu estava desesperada, então mergulhei fundo.

O que encontrei foi um fluxo de trabalho surpreendentemente simples que trouxe resultados. Conseguimos reduzir nosso tempo de inferência para cerca de 50-70ms por inferência na mesma GPU e até vimos um desempenho decente em uma CPU para tarefas menos críticas. Isso é um aumento de 2-3x de velocidade, o que no mundo da IA em tempo real é uma enorme vitória. Isso significou que poderíamos escalar nosso serviço de forma muito mais eficiente e fornecer respostas mais rápidas aos clientes, impactando diretamente sua experiência.

O Problema que Ele Resolve: Desempenho e Portabilidade

Vamos ser honestos, implementar modelos de IA pode ser uma dor de cabeça. Você treina um lindo modelo no PyTorch e então tem que descobrir como fazê-lo funcionar de forma eficiente em produção. Às vezes, você está preso a uma configuração de hardware específica ou precisa implementar em um dispositivo na borda com recursos limitados. É aí que o ONNX entra. Ele fornece um formato comum, desacoplando seu modelo do framework de treinamento.

O Optimum leva isso um passo adiante. Não se trata apenas de converter para ONNX; trata-se de otimizar esse modelo ONNX. Ele pode aplicar técnicas como otimizações de grafo, fusão de operadores e até mesmo quantizar seu modelo para reduzir seu tamanho e acelerar a inferência, muitas vezes com impacto mínimo na precisão. Isso é especialmente útil para modelos menores ou quando você está limitado por memória ou capacidade de computação em seu alvo de implantação.

O caso de uso do meu cliente foi um exemplo perfeito. Tínhamos um modelo PyTorch, mas queríamos implementá-lo em uma instância na nuvem com GPUs da NVIDIA, e precisávamos de máximo rendimento. O Optimum ONNX Runtime nos permitiu exportar o modelo, aplicar otimizações específicas para nosso hardware-alvo e fazê-lo funcionar como um sonho.

Começando com o Optimum ONNX Runtime: Um Exemplo Prático

Vamos passar por um exemplo básico de como você pode usar o Optimum para exportar e otimizar um modelo do Hugging Face para o ONNX Runtime. Para isso, usaremos um modelo simples de análise de sentimentos.

Primeiro, você precisará instalar as bibliotecas necessárias:

pip install transformers optimum[onnxruntime] onnx

Agora, vamos escrever um código Python para exportar um modelo pré-treinado de análise de sentimentos.

Exemplo 1: Exportando um Modelo de Análise de Sentimentos

Aqui, estamos pegando um modelo padrão `distilbert-base-uncased-finetuned-sst-2-english` e exportando-o para o formato ONNX usando o Optimum.

from transformers import pipeline
from optimum.onnxruntime import ORTModelForSequenceClassification
from transformers import AutoTokenizer

model_id = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Exportar o modelo para ONNX
# O `save_directory` é onde seu modelo ONNX e tokenizer serão salvos.
# `opset` especifica a versão do conjunto de operadores ONNX.
# `input_names` são importantes para definir as entradas do seu grafo ONNX.
onnx_path = "./onnx_sentiment_model/"
ort_model = ORTModelForSequenceClassification.from_pretrained(model_id, from_transformers=True)
ort_model.save_pretrained(onnx_path)
tokenizer.save_pretrained(onnx_path)

print(f"Modelo e tokenizer exportados para {onnx_path}")

Depois de executar isso, você terá um diretório chamado `onnx_sentiment_model` contendo seu arquivo `model.onnx` e os arquivos do tokenizer. Esse arquivo `model.onnx` é a versão otimizada pronta para o ONNX Runtime.

Exemplo 2: Executando Inferência com o Modelo ONNX

Agora, vamos carregar esse modelo exportado e rodar algumas inferências com ele. Note como carregamos o `ORTModelForSequenceClassification` diretamente do `onnx_path` que salvamos.

from optimum.onnxruntime import ORTModelForSequenceClassification
from transformers import AutoTokenizer, pipeline
import time

onnx_path = "./onnx_sentiment_model/"

# Carregar o modelo ONNX e o tokenizer
ort_model = ORTModelForSequenceClassification.from_pretrained(onnx_path)
tokenizer = AutoTokenizer.from_pretrained(onnx_path)

# Criar um pipeline para fácil inferência
onnx_pipeline = pipeline(
 "sentiment-analysis",
 model=ort_model,
 tokenizer=tokenizer,
 accelerator="ort" # Isso diz ao pipeline para usar o ONNX Runtime
)

text_samples = [
 "Eu amo este produto, é incrível!",
 "Este filme foi apenas ok, um pouco chato.",
 "Eu odeio absolutamente esperar em longas filas.",
 "O serviço foi incrivelmente rápido e eficiente."
]

print("\n--- Executando Inferência com Modelo ONNX ---")
start_time = time.time()
results = onnx_pipeline(text_samples)
end_time = time.time()

for i, res in enumerate(results):
 print(f"Texto: '{text_samples[i]}' -> Rótulo: {res['label']}, Pontuação: {res['score']:.4f}")

print(f"Tempo de inferência para {len(text_samples)} amostras: {(end_time - start_time):.4f} segundos")

Quando você executar isso, verá as previsões de sentimentos. Mais importante, se você comparar o tempo de inferência com o modelo original do PyTorch no mesmo hardware, provavelmente observará um aumento notável de velocidade, especialmente para lotes maiores ou modelos mais complexos. O parâmetro `accelerator=”ort”` no pipeline é uma bandeira pequena, mas poderosa, que diz ao Hugging Face para usar o ONNX Runtime para inferência, que é onde a mágica acontece.

Exemplo 3: Controlando Recursos de Otimização (Opcional, mas Poderoso)

O Optimum permite controle detalhado sobre o processo de otimização. Por exemplo, você pode especificar o nível de otimização ou até escolher otimizações específicas do grafo. Isso pode ser crucial quando você está tentando extrair cada último ápice de desempenho do seu modelo ou quando precisa fazer compensações entre velocidade e precisão (por exemplo, com quantização).

from optimum.onnxruntime import ORTModelForSequenceClassification, ORTConfig
from transformers import AutoTokenizer
from optimum.exporters.tasks import TasksManager
from optimum.onnxruntime.configuration import AutoOptimizationConfig

model_id = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Defina a configuração de otimização
# Aqui, estamos usando a otimização padrão, mas você pode personalizar ainda mais
# Por exemplo, para aplicar quantização: `optimization_config = AutoOptimizationConfig.O2()`
optimization_config = AutoOptimizationConfig.O1() # O1 para otimização básica, O2 para mais agressiva, O3 para total

# Exporte o modelo com configuração de otimização explícita
onnx_path_optimized = "./onnx_sentiment_model_optimized/"
task = TasksManager.get_task_from_model_or_model_name(model_id)
# Você pode precisar ajustar o parâmetro `feature` com base na tarefa do seu modelo
# Para classificação de sequência, costuma ser 'sequence-classification'
ORTModelForSequenceClassification.from_pretrained(
 model_id,
 from_transformers=True,
 export_feature=task.feature,
 optimization_config=optimization_config,
).save_pretrained(onnx_path_optimized)
tokenizer.save_pretrained(onnx_path_optimized)

print(f"Modelo otimizado e tokenizer exportados para {onnx_path_optimized}")

O `AutoOptimizationConfig` é seu amigo aqui. `O1` oferece otimizações básicas de gráfico, `O2` adiciona fusões mais agressivas e eliminações de nós, e `O3` inclui todas as otimizações disponíveis, incluindo quantização, se aplicável. Escolher o nível certo depende das suas necessidades específicas e do hardware que você está visando. Para o meu cliente, nós experimentamos entre `O1` e `O2` para encontrar o ponto ideal, inclinando-nos para `O2` em busca do melhor equilíbrio entre velocidade e precisão.

Minhas Conclusões e Próximos Passos

Minha experiência com o Hugging Face Optimum para ONNX Runtime tem sido extremamente positiva. Não é uma solução mágica para todo tipo de implementação de IA, mas atende a uma necessidade comum e crítica: fazer seus modelos funcionarem mais rápido e de forma mais eficiente em produção, especialmente quando você está trabalhando com modelos do Hugging Face.

• Aumento de Performance: O principal benefício é a redução significativa no tempo de inferência. Para aplicações em tempo real, isso pode representar uma mudança significativa, melhorando a experiência do usuário e reduzindo custos de infraestrutura.
• Portabilidade: Ao converter para ONNX, seus modelos tornam-se mais portáteis, podendo ser executados em diferentes hardwares e sistemas operacionais sem estar atrelados a um framework específico de aprendizado profundo.
• Facilidade de Uso: A integração com a biblioteca `transformers` do Hugging Face é notavelmente fluida. Se você já está familiarizado com o Hugging Face, a curva de aprendizado para o Optimum é bem tranquila.
• Eficiência de Recursos: Modelos otimizados costumam requerer menos memória e ciclos de CPU/GPU, o que é crucial para implementações em edge ou ambientes de nuvem sensíveis a custos.

Uma coisa que aprendi é que vale a pena experimentar diferentes níveis e configurações de otimização. Não se contente apenas com o padrão. Experimente `O1`, `O2` e até `O3` (com quantização se seu caso de uso permitir) e compare os resultados no seu hardware alvo real. Os ganhos podem ser surpreendentes!

Olhando para o futuro, acredito que ferramentas como o Hugging Face Optimum se tornarão ainda mais essenciais. À medida que os modelos de IA se proliferam e se movem para ambientes de implantação mais diversos, a capacidade de otimizar e simplificar suas inferências será primordial. Estou particularmente animado para ver como o Optimum evolui com novos aceleradores de hardware e técnicas de quantização mais avançadas.

Conclusões para Sua Próxima Projeto de IA:

1. Avalie Suas Necessidades de Inferência: Antes de explorar otimizações, defina claramente seus requisitos de desempenho. Qual é uma latência aceitável? Qual é sua meta de throughput?
2. Considere ONNX Desde Cedo: Se você está usando modelos do Hugging Face e a performance é uma preocupação, comece a pensar na exportação e otimização para ONNX durante seu ciclo de desenvolvimento, não apenas na implantação.
3. Compare, Compare, Compare: Sempre meça a melhoria real de desempenho (ou degradação) após aplicar as otimizações. Não confie em ganhos teóricos. Use dados reais e hardware real.
4. Experimente Níveis de Otimização: Não use apenas as configurações padrão. Brinque com `AutoOptimizationConfig.O1()`, `O2()` e `O3()` para encontrar o melhor equilíbrio para seu modelo e caso de uso.
5. Mantenha-se Atualizado: A biblioteca Hugging Face Optimum está em desenvolvimento ativo. Fique atento aos lançamentos e à documentação para novas funcionalidades e melhorias de desempenho.

Isso é tudo por esta semana! Se você tem tido dificuldades com o desempenho de implementação de modelos, experimente o Hugging Face Optimum para ONNX Runtime. Pode ser exatamente o que você precisa. Deixe-me saber nos comentários se você já usou ou se tem outras ferramentas favoritas para otimização de modelos. Boa inferência!

🕒 Published: April 3, 2026