Dela via

Självstudie: Använda Azure Cache for Redis som en semantisk cache

  • Artikel

I den här självstudien använder du Azure Cache for Redis som en semantisk cache med en AI-baserad stor språkmodell (LLM). Du använder Azure OpenAI Service för att generera LLM-svar på frågor och cachelagrar dessa svar med hjälp av Azure Cache for Redis, vilket ger snabbare svar och lägre kostnader.

Eftersom Azure Cache for Redis erbjuder inbyggd vektorsökningsfunktion kan du även utföra semantisk cachelagring. Du kan returnera cachelagrade svar för identiska frågor och även för frågor som är liknande, även om texten inte är densamma.

I den här självstudien lär du dig att:

  • Skapa en Azure Cache for Redis-instans som konfigurerats för semantisk cachelagring
  • Använd LangChain andra populära Python-bibliotek.
  • Använd Azure OpenAI-tjänsten för att generera text från AI-modeller och cacheresultat.
  • Se prestandafördelarna med att använda cachelagring med LLM:er.

Viktigt!

Den här självstudien beskriver hur du skapar en Jupyter Notebook. Du kan följa den här självstudien med en Python-kodfil (.py) och få liknande resultat, men du måste lägga till alla kodblock i den här självstudien .py i filen och köra en gång för att se resultat. Med andra ord ger Jupyter Notebooks mellanliggande resultat när du kör celler, men det här är inte det beteende du bör förvänta dig när du arbetar i en Python-kodfil.

Viktigt!

Om du vill följa med i en slutförd Jupyter-anteckningsbok i stället laddar du ned Jupyter Notebook-filen med namnet semanticcache.ipynb och sparar den i den nya mappen semanticcache .

Förutsättningar

Skapa en Azure Cache for Redis-instans

Följ snabbstarten : Skapa en Redis Enterprise-cacheguide . På sidan Avancerat ser du till att du har lagt till RediSearch-modulen och valt enterprise-klusterprincipen. Alla andra inställningar kan matcha standardvärdet som beskrivs i snabbstarten.

Det tar några minuter innan cacheminnet skapas. Du kan gå vidare till nästa steg under tiden.

Screenshot showing the Enterprise tier Basics tab filled out.

Konfigurera utvecklingsmiljön

  1. Skapa en mapp på den lokala datorn med namnet semanticcache på den plats där du vanligtvis sparar dina projekt.

  2. Skapa en ny Python-fil (tutorial.py) eller Jupyter Notebook (tutorial.ipynb) i mappen.

  3. Installera nödvändiga Python-paket:

    pip install openai langchain redis tiktoken

Skapa Azure OpenAI-modeller

Kontrollera att du har två modeller distribuerade till din Azure OpenAI-resurs:

  • En LLM som tillhandahåller textsvar. Vi använder GPT-3.5-turbo-instruct-modellen för den här självstudien.

  • En inbäddningsmodell som konverterar frågor till vektorer så att de kan jämföras med tidigare frågor. Vi använder modellen text-embedding-ada-002 (version 2) för den här självstudien.

Mer detaljerade instruktioner finns i Distribuera en modell . Registrera namnet du valde för varje modelldistribution.

Importera bibliotek och konfigurera anslutningsinformation

Om du vill göra ett anrop mot Azure OpenAI behöver du en slutpunkt och en nyckel. Du behöver också en slutpunkt och en nyckel för att ansluta till Azure Cache for Redis.

  1. Gå till din Azure OpenAI-resurs i Azure-portalen.

  2. Leta upp slutpunkt och nycklar i avsnittet Resurshantering i din Azure OpenAI-resurs. Kopiera slutpunkten och åtkomstnyckeln eftersom du behöver båda för att autentisera dina API-anrop. En exempelslutpunkt är: https://docs-test-001.openai.azure.com. Du kan använda antingen KEY1 eller KEY2.

  3. Gå till översiktssidan för din Azure Cache for Redis-resurs i Azure-portalen. Kopiera slutpunkten.

  4. Leta upp åtkomstnycklar i avsnittet Inställningar. Kopiera din åtkomstnyckel. Du kan använda antingen Primary eller Secondary.

  5. Lägg till följande kod i en ny kodcell:

       # Code cell 2

import openai
import redis
import os
import langchain
from langchain.llms import AzureOpenAI
from langchain.embeddings import AzureOpenAIEmbeddings
from langchain.globals import set_llm_cache
from langchain.cache import RedisSemanticCache
import time


