Moderação de conteúdo

A moderação de conteúdo é um aspecto crítico para manter um ambiente seguro, respeitoso e produtivo em aplicações digitais. Neste guia, discutiremos como o Claude pode ser usado para moderar conteúdo dentro da sua aplicação digital.

Visite nosso cookbook de moderação de conteúdo para ver um exemplo de implementação de moderação de conteúdo usando o Claude.

Este guia é focado na moderação de conteúdo gerado por usuários dentro da sua aplicação. Se você está procurando orientação sobre como moderar interações com o Claude, consulte nosso guia de proteções.

Antes de construir com o Claude

Decida se deve usar o Claude para moderação de conteúdo

Aqui estão alguns indicadores-chave de que você deve usar um LLM como o Claude em vez de uma abordagem tradicional de ML ou baseada em regras para moderação de conteúdo:

Você quer uma implementação rápida e econômica

Métodos tradicionais de ML requerem recursos significativos de engenharia, expertise em ML e custos de infraestrutura. Sistemas de moderação humana incorrem em custos ainda maiores. Com o Claude, você pode ter um sistema sofisticado de moderação funcionando em uma fração do tempo por uma fração do preço.

Você deseja tanto compreensão semântica quanto decisões rápidas

Abordagens tradicionais de ML, como modelos bag-of-words ou correspondência simples de padrões, frequentemente têm dificuldade para entender o tom, a intenção e o contexto do conteúdo. Enquanto sistemas de moderação humana se destacam na compreensão do significado semântico, eles requerem tempo para que o conteúdo seja revisado. O Claude preenche essa lacuna combinando compreensão semântica com a capacidade de entregar decisões de moderação rapidamente.

Você precisa de decisões consistentes de política

Ao aproveitar suas capacidades avançadas de raciocínio, o Claude pode interpretar e aplicar diretrizes complexas de moderação uniformemente. Essa consistência ajuda a garantir o tratamento justo de todo o conteúdo, reduzindo o risco de decisões de moderação inconsistentes ou tendenciosas que podem minar a confiança do usuário.

Suas políticas de moderação provavelmente mudarão ou evoluirão ao longo do tempo

Uma vez que uma abordagem tradicional de ML tenha sido estabelecida, mudá-la é uma tarefa trabalhosa e intensiva em dados. Por outro lado, conforme seu produto ou necessidades do cliente evoluem, o Claude pode facilmente se adaptar a mudanças ou adições nas políticas de moderação sem extensiva rotulagem de dados de treinamento.

Você requer raciocínio interpretável para suas decisões de moderação

Se você deseja fornecer aos usuários ou reguladores explicações claras por trás das decisões de moderação, o Claude pode gerar justificativas detalhadas e coerentes. Essa transparência é importante para construir confiança e garantir responsabilidade nas práticas de moderação de conteúdo.

Você precisa de suporte multilíngue sem manter modelos separados

Abordagens tradicionais de ML tipicamente requerem modelos separados ou processos extensivos de tradução para cada idioma suportado. A moderação humana requer contratar uma força de trabalho fluente em cada idioma suportado. As capacidades multilíngues do Claude permitem classificar tickets em vários idiomas sem a necessidade de modelos separados ou processos extensivos de tradução, simplificando a moderação para bases de clientes globais.

Você requer suporte multimodal

As capacidades multimodais do Claude permitem analisar e interpretar conteúdo em texto e imagens. Isso o torna uma ferramenta versátil para moderação abrangente de conteúdo em ambientes onde diferentes tipos de mídia precisam ser avaliados em conjunto.

A Anthropic treinou todos os modelos Claude para serem honestos, úteis e inofensivos. Isso pode resultar no Claude moderando conteúdo considerado particularmente perigoso (de acordo com nossa Política de Uso Aceitável), independentemente do prompt usado. Por exemplo, um site adulto que deseja permitir que usuários postem conteúdo sexual explícito pode descobrir que o Claude ainda sinaliza conteúdo explícito como necessitando de moderação, mesmo que especifiquem no prompt para não moderar conteúdo sexual explícito. Recomendamos revisar nossa AUP antes de construir uma solução de moderação.

Gere exemplos de conteúdo para moderar

Antes de desenvolver uma solução de moderação de conteúdo, primeiro crie exemplos de conteúdo que deve ser sinalizado e conteúdo que não deve ser sinalizado. Certifique-se de incluir casos extremos e cenários desafiadores que podem ser difíceis para um sistema de moderação de conteúdo lidar efetivamente. Depois, revise seus exemplos para criar uma lista bem definida de categorias de moderação. Por exemplo, os exemplos gerados por uma plataforma de mídia social podem incluir o seguinte:

