Otimize o desempenho da IA com MongoDB Atlas e Fireworks AI

IA do MongoDB e do Fireworks

O esquema flexível, a indexação eficiente e a arquitetura distribuída do MongoDB permitem que as organizações dimensionem a infraestrutura de dados sob demanda. Combinada com as funcionalidades de otimização de modelos do Fireworks AI, essa solução melhora o desempenho da IA e reduz os custos.

O framework FireOptimizer integra o MongoDB ao processo de ajuste de modelos do Fireworks AI para acelerar a inferência em lote por meio dos seguintes componentes:

• FireAttention: aprimora o processamento em solicitações e otimiza a utilização de recursos

• Ajuste fino com eficiência de parâmetros: usa os métodos LoRA e QLoRA para ajustar modelos de forma eficiente com dados de rastreamento ou etiqueta, reduzindo os requisitos computacionais

Figura 1. Arquitetura do FireOptimizer para otimização adaptativa e inferência de alta qualidade

Esta solução fornece os seguintes benefícios:

• Velocidade de inferência aprimorada: a execução especulativa adaptativa do FireOptimizer fornece até 3x melhorias de latência para cargas de trabalho de produção.

• Otimização automatizada: o FireOptimizer lida com processos de otimização complexos automaticamente.

FireOptimizer: geração de token adaptável

Os LLMs geram saídas um token de cada vez, o que retarda as respostas para saídas longas. A decodificação especulativa acelera esse processo usando um modelo de rascunho menor para gerar vários candidatos a token enquanto o LLM principal processa. O LLM avalia e retém apenas projeções precisas.

Os modelos de rascunho tradicionais formados em dados genéricos funcionam bem para tarefas gerais, mas têm menor precisão em domínios especializados, como codificação ou análise financeira.

Com o Fireworks IA, a execução especulativa adaptativa melhora essa abordagem usando modelos específicos de domínio ou personalizados de perfil de usuário, em vez de modelos genéricos. Essa otimização aumenta a precisão e as taxas de acerto, como de 29% a 76% na geração de código, reduz os custos de inferência e fornece melhorias de latência em até 3x.

FireAttention: em processamento de contexto longo

Os prompts longos que usam entre 8K-32K tokens criam gargalos de desempenho para aplicativos como análise de documento ou conclusão de código. O FireAttention V2 da Firework IA aborda esse desafio fornecendo 12x mais rápido em processamento para tarefas de contexto longo por meio dos seguintes recursos:

• Dimensionamento otimizado da atenção: reduz a sobrecarga computacional para entradas demoradas

• Implantação multi-hospedar: distribui cargas de trabalho de forma eficiente entre todas as GPUs

• Kernels avançados: simplifica operações para execução mais rápida

O FireAttention V3 estende o suporte às gráficos de MI300 da AMD como uma alternativa eficiente em termos de custo à nvidia. As melhorias de desempenho incluem:

• 1.4x –1.8x maior taxa de transferência para modelos como LLaMA 8B e 70B

• Até 5.5x de ganhos de velocidade em cenários de baixa latência

• Melhor desempenho por meio de kernels de atenção redesenhados e uso otimizado da memória

Essas funcionalidades aprimoram o ajuste fino dos SLMs, permitindo o processamento eficiente em entradas de contexto longo para tarefas específicas do domínio. Os mecanismos de atenção otimizados reduzem a sobrecarga computacional, oferecem suporte a ciclos de treinamento mais rápidos e permitem tamanhos de lote maiores em implantações de GPU com múltiplos hospedar.

Otimização adaptativa de recursos

As otimizações da IA do Fireworks se estendem além da especulação adaptativa por meio de três técnicas que maximizam a taxa de transferência e a eficiência de custos:

• Cache adaptável: reutiliza cálculos frequentes para ignorar o trabalho redundante, reduzindo a latência em 30% a50% para cargas de trabalho de alto tráfego

• Quantização personalizável: equilibra a precisão de 4-/8bits com a qualidade do modelo, duplicando as velocidades enquanto mantém mais de 99% de precisão para tarefas em processamento em lote

