LLMs génératifs en cache | Économiser les coûts d’API

LLMs génératifs en cache | Économie de coûts d'API

Introduction

L’IA générative a tellement prévalu que la plupart d’entre nous travailleront déjà sur des applications impliquant des modèles d’IA générative, que ce soit des générateurs d’images ou les célèbres modèles de langage à grande échelle. La plupart d’entre nous travaillons avec des modèles de langage à grande échelle, en particulier ceux qui sont propriétaires comme OpenAI, où nous devons payer pour utiliser les modèles développés par eux. Maintenant, si nous sommes assez prudents, nous pouvons minimiser les coûts lors de l’utilisation de ces modèles, mais d’une manière ou d’une autre, les prix finissent par s’accumuler beaucoup. Et c’est ce que nous allons examiner dans cet article, c’est-à-dire comment capturer les réponses / appels API envoyés aux modèles de langage à grande échelle. Êtes-vous enthousiaste à l’idée d’apprendre sur la mise en cache des modèles LLM génératifs ?

Objectifs d’apprentissage

• Comprendre ce qu’est la mise en cache et comment elle fonctionne
• Apprendre comment mettre en cache des modèles de langage à grande échelle
• Apprendre différentes façons de mettre en cache des modèles LLM dans LangChain
• Comprendre les avantages potentiels de la mise en cache et comment elle réduit les coûts d’API

Cet article a été publié dans le cadre du Data Science Blogathon.

Qu’est-ce que la mise en cache ? Pourquoi est-elle nécessaire ?

Une mise en cache est un endroit où stocker temporairement des données afin de pouvoir les réutiliser, et le processus de stockage de ces données s’appelle la mise en cache. Ici, les données les plus fréquemment consultées sont stockées pour y accéder plus rapidement. Cela a un effet radical sur les performances du processeur. Imaginez le processeur effectuant une tâche intensive nécessitant beaucoup de temps de calcul. Maintenant, imaginez une situation où le processeur doit effectuer le même calcul à nouveau. Dans ce scénario, la mise en cache du résultat précédent est vraiment utile. Cela réduira le temps de calcul, car le résultat a été mis en cache lorsque la tâche a été effectuée.

Dans le type de mise en cache mentionné ci-dessus, les données sont stockées dans le cache du processeur, et la plupart des processus se trouvent dans une mémoire cache intégrée. Mais cela peut ne pas être suffisant pour d’autres applications. Dans ces cas, le cache est stocké dans la RAM. L’accès aux données depuis la RAM est beaucoup plus rapide que depuis un disque dur ou un SSD. La mise en cache peut également permettre d’économiser des coûts d’appels API. Supposons que nous envoyions une requête similaire au modèle Open AI. Nous serons facturés pour chaque requête envoyée, et le temps nécessaire pour obtenir une réponse sera plus long. Mais si nous mettons en cache ces appels, nous pouvons d’abord rechercher le cache pour vérifier si nous avons envoyé une requête similaire au modèle, et si c’est le cas, au lieu d’appeler l’API, nous pouvons récupérer les données, c’est-à-dire la réponse, à partir du cache.

• Décomposition de l’indice de Gini Comment l’économie a inspiré l’apprentissage automatique
• Guide du débutant pour comprendre les performances des tests A/B grâce aux simulations de Monte Carlo
• Créez votre propre assistant analyste de données avec les agents de Langchain

Mise en cache dans les modèles de langage à grande échelle

Nous savons que les modèles propriétaires tels que GPT 3.5 d’OpenAI et d’autres facturent l’utilisateur pour les appels API effectués vers leurs modèles de langage à grande échelle génératifs. Le coût associé à l’appel API dépend largement du nombre de jetons transmis. Plus le nombre de jetons est élevé, plus le coût associé est élevé. Il est donc important de gérer cela avec précaution afin de ne pas payer de sommes importantes.

