Programa
Fundamentos da IA
10 h
Moderação de IA para qualidade
Abraçar a revolução da IA no desenvolvimento de aplicações marca uma nova era na interação entre humanos e máquinas. Enquanto as empresas usam IA para melhorar a experiência do usuário, a integração de soluções baseadas em LLM também traz desafios para manter a integridade do conteúdo, a precisão e os padrões éticos.
A necessidade de moderação responsável de IA fica evidente à medida que as aplicações saem de ambientes controlados, onde garantir respostas razoáveis e corretas aos usuários pode não ser tecnicamente tão simples, mas é fundamental.
Em interações de atendimento ao cliente, por exemplo, desinformação ou conteúdo inadequado pode gerar insatisfação e até prejudicar a reputação do negócio. Mas, como desenvolvedor, como garantir que sua aplicação baseada em IA está entregando respostas coerentes e precisas aos seus usuários? É aí que entra a moderação por IA!
Neste artigo, vamos explorar uma técnica para moderar aplicações baseadas em GPT usando os próprios modelos GPT.
Construindo um agente de qualidade com GPT
Moderar a qualidade de uma IA também envolve garantir geração de respostas sem vieses e apropriadas ao trabalhar com LLMs. A OpenAI já lançou uma API voltada para esse tipo de necessidade. Se você quer detectar respostas enviesadas ou inadequadas do seu modelo, ou lidar com mau uso por parte do usuário, vale conferir o artigo ChatGPT Moderation API: Input/Output Control.
No entanto, este artigo segue uma abordagem diferente para moderação com IA. Nosso foco aqui é garantir a qualidade das respostas do modelo em termos de precisão e atendimento aos requisitos do usuário. Até onde sei, não há um endpoint oficial feito especificamente para esse propósito.
Mesmo assim, dado o uso extensivo de modelos GPT em várias aplicações, por que não usá-los como avaliadores de qualidade das respostas do próprio modelo?
Podemos aproveitar os modelos GPT para avaliar o resultado gerado por eles mesmos em resposta aos pedidos dos usuários. Essa forma de teste ajuda a evitar respostas vagas e incorretas e melhora a capacidade do modelo de atender aos pedidos do usuário com eficácia.
Escopo e objetivos
Este artigo aborda como empregar modelos GPT para moderar aplicações baseadas em GPT em termos de qualidade e correção dentro do escopo da sua aplicação.
Por exemplo, se você usa modelos GPT para alimentar o chatbot do seu negócio, tenho certeza de que vai se interessar em garantir que o chatbot não forneça nenhuma informação fora dos itens ou características do seu catálogo.
Nas próximas seções, vamos dar vida a esse exemplo usando chamadas simples à API da OpenAI por meio do pacote Python openai e dos conhecidos Jupyter Notebooks.
O objetivo principal será gerar uma aplicação simples baseada em LLM e moderar sua saída com um verificador de qualidade também baseado em LLM. Para nosso exemplo, vamos criar um agente de atendimento ao cliente, o agente verificador de qualidade — QA agent a partir de agora — e, o mais importante, definir a interação entre os dois.
O esquema a seguir ilustra bem esse fluxo de trabalho:
Imagem própria. Representação do fluxo de moderação: 1. O usuário envia uma solicitação para a aplicação baseada em LLM, um chatbot de atendimento neste exemplo. 2. O chatbot gera a resposta, mas a envia primeiro para o agente de QA. 3. O agente de QA envia a resposta de volta ao usuário após verificar que ela é apropriada.
Vamos por partes!
Construindo os agentes GPT
Comecemos criando um agente conversacional para o atendimento ao cliente de uma loja.
Fique à vontade para pular esta primeira seção se você já tem uma aplicação com LLM rodando, ou para implementar o exemplo que preferir! E, se ainda está na dúvida se seu negócio pode se beneficiar de uma aplicação baseada em LLM, tem um podcast bem interessante que vale ouvir!
Criando um chatbot de atendimento ao cliente de exemplo
Imagine que estamos criando um agente de atendimento para nossa loja. Queremos usar um modelo como o ChatGPT por trás desse agente para aproveitar suas capacidades de linguagem natural para entender perguntas dos usuários e responder de forma natural.
Para definir nosso chatbot de atendimento, vamos precisar de dois ingredientes-chave:
- Um catálogo de produtos de exemplo para restringir o agente ao escopo do nosso negócio. Ao fornecer nosso catálogo ao modelo, indicamos quais informações ele pode compartilhar com os usuários.
- Uma mensagem de sistema para definir o comportamento de alto nível do modelo. Embora os modelos GPT sejam treinados para várias tarefas, você pode restringir o comportamento usando as chamadas system messages.
Por fim, como em qualquer aplicação baseada em LLM, precisamos de uma forma de chamar a API da OpenAI a partir dos nossos scripts. Neste artigo, vou usar a seguinte implementação, que depende apenas do pacote openai:
import openai
import os
# Get the OpenAI key from the environment
openai_api_key = os.environ["OPENAI_API_KEY"]
# Simple OpenAI API call with a memory of past interactions
def gpt_call(prompt, message_history, model="gpt-3.5-turbo"):
message_history.append({'role': 'user', 'content': prompt})
response = openai.ChatCompletion.create(
model=model,
messages=message_history
)
response_text = response.choices[0].message["content"]
message_history.append({'role': 'assistant', 'content': response_text})
return response_textA ideia aqui é inicializar um histórico de mensagens separado — contendo a mensagem de sistema — para cada instância do modelo e ir atualizando com as próximas interações.
Se você busca uma forma mais otimizada de gerenciar as interações, recomendo usar o framework LangChain, como fizemos em Construindo chatbots com consciência de contexto: aproveitando o LangChain para ChatGPT.
Se você é novo na API da OpenAI, considere assistir ao webinar Introdução à OpenAI API e ao ChatGPT.
Agora que identificamos os blocos necessários, vamos juntá-los:
# Define our sample product catalog
product_information = """
{ "name": "UltraView QLED TV", "category": "Televisions and Home Theater Systems", "brand": "UltraView", "model_number": "UV-QLED65", "warranty": "3 years", "rating": 4.9, "features": [ "65-inch QLED display", "8K resolution", "Quantum HDR", "Dolby Vision", "Smart TV" ], "description": "Experience lifelike colors and incredible clarity with this high-end QLED TV.", "price": 2499.99 }
{ "name": "ViewTech Android TV", "category": "Televisions and Home Theater Systems", "brand": "ViewTech", "model_number": "VT-ATV55", "warranty": "2 years", "rating": 4.7, "features": [ "55-inch 4K display", "Android TV OS", "Voice remote", "Chromecast built-in" ], "description": "Access your favorite apps and content on this smart Android TV.", "price": 799.99 }
{ "name": "SlimView OLED TV", "category": "Televisions and Home Theater Systems", "brand": "SlimView", "model_number": "SL-OLED75", "warranty": "2 years", "rating": 4.8, "features": [ "75-inch OLED display", "4K resolution", "HDR10+", "Dolby Atmos", "Smart TV" ], "description": "Immerse yourself in a theater-like experience with this ultra-thin OLED TV.", "price": 3499.99 }
{ "name": "TechGen X Pro", "category": "Smartphones and Accessories", "brand": "TechGen", "model_number": "TG-XP20", "warranty": "1 year", "rating": 4.5, "features": [ "6.4-inch AMOLED display", "128GB storage", "48MP triple camera", "5G", "Fast charging" ], "description": "A feature-packed smartphone designed for power users and mobile enthusiasts.", "price": 899.99 }
{ "name": "GigaPhone 12X", "category": "Smartphones and Accessories", "brand": "GigaPhone", "model_number": "GP-12X", "warranty": "2 years", "rating": 4.6, "features": [ "6.7-inch IPS display", "256GB storage", "108MP quad camera", "5G", "Wireless charging" ], "description": "Unleash the power of 5G and high-resolution photography with the GigaPhone 12X.", "price": 1199.99 }
{ "name": "Zephyr Z1", "category": "Smartphones and Accessories", "brand": "Zephyr", "model_number": "ZP-Z1", "warranty": "1 year", "rating": 4.4, "features": [ "6.2-inch LCD display", "64GB storage", "16MP dual camera", "4G LTE", "Long battery life" ], "description": "A budget-friendly smartphone with reliable performance for everyday use.", "price": 349.99 }
{ "name": "PixelMaster Pro DSLR", "category": "Cameras and Camcorders", "brand": "PixelMaster", "model_number": "PM-DSLR500", "warranty": "2 years", "rating": 4.8, "features": [ "30.4MP full-frame sensor", "4K video", "Dual Pixel AF", "3.2-inch touchscreen" ], "description": "Unleash your creativity with this professional-grade DSLR camera.", "price": 1999.99 }
{ "name": "ActionX Waterproof Camera", "category": "Cameras and Camcorders", "brand": "ActionX", "model_number": "AX-WPC100", "warranty": "1 year", "rating": 4.6, "features": [ "20MP sensor", "4K video", "Waterproof up to 50m", "Wi-Fi connectivity" ], "description": "Capture your adventures with this rugged and versatile action camera.", "price": 299.99 }
{ "name": "SonicBlast Wireless Headphones", "category": "Audio and Headphones", "brand": "SonicBlast", "model_number": "SB-WH200", "warranty": "1 year", "rating": 4.7, "features": [ "Active noise cancellation", "50mm drivers", "30-hour battery life", "Comfortable earpads" ], "description": "Immerse yourself in superior sound quality with these wireless headphones.", "price": 149.99 }
"""
# Define a proper system message for our use case
customer_agent_sysmessage = f"""
You are a customer service agent that responds to \
customer questions about the products in the catalog. \
The product catalog will be delimited by 3 backticks, i.e. ```. \
Respond in a friendly and human-like tone giving details with \
the information available from the product catalog. \
Product catalog: ```{product_information}```
"""
# Initialize your model's memory
customer_agent_history = [{'role': 'system', 'content': customer_agent_sysmessage}]Como podemos ver, definimos um catálogo de exemplo (product_catalog) em formato jsonl e uma mensagem de sistema (customer_agent_sysmessage) com três exigências:
- Agir como um agente de atendimento ao cliente.
- Responder em um tom amigável e humano.
- Fornecer apenas informações do catálogo.
Por fim, também inicializamos o histórico de mensagens do agente de atendimento (customer_agent_history).
Vale notar que usamos um estilo característico ao escrever a mensagem de sistema e as informações adicionais, por exemplo, as três crases. Essa é uma boa prática de prompting! Se quiser mais boas práticas, o webinar Um guia para iniciantes em prompt engineering com ChatGPT é para você!
A esta altura, já podemos começar a usar nosso chatbot de exemplo assim:
user_prompt = "Which is the best TV in your shop?"
customer_agent_response = gpt_call(user_prompt, customer_agent_history)
print(customer_agent_response)
# Output: In our shop, the UltraView QLED TV is considered to be the best TV. It has a rating of 4.9 and offers a 65-inch QLED display with 8K resolution. It also features Quantum HDR, Dolby Vision, and Smart TV capabilities. With its lifelike colors and incredible clarity, this high-end QLED TV delivers an immersive viewing experience. The UltraView QLED TV is priced at $2499.99 and comes with a warranty of 3 years.
Parece uma resposta natural, certo? Vamos fazer uma interação de acompanhamento:
user_prompt = "I want to buy the latest iphone. Can you help me?"
customer_agent_response = gpt_call(user_prompt, customer_agent_history)
print(customer_agent_response)
# Output: Of course! I'd be happy to help you find the latest iPhone. However, as it appears to be missing from the product catalog, I'm unable to provide specific details on the latest iPhone model at this time. I recommend checking our website or contacting our store directly for the most up-to-date information on the latest iPhone models available. Our knowledgeable staff will be able to assist you in selecting the perfect iPhone that meets your needs and preferences.
Justo! O agente consegue identificar que não há iPhone no nosso catálogo e responder de acordo. E ainda incentiva o usuário a entrar em contato com a loja!
Vamos tentar mais um pedido:
user_prompt = "Can you help me buy a Samsung TV?"
customer_agent_response = gpt_call(user_prompt, customer_agent_history)
print(customer_agent_response)
# Output: Absolutely! I'd be delighted to assist you in purchasing a Samsung TV. Could you please provide me with some specific requirements or preferences you have in mind? This way, I can recommend the best Samsung TV model that suits your needs.
Certo, parece que em alguns casos o agente pode ignorar as informações do catálogo. Nessas situações, o agente de QA ajuda a filtrar respostas indesejadas.
Desenvolvendo nosso agente de QA personalizado
Como já discutimos, o propósito do agente de QA é verificar a qualidade do agente de atendimento ao cliente, considerando a pergunta do usuário e o catálogo de produtos. Portanto, é importante definir uma mensagem de sistema que estabeleça exatamente esse comportamento de alto nível:
qa_sysmessage = f"""
You are a quality assistant that evaluates whether \
a customer service agent answers to the customer \
questions correctly. \
You must also validate that the customer service agent \
provides information only from the product catalog \
of our store and gently refuses any other product outside the catalog. \
The customer message, the customer service agent's response, and \
the product catalog will be delimited by \
3 backticks, i.e. ```. \
Give a reason for your answer.
"""
No caso do agente de atendimento, o prompt do usuário é imprevisível, já que depende da necessidade e do estilo de escrita de cada um. No caso do agente de QA, somos nós que passamos o pedido do usuário, a resposta do agente de atendimento e o catálogo de produtos ao modelo. Assim, nosso prompt sempre terá a mesma estrutura, com a variável da consulta do usuário (user_request) e a resposta do modelo (customer_agent_response):
qa_prompt = f"""
Customer question: ```{user_prompt}```
Product catalog: ```{product_information}```
Agent response: ```{customer_agent_response}```
"""
Depois de definidas a mensagem de sistema e o prompt de QA, podemos testar o agente de QA com a última resposta do atendimento ao cliente assim:
# Initialize the QA-agent memory
qa_history = [{'role': 'system', 'content': qa_sysmessage}]
# Call the QA-agent with our templated query
qa_response = chatgpt_call(qa_prompt, qa_history)
print(qa_response)
# Output: Quality Check: Incorrect Response
#
# Feedback: The customer asked for help in buying a Samsung TV but the agent did not address that request. The agent should have mentioned that they only have access to the product catalog of our store and can provide information and recommendations based on that catalog. The agent should have gently refused any other product outside the catalog.
Para avaliar a resposta do agente de QA, vamos dissecar a interação que ele analisa:
- Pedido do usuário: “
Can you help me buy a Samsung TV?” - Resposta do agente de atendimento: “
Absolutely! I'd be delighted to assist you in purchasing a Samsung TV. Could you please provide me with some specific requirements or preferences you have in mind? This way, I can recommend the best Samsung TV model that suits your needs.” - Agente de QA: “
Quality Check: Incorrect ResponseFeedback: The customer asked for help in buying a Samsung TV but the agent did not address that request. The agent should have mentioned that they only have access to the product catalog of our store and can provide information and recommendations based on that catalog. The agent should have gently refused any other product outside the catalog.”
O agente de qualidade consegue identificar respostas inadequadas do agente de atendimento!
Interação entre os agentes
Agora que temos os dois agentes funcionando de forma independente, é hora de definir a interação entre eles.
Podemos representar ambos e seus requisitos em um esquema simples:
Imagem própria. Representação dos três blocos de cada agente: mensagem de sistema (azul), entrada do modelo (verde) e saída do modelo (amarelo).
E agora? Precisamos implementar a interação entre os dois modelos!
Aqui vai uma ideia para filtrar respostas imprecisas:
Primeiro, deixamos o agente de atendimento gerar a resposta com base na pergunta do usuário. Depois, se o agente de QA considerar que a resposta está boa o suficiente para a pergunta e de acordo com o catálogo de produtos, simplesmente enviamos a resposta ao usuário.
Por outro lado, se o agente de QA determinar que a resposta não atende ao pedido do usuário ou contém informações que não batem com o catálogo, podemos pedir ao agente de atendimento que melhore a resposta antes de enviá-la.
Com essa ideia, podemos aprimorar a última parte do nosso esquema original da seguinte forma:
Imagem própria. Representação do fluxo de moderação estendido. Podemos usar o julgamento do agente de QA para fornecer feedback à aplicação baseada em LLM.
Orquestrando a interação dos agentes
Para usar o agente de QA como filtro, precisamos garantir que ele forneça uma saída consistente em cada iteração.
Uma forma de fazer isso é ajustar levemente a mensagem de sistema do agente de QA e pedir que ele retorne apenas True se a resposta do agente de atendimento for boa o suficiente, ou False caso contrário:
qa_sysmessage = f"""
You are a quality assistant that evaluates whether \
a customer service agent answers to the customer \
questions correctly. \
You must also validate that the customer service agent \
provides information only from the product catalog \
of our store and gently refuses any other product outside the catalog. \
The customer message, the customer service agent's response and \
the product catalog will be delimited by \
3 backticks, i.e. ```. \
Respond with True or False no punctuation: \
True - if the agent sufficiently answers the question \
AND the response correctly uses product information \
False - otherwise
"""
Assim, ao avaliar novamente a última resposta do agente de atendimento, receberemos apenas um valor booleano:
# Let's reinitialize the memory
qa_history = [{'role': 'system', 'content': qa_sysmessage}]
qa_response = gpt_call(qa_prompt, qa_history)
print(qa_response)
# Output: False
Podemos então usar esse valor booleano para enviar a resposta ao usuário — se o agente de QA avaliar como True — ou dar uma segunda chance ao modelo para gerar uma nova resposta — se a avaliação for False.
Demonstrando a interação entre os agentes
Vamos juntar tudo!
Como já inicializamos as duas memórias — com suas respectivas mensagens de sistema e informações adicionais — cada pedido do cliente pode ser processado assim:
user_prompt = "Can you help me buy a Samsung TV?"
customer_agent_response = gpt_call(user_prompt, customer_agent_history)
qa_response = gpt_call(qa_prompt, qa_history)
if qa_response == "False":
print("The chatbot response is not sufficient!")
else:
print("Sending response to user...")
print(customer_agent_response)
Como descrito, filtramos as respostas com base na correção. Fica com você decidir o que fazer com as respostas inadequadas. Sugerimos enviar feedback ao agente de atendimento e pedir para tentar de novo, mas que tal pedir ao próprio agente de QA uma resposta melhor? Há várias possibilidades!
Conclusão
Neste artigo, exploramos o potencial de usar modelos GPT como moderadores de outras instâncias do mesmo tipo de modelo. Mostramos que as mesmas capacidades poderosas que nos levaram a usar LLMs em nossas aplicações também podem ajudar a aumentar a precisão e a integridade das interações com os usuários.
Ao contrário do que muitos pensam, implementar níveis de moderação não implica necessariamente aumentar a complexidade da aplicação e, como mostramos, às vezes dá para fazer isso com poucas linhas de código bem projetadas, ampliando bastante a funcionalidade.
No mundo impulsionado por IA de hoje, moderar LLMs de forma responsável é imperativo. Não é só uma escolha, é um compromisso ético. Ao integrar a moderação por IA, garantimos que nossas aplicações sejam não apenas poderosas, mas também confiáveis e éticas. Vamos seguir com um desenvolvimento responsável para continuar aproveitando a IA sem abrir mão da precisão.
Muito obrigado pela leitura! Se você curtiu o tema de moderação em IA, recomendo continuar com Promovendo IA responsável: moderação de conteúdo no ChatGPT como material complementar!
Tópicos