AZURE_ENDPOINT=<your-openai-endpoint>
API_KEY=<your-openai-key>
API_VERSION="2023-05-15"
LLM_DEPLOYMENT_NAME=<your-llm-model-name>
LLM_MODEL_NAME="gpt-35-turbo-instruct"
EMBEDDINGS_DEPLOYMENT_NAME=<your-embeddings-model-name>
EMBEDDINGS_MODEL_NAME="text-embedding-ada-002"

REDIS_ENDPOINT = <your-redis-endpoint>
REDIS_PASSWORD = <your-redis-password>

  6. Uppdatera värdet API_KEY för och RESOURCE_ENDPOINT med nyckel- och slutpunktsvärdena från Azure OpenAI-distributionen.

  7. Ange LLM_DEPLOYMENT_NAME och EMBEDDINGS_DEPLOYMENT_NAME till namnet på de två modeller som distribuerats i Azure OpenAI Service.

  8. Uppdatera REDIS_ENDPOINT och REDIS_PASSWORD med slutpunkten och nyckelvärdet från din Azure Cache for Redis-instans.

    Viktigt!

    Vi rekommenderar starkt att du använder miljövariabler eller en hemlig chef som Azure Key Vault för att skicka in information om API-nyckeln, slutpunkten och distributionsnamnet. Dessa variabler anges i klartext här för enkelhetens skull.

  9. Kör kodcell 2.

Initiera AI-modeller

Sedan initierar du LLM- och inbäddningsmodellerna

  1. Lägg till följande kod i en ny kodcell:

       # Code cell 3

llm = AzureOpenAI(
    deployment_name=LLM_DEPLOYMENT_NAME,
    model_name="gpt-35-turbo-instruct",
    openai_api_key=API_KEY,
    azure_endpoint=AZURE_ENDPOINT,
    openai_api_version=API_VERSION,
)
embeddings = AzureOpenAIEmbeddings(
    azure_deployment=EMBEDDINGS_DEPLOYMENT_NAME,
    model="text-embedding-ada-002",
    openai_api_key=API_KEY,
    azure_endpoint=AZURE_ENDPOINT,
    openai_api_version=API_VERSION
)

  2. Kör kodcell 3.

Konfigurera Redis som en semantisk cache

Ange sedan Redis som en semantisk cache för din LLM.

  1. Lägg till följande kod i en ny kodcell:

       # Code cell 4

redis_url = "rediss://:" + REDIS_PASSWORD + "@"+ REDIS_ENDPOINT
set_llm_cache(RedisSemanticCache(redis_url = redis_url, embedding=embeddings, score_threshold=0.05))

    Viktigt!

    Värdet för parametern score_threshold avgör hur lika två frågor måste vara för att returnera ett cachelagrat resultat. Ju lägre tal, desto mer lika måste frågorna vara. Du kan leka med det här värdet för att finjustera det till ditt program.

  2. Kör kodcell 4.

Fråga efter och hämta svar från LLM

Slutligen frågar du LLM för att få ett AI-genererat svar. Om du använder en Jupyter-anteckningsbok kan du lägga till %%time längst upp i cellen för att mata ut hur lång tid det tar att köra koden.

  1. Lägg till följande kod i en ny kodcell och kör den:

    # Code cell 5
%%time
response = llm("Please write a poem about cute kittens.")
print(response)

    Du bör se utdata och utdata som liknar följande:

    Fluffy balls of fur,
With eyes so bright and pure,
Kittens are a true delight,
Bringing joy into our sight.

With tiny paws and playful hearts,
They chase and pounce, a work of art,
Their innocence and curiosity,
Fills our hearts with such serenity.

Their soft meows and gentle purrs,
Are like music to our ears,
They curl up in our laps,
And take the stress away in a snap.

Their whiskers twitch, they're always ready,
To explore and be adventurous and steady,
With their tails held high,
They're a sight to make us sigh.

Their tiny faces, oh so sweet,
With button noses and paw-sized feet,
They're the epitome of cuteness,
...
Cute kittens, a true blessing,
In our hearts, they'll always be reigning.
CPU times: total: 0 ns
Wall time: 2.67 s

    Visar Wall time värdet 2,67 sekunder. Det var så mycket verklig tid det tog att fråga LLM och att LLM skulle generera ett svar.

  2. Kör cell 5 igen. Du bör se exakt samma utdata, men med en mindre väggtid:

    Fluffy balls of fur,