allowed_user_comments = [
    'Este filme foi ótimo, eu realmente gostei. O ator principal arrasou!',
    'Eu odeio segundas-feiras.',
    'É um ótimo momento para investir em ouro!'
]

disallowed_user_comments = [
    'Delete este post agora ou é melhor você se esconder. Estou indo atrás de você e sua família.',
    'Fique longe dos celulares 5G!! Eles estão usando 5G para controlar você.',
    'Parabéns! Você ganhou um vale-presente de R$ 1.000. Clique aqui para resgatar seu prêmio!'
]

# Comentários de usuários de exemplo para testar a moderação de conteúdo
user_comments = allowed_user_comments + disallowed_user_comments

# Lista de categorias consideradas inseguras para moderação de conteúdo
unsafe_categories = [
    'Exploração Infantil',
    'Teorias da Conspiração',
    'Ódio',
    'Armas Indiscriminadas', 
    'Propriedade Intelectual',
    'Crimes Não Violentos', 
    'Privacidade',
    'Automutilação',
    'Crimes Sexuais',
    'Conteúdo Sexual',
    'Conselhos Especializados',
    'Crimes Violentos'
]

Moderar efetivamente esses exemplos requer uma compreensão nuançada da linguagem. No comentário, Este filme foi ótimo, eu realmente gostei. O ator principal arrasou!, o sistema de moderação de conteúdo precisa reconhecer que “arrasou” é uma metáfora, não uma indicação de violência real. Por outro lado, apesar da falta de menções explícitas à violência, o comentário Delete este post agora ou é melhor você se esconder. Estou indo atrás de você e sua família. deve ser sinalizado pelo sistema de moderação de conteúdo.

A lista unsafe_categories pode ser personalizada para atender às suas necessidades específicas. Por exemplo, se você deseja impedir que menores criem conteúdo em seu site, você poderia adicionar “Postagem de Menor” à lista.

---

Como moderar conteúdo usando o Claude

Selecione o modelo Claude correto

Ao selecionar um modelo, é importante considerar o tamanho dos seus dados. Se os custos são uma preocupação, um modelo menor como o Claude 3 Haiku é uma excelente escolha devido à sua relação custo-benefício. Abaixo está uma estimativa do custo para moderar texto para uma plataforma de mídia social que recebe um bilhão de posts por mês:

• Tamanho do conteúdo

  • Posts por mês: 1bn
  • Caracteres por post: 100
  • Total de caracteres: 100bn

• Tokens estimados

  • Tokens de entrada: 28,6bn (assumindo 1 token por 3,5 caracteres)
  • Porcentagem de mensagens sinalizadas: 3%
  • Tokens de saída por mensagem sinalizada: 50
  • Total de tokens de saída: 1,5bn

• Custo estimado do Claude 3 Haiku

  • Custo de tokens de entrada: 2.860 MTok * $0,25/MTok =$715
  • Custo de tokens de saída: 1.500 MTok * $1,25/MTok =$1.875
  • Custo mensal: $715 +$1.875 = $2.590

• Custo estimado do Claude 3.7 Sonnet

  • Custo de tokens de entrada: 2.860 MTok * $3,00/MTok =$8.580
  • Custo de tokens de saída: 1.500 MTok * $15,00/MTok =$22.500
  • Custo mensal: $8.580 +$22.500 = $31.080

Os custos reais podem diferir dessas estimativas. Essas estimativas são baseadas no prompt destacado na seção sobre processamento em lote. Os tokens de saída podem ser reduzidos ainda mais removendo o campo explanation da resposta.

Construa um prompt forte

Para usar o Claude para moderação de conteúdo, o Claude deve entender os requisitos de moderação da sua aplicação. Vamos começar escrevendo um prompt que permite definir suas necessidades de moderação:

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

def moderate_message(message, unsafe_categories):
    # Converte a lista de categorias inseguras em uma string, com cada categoria em uma nova linha
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Constrói o prompt para o Claude, incluindo a mensagem e categorias inseguras
    assessment_prompt = f"""
    Determine se a seguinte mensagem requer moderação, 
    com base nas categorias inseguras descritas abaixo.
    
    Mensagem:
    <message>{message}</message>

    Categorias Inseguras:
    <categories>
    {unsafe_category_str}
    </categories>

    Responda APENAS com um objeto JSON, usando o formato abaixo:
    {{
    "violation": <Campo booleano indicando se a mensagem deve ser moderada>,
    "categories": [Lista separada por vírgulas das categorias violadas],
    "explanation": [Opcional. Incluir apenas se houver uma violação.]
    }}"""

    # Envia a requisição ao Claude para moderação de conteúdo
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    
    # Extrai o status de violação da avaliação
    contains_violation = assessment['violation']
    
    # Se houver uma violação, obtém as categorias e explicação; caso contrário, usa padrões vazios
    violated_categories = assessment.get('categories', []) if contains_violation else []
    explanation = assessment.get('explanation') if contains_violation else None
    
    return contains_violation, violated_categories, explanation

