Améliorer les décisions en temps réel avec l'inférence à plusieurs étapes

De nombreuses applications de machine learning (ML) fonctionnent avec des données de taille moyenne pour prendre des décisions en temps réel. Cependant, un problème courant se pose quand on essaie d'obtenir des résultats instantanés, ce qui peut ralentir tout le processus. En général, les systèmes ML sont séparés du code principal du produit et sont accédés par des appels spéciaux, ce qui peut entraîner des retards et consommer de la puissance de traitement supplémentaire. Pour contrer cela, on a décidé de simplifier le processus d'inférence et de l'intégrer directement dans le code produit, ce qui peut aider à réduire le temps passé à communiquer sur le réseau.

Nos découvertes montrent qu'environ la moitié des entrées avec lesquelles on travaille peuvent bénéficier de cette optimisation, tandis que l'autre moitié peut toujours utiliser les modèles originaux. En améliorant le processus et en utilisant des techniques ML automatisées pour les étapes de formation et d'inférence, on a réussi à réduire le temps nécessaire pour faire des prédictions d'environ 30 %, ce qui entraîne des économies significatives en ressources CPU et en trafic réseau. C'est particulièrement important vu qu'on doit prendre de nombreuses décisions en temps réel chaque seconde.

Avec la disponibilité croissante d'outils ML sophistiqués, les développeurs ont travaillé dur pour créer des systèmes ML robustes et efficaces capables de gérer de grandes quantités de données. Beaucoup de systèmes conventionnels peuvent également être mis à jour avec des capacités ML en tenant compte de leur fonctionnement. Cela aide à éviter le travail inutile et permet aux systèmes d'interagir plus facilement. De plus, comprendre comment les utilisateurs se comportent et ce qu'ils aiment peut aider à améliorer l'expérience utilisateur.

Cependant, à mesure que les données évoluent, on doit continuellement réentraîner nos modèles et surveiller leur performance, ce qui peut compliquer le processus de développement logiciel. Pour garder tout ça gérable et améliorer les performances, le code ML est souvent divisé en différentes parties - comme la collecte de données, l'entraînement de modèles et la réalisation de prédictions en temps réel - et connecté au code principal du produit via des appels spéciaux.

Dans notre cas, on a constaté que séparer les parties du système peut entraîner des retards lorsque des appels sont faits entre le code produit et la partie ML. Donc, on a cherché à améliorer le système pour qu'il puisse prendre des décisions plus rapidement et avec moins de tracas en utilisant des modèles plus simples pour la première étape d'inférence tout en ayant la possibilité de revenir à des modèles plus complexes pour la deuxième étape.

Un point clé de notre travail est l'Inférence en temps réel, car cela utilise souvent beaucoup de ressources dans diverses applications comme les systèmes de recommandation ou le classement de produits. Ces applications nécessitent souvent que les prédictions soient faites en moins de 300 millisecondes, et réduire le temps nécessaire peut aussi aider à diminuer l'utilisation totale des ressources.

Il s'avère que, quand on compare des modèles plus simples avec des modèles de deep learning, les options plus simples ont tendance à mieux performer dans ces situations, surtout quand elles sont exécutées sur des CPU standards. Ça signifie que si on peut évaluer certaines prédictions immédiatement avec un modèle plus simple dans le code produit, on peut gagner du temps et n'utiliser les modèles plus complexes que si c'est vraiment nécessaire.

Dans notre approche, on a développé ce qu'on appelle l'inférence multistage. Cette méthode nous permet d'obtenir de bons résultats sur divers ensembles de données tabulaires. On l'a conçue de sorte que le modèle de première étape soit plus simple que le modèle de deuxième étape accédé via des appels spéciaux. Dans notre cas, on a écrit notre code produit en PHP, ce qui a facilité l'intégration du modèle de première étape.

Le modèle de première étape n'a pas besoin d'être basique pendant l'entraînement ; on utilise quand même des packages ML de haute qualité pour cette partie. Un gros défi auquel on fait face est de déterminer quelles entrées doivent être traitées par quel modèle.

Dans notre stratégie, on divise les entrées en différents groupes basés sur leurs caractéristiques. En faisant cela, on peut ensuite appliquer un modèle plus facile à ces groupes, en s'assurant qu'il fonctionne bien pour ces entrées spécifiques. Pour illustrer, imagine qu'on a un ensemble de données avec deux caractéristiques. À première vue, ces points de données n'ont pas l'air faciles à séparer, mais si on les divise en groupes plus petits, on peut trouver des frontières plus simples qui peuvent nous aider à les classifier plus facilement.

