Mise en cache adaptatif pour les réponses d’un compagnon IA sur smartphone

Pourquoi la mise en cache est indispensable

Les compagnons IA fonctionnent souvent grâce à des modèles de langage qui nécessitent des appels fréquents à des API ou à des moteurs locaux. Chaque requête implique du calcul, de la mémoire et, sur un smartphone, de l’énergie. Un cache bien conçu permet de :

• Réduire le temps d’attente perçu par l’utilisateur ;
• Limiter les requêtes réseau (et donc l’empreinte carbone) ;
• Diminuer la charge sur le processeur, ce qui prolonge l’autonomie de la batterie.

Dans le contexte d’un usage quotidien, les mêmes intentions reviennent régulièrement (ex. : rappel de méditation, suivi d’habitudes, réponses à des questions fréquentes). Capturer ces répétitions grâce à un cache adaptatif améliore à la fois le confort et la durabilité du compagnon.

Principes d’un cache adaptatif

Un cache adaptatif se distingue d’un simple cache statique par trois capacités :

1. Apprentissage des motifs d’utilisation – Le système observe la fréquence et la récence des requêtes pour identifier les réponses les plus susceptibles d’être réutilisées.
2. Gestion dynamique de la taille – Plutôt que de fixer une capacité, le cache ajuste son volume en fonction de la disponibilité de la RAM et de la consommation énergétique du dispositif.
3. Expiration contextuelle – Au lieu d’une durée fixe, la validité d’une entrée dépend du contexte (ex. : l’heure de la journée, le lieu, le profil d’activité).

Ces mécanismes requièrent peu de code supplémentaire mais apportent un gain notable en réactivité.

Implémentation concrète en Python

Voici un exemple minimaliste qui illustre comment combiner le décorateur functools.lru_cache avec une couche adaptative basée sur la fréquence d’accès. Le code peut être intégré dans une application mobile grâce à Chaquopy (Python pour Android) ou à une WebView avec un serveur local.

import time
from collections import Counter
from functools import lru_cache

# --- Cache de base (LRU) -------------------------------------------------
@lru_cache(maxsize=128)  # taille initiale, ajustable dynamiquement
def get_response(prompt: str) -> str:
    """Simule l’appel à un modèle de langage lourd."""
    # Ici, on ferait appel à l'API ou au moteur local.
    time.sleep(0.5)  # latence simulée
    return f"Réponse générée pour : {prompt}"

# --- Couche adaptative ---------------------------------------------------
class AdaptiveCache:
    def __init__(self, max_entries: int = 128):
        self.max_entries = max_entries
        self.usage_counter = Counter()
        self.last_cleanup = time.time()

    def query(self, prompt: str) -> str:
        # Compter l’utilisation pour chaque prompt
        self.usage_counter[prompt] += 1
        # Ajuster la taille du cache toutes les 60 s
        if time.time() - self.last_cleanup > 60:
            self._adjust_cache()
        return get_response(prompt)

    def _adjust_cache(self):
        # Exemple simple : si la mémoire disponible est < 200 Mo, réduire le LRU
        # (dans une vraie appli, on interroge le système d’exploitation).
        # Ici on se base uniquement sur le nombre d’entrées fréquemment utilisées.
        frequent = [k for k, v in self.usage_counter.items() if v > 5]
        new_size = max(32, min(self.max_entries, len(frequent) * 2))
        get_response.cache_clear()  # vider l’ancien LRU
        get_response = lru_cache(maxsize=new_size)(get_response.__wrapped__)
        self.max_entries = new_size
        self.last_cleanup = time.time()
        # Réinitialiser le compteur pour la prochaine période
        self.usage_counter.clear()

# Utilisation dans l’application
adaptive = AdaptiveCache()
print(adaptive.query("Quel est mon objectif du jour ?"))
print(adaptive.query("Quelle est ma routine matinale ?"))

Ce code montre :

• Collecte de métriques : Counter enregistre le nombre d’appels par prompt.
• Réévaluation périodique : toutes les minutes, la taille du LRU est adaptée.
• Nettoyage transparent : le décorateur lru_cache est re‑défini avec la nouvelle capacité.

Dans une application réelle, on remplacerait le simple time.sleep par l’appel réel au moteur IA, et on exploiterait les API du système d’exploitation (Android ActivityManager, iOS memoryPressure) pour obtenir des mesures précises de la mémoire disponible.

Bonnes pratiques et limites

• Ne pas cacher les réponses sensibles : les contenus personnels (ex. : diagnostics, informations de santé) doivent rester hors du cache ou être chiffrés.
• Surveiller l’impact énergétique : même un petit cache consomme de la RAM, qui peut à son tour augmenter la consommation du processeur. Testez l’effet sur différents appareils avant de déployer largement.
• Définir une politique d’expiration claire : pour les réponses dépendantes du contexte (heure, localisation), ajoutez un horodatage et invalidez les entrées lorsqu’elles ne sont plus pertinentes.
• Faire appel à la communauté : les bibliothèques comme cachetools offrent des stratégies avancées (TTL, LFU) qui peuvent être combinées avec l’approche présentée.

En appliquant ces principes, vous offrez à vos utilisateurs une expérience plus fluide, tout en respectant les exigences de performance et de respect de la vie privée. Le cache adaptatif devient ainsi un allié discret mais puissant pour tout compagnon IA soucieux d’être à la fois efficace et bienveillant.