Como construir um detector de plágio usando Python

Como o conteúdo digital cresceu em popularidade, tornou-se mais importante do que nunca protegê-lo contra cópia e uso indevido. Uma ferramenta de detecção de plágio pode ajudar os professores a avaliar o trabalho dos alunos, as instituições a verificar os trabalhos de pesquisa e os escritores a detectar o roubo de sua propriedade intelectual.

Construir uma ferramenta de plágio pode ajudá-lo a entender a correspondência de sequência, operações de arquivo e interfaces de usuário. Você também explorará técnicas de processamento de linguagem natural (PNL) para aprimorar seu aplicativo.

Módulo Tkinter e Difflib

Para construir um detector de plágio, você usará Tkinter e o módulo Difflib. Tkinter é uma biblioteca simples e multiplataforma que você pode usar para criar interfaces gráficas de usuário rapidamente.

O módulo Difflib faz parte da biblioteca padrão do Python que fornece classes e funções para comparar sequências como strings, listas e arquivos. Com ele, você pode construir programas como um corretor automático de texto, um

sistema de controle de versão, ou uma ferramenta de resumo de texto.

Como construir um detector de plágio usando Python

Você pode encontrar todo o código-fonte construindo um detector de plágio usando Python neste Repositório GitHub.

Importe os módulos necessários. Defina um método, load_file_or_display_contents() isso leva entrada e text_widget como argumentos. Este método carregará um arquivo de texto e exibirá seu conteúdo em um widget de texto.

Use o pegar() para extrair o caminho do arquivo. Se o usuário não digitou nada, use o askopenfilename() método para abrir uma janela de diálogo de arquivo para selecionar o arquivo desejado para verificação de plágio. Se o usuário selecionar o caminho do arquivo, limpe a entrada anterior, se houver, do início ao fim e insira o caminho selecionado.

import tkinter as tk
from tkinter import filedialog
from difflib import SequenceMatcher
defload_file_or_display_contents(entry, text_widget):
 file_path = entry.get()
ifnot file_path:
 file_path = filedialog.askopenfilename()
if file_path:
 entry.delete(0, tk.END)
 entry.insert(tk.END, file_path)

Abra o arquivo no modo de leitura e armazene o conteúdo no texto variável. Limpe o conteúdo do text_widget e insira o texto que você extraiu anteriormente.

with open(file_path, 'r') as file:
 text = file.read()
 text_widget.delete(1.0, tk.END)
 text_widget.insert(tk.END, text)

Defina um método, comparar_texto() que você usará para comparar duas partes do texto e calcular sua porcentagem de similaridade. Use Difflib's SequenceMatcher() class para comparar sequências e determinar a similaridade. Defina a função de comparação personalizada para Nenhum para usar a comparação padrão e passe o texto que deseja comparar.

Use o método de proporção para obter a similaridade em um formato de ponto flutuante que você pode usar para calcular a porcentagem de similaridade. Use o get_opcodes() para recuperar um conjunto de operações que você pode usar para realçar partes semelhantes do texto e retorná-las junto com a porcentagem de similaridade.

defcompare_text(text1, text2):
 d = SequenceMatcher(None, text1, text2)
 similarity_ratio = d.ratio()
 similarity_percentage = int(similarity_ratio * 100)
 diff = list(d.get_opcodes())
return similarity_percentage, diff

Defina um método, show_similarity(). Use o pegar() método para extrair o texto de ambas as caixas de texto e passá-los para o comparar_texto() função. Limpe o conteúdo da caixa de texto que exibirá o resultado e insira o percentual de similaridade. Remova o "mesmo" tag do destaque anterior (se houver).

defshow_similarity():
 text1 = text_textbox1.get(1.0, tk.END)
 text2 = text_textbox2.get(1.0, tk.END)
 similarity_percentage, diff = compare_text(text1, text2)
 text_textbox_diff.delete(1.0, tk.END)
 text_textbox_diff.insert(tk.END, f"Similarity: {similarity_percentage}%")
 text_textbox1.tag_remove("same", "1.0", tk.END)
 text_textbox2.tag_remove("same", "1.0", tk.END)

O get_opcode() método retorna cinco tuplas: a string opcode, o índice inicial da primeira sequência, o índice final da primeira sequência, o índice inicial da segunda sequência e o índice final da segunda seqüência.

A string opcode pode ser um dos quatro valores possíveis: substituir, excluir, inserir e igual. Você vai ter substituir quando uma parte do texto em ambas as sequências é diferente e alguém substitui uma parte por outra. Você vai ter excluir quando uma parte do texto existe na primeira sequência, mas não na segunda.

você consegue inserir quando uma parte do texto está ausente na primeira sequência, mas presente na segunda. Você fica igual quando as partes do texto são as mesmas. Armazene todos esses valores em variáveis ​​apropriadas. Se a string opcode for igual, Adicione o mesmo tag à sequência de texto.

