Melhorando Decisões em Tempo Real com Inferência Multinível

Muitas aplicações de machine learning (ML) trabalham com dados de tamanho médio pra tomar decisões em tempo real. Mas rola um problema comum quando tentamos obter resultados instantâneos, o que pode atrasar todo o processo. Normalmente, os sistemas de ML são separados do código principal do produto e acessados por chamadas especiais, o que pode causar atrasos e usar mais poder de processamento. Pra resolver isso, decidimos simplificar o processo de inferência e integrar diretamente no código do produto, ajudando a reduzir o tempo gasto se comunicando pela rede.

Nossas descobertas mostram que cerca da metade das entradas que lidamos podem se beneficiar dessa otimização, enquanto a outra metade ainda pode usar os modelos originais. Melhorando o processo e usando técnicas de ML automatizadas tanto para os passos de treinamento quanto de inferência, conseguimos diminuir o tempo pra fazer previsões em cerca de 30%, resultando em uma economia significativa de recursos de CPU e tráfego de rede. Isso é especialmente importante, pois lidamos com várias decisões em tempo real a cada segundo.

Com ferramentas de ML sofisticadas ficando mais disponíveis, os desenvolvedores têm se esforçado pra criar sistemas de ML robustos e eficientes que conseguem lidar com grandes volumes de dados. Muitos sistemas convencionais também podem ser atualizados com capacidades de ML, considerando como eles operam. Isso ajuda a evitar trabalho desnecessário e permite que os sistemas interajam de forma mais suave. Além disso, entender como os usuários se comportam e o que gostam pode ajudar a melhorar a experiência do usuário.

Mas, à medida que os dados mudam com o tempo, precisamos continuamente re-treinar nossos modelos e monitorar seu desempenho, o que pode tornar o processo de desenvolvimento de software mais complexo. Pra manter as coisas gerenciáveis e aumentar a performance, o código de ML costuma ser dividido em partes diferentes - como coleta de dados, treinamento de modelos e fazer previsões em tempo real - e conectado ao código principal do produto usando chamadas especiais.

Na nossa configuração, vimos que separar as partes do sistema pode causar atrasos nas chamadas entre o código do produto e o lado de ML. Então, decidimos melhorar o sistema pra que pudesse tomar decisões mais rápido e com menos complicação, usando modelos mais simples pra primeira fase da inferência, mas ainda tendo a opção de voltar pra modelos mais complexos na segunda fase.

Um dos focos principais do nosso trabalho é em Inferência em Tempo Real, já que isso muitas vezes consome muitos recursos em várias aplicações, como sistemas de recomendação ou classificação de produtos. Essas aplicações frequentemente exigem que as previsões sejam feitas em menos de 300 milissegundos, e reduzir o tempo pode ajudar a cortar o uso total de recursos.

Acontece que, quando comparamos modelos mais simples com modelos de deep learning, as opções mais simples costumam ter um desempenho melhor nessas situações, especialmente quando executadas em CPUs padrão. Isso significa que, se conseguirmos avaliar certas previsões imediatamente com um modelo mais simples no código do produto, podemos economizar tempo e usar os modelos mais complexos só quando realmente necessário.

Na nossa abordagem, desenvolvemos o que chamamos de inferência em múltiplas fases. Esse método nos permite obter bons resultados em vários conjuntos de dados tabulares. A gente desenhou pra que o modelo da primeira fase seja mais simples que o modelo da segunda fase acessado pelas chamadas especiais. No nosso caso, escrevemos nosso código de produto em PHP, o que facilitou integrar o modelo da primeira fase.

O modelo da primeira fase não precisa ser simples durante o treinamento; ainda usamos pacotes de ML de alta qualidade pra isso. Um grande desafio que enfrentamos é determinar quais entradas devem ser processadas por qual modelo.

Na nossa estratégia, dividimos as entradas em diferentes grupos com base nas suas características. Fazendo isso, conseguimos aplicar um modelo mais fácil a esses grupos, garantindo que funcione bem pra aquelas entradas específicas. Pra ilustrar, imagine que temos um conjunto de dados com duas características. À primeira vista, esses pontos de dados podem não parecer fáceis de separar, mas se dividirmos em grupos menores, conseguimos encontrar limites mais simples que podem ajudar a classificá-los mais facilmente.