Maintenant, une façon de résoudre cela / de réduire les coûts des appels API est de mettre en cache les requêtes et leurs réponses correspondantes. Lorsque nous envoyons d’abord une requête au modèle et obtenons la réponse correspondante, nous la stockons dans le cache. Maintenant, lorsqu’une autre requête est envoyée, avant de l’envoyer au modèle, c’est-à-dire avant de passer un appel API, nous vérifierons si la requête est similaire à l’une de celles enregistrées dans le cache ; si c’est le cas, nous prendrons la réponse à partir du cache au lieu d’envoyer la requête au modèle (c’est-à-dire de passer un appel API) et d’obtenir ensuite la réponse.

Cela permet d’économiser des coûts chaque fois que nous demandons des requêtes similaires au modèle, et même le temps de réponse sera réduit, car nous l’obtenons directement depuis le cache au lieu d’envoyer une requête au modèle et d’obtenir une réponse de celui-ci. Dans cet article, nous verrons différentes façons de mettre en cache les réponses du modèle.

Mise en cache avec le cache en mémoire de LangChain

Oui, vous avez bien lu. Nous pouvons mettre en cache les réponses et les appels au modèle avec la bibliothèque LangChain. Dans cette section, nous verrons comment configurer le mécanisme de mise en cache et même voir des exemples pour nous assurer que nos résultats sont mis en cache et que les réponses aux requêtes similaires proviennent du cache. Commençons par télécharger les bibliothèques nécessaires.

!pip install langchain openai

Pour commencer, installez les bibliothèques LangChain et OpenAI avec la commande pip. Nous travaillerons avec les modèles OpenAI et verrons comment ils facturent nos appels API et comment nous pouvons utiliser le cache pour les réduire. Maintenant, commençons par le code.

import os
import openai
from langchain.llms import OpenAI


os.environ["OPENAI_API_KEY"] = "Votre jeton d'API"

llm = OpenAI(model_name="text-davinci-002", openai_api_key=os.environ["OPENAI_API_KEY"])

llm("Qui a été la première personne à aller dans l'espace?")

• Ici, nous avons défini le modèle OpenAI avec lequel nous allons travailler. Nous devons fournir la clé d’API OpenAI à os.environ [] pour stocker notre clé d’API dans la variable d’environnement OPENAI_API_KEY.
• Ensuite, nous importons l’enveloppe LLM de LangChain pour OpenAI. Ici, le modèle sur lequel nous travaillons est “text-davinci-002” et nous passons également à la fonction OpenAI() la variable d’environnement contenant notre clé d’API.
• Pour tester le bon fonctionnement du modèle, nous pouvons effectuer des appels API et interroger le LLM avec une question simple.
• Nous pouvons voir la réponse générée par le LLM dans l’image ci-dessus. Cela garantit que le modèle est opérationnel et que nous pouvons envoyer des requêtes au modèle et obtenir des réponses générées par celui-ci.

Mise en cache avec LangChain

Regardons maintenant la mise en cache avec LangChain.

import langchain
from langchain.cache import InMemoryCache
from langchain.callbacks import get_openai_callback


langchain.llm_cache = InMemoryCache()

• La bibliothèque LangChain dispose d’une fonction intégrée de mise en cache appelée InMemoryCache. Nous allons travailler avec cette fonction pour mettre en cache les LLM.
• Pour commencer la mise en cache avec LangChain, nous passons la fonction InMemoryCache() à langchain.llm_cache.
• Donc ici, nous créons d’abord une mise en cache LLM dans LangChain en utilisant langchain.llm_cache.
• Ensuite, nous prenons le InMemoryCache (une technique de mise en cache) et le passons à langchain.llm_cache.
• Cela créera maintenant un InMemoryCache pour nous dans LangChain. Nous remplaçons le InMemoryCache par celui avec lequel nous voulons travailler pour utiliser un mécanisme de mise en cache différent.
• Nous importons même get_openai_callback. Cela nous donnera des informations sur le nombre de jetons passés au modèle lorsqu’un appel API est effectué, le coût qu’il a pris, le nombre de jetons de réponse et le temps de réponse.