for opcode in diff:
 tag = opcode[0]
 start1 = opcode[1]
 end1 = opcode[2]
 start2 = opcode[3]
 end2 = opcode[4]
if tag == "equal":
 text_textbox1.tag_add("same", f"1.0+{start1}c", f"1.0+{end1}c")
 text_textbox2.tag_add("same", f"1.0+{start2}c", f"1.0+{end2}c")

Inicialize a janela raiz do Tkinter. Defina o título da janela e defina um quadro dentro dela. Organize o quadro com preenchimento apropriado em ambas as direções. Definir dois rótulos para exibir Texto 1 e Texto 2. Defina o elemento pai no qual ele deve residir e o texto que deve ser exibido.

Defina três caixas de texto, duas para os textos que deseja comparar e uma para exibir o resultado. Declare o elemento pai, a largura e a altura e defina a opção de quebra para tk. PALAVRA para garantir que o programa envolva as palavras no limite mais próximo e não quebre nenhuma palavra no meio.

root = tk.Tk()
root.title("Text Comparison Tool")
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)
text_label1 = tk.Label(frame, text="Text 1:")
text_label1.grid(row=0, column=0, padx=5, pady=5)
text_textbox1 = tk.Text(frame, wrap=tk.WORD, width=40, height=10)
text_textbox1.grid(row=0, column=1, padx=5, pady=5)
text_label2 = tk.Label(frame, text="Text 2:")
text_label2.grid(row=0, column=2, padx=5, pady=5)
text_textbox2 = tk.Text(frame, wrap=tk.WORD, width=40, height=10)
text_textbox2.grid(row=0, column=3, padx=5, pady=5)

Defina três botões, dois para carregar os arquivos e um para comparação. Defina o elemento pai, o texto que ele deve exibir e a função que deve executar quando clicado. Crie dois widgets de entrada para inserir o caminho do arquivo e definir o elemento pai junto com sua largura.

Organize todos esses elementos em linhas e colunas usando o gerenciador de grade. Use o pacote para organizar o botão_comparar e a text_textbox_diff. Adicione preenchimento apropriado onde necessário.

file_entry1 = tk.Entry(frame, width=50)
file_entry1.grid(row=1, column=2, columnspan=2, padx=5, pady=5)
load_button1 = tk.Button(frame, text="Load File 1", command=lambda: load_file_or_display_contents(file_entry1, text_textbox1))
load_button1.grid(row=1, column=0, padx=5, pady=5, columnspan=2)
file_entry2 = tk.Entry(frame, width=50)
file_entry2.grid(row=2, column=2, columnspan=2, padx=5, pady=5)
load_button2 = tk.Button(frame, text="Load File 2", command=lambda: load_file_or_display_contents(file_entry2, text_textbox2))
load_button2.grid(row=2, column=0, padx=5, pady=5, columnspan=2)
compare_button = tk.Button(root, text="Compare", command=show_similarity)
compare_button.pack(pady=5)
text_textbox_diff = tk.Text(root, wrap=tk.WORD, width=80, height=1)
text_textbox_diff.pack(padx=10, pady=10)

Destaque o texto marcado como o mesmo com fundo amarelo e fonte vermelha.

text_textbox1.tag_configure("same", foreground="red", background="lightyellow")
text_textbox2.tag_configure("same", foreground="red", background="lightyellow")

O circuito principal() A função diz ao Python para executar o loop de eventos Tkinter e escutar os eventos até que você feche a janela.

root.mainloop()

Junte tudo e execute o código para detectar plágio.

Exemplo de Saída do Detector de Plágio

Quando você executa o programa, ele exibe uma janela. Ao acertar o Carregar Arquivo 1 botão, uma caixa de diálogo de arquivo é aberta e solicita que você escolha um arquivo. Ao escolher um arquivo, o programa mostra o conteúdo dentro da primeira caixa de texto. Ao entrar no caminho e bater Carregar Arquivo 2, o programa exibe o conteúdo na segunda caixa de texto. Ao acertar o Comparar botão, você obtém a similaridade como 100% e destaca todo o texto para 100% de similaridade.

Se você adicionar outra linha a uma das caixas de texto e clicar Comparar, o programa destaca a parte semelhante e deixa de fora o resto.

Se houver pouca ou nenhuma semelhança, o programa destaca algumas letras ou palavras, mas a porcentagem de semelhança é bem baixa.

Usando NLP para detecção de plágio

Embora o Difflib seja um método poderoso para comparação de texto, ele é sensível a pequenas alterações, possui compreensão limitada do contexto e geralmente é ineficaz para textos grandes. Você deve considerar explorar o Processamento de Linguagem Natural, pois ele pode realizar a análise semântica do texto, extrair recursos significativos e ter compreensão contextual.

Além disso, você pode treinar seu modelo para diferentes idiomas e otimizá-lo para eficiência. Algumas das técnicas que você pode usar para detecção de plágio incluem similaridade de Jaccard, similaridade de cosseno, incorporação de palavras, análise de sequência latente e modelos de sequência para sequência.