Visualização e Qualidade de Dados no Wikidata/Avaliação de Qualidade no Wikidata/ProVe
ProVe
Conteúdo
Infraestrutura
[editar | editar código]O funcionamento envolve uma cadeia de processamento baseada em técnicas de inteligência artificial, incluindo modelos de linguagem natural. Inicialmente, as declarações elegíveis são transformadas de sua representação estrutural em sentenças legíveis (verbalização), o que permite compará-las ao conteúdo textual das fontes vinculadas. Em seguida, as páginas referenciadas são recuperadas, o texto é extraído e segmentado em sentenças; algoritmos de similaridade semântica selecionam passagens potencialmente relevantes, e modelos de inferência textual avaliam se essas passagens apoiam, refutam ou são inconclusivas em relação à afirmação verbalizada.[1][2]
Os resultados dessa análise são agregados em uma pontuação numérica, variando de −1 a 1, que resume o nível de suporte observado para o conjunto de referências do item: valores positivos indicam maior proporção de evidências de apoio, valores negativos sugerem predominância de evidências de refutação e valores próximos de zero refletem ausência de informação suficiente ou equilíbrio entre rótulos.[1][2]
Uso do ProVe
[editar | editar código]Na interface do Wikidata, o ProVe pode ser ativado como gadget de usuário e acrescenta componentes visuais às páginas dos itens. O sistema exibe um indicador de pontuação no topo da página e sintetiza os resultados por afirmação em tabelas expansíveis, nas quais é possível inspecionar a relação entre cada declaração e suas respectivas fontes. Essa apresentação facilita a localização de trechos analisados e a navegação até as declarações que necessitam de revisão, inclusive nos casos em que não há referências associadas, em que as fontes não tratam do conteúdo alegado ou em que fontes distintas vinculadas à mesma afirmação levam a classificações divergentes.[1]
Além do uso interativo, o ProVe pode ser acessado de forma programática. Os resultados podem ser consultados por meio de serviços de API, o que viabiliza integrações com análises externas, painéis de monitoramento e estudos sobre qualidade de dados. Em termos operacionais, a execução envolve componentes de coleta de declarações via API do Wikidata, armazenamento intermediário de textos e resultados, e modelos de processamento de linguagem para as etapas de verbalização, seleção de passagens e verificação textual. Como o foco está em referências externas, o sistema não avalia referências que apontam somente para entidades internas do ecossistema Wikimedia.[1][2]
Fundamentação
[editar | editar código]A fundamentação do ProVe se apoia em pesquisas sobre qualidade de dados em grafos de conhecimento colaborativos. A documentação técnica e relatórios de avaliação incluem descrições do pipeline, critérios de rotulagem de suporte/refutação e estratégias de agregação de escores. No âmbito comunitário, a página Wikidata:ProVe concentra instruções de instalação do gadget, exemplos de uso e atualizações sobre o desenvolvimento. Essa combinação de documentação acadêmica e orientações práticas permite reproduzir os resultados e entender as limitações do método, como a dependência da disponibilidade e legibilidade das páginas referenciadas, eventuais barreiras de acesso a conteúdo e possíveis ambiguidades em textos fonte.[1]
O objetivo do ProVe é fornecer um procedimento sistemático para apoiar a verificação de referências no Wikidata. Ao sintetizar evidências textuais em indicadores compreensíveis, a ferramenta auxilia editores na revisão de afirmações e informa consumidores de dados sobre o nível de suporte observado para um item específico. Em um cenário de crescimento contínuo do acervo, a abordagem busca tornar a inspeção de referências mais escalável, mantendo a ênfase no princípio da verificabilidade sem substituir o julgamento editorial humano, mas fornecendo sinais operacionais para priorização e revisão.[1]
Implementação
[editar | editar código]import time
import requests
# Script de consulta à API do ProVe/RQV (Provenance Verification)
# Fluxo:
# 1) Dispara o processamento de um item do Wikidata (request_item)
# 2) Faz polling do status até "completed" ou "error" (check_status)
# 3) Busca um resultado simplificado (get_simple_result)
#
# Observações importantes:
# - Este script usa "polling" com intervalo fixo (5s). Em produção,
# considere implementar backoff exponencial e/ou timeout total.
# - r.raise_for_status() dispara exceção (requests.HTTPError) para HTTP != 2xx.
# - A API é acessada por métodos GET com parâmetros de query (?qid=...).
# - Adapte BASE_URL se o endpoint mudar e QID para o item desejado.
BASE_URL = "https://kclwqt.sites.er.kcl.ac.uk/api" # endpoint base da API
QID = "Q12133" # identificador do item no Wikidata (ex.: "Q42", "Q12133", etc.)
def request_item(qid):
"""
Dispara o processamento de um item do Wikidata no backend do ProVe/RQV.
Parâmetros
----------
qid : str
QID do item no Wikidata (ex.: "Q12133").
Retorno
-------
dict
Resposta JSON do servidor. Tipicamente contém um sinal de aceite do pedido
(ex.: {"message": "Item enqueued"} ou metadados similares).
Erros
-----
requests.HTTPError
Lançada por r.raise_for_status() se a resposta HTTP não for 2xx.
"""
url = f"{BASE_URL}/requests/requestItem"
params = {"qid": qid}
r = requests.get(url, params=params) # GET com querystring ?qid=<...>
r.raise_for_status() # dispara exceção se status_code não for 2xx
return r.json() # converte resposta para dict (JSON)
def check_status(qid):
"""
Consulta o status de processamento de um item previamente requisitado.
Parâmetros
----------
qid : str
QID do item no Wikidata.
Retorno
-------
dict
Um dicionário com o estado atual do processamento.
Exemplo (ilustrativo): {"status": "queued" | "processing" | "completed" | "error", ...}
Erros
-----
requests.HTTPError
Lançada por r.raise_for_status() se a resposta HTTP não for 2xx.
"""
url = f"{BASE_URL}/items/checkItemStatus"
params = {"qid": qid}
r = requests.get(url, params=params)
r.raise_for_status()
return r.json()
def get_simple_result(qid):
"""
Recupera um 'resultado simplificado' do ProVe/RQV para o item.
Parâmetros
----------
qid : str
QID do item no Wikidata.
Retorno
-------
dict
Conteúdo simplificado do resultado (estrutura depende da API).
Em geral, pode incluir uma pontuação agregada, rótulos de suporte/refutação
por declaração, trechos mais relevantes, etc.
Erros
-----
requests.HTTPError
Lançada por r.raise_for_status() se a resposta HTTP não for 2xx.
"""
url = f"{BASE_URL}/items/getSimpleResult"
params = {"qid": qid}
r = requests.get(url, params=params)
r.raise_for_status()
return r.json()
def main():
"""
Executa o fluxo completo:
1) Dispara processamento
2) Faz polling do status até completar/erro
3) Exibe resultado simplificado
Boas práticas (para produção):
- Implementar um timeout máximo (ex.: parar após X minutos/tentativas).
- Tratar exceções (try/except) para conexões falhas, timeouts, etc.
- Fazer logs estruturados ao invés de prints (ex.: logging).
"""
print(f"Solicitando processamento do item {QID}...")
request_item(QID) # Se a API aceitar repetidos, chamadas subsequentes podem re-enfileirar
# Polling: aguarda até que o processamento seja concluído
# Em produção, considere:
# * adicionar um contador de tentativas (max_retries)
# * usar backoff exponencial (ex.: 2, 4, 8, 16s...) em vez de 5s fixos
while True:
status = check_status(QID)
print("Status:", status) # útil para depuração/monitoramento
# status.get("status") evita KeyError se a chave não existir.
# A API costuma devolver rótulos como: "queued", "processing", "completed", "error".
state = status.get("status")
if state == "completed":
# Sai do loop assim que a API sinaliza conclusão
break
elif state == "error":
# Se a API já indicar erro, abortamos e mostramos a resposta de status
print("Erro no processamento:", status)
return
# Se ainda estiver "queued" ou "processing", aguarda 5s antes de checar novamente
time.sleep(5)
# Quando concluído, recupera o resultado "simplificado"
result = get_simple_result(QID)
print("\n=== Resultado Simplificado ===")
# A estrutura exata depende da API; pode ser necessário formatar a saída.
print(result)
if __name__ == "__main__":
main()
Referências
Conteúdos audiovisuais
Quiz
Caro(a) aluno(a), lembre-se que o quiz é uma autoavaliação.
Conteúdo adicional
Você também pode usar o botão de edição no canto superior direito de uma seção para editar seu conteúdo.
Discussão