Interroger le LLM

Maintenant, nous allons interroger le LLM, puis mettre en cache la réponse, puis interroger le LLM pour vérifier si la mise en cache fonctionne et si les réponses sont stockées et récupérées à partir du cache lorsque des questions similaires sont posées.

%%time
import time


with get_openai_callback() as cb:
  start = time.time()
  result = llm("Quelle est la distance entre la Terre et la Lune?")
  end = time.time()
  print("Temps pris pour la réponse",end-start)
  print(cb)
  print(result)

Fonction de temps

Dans le code ci-dessus, nous utilisons la fonction %%time pour connaître le temps que prend la cellule pour s’exécuter. Nous importons également la fonction time pour obtenir le temps nécessaire pour effectuer l’appel API et obtenir la réponse. Ici, comme indiqué précédemment, nous travaillons avec get_openai_callback(). Nous l’imprimons ensuite après avoir passé la requête au modèle. Cette fonction affiche le nombre de jetons passés, le coût du traitement de l’appel API et le temps écoulé. Regardons la sortie ci-dessous.

La sortie montre que le temps nécessaire pour traiter la requête est de 0,8 seconde. Nous pouvons même voir le nombre de jetons dans la requête de l’invite que nous avons envoyée, qui est de 9, et le nombre de jetons dans la sortie générée, c’est-à-dire 21. Nous pouvons même voir le coût du traitement de notre appel API dans les rappels générés, c’est-à-dire 0,0006 $. Le temps CPU est de 9 millisecondes. Maintenant, essayons de relancer le code avec la même requête et voyons la sortie générée.

Ici, nous constatons une différence significative dans le temps qu’il a fallu pour obtenir la réponse. Cela prend 0,0003 secondes, ce qui est 2666 fois plus rapide que la première fois que nous l’avons exécuté. Même dans la sortie de rappel, nous constatons que le nombre de jetons de prompt est de 0, le coût est de 0 $ et les jetons de sortie sont également de 0. Même les requêtes réussies sont définies sur 0, ce qui indique qu’aucun appel/requête API n’a été envoyé au modèle. Au lieu de cela, il a été obtenu à partir du cache.

Ainsi, nous pouvons dire que LangChain a mis en cache le prompt et la réponse générée par le modèle de langage large d’OpenAI lorsqu’il a été exécuté pour le même prompt la dernière fois. C’est la méthode pour mettre en cache les LLM via la fonction InMemoryCache() de LangChain.

Mise en cache avec SQLiteCache

Une autre façon de mettre en cache les prompts et les réponses du modèle de langage large consiste à utiliser SQLiteCache. Commençons par le code

from langchain.cache import SQLiteCache

langchain.llm_cache = SQLiteCache(database_path=".langchain.db")

Ici, nous définissons le cache LLM dans LangChain de la même manière que nous l’avons fait précédemment. Mais ici, nous utilisons une méthode de mise en cache différente. Nous utilisons SQLiteCache, qui stocke les prompts et les réponses du modèle de langage large dans une base de données. Nous fournissons même le chemin de la base de données où stocker ces prompts et réponses. Ici, ce sera langchain.db.

Essayons maintenant de tester le mécanisme de mise en cache comme nous l’avons fait précédemment. Nous exécuterons une requête sur le modèle de langage large d’OpenAI deux fois, puis vérifierons si les données sont mises en cache en observant la sortie générée lors de la deuxième exécution. Le code sera le suivant

%%time
import time

start = time.time()
result = llm("Qui a créé la bombe atomique ?")
end = time.time()
print("Temps pris pour la réponse",end-start)
print(result)

%%time
import time

start = time.time()
result = llm("Qui a créé la bombe atomique ?")
end = time.time()
print("Temps pris pour la réponse",end-start)
print(result)