With eyes so bright and pure,
Kittens are a true delight,
Bringing joy into our sight.

With tiny paws and playful hearts,
They chase and pounce, a work of art,
Their innocence and curiosity,
Fills our hearts with such serenity.

Their soft meows and gentle purrs,
Are like music to our ears,
They curl up in our laps,
And take the stress away in a snap.

Their whiskers twitch, they're always ready,
To explore and be adventurous and steady,
With their tails held high,
They're a sight to make us sigh.

Their tiny faces, oh so sweet,
With button noses and paw-sized feet,
They're the epitome of cuteness,
...
Cute kittens, a true blessing,
In our hearts, they'll always be reigning.
CPU times: total: 0 ns
Wall time: 575 ms

    Väggtiden verkar förkortas med en faktor på fem - hela vägen ner till 575 millisekunder.

  3. Ändra frågan från Please write a poem about cute kittens till Write a poem about cute kittens och kör cell 5 igen. Du bör se exakt samma utdata och en kortare väggtid än den ursprungliga frågan. Även om frågan ändrades förblev frågans semantiska betydelse densamma så att samma cachelagrade utdata returnerades. Det här är fördelen med semantisk cachelagring!

Ändra tröskelvärdet för likhet

  1. Prova att köra en liknande fråga med en annan betydelse, till exempel Please write a poem about cute puppies. Observera att det cachelagrade resultatet också returneras här. Ordets semantiska innebörd puppies är tillräckligt nära ordet kittens att det cachelagrade resultatet returneras.

  2. Likhetströskelvärdet kan ändras för att avgöra när det semantiska cacheminnet ska returnera ett cachelagrat resultat och när det ska returnera nya utdata från LLM. I kodcell 4 ändrar du score_threshold från 0.05 till 0.01:

    # Code cell 4

redis_url = "rediss://:" + REDIS_PASSWORD + "@"+ REDIS_ENDPOINT
set_llm_cache(RedisSemanticCache(redis_url = redis_url, embedding=embeddings, score_threshold=0.01))

  3. Försök med frågan Please write a poem about cute puppies igen. Du bör få nya utdata som är specifika för valpar:

    Oh, little balls of fluff and fur
With wagging tails and tiny paws
Puppies, oh puppies, so pure
The epitome of cuteness, no flaws

With big round eyes that melt our hearts
And floppy ears that bounce with glee
Their playful antics, like works of art
They bring joy to all they see

Their soft, warm bodies, so cuddly
As they curl up in our laps
Their gentle kisses, so lovingly
Like tiny, wet, puppy taps

Their clumsy steps and wobbly walks
As they explore the world anew
Their curiosity, like a ticking clock
Always eager to learn and pursue

Their little barks and yips so sweet
Fill our days with endless delight
Their unconditional love, so complete
...
For they bring us love and laughter, year after year
Our cute little pups, in every way.
CPU times: total: 15.6 ms
Wall time: 4.3 s

    Du behöver förmodligen finjustera likhetströskelvärdet baserat på ditt program för att säkerställa att rätt känslighet används när du avgör vilka frågor som ska cachelageras.

Rensa resurser

Om du vill fortsätta att använda de resurser som du skapade i den här artikeln behåller du resursgruppen.

Om du är klar med resurserna kan du ta bort den Azure-resursgrupp som du skapade för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. När du tar bort en resursgrupp tas alla resurser som ingår i den bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna i en befintlig resursgrupp som innehåller resurser som du vill behålla kan du ta bort varje resurs individuellt i stället för att ta bort resursgruppen.

Ta bort en resursgrupp

  1. Logga in på Azure-portalen och välj Resursgrupper.

  2. Välj den resursgrupp som du vill ta bort.

    Om det finns många resursgrupper använder du rutan Filter för alla fält... och skriver namnet på resursgruppen som du skapade för den här artikeln. Välj resursgruppen i resultatlistan.

    Screenshot showing a list of resource groups to delete in the working pane.

  3. Välj Ta bort resursgrupp.

  4. Du blir ombedd att bekräfta borttagningen av resursgruppen. Skriv namnet på din resursgrupp för att bekräfta och välj sedan Ta bort.

    Screenshot showing a form that requires the resource name to confirm deletion.

Efter en liten stund tas resursgruppen och de resurser som finns i den bort.

Relaterat innehåll