Compartilhar via

Tutorial: Usar o Cache do Azure para Redis como um cache semântico

  • Artigo

Neste tutorial, você usará o Cache do Azure para Redis como um cache semântico com um modelo de linguagem grande (LLM) baseado em IA. Você usa o Serviço OpenAI do Azure para gerar respostas LLM para consultas e armazenar essas respostas em cache usando o Cache do Azure para Redis, fornecendo respostas mais rápidas e reduzindo custos.

Como o Cache do Azure para Redis oferece funcionalidade de busca em vetores interna, você também pode executar o cache semântico. Você pode retornar respostas em cache para consultas idênticas e também para consultas com significado semelhante, mesmo que o texto não seja o mesmo.

Neste tutorial, você aprenderá a:

  • Crie uma instância de Cache do Azure para Redis configurada para pesquisa de vetor
  • Use o LangChain em outras bibliotecas populares do Python.
  • Use o serviço OpenAI do Azure para gerar texto de modelos de IA e resultados de cache.
  • Veja os ganhos de desempenho usando o cache com LLMs.

Importante

Este tutorial o orientará na criação de um Jupyter Notebook. Você pode seguir este tutorial com um arquivo de código Python (.py) e obter resultados semelhantes, mas você precisa adicionar todos os blocos de código neste tutorial ao arquivo .py e executar uma vez para ver os resultados. Em outras palavras, o Jupyter Notebooks fornece resultados intermediários à medida que você executa células, mas esse não é o comportamento que você deve esperar ao trabalhar em um arquivo de código Python.

Importante

Se você quiser acompanhar em um bloco de anotações do Jupyter concluído, baixe o arquivo de anotações do Jupyter chamado semanticcache.ipynb e salve-o na nova pasta semanticcache.

Pré-requisitos

Criar uma instância de Cache do Azure para Redis

Siga o guia Início Rápido: criar um cache Redis Enterprise. Na página Avançado, adicione o módulo RediSearch e escolha a Política de Cluster do Enterprise. Todas as outras configurações podem corresponder ao padrão descrito no início rápido.

O cache leva alguns minutos para ser criado. Você pode passar para a próxima etapa enquanto isso.

Captura de tela que mostra a guia Informações básicas da camada Enterprise preenchida.

Configurar seu ambiente de desenvolvimento

  1. Crie uma pasta no seu computador local chamada semanticcache no local em que você normalmente salva seus projetos.

  2. Crie um novo arquivo Python (tutorial.py) ou notebook do Jupyter (tutorial.ipynb) na pasta.

  3. Instale os pacotes necessários do Python:

    pip install openai langchain redis tiktoken

Implantar os modelos do OpenAI do Azure

Verifique se você tem dois modelos implantados no recurso do OpenAI do Azure:

  • Uma LLM que fornece respostas de texto. Usamos o modelo GPT-3.5-turbo-instruct para este tutorial.

  • Um modelo de inserção que converte consultas em vetores para permitir que elas sejam comparadas às consultas passadas. Usar o modelo text-embedding-ada-002 (Versão 2) para este tutorial.

Consulte Implantar um modelo para obter instruções mais detalhadas. Registre o nome que você escolheu para cada implantação de modelo.

Importar as bibliotecas e configurar as informações de conexão

Para efetuar uma chamada com êxito no Serviço OpenAI do Azure, um ponto de extremidade e uma chave serão necessários. Você também precisa de um ponto de extremidade e uma chave para se conectar ao Cache do Azure para Redis.

  1. Acesse o recurso do Azure OpenAI no portal do Azure.

  2. O Ponto de extremidade e as Chaves na seção Gerenciamento de Recursos do seu recurso do OpenAI do Azure. Copie seu ponto de extremidade e a chave de acesso, pois você precisa de ambos para autenticar suas chamadas à API. Um ponto de extremidade de exemplo é: https://docs-test-001.openai.azure.com. Você pode usar KEY1 ou KEY2.

  3. Acesse a página Visão geral do recurso Cache do Azure para Redis no portal do Azure. Consultar seu ponto de extremidade.

  4. Clique em Chaves de acesso na seção Configurações. Copie sua chave de acesso. Você pode usar Primary ou Secondary.

  5. Adicione o seguinte código a uma nova célula de código:

       # 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. Atualize o valor de API_KEY e RESOURCE_ENDPOINT com os valores de chave e ponto de extremidade da implantação do Azure OpenAI.

  7. Defina LLM_DEPLOYMENT_NAME e EMBEDDINGS_DEPLOYMENT_NAME com o nome dos seus dois modelos implantados no Serviço OpenAI do Azure.

  8. Atualize REDIS_ENDPOINT e REDIS_PASSWORD com o ponto de extremidade e o valor da chave da sua instância de Cache do Azure para Redis.

    Importante

    É altamente recomendável usar variáveis ambientais ou um gerente de segredos como o Azure Key Vault para passar as informações de chave de API, ponto de extremidade e nome de implantação. Essas variáveis são definidas em texto sem formatação aqui para simplificar.

  9. Execute a célula de código 2.

