Cómo construir un detector de plagio usando Python

A medida que el contenido digital ha ganado popularidad, se ha vuelto más importante que nunca protegerlo contra la copia y el uso indebido. Una herramienta de detección de plagio puede ayudar a los maestros a evaluar el trabajo de los estudiantes, las instituciones verifican los trabajos de investigación y los escritores detectan el robo de su propiedad intelectual.

La creación de una herramienta de plagio puede ayudarlo a comprender la coincidencia de secuencias, las operaciones de archivos y las interfaces de usuario. También explorará técnicas de procesamiento de lenguaje natural (NLP) para mejorar su aplicación.

El módulo Tkinter y Difflib

Para construir un detector de plagio, utilizará Tkinter y el módulo Difflib. Tkinter es una biblioteca simple, multiplataforma que puedes usar para crear interfaces gráficas de usuario rápidamente.

El módulo Difflib es parte de la biblioteca estándar de Python que proporciona clases y funciones para comparar secuencias como cadenas, listas y archivos. Con él, puede crear programas como un autocorrector de texto, un

sistema de control de versiones, o una herramienta de resumen de texto.

Cómo construir un detector de plagio usando Python

Puede encontrar el código fuente completo construyendo un detector de plagio usando Python en este repositorio GitHub.

Importe los módulos requeridos. Definir un método, cargar_archivo_o_mostrar_contenidos() eso toma entrada y texto_widget como argumentos. Este método cargará un archivo de texto y mostrará su contenido en un widget de texto.

Utilizar el conseguir() método para extraer la ruta del archivo. Si el usuario no ha ingresado nada, use el askopenfilename() método para abrir una ventana de diálogo de archivo para seleccionar el archivo deseado para la verificación de plagio. Si el usuario selecciona la ruta del archivo, borre la entrada anterior, si la hay, desde el principio hasta el final e inserte la ruta que seleccionó.

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 el archivo en modo lectura y guarde el contenido en el texto variable. Borre el contenido de text_widget e inserte el texto que extrajo anteriormente.

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

Definir un método, comparar_texto() que utilizará para comparar dos fragmentos de texto y calcular su porcentaje de similitud. Usa Difflib Coincidencia de secuencia() clase para comparar secuencias y determinar la similitud. Establezca la función de comparación personalizada en Ninguno para usar la comparación predeterminada y pasar el texto que desea comparar.

Usa el método de la proporción para obtener la similitud en un formato de punto flotante que puedes usar para calcular el porcentaje de similitud. Utilizar el get_opcodes() para recuperar un conjunto de operaciones que puede usar para resaltar partes similares de texto y devolverlo junto con el porcentaje de similitud.

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

Definir un método, mostrar_similitud(). Utilizar el conseguir() método para extraer el texto de ambos cuadros de texto y pasarlos al comparar_texto() función. Borre el contenido del cuadro de texto que mostrará el resultado e inserte el porcentaje de similitud. Eliminar el "mismo" etiqueta del resaltado anterior (si corresponde).

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)

El get_opcode() método devuelve cinco tuplas: la cadena de código de operación, el índice de inicio de la primera secuencia, el índice final de la primera secuencia, el índice de inicio de la segunda secuencia y el índice final de la segunda secuencia.

La cadena de código de operación puede ser uno de cuatro valores posibles: reemplazar, eliminar, insertar e igual. Conseguirás reemplazar cuando una parte del texto en ambas secuencias es diferente y alguien reemplazó una parte por otra. Conseguirás borrar cuando una parte del texto existe en la primera secuencia pero no en la segunda.

Usted obtiene insertar cuando una parte del texto está ausente en la primera secuencia pero presente en la segunda. Obtienes igual cuando las partes del texto son iguales. Almacene todos estos valores en las variables apropiadas. Si la cadena de código de operación es igual, añade el mismo etiqueta a la secuencia 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")

Inicialice la ventana raíz de Tkinter. Establezca el título de la ventana y defina un marco dentro de ella. Organice el marco con el acolchado adecuado en ambas direcciones. Definir dos etiquetas para mostrar Texto 1 y Texto 2. Establezca el elemento principal en el que debe residir y el texto que debe mostrar.

Defina tres cuadros de texto, dos para los textos que desea comparar y uno para mostrar el resultado. Declare el elemento principal, el ancho y el alto, y establezca la opción de ajuste en tk. PALABRA para asegurarse de que el programa envuelve las palabras en el límite más cercano y no rompe ninguna palabra en el medio.

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 tres botones, dos para cargar los archivos y uno para comparar. Defina el elemento principal, el texto que debe mostrar y la función que debe ejecutar al hacer clic. Cree dos widgets de entrada para ingresar la ruta del archivo y defina el elemento principal junto con su ancho.

Organiza todos estos elementos en filas y columnas usando el administrador de grillas. Utilice el paquete para organizar el botón_comparar y el text_textbox_diff. Agregue el relleno apropiado donde sea necesario.

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)

Resalte el texto marcado como el mismo con un fondo amarillo y un color de fuente rojo.

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

El bucle principal() La función le dice a Python que ejecute el ciclo de eventos de Tkinter y escuche los eventos hasta que cierre la ventana.

root.mainloop()

Póngalo todo junto y ejecute el código para detectar plagio.

Salida de ejemplo del detector de plagio

Cuando ejecuta el programa, muestra una ventana. Al golpear el Cargar archivo 1 se abre un cuadro de diálogo de archivo y le pide que elija un archivo. Al elegir un archivo, el programa muestra el contenido dentro del primer cuadro de texto. Al entrar en el camino y golpear Cargar archivo 2, el programa muestra el contenido en el segundo cuadro de texto. Al golpear el Comparar botón, obtienes la similitud como 100%, y resalta todo el texto para una similitud del 100%.

Si agrega otra línea a uno de los cuadros de texto y presiona Comparar, el programa destaca la parte similar y omite el resto.

Si hay poca o ninguna similitud, el programa resalta algunas letras o palabras, pero el porcentaje de similitud es bastante bajo.

Uso de PNL para la detección de plagio

Si bien Difflib es un método poderoso para la comparación de textos, es sensible a cambios menores, tiene una comprensión limitada del contexto y, a menudo, es ineficaz para textos extensos. Debería considerar explorar el procesamiento del lenguaje natural, ya que puede realizar un análisis semántico del texto, extraer características significativas y tiene comprensión contextual.

Además, puede entrenar su modelo para diferentes idiomas y optimizarlo para que sea eficiente. Algunas de las técnicas que puede utilizar para la detección de plagio incluyen similitud de Jaccard, similitud de coseno, incrustaciones de palabras, análisis de secuencia latente y modelos de secuencia a secuencia.