• Serviço desagregado: adapta a alocação de hardware à carga de trabalho, hospedando várias cópias de modelos leves ou fragmentando modelos grandes em GPUs para tarefas complexas

Desafios e soluções atuais

Os LLMs causam tempos de resposta mais lentos devido a cálculos complexos em bilhões de parâmetros. As recomendações de cartão de crédito exigem várias consultas do LLM, resultando em 10 a 20 segundos de tempo de resposta total, com cada consulta levando 5 ou mais segundos. Os LLMs são difíceis e caros de implantar e dimensionar para milhões de usuários.

• Modelos de linguagem pequenos: SLMs fornecem velocidades de processamento mais rápidas e eficiência de custo. Os SLMs exigem menos capacidade computacional, o que os torna adequados para dispositivos com recursos limitados. Elas oferecem respostas mais rápidas e custos operacionais mais baixos.

• PEFT e LoRA: O PEFT e o LoRA melhoram a eficiência otimizando subconjuntos de parâmetros. Essa abordagem reduz os requisitos de memória e os custos operacionais. A integração do MongoDB aprimora o manuseio de dados e permite o ajuste eficiente do modelo.

• MongoDB: o MongoDB fornece gerenciamento de dados e integração em tempo real que melhora a eficiência operacional. O MongoDB armazena dados de rastreamento como JSON e permite recuperação e armazenamento eficientes, agregando valor ao ajuste fino do modelo. O MongoDB atua como uma camada de cache para evitar invocações repetidas de LLM para solicitações idênticas.

Ajuste um modelo de linguagem pequeno com o Fireworks AI

A demonstração do Aplicativo de cartão de crédito explica as pontuações de crédito aos clientes em linguagem clara. LLMs como o LLaMA 3.1-405B da Meta geram essas explicações usando parâmetros de perfil do usuário, recursos de entrada do modelo e importâncias de recursos do modelo que preveem a pontuação ou classificação de crédito do cliente. Os SLMs não podem realizar essas tarefas de forma consistente devido a parâmetros limitados para argumentos e explicações eficazes. Use o processo de ajuste fino com a plataforma de ajuste fino de IA do Fireworks para obter o resultado desejado.

O processo para ajustar um SLM usa o seguinte fluxo de trabalho:

Figura 2. Processo de ajuste fino de LLMs/SLMs

O processo de ajuste fino começa com a coleta de dados relevantes e específicos da tarefa. A figura 2 mostra como o MongoDB Atlas armazena em cache respostas LLM/SLM para usuários específicos com base em suas entradas de aplicativo de cartão de crédito. Os usuários podem simular perfis de crédito na interface do usuário da web. O seguinte trecho de código Python demonstra como configurar um decorador para armazenar em cache as respostas LLM/SLM no MongoDB Atlas:

class mdbcache:
   def __init__(self, function):
         self.function = function
   def __call__(self, *args, **kwargs):
         key = str(args) + str(kwargs)
         ele = ccol.find_one({"key": key})
         if ele:
            return ele["response"]
         value = self.function(*args, **kwargs)
         ccol.insert_one({"key":key, "response": value})
         return value
@mdbcache
def invoke_llm(prompt):
   """
   Invoke the language model with the given prompt with cache. The llm.invoke  method can invoke either a LLM or SLM based on the Fireworks Model ID provided at the start of application.
   Args:
         prompt (str): The prompt to pass to the LLM.
   """
   response = llm.invoke(prompt)
   return response

Conforme mostrado no diagrama, você pode gerar o conjunto de dados de treinamento usando um simulador. Este exemplo simula perfis de usuário com amostragem estratificada para selecionar amostras iguais para todas as três classificações de crédito: Boa, Normal e Ruim. Esta demonstração gera cerca de 1,300 respostas de amostra.