Essa ideia é a base do nosso modelo da primeira fase, que chamamos de Regressão Logística com Bins (LRwBins). Esse modelo combina a inferência da primeira fase com o modelo mais complexo da segunda fase. O primeiro passo é dividir os dados em grupos menores com base nas características mais importantes que identificamos, e então treinamos um modelo de regressão logística pra lidar com esses grupos.

Depois, precisamos decidir qual modelo usar pra fazer previsões pra cada grupo. Avaliamos o desempenho dos modelos em um conjunto de validação pra determinar como alocar as previsões. Então, quando recebemos novos dados, conseguimos facilmente mapeá-los pro grupo correto e usar o modelo associado pra inferência.

Pra tornar esse processo de tomada de decisão eficaz, ficamos de olho nas métricas de desempenho dos nossos modelos. Classificamos esses grupos pelo quão bem o modelo da primeira fase performa em comparação com o modelo da segunda fase. Dessa forma, conseguimos distribuir a carga de trabalho de forma eficaz e assegurar que maximizamos o número de previsões feitas pelo modelo mais rápido e simples, enquanto ainda contamos com o modelo mais complexo quando necessário.

O papel do ML automatizado em tudo isso é crucial. Ele nos ajuda a determinar como formar os grupos e otimizar o desempenho dos nossos modelos. Usamos ele pra ajustar parâmetros, assim conseguimos tomar as decisões mais informadas sobre como implementar nossos modelos de forma eficiente.

Nossa implementação prática desse método mostrou benefícios significativos. Treinando o modelo da segunda fase com todos os dados disponíveis, garantimos que temos uma opção de backup confiável quando o modelo mais simples não performa bem. Asseguramos que todo o nosso treinamento utiliza pacotes de ML de alta qualidade enquanto mantemos a inferência da primeira fase facilmente acessível dentro do código do produto.

Ao implementar o AutoML, também agilizamos o processo de ajuste de parâmetros e seleção de características que nos permitem equilibrar o desempenho da abordagem em duas fases de forma eficaz. Nosso objetivo é alcançar mais de 50% de cobertura de entradas com perda mínima de desempenho, o que pode levar a economias substanciais de tempo e recursos.

Fizemos experimentos usando vários conjuntos de dados, comparando nosso modelo mais simples com opções mais complexas como o XGBoost. Os resultados mostraram que, apesar de nosso modelo LRwBins talvez não superar sempre os modelos mais sofisticados, ele ofereceu uma opção útil que nos permitiu lidar com uma boa fração dos dados de forma eficiente, minimizando a queda de desempenho.

No geral, nossa abordagem de inferência em múltiplas fases se mostrou bastante eficaz em melhorar a latência e o uso de recursos. Não só nos permite tomar decisões mais rápido, mas também minimiza a carga de trabalho nos nossos sistemas, levando a uma melhor eficiência em lidar com os dados que encontramos.

À medida que avançamos em nosso trabalho, percebemos que, embora nossos métodos funcionem bem pra muitas aplicações, existem desafios que precisamos estar atentos. Alguns conjuntos de dados apresentaram uma queda de desempenho inesperada quando tentamos categorizar os dados usando nosso modelo mais simples, enfatizando a importância de encontrar o modelo certo pra casos específicos.

Nossa abordagem também mostrou compatibilidade com aceleradores de hardware, que podem ser uma opção promissora pra desenvolvimentos futuros. Ao otimizar nossos modelos pra diferentes hardwares, podemos melhorar ainda mais o desempenho e agilizar o processo geral de fazer previsões.

Em conclusão, nosso trabalho em inferência em múltiplas fases destaca a importância de equilibrar desempenho com eficiência em aplicações de ML. Ao embutir um modelo da primeira fase mais simples diretamente no código do produto, conseguimos fazer melhorias significativas em velocidade e uso de recursos, nos permitindo lidar com um volume maior de previsões de forma eficiente.

Com uma consideração cuidadosa da cobertura de entradas e uso eficaz de técnicas de ML automatizadas, conseguimos garantir um sistema robusto que atende nossas necessidades sem sobrecarregar o código do produto. Esse tipo de design cuidadoso continuará a impulsionar as capacidades dos sistemas de ML em aplicações do mundo real, seja em ambientes comerciais ou em iniciativas de dados mais amplas.