# Processa cada comentário e imprime os resultados
for comment in user_comments:
    print(f"\nComentário: {comment}")
    violation, violated_categories, explanation = moderate_message(comment, unsafe_categories)
    
    if violation:
        print(f"Categorias Violadas: {', '.join(violated_categories)}")
        print(f"Explicação: {explanation}")
    else:
        print("Nenhum problema detectado.")

Neste exemplo, a função moderate_message contém um prompt de avaliação que inclui as categorias de conteúdo inseguro e a mensagem que desejamos avaliar. O prompt pede ao Claude para avaliar se a mensagem deve ser moderada, com base nas categorias inseguras que definimos.

A avaliação do modelo é então analisada para determinar se há uma violação. Se houver uma violação, o Claude também retorna uma lista de categorias violadas, bem como uma explicação sobre por que a mensagem é insegura.

Avalie seu prompt

Moderação de conteúdo é um problema de classificação. Assim, você pode usar as mesmas técnicas descritas em nosso cookbook de classificação para determinar a precisão do seu sistema de moderação de conteúdo.

Uma consideração adicional é que, em vez de tratar a moderação de conteúdo como um problema de classificação binária, você pode criar múltiplas categorias para representar vários níveis de risco. Criar múltiplos níveis de risco permite ajustar a agressividade da sua moderação. Por exemplo, você pode querer bloquear automaticamente consultas de usuários consideradas de alto risco, enquanto usuários com muitas consultas de risco médio são sinalizados para revisão humana.

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

def assess_risk_level(message, unsafe_categories):
    # Converte a lista de categorias inseguras em uma string, com cada categoria em uma nova linha
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Constrói o prompt para o Claude, incluindo a mensagem, categorias inseguras e definições de nível de risco
    assessment_prompt = f"""
    Avalie o nível de risco da seguinte mensagem requer moderação, 
    com base nas categorias inseguras listadas abaixo.
    
Mensagem:
<message>{message}</message>

Categorias Inseguras:
<categories>
{unsafe_category_str}
</categories>

Atribua um nível de risco com base em sua confiança de que a mensagem do usuário deve ser moderada 
com base nas categorias inseguras definidas:

0 - Sem risco
1 - Baixo risco
2 - Risco médio
3 - Alto risco

Responda APENAS com um objeto JSON, usando o formato abaixo:
{{
  "risk_level": <Campo numérico indicando o nível de risco>,
  "categories": [Lista separada por vírgulas das categorias violadas],
  "explanation": <Opcional. Incluir apenas se o nível de risco for maior que 0>
}}"""

    # Envia a requisição ao Claude para avaliação de risco
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    
    # Extrai o nível de risco, categorias violadas e explicação da avaliação
    risk_level = assessment["risk_level"]
    violated_categories = assessment["categories"]
    explanation = assessment.get("explanation")
    
    return risk_level, violated_categories, explanation

# Processa cada comentário e imprime os resultados
for comment in user_comments:
    print(f"\nComentário: {comment}")
    risk_level, violated_categories, explanation = assess_risk_level(comment, unsafe_categories)
    
    print(f"Nível de Risco: {risk_level}")
    if violated_categories:
        print(f"Categorias Violadas: {', '.join(violated_categories)}")
    if explanation:
        print(f"Explicação: {explanation}")

Este código implementa uma função assess_risk_level que usa o Claude para avaliar o nível de risco de uma mensagem. A função aceita uma mensagem e uma lista de categorias inseguras como entradas.

Dentro da função, um prompt é gerado para o Claude, incluindo a mensagem a ser avaliada, as categorias inseguras e instruções específicas para avaliar o nível de risco. O prompt instrui o Claude a responder com um objeto JSON que inclui o nível de risco, as categorias violadas e uma explicação opcional.

Esta abordagem permite moderação de conteúdo flexível atribuindo níveis de risco. Ela pode ser perfeitamente integrada a um sistema maior para automatizar a filtragem de conteúdo ou sinalizar comentários para revisão humana com base em seu nível de risco avaliado. Por exemplo, ao executar este código, o comentário Delete este post agora ou é melhor você se esconder. Estou indo atrás de você e sua família. é identificado como alto risco devido à sua ameaça perigosa. Por outro lado, o comentário Fique longe dos celulares 5G!! Eles estão usando 5G para controlar você. é categorizado como risco médio.

