Controle de Qualidade para Anotação por Crowdsourcing

O controle de qualidade é o que separa anotações úteis de ruído. Este guia cobre estratégias que funcionam na prática para projetos de anotação por crowdsourcing e internos. Para os recursos subjacentes, consulte a documentação de controle de qualidade.

Visão Geral do Controle de Qualidade

Nenhuma verificação isolada é suficiente por si só, então a maioria dos projetos combina algumas em camadas:

1. Verificações de atenção: Confirmam que os anotadores estão engajados com a tarefa
2. Redundância: Coleta de múltiplas anotações por item
3. Métricas de concordância: Medem a consistência entre anotadores
4. Treinamento e diretrizes: Garantem que os anotadores entendam a tarefa
5. Revisão manual: Amostragem e revisão da qualidade da anotação

Verificações de Atenção via Surveyflow

O Potato oferece verificações de atenção básicas pelo sistema surveyflow. Você pode inserir páginas de pesquisa entre lotes de anotação que pedem aos anotadores que confirmem que estão prestando atenção.

annotation_task_name: "Sentiment Annotation with Checks"
 
surveyflow:
  on: true
  order:
    - survey_instructions
    - annotation
    - survey_attention_check
    - annotation
    - survey_completion

Defina as perguntas de verificação de atenção como uma página de pesquisa:

# In your surveyflow survey definitions
survey_attention_check:
  - question: "To confirm you're paying attention, please select 'Strongly Agree'."
    type: radio
    options:
      - Strongly Disagree
      - Disagree
      - Neutral
      - Agree
      - Strongly Agree

O suporte integrado do Potato a verificações de atenção é limitado. Se quiser detecção automática de falhas, exclusão de anotadores e lógicas semelhantes, vai precisar de scripts de pós-processamento ou dos recursos de qualidade da sua própria plataforma de crowdsourcing.

Redundância: Múltiplas Anotações Por Item

Coletar múltiplas anotações por item é um dos métodos de controle de qualidade mais confiáveis. Configure isso na sua definição de dados:

annotation_task_name: "Multi-Annotator Sentiment Task"
 
data_files:
  - path: data.json
    list_as_text: false
    sampling: random
 
# Control how many annotators see each item through assignment logic
# This is typically managed through your annotator assignment system

Ao usar plataformas de crowdsourcing como o Prolific, você pode:

• Publicar o mesmo HIT várias vezes para obter anotações redundantes
• Usar lotes diferentes de trabalhadores para os mesmos dados
• Implementar lógica de atribuição personalizada no seu pipeline de dados

Medindo a Concordância Entre Anotadores

Embora o Potato não calcule métricas de concordância automaticamente durante a anotação, você deve calculá-las no pós-processamento. Métricas comuns incluem:

Kappa de Cohen (Dois Anotadores)

Para anotações categóricas com dois anotadores:

from sklearn.metrics import cohen_kappa_score
 
# After collecting annotations
annotator1_labels = ["Positive", "Negative", "Positive", ...]
annotator2_labels = ["Positive", "Negative", "Neutral", ...]
 
kappa = cohen_kappa_score(annotator1_labels, annotator2_labels)
print(f"Cohen's Kappa: {kappa:.3f}")

Kappa de Fleiss (Múltiplos Anotadores)

Para três ou mais anotadores:

from statsmodels.stats.inter_rater import fleiss_kappa
import numpy as np
 
# Build a matrix of label counts per item
# Each row is an item, each column is a label category
ratings_matrix = np.array([
    [3, 0, 0],  # Item 1: 3 Positive, 0 Negative, 0 Neutral
    [2, 1, 0],  # Item 2: 2 Positive, 1 Negative, 0 Neutral
    [0, 0, 3],  # Item 3: 0 Positive, 0 Negative, 3 Neutral
    ...
])
 
kappa = fleiss_kappa(ratings_matrix)
print(f"Fleiss' Kappa: {kappa:.3f}")

Diretrizes de Interpretação

O Potato oferece suporte a verificações de atenção, itens padrão-ouro e rastreamento da concordância entre anotadores para manter a qualidade da anotação:

Itens Padrão-Ouro

Itens padrão-ouro são itens pré-rotulados com respostas corretas conhecidas que você mistura aos seus dados. Eles ajudam a identificar anotadores que estão chutando ou não prestando atenção.

Criando Itens Padrão-Ouro

1. Crie um conjunto de itens com respostas corretas claras e inequívocas
2. Faça com que especialistas rotulem esses itens
3. Misture-os aos seus dados de anotação regulares

[
  {
    "id": "gold_001",
    "text": "I absolutely love this product! Best purchase ever!",
    "is_gold": true,
    "gold_label": "Positive"
  },
  {
    "id": "gold_002",
    "text": "This is terrible. Complete waste of money. Worst experience.",
    "is_gold": true,
    "gold_label": "Negative"
  },
  {
    "id": "regular_001",
    "text": "The product arrived on time and works as expected.",
    "is_gold": false
  }
]