Inicialize os modelos de IA

Em seguida, inicialize os modelos LLM e de inserção

  1. Adicione o seguinte código a uma nova célula de código:

       # 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. Execute a célula de código 3.

Configure o Redis como um cache semântico

Na sequência, especifique o Redis como um cache semântico para sua LLM.

  1. Adicione o seguinte código a uma nova célula de código:

       # Code cell 4

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

    Importante

    O valor do parâmetro score_threshold determina a semelhança entre duas consultas para retornar um resultado em cache. Quanto menor o número, mais semelhantes as consultas precisam ser. Você pode brincar com esse valor para ajustá-lo ao seu aplicativo.

  2. Execute a célula de código 4.

Consulte e obtenha respostas da LLM

Por fim, consulte a LLM para obter uma resposta gerada por IA. Se você estiver usando um bloco de anotações do Jupyter, poderá adicionar %%time na parte superior da célula para gerar o tempo necessário para executar o código.

  1. Adicione o seguinte código a uma nova célula de código:

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

    Você deverá ver uma saída semelhante a esta:

    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

    O Wall time mostra um valor de 2,67 segundos. Esse é o tempo real necessário para consultar o LLM e para que o LLM gere uma resposta.

  2. Reexecute a célula 5. Você deve ver exatamente a mesma saída, mas com um tempo de parede menor:

    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

    O tempo de parede parece ser reduzido em um fator de cinco - até 575 milissegundos.

  3. Altere a consulta de Please write a poem about cute kittens para Write a poem about cute kittens e reexecute a célula 5. Você deve consultar o exatamente a mesma saída e um tempo de parede menor do que a consulta original. Mesmo que a consulta tenha sido alterada, o significado semântico da consulta permaneceu o mesmo para que a mesma saída armazenada em cache fosse retornada. Essa é a vantagem do cache semântico!

Alterar o limite de similaridade

  1. Tente executar uma consulta semelhante com um significado diferente, como Please write a poem about cute puppies. Observe que o resultado em cache também é retornado aqui. O significado semântico da palavra puppies é próximo o suficiente da palavra kittens que o resultado armazenado em cache é retornado.

  2. O limite de similaridade pode ser modificado para determinar quando o cache semântico deve retornar um resultado armazenado em cache e quando ele deve retornar uma nova saída do LLM. Na célula de código 4, altere score_threshold de 0.05 para 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. Tente a consulta Please write a poem about cute puppies novamente. Você deve receber uma nova saída específica para filhotes:

    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

    É provável que você precise ajustar o limite de similaridade com base no seu aplicativo para garantir que a sensibilidade correta seja usada ao determinar quais consultas devem ser armazenadas em cache.

Limpar os recursos

Se quiser continuar a usar os recursos que você criou neste artigo, conserve o grupo de recursos.

Caso contrário, se não pretende mais usar os recursos, você poderá excluir o grupo de recursos criado no Azure para evitar a cobrança.

Importante

A exclusão de um grupo de recursos é irreversível. Ao excluir o grupo de recursos, todos os recursos nele são excluídos permanentemente. Não exclua acidentalmente o grupo de recursos ou os recursos incorretos. Se você criou os recursos dentro de um grupo de recursos existente que contém recursos que você quer manter, você pode excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para excluir um grupo de recursos

  1. Entre no portal do Azure e selecione Grupos de recursos.

  2. Selecione o grupo de recursos que você quer excluir.

    Se existirem muitos grupos de recursos, use a caixa Filtrar para qualquer campo... e digite o nome do seu grupo de recursos que você criou para este artigo. Selecione o grupo de recursos na lista de resultados.

    Captura de tela mostrando uma lista dos grupos de recursos a serem excluídos no painel de trabalho.

  3. Selecione Excluir grupo de recursos.

  4. Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Digite o nome do grupo de recursos para confirmar e selecione Excluir.

    Captura de tela mostrando um formulário que requer que a exclusão do nome do recurso seja confirmada.

Após alguns instantes, o grupo de recursos, e todos os recursos nele são excluídos.

Conteúdo relacionado