Dans la première sortie, lorsque nous avons exécuté la requête pour la première fois sur le modèle de langage large, le temps nécessaire pour envoyer la requête au modèle et obtenir la réponse était de 0,7 secondes. Mais lorsque nous avons essayé d’exécuter la même requête sur le modèle de langage large, nous avons constaté que le temps pris pour la réponse était de 0,002 secondes. Cela prouve que lorsque la requête “Qui a créé la bombe atomique ?” a été exécutée pour la première fois, à la fois le prompt et la réponse générée par le modèle de langage large ont été mis en cache dans la base de données SQLiteCache.

Ensuite, lorsque nous avons exécuté la même requête pour la deuxième fois, il a d’abord cherché dans le cache, et comme il était disponible, il a simplement pris la réponse correspondante dans le cache au lieu d’envoyer une requête au modèle d’OpenAI et d’obtenir une réponse. C’est donc une autre façon de mettre en cache les modèles de langage large.

Avantages de la mise en cache

Réduction des coûts

La mise en cache réduit considérablement les coûts de l’API lors de l’utilisation de modèles de langage large. Les coûts de l’API sont liés à l’envoi d’une requête au modèle et à la réception de sa réponse. Ainsi, plus nous envoyons de requêtes au modèle de langage génératif, plus nos coûts sont élevés. Nous avons constaté que lorsque nous avons exécuté la même requête pour la deuxième fois, la réponse pour la requête provenait du cache au lieu d’envoyer une requête au modèle pour générer une réponse. Cela est très utile lorsque vous avez une application où de nombreuses requêtes similaires sont envoyées aux modèles de langage large.

Amélioration des performances/ Réduction du temps de réponse

Oui. La mise en cache contribue à améliorer les performances. Bien que ce ne soit pas directement, mais indirectement. Une amélioration des performances se produit lorsque nous mettons en cache des réponses qui ont pris beaucoup de temps à être calculées par le processeur, puis que nous devons les recalculer. Mais si nous les avons mis en cache, nous pouvons accéder directement à la réponse au lieu de la recalculer. Ainsi, le processeur peut consacrer du temps à d’autres activités.

Lorsqu’il s’agit de mettre en cache de grands modèles de langage, nous mettons en cache à la fois la requête et la réponse. Ainsi, lorsque nous répétons une requête similaire, la réponse est récupérée depuis le cache au lieu d’envoyer une requête au modèle. Cela réduit considérablement le temps de réponse, car il provient directement du cache plutôt que d’envoyer une requête au modèle et de recevoir une réponse. Nous avons même vérifié les vitesses de réponse dans nos exemples.

Conclusion

Dans cet article, nous avons appris comment fonctionne la mise en cache dans LangChain. Vous avez développé une compréhension de ce qu’est la mise en cache et de son objectif. Nous avons également vu les avantages potentiels de travailler avec un cache plutôt que sans. Nous avons examiné différentes façons de mettre en cache de grands modèles de langage dans LangChain (InMemoryCache et SQLiteCache). À travers des exemples, nous avons découvert les avantages de l’utilisation d’un cache, comment il peut réduire les coûts de notre application et, en même temps, garantir des réponses rapides.

Points clés à retenir

Certains des points clés à retenir de ce guide comprennent :

• La mise en cache est un moyen de stocker des informations qui peuvent ensuite être récupérées ultérieurement
• Les grands modèles de langage peuvent être mis en cache, où la requête et la réponse générée sont celles qui sont enregistrées dans la mémoire cache.
• LangChain permet différentes techniques de mise en cache, y compris InMemoryCache, SQLiteCache, Redis, et bien d’autres.
• La mise en cache de grands modèles de langage permettra de réduire le nombre d’appels API aux modèles, de réduire les coûts des API et de fournir des réponses plus rapides.

Questions fréquemment posées

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!