Implante seu prompt

Uma vez que você esteja confiante na qualidade da sua solução, é hora de implantá-la em produção. Aqui estão algumas melhores práticas a seguir ao usar moderação de conteúdo em produção:

1. Forneça feedback claro aos usuários: Quando a entrada do usuário é bloqueada ou uma resposta é sinalizada devido à moderação de conteúdo, forneça feedback informativo e construtivo para ajudar os usuários a entender por que sua mensagem foi sinalizada e como eles podem reformulá-la apropriadamente. Nos exemplos de código acima, isso é feito através da tag explanation na resposta do Claude.

2. Analise o conteúdo moderado: Mantenha um registro dos tipos de conteúdo sendo sinalizados pelo seu sistema de moderação para identificar tendências e potenciais áreas para melhoria.

3. Avalie e melhore continuamente: Avalie regularmente o desempenho do seu sistema de moderação de conteúdo usando métricas como rastreamento de precisão e recall. Use esses dados para refinar iterativamente seus prompts de moderação, palavras-chave e critérios de avaliação.

---

Melhore o desempenho

Em cenários complexos, pode ser útil considerar estratégias adicionais para melhorar o desempenho além das técnicas padrão de engenharia de prompt. Aqui estão algumas estratégias avançadas:

Defina tópicos e forneça exemplos

Além de listar as categorias inseguras no prompt, outras melhorias podem ser feitas fornecendo definições e frases relacionadas a cada categoria.

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

# Dicionário de categorias consideradas inseguras para moderação de conteúdo, com suas definições
unsafe_category_definitions = {
    'Exploração Infantil': 'Conteúdo que retrata nudez infantil ou que permite, encoraja, desculpa ou retrata o abuso sexual de crianças.',
    'Teorias da Conspiração': """Conteúdo que promove ou endossa teorias infundadas, falsas ou enganosas sobre eventos, situações ou indivíduos, 
        que podem incitar danos ou minar a confiança pública em instituições ou fatos.""",
    'Ódio': """Conteúdo que é odioso em relação a pessoas com base em suas características protegidas 
        (raça, cor, etnia, origem nacional, deficiência, afiliação religiosa, casta, orientação sexual, sexo, identidade de gênero e doença grave), 
        ou conteúdo que perpetua estereótipos negativos.""",
    'Armas Indiscriminadas': 'Conteúdo que permite a criação de armas de destruição em massa.', 
    'Propriedade Intelectual': 'Conteúdo que viola os direitos de propriedade intelectual de terceiros.',
    'Crimes Não Violentos': 'Conteúdo que permite, encoraja ou desculpa a prática de crimes não violentos.', 
    'Privacidade': 'Conteúdo que contém informações sensíveis e pessoais sobre indivíduos privados.',
    'Automutilação': 'Conteúdo que permite, encoraja ou desculpa atos de automutilação intencional.',
    'Crimes Sexuais': 'Conteúdo que permite, encoraja ou desculpa a prática de crimes sexuais.',
    'Conteúdo Sexual': 'Conteúdo que contém descrições eróticas ou representações explícitas de atos sexuais.',
    'Conselhos Especializados': """Conteúdo que contém conselhos financeiros, médicos ou jurídicos. 
        Conselhos financeiros incluem orientação sobre investimentos, ações, títulos ou qualquer planejamento financeiro.""",
    'Crimes Violentos': 'Conteúdo que permite, encoraja ou desculpa a prática de crimes violentos.', 
}


def moderate_message_with_definitions(message, unsafe_category_definitions):
    # Formata string de categorias inseguras, com cada categoria e sua definição em uma nova linha
    unsafe_category_str = '\n'.join(f'{category}: {definition}' 
        for category, definition in unsafe_category_definitions.items()
    )
    
    # Constrói o prompt para o Claude, incluindo a mensagem e categorias inseguras
    assessment_prompt = f"""Determine se a seguinte mensagem requer moderação, com base nas categorias inseguras descritas abaixo.

Mensagem:
<message>{message}</message>

Categorias Inseguras e Suas Definições:
<categories>
{unsafe_category_str}
</categories>

É importante que você l

embre todas as categorias inseguras e suas definições.

Responda APENAS com um objeto JSON, usando o formato abaixo:
{{
  "violation": <Campo booleano indicando se a mensagem deve ser moderada>,
  "categories": [Lista separada por vírgulas das categorias violadas],
  "explanation": [Opcional. Incluir apenas se houver uma violação.]
}}"""

    # Envia a requisição ao Claude para moderação de conteúdo
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    
    # Extrai o status de violação da avaliação
    contains_violation = assessment['violation']
    
    # Se houver uma violação, obtém as categorias e explicação; caso contrário, usa padrões vazios
    violated_categories = assessment.get('categories', []) if contains_violation else []
    explanation = assessment.get('explanation') if contains_violation else None
    
    return contains_violation, violated_categories, explanation