Transforme as respostas geradas no formato compatível com a plataforma Fireworks IA para ajuste fino. Gere o arquivo cc_cache.jsonl usado no processo de ajuste executando o seguinte código:

 from pymongo import MongoClient
 import pandas as pd
 import json
 client = MongoClient("mongodb+srv://<uid>:<pwd>@bfsi-demo.2wqno.mongodb.net/?retryWrites=true&w=majority")
 df = pd.DataFrame.from_records(client["bfsi-genai"]["cc_cache"].find({},{"_id": 0}))
 df["prompt"] = df["key"].apply(lambda x: x.strip('(').strip('"').strip(")").strip("\\"))
 del df["key"]
 df["response"] = df["response"].apply(lambda x: x.strip())
 df.to_json("cc_cache.jsonl", orient="records", lines=True)
 # transform cache to messages
 messages = []
 for item in df.iterrows():
   messages += [{"messages": [{"role": "user", "content": item["prompt"].strip("    \\")}, {"role": "assistant", "content": item["response"]}]}]
 with open("cc_cache.jsonl", "w") as f:
   for item in messages:
      f.write(json.dumps(item) + "\n")

Depois de preparar o conjunto de dados e gerar o arquivo cc_cache.jsonl, ajuste o modelo llama-v3p1-8b-instruct pré-treinado seguindo as etapas abaixo:

Passos

1

Instale o firectl, a ferramenta de linha de comando para gerenciar os recursos da plataforma Fireworks AI

pip install firectl

2

Autentique diretamente com sua conta Fireworks

firectl login

3

Carregue seu conjunto de dados de ajuste fino na plataforma Fireworks

firectl create dataset <dataset_name> cc_cache.jsonl

4

Crie uma tarefa de ajuste fino com o conjunto de dados carregado e o modelo escolhido

firectl create sftj --base-model accounts/fireworks/models/llama-v3p1-8b-instruct --dataset <dataset_name> --output-model ccmodel --lora-rank 8 --epochs 1

5

Monitorar o processo de ajuste fino usando o portal para garantir que ele seja executado sem problemas

Figura 3. Monitoramento do processo de ajuste fino

6

Implante o modelo ajustado na plataforma Fireworks para inferência

firectl deploy ccmodel

Esse procedimento demonstra como a integração de IA do MongoDB e do Fireworks melhora o desempenho do modelo de IA de forma econômica em termos de custo.

Depois de implantar o modelo na plataforma Fireworks como uma API sem servidor, use a id do modelo, models/ft-m88hxaga-pi11m, mostrada na figura 2 para invocar o modelo SLM ajustado usando a estrutura do modelo de linguagem de sua preferência.

Ajustar o SLM para recomendações de cartão de crédito produz os seguintes resultados:

1. Melhoria no tempo de resposta: o tempo de resposta do LLM é em média de 5 segundos. Os SLMs reduzem isso para aproximadamente 0.15 segundos, proporcionando uma redução de latência de 19x.

   import time
   class tiktok:
   """
   Decorator to time the execution of a function and log the time taken.
   """
   def __init__(self, function):
         self.function = function
   def __call__(self, *args, **kwargs):
         import time
         start = time.time()
         value = self.function(*args, **kwargs)
         end = time.time()
         print(f"Time taken for {self.function.__name__}: {end - start} seconds")
         return value
   @tiktok
   @mdbcache
   def invoke_llm(prompt):
   """
   Invoke the language model with the given prompt with cache. The
   invoke LLM method can invoke either a LLM or SLM based on the
   Fireworks Model ID initialized.
   Args:
         prompt (str): The prompt to pass to the LLM.
   """
   ...

   Modelo	Tempo de inferência 1 (s)	Tempo de inferência 2 (s)	Tempo de inferência 3 (s)	Tempo Médio (s)
   llama-v3p1-405b-instruct	5.5954	7.5936	4.9121	6.0337
   SLM - llama-v3p1-8b ajustado	0.3554	0.0480	0.0473	0.1502

2. Redução de memória: os LLMs normalmente exigem 8x80GB de VRAM. Os SLMs operam com 16 GB de VRAM, reduzindo o uso de memória em 97.5%.

3. Redução de hardware: os LLMs exigem CPUs de última geração ou vários servidores. Os SLMs podem implantar em CPUs padrão ou servidores únicos, reduzindo os custos de hardware.