Analisando o Desempenho no Padrão-Ouro

Após a coleta, analise como cada anotador se saiu nos itens padrão-ouro:

import json
 
def calculate_gold_accuracy(annotations_file, gold_labels):
    with open(annotations_file) as f:
        annotations = json.load(f)
 
    annotator_scores = {}
 
    for item_id, item_annotations in annotations.items():
        if item_id in gold_labels:
            expected = gold_labels[item_id]
            for annotator, label in item_annotations.items():
                if annotator not in annotator_scores:
                    annotator_scores[annotator] = {'correct': 0, 'total': 0}
                annotator_scores[annotator]['total'] += 1
                if label == expected:
                    annotator_scores[annotator]['correct'] += 1
 
    for annotator, scores in annotator_scores.items():
        accuracy = scores['correct'] / scores['total']
        print(f"{annotator}: {accuracy:.1%} gold accuracy")
 
    return annotator_scores

Indicadores de Qualidade Baseados em Tempo

O Potato registra o tempo de anotação nos arquivos de saída. Use esses dados para sinalizar anotações potencialmente de baixa qualidade:

Analisando Dados de Tempo

import json
from statistics import mean, stdev
 
def analyze_timing(annotations_file):
    with open(annotations_file) as f:
        data = json.load(f)
 
    times = []
    for item in data.values():
        if 'time_spent' in item:
            times.append(item['time_spent'])
 
    avg_time = mean(times)
    std_time = stdev(times)
 
    # Flag annotations that are too fast (< 2 std below mean)
    threshold = max(avg_time - 2 * std_time, 2)  # At least 2 seconds
 
    flagged = [t for t in times if t < threshold]
    print(f"Average time: {avg_time:.1f}s")
    print(f"Flagged as too fast: {len(flagged)} items")

Controle de Qualidade no Nível da Plataforma

Ao usar plataformas de crowdsourcing, aproveite os recursos de qualidade integrados delas:

Prolific

• Use filtros de pré-seleção (taxa de aprovação, estudos anteriores)
• Defina requisitos mínimos de tempo de conclusão
• Use perguntas de verificação de atenção na sua pré-pesquisa
• Revise as submissões antes de aprovar o pagamento

MTurk

• Exija uma taxa mínima de aprovação de HITs (>95%)
• Use testes de qualificação
• Configure aprovação/rejeição automática com base em critérios
• Bloqueie trabalhadores que falham nas verificações de qualidade

Verificações de Qualidade no Pós-Processamento

Implemente verificações automatizadas nos dados coletados:

def quality_check_annotations(annotations_file):
    with open(annotations_file) as f:
        data = json.load(f)
 
    issues = []
 
    for annotator_id, items in group_by_annotator(data).items():
        labels = [item['label'] for item in items]
 
        # Check for single-label bias (always selecting same option)
        unique_labels = set(labels)
        if len(unique_labels) == 1 and len(labels) > 10:
            issues.append(f"{annotator_id}: Only used label '{labels[0]}'")
 
        # Check for position bias (always selecting first option)
        # Requires knowing option order in your schema
 
        # Check for very fast submissions
        times = [item.get('time_spent', 0) for item in items]
        avg_time = sum(times) / len(times) if times else 0
        if avg_time < 3:
            issues.append(f"{annotator_id}: Average time only {avg_time:.1f}s")
 
    return issues

Boas Práticas

Integre os anotadores com a fase de treinamento do Potato antes que qualquer anotação real comece. Escreva diretrizes claras, já que diretrizes ambíguas geram desacordo que nada tem a ver com a qualidade do anotador. Rode um pequeno piloto para revelar problemas antes de implantar em escala. Combine suas verificações em vez de depender de uma só: verificações de atenção, padrões-ouro e redundância capturam coisas diferentes. Comece com limites mais permissivos e aperte-os depois de ver dados reais. Dê feedback aos anotadores quando possível. Continue monitorando, porque a qualidade cai à medida que as pessoas cansam. E registre como você lida com casos extremos para que suas decisões permaneçam consistentes.

Para configurar a etapa de integração especificamente, consulte a documentação da fase de treinamento.

Resumo

O controle de qualidade para anotação funciona melhor em camadas:

A maior parte dessa análise acontece após a coleta, por meio de scripts de pós-processamento. Planeje esse pipeline antes de coletar qualquer coisa, para que você realmente capture os campos de que vai precisar.

Próximos Passos

• Aprenda sobre os cálculos de concordância entre anotadores em detalhes
• Configure a integração com o Prolific para anotação por crowdsourcing
• Configure fases de treinamento para a integração dos anotadores

Para saber mais sobre fluxos de trabalho de anotação, consulte a documentação de esquemas de anotação.