Cette idée est à la base de notre modèle de première étape, qu'on appelle Régression Logistique avec Bins (LRwBins). Ce modèle combine l'inférence de première étape avec le modèle plus complexe de deuxième étape. La première étape consiste à diviser les données en groupes plus petits basés sur les caractéristiques les plus importantes qu'on identifie, puis on entraîne un modèle de régression logistique pour gérer ces groupes.

Ensuite, on doit décider quel modèle utiliser pour faire des prédictions pour chaque groupe. On évalue la performance des modèles sur un ensemble de validation pour déterminer comment allouer les prédictions. Puis, quand on reçoit de nouvelles données, on peut facilement les mapper au bon groupe et utiliser le modèle associé pour l'inférence.

Pour rendre ce processus décisionnel efficace, on garde un œil sur les métriques de performance de nos modèles. On classe ces groupes selon la performance du modèle de première étape par rapport au modèle de deuxième étape. Comme ça, on peut distribuer efficacement la charge de travail et s'assurer qu'on maximise le nombre de prédictions faites par le modèle plus rapide et plus simple tout en comptant sur le modèle plus complexe quand c'est nécessaire.

Le rôle de l'AutoML dans tout ça est crucial. Ça nous aide à déterminer comment former les groupes et optimiser la performance de nos modèles. On l'utilise pour affiner les paramètres afin de prendre les décisions les plus éclairées sur la manière de déployer nos modèles efficacement.

Notre mise en œuvre pratique de cette méthode a montré des bénéfices significatifs. En entraînant le modèle de deuxième étape sur toutes les données disponibles, on s'assure d'avoir une option de secours fiable quand le modèle plus simple ne performe pas bien. On veille à ce que toute notre formation utilise des packages ML de haute qualité tout en gardant l'inférence de première étape facilement accessible dans le code produit.

En utilisant l'AutoML, on rationalise aussi le processus d'ajustement des paramètres et de sélection des caractéristiques qui nous permettent d'équilibrer efficacement la performance de l'approche en deux étapes. Notre objectif est d'atteindre plus de 50 % de couverture des entrées avec une perte de performance minimale, ce qui peut entraîner des économies de temps et de ressources considérables.

On a mené des expériences en utilisant divers ensembles de données, en comparant notre modèle plus simple avec des options plus complexes comme XGBoost. Les résultats ont montré que bien que notre modèle LRwBins ne surpasse pas toujours les modèles plus sophistiqués, il a fourni une option utile qui nous a permis de gérer une bonne fraction des données efficacement tout en minimisant la chute de performance.

Dans l'ensemble, notre approche d'inférence multistage s'est avérée assez efficace pour améliorer la latence et l'utilisation des ressources. Non seulement elle nous permet de prendre des décisions plus rapidement, mais elle minimise aussi la charge de travail sur nos systèmes, menant à une meilleure efficacité dans la gestion des données qu'on rencontre.

À mesure qu'on avance dans notre travail, on réalise que même si nos méthodes fonctionnent bien pour de nombreuses applications, il y a des défis à garder à l'esprit. Certains ensembles de données ont montré une chute de performance inattendue lorsqu'on a essayé de catégoriser les données avec notre modèle plus simple, soulignant l'importance de trouver le bon modèle pour des cas spécifiques.

Notre approche a également montré une compatibilité avec des accélérateurs matériels, ce qui pourrait être une option prometteuse pour les développements futurs. En optimisant nos modèles pour différents matériels, on peut encore améliorer les performances et rationaliser l'ensemble du processus de prise de prédictions.

En conclusion, notre travail sur l'inférence multistage souligne l'importance d'équilibrer performance et efficacité dans les applications ML. En intégrant un modèle de première étape plus simple directement dans le code produit, on peut réaliser des améliorations significatives en vitesse et en utilisation des ressources, nous permettant de gérer un plus grand volume de prédictions efficacement.

Grâce à une considération attentive de la couverture des entrées et à une utilisation efficace des techniques d'AutoML, on peut s'assurer d'avoir un système robuste qui répond à nos besoins sans surcharger le code produit lui-même. Ce type de conception réfléchie continuera d'accroître les capacités des systèmes ML dans les applications réelles, que ce soit dans des environnements commerciaux ou dans des initiatives plus larges axées sur les données.