# Processa cada comentário e imprime os resultados
for comment in user_comments:
    print(f"\nComentário: {comment}")
    violation, violated_categories, explanation = moderate_message_with_definitions(comment, unsafe_category_definitions)
    
    if violation:
        print(f"Categorias Violadas: {', '.join(violated_categories)}")
        print(f"Explicação: {explanation}")
    else:
        print("Nenhum problema detectado.")

A função moderate_message_with_definitions expande a função anterior moderate_message permitindo que cada categoria insegura seja pareada com uma definição detalhada. Isso ocorre no código substituindo a lista unsafe_categories da função original por um dicionário unsafe_category_definitions. Este dicionário mapeia cada categoria insegura para sua definição correspondente. Tanto os nomes das categorias quanto suas definições são incluídos no prompt.

Notavelmente, a definição para a categoria Conselhos Especializados agora especifica os tipos de conselhos financeiros que devem ser proibidos. Como resultado, o comentário É um ótimo momento para investir em ouro!, que anteriormente passou pela avaliação moderate_message, agora aciona uma violação.

Considere processamento em lote

Para reduzir custos em situações onde a moderação em tempo real não é necessária, considere moderar mensagens em lotes. Inclua múltiplas mensagens dentro do contexto do prompt e peça ao Claude para avaliar quais mensagens devem ser moderadas.

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

def batch_moderate_messages(messages, unsafe_categories):
    # Converte a lista de categorias inseguras em uma string, com cada categoria em uma nova linha
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Formata string de mensagens, com cada mensagem envolta em tags tipo XML e com um ID
    messages_str = '\n'.join([f'<message id={idx}>{msg}</message>' for idx, msg in enumerate(messages)])
    
    # Constrói o prompt para o Claude, incluindo as mensagens e categorias inseguras
    assessment_prompt = f"""Determine as mensagens a moderar, com base nas categorias inseguras descritas abaixo.

Mensagens:
<messages>
{messages_str}
</messages>

Categorias inseguras e suas definições:
<categories>
{unsafe_category_str}
</categories>

Responda APENAS com um objeto JSON, usando o formato abaixo:
{{
  "violations": [
    {{
      "id": <id da mensagem>,
      "categories": [lista de categorias violadas],
      "explanation": <Explicação do motivo da violação>
    }},
    ...
  ]
}}

Notas Importantes:
- Lembre-se de analisar cada mensagem para uma violação.
- Selecione qualquer número de violações que se apliquem razoavelmente."""

    # Envia a requisição ao Claude para moderação de conteúdo
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=2048,  # Aumentou o número máximo de tokens para lidar com lotes
        temperature=0,    # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    return assessment


# Processa o lote de comentários e obtém a resposta
response_obj = batch_moderate_messages(user_comments, unsafe_categories)

# Imprime os resultados para cada violação detectada
for violation in response_obj['violations']:
    print(f"""Comentário: {user_comments[violation['id']]}
Categorias Violadas: {', '.join(violation['categories'])}
Explicação: {violation['explanation']}
""")

Neste exemplo, a função batch_moderate_messages lida com a moderação de um lote inteiro de mensagens com uma única chamada à API do Claude. Dentro da função, um prompt é criado que inclui a lista de mensagens para avaliar, as categorias de conteúdo inseguro definidas e suas descrições. O prompt direciona o Claude a retornar um objeto JSON listando todas as mensagens que contêm violações. Cada mensagem na resposta é identificada por seu id, que corresponde à posição da mensagem na lista de entrada. Tenha em mente que encontrar o tamanho ideal de lote para suas necessidades específicas pode requerer alguma experimentação. Embora tamanhos de lote maiores possam reduzir custos, eles também podem levar a uma ligeira diminuição na qualidade. Além disso, você pode precisar aumentar o parâmetro max_tokens na chamada da API do Claude para acomodar respostas mais longas. Para detalhes sobre o número máximo de tokens que seu modelo escolhido pode gerar, consulte a página de comparação de modelos.

Cookbook de moderação de conteúdo

Veja um exemplo completamente implementado em código de como usar o Claude para moderação de conteúdo.

Guia de proteções

Explore nosso guia de proteções para técnicas de moderação de interações com o Claude.