Comment construire un détecteur de plagiat en utilisant Python

Alors que le contenu numérique gagne en popularité, il est devenu plus important que jamais de le protéger contre la copie et l'utilisation abusive. Un outil de détection de plagiat peut aider les enseignants à évaluer le travail des étudiants, les établissements à vérifier les articles de recherche et les auteurs à détecter le vol de leur propriété intellectuelle.

La création d'un outil anti-plagiat peut vous aider à comprendre la correspondance des séquences, les opérations sur les fichiers et les interfaces utilisateur. Vous explorerez également les techniques de traitement du langage naturel (TAL) pour améliorer votre application.

Le module Tkinter et Difflib

Pour construire un détecteur de plagiat, vous utiliserez Tkinter et le module Difflib. Tkinter est une bibliothèque simple et multiplateforme que vous pouvez utiliser pour créer interfaces utilisateur graphiques rapidement.

Le module Difflib fait partie de la bibliothèque standard Python qui fournit des classes et des fonctions pour comparer des séquences telles que des chaînes, des listes et des fichiers. Avec lui, vous pouvez créer des programmes comme un correcteur de texte automatique, un outil simplifié

système de gestion des versions, ou un outil de synthèse de texte.

Comment construire un détecteur de plagiat en utilisant Python

Vous pouvez trouver l'intégralité du code source créant un détecteur de plagiat à l'aide de Python dans ce Référentiel GitHub.

Importez les modules requis. Définir une méthode, load_file_or_display_contents() qui prend entrée et text_widget comme arguments. Cette méthode chargera un fichier texte et affichera son contenu dans un widget texte.

Utilisez le obtenir() méthode pour extraire le chemin du fichier. Si l'utilisateur n'a rien saisi, utilisez le askopenfilename() méthode pour ouvrir une fenêtre de dialogue de fichier pour sélectionner le fichier souhaité pour la vérification du plagiat. Si l'utilisateur sélectionne le chemin du fichier, effacez l'entrée précédente, le cas échéant, du début à la fin et insérez le chemin qu'il a sélectionné.

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)

Ouvrez le fichier en mode lecture et stockez le contenu dans le texte variable. Effacez le contenu du text_widget et insérez le texte que vous avez extrait précédemment.

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

Définir une méthode, compare_text() que vous utiliserez pour comparer deux morceaux de texte et calculer leur pourcentage de similarité. Utiliser Difflib SéquenceMatcher() classe pour comparer les séquences et déterminer la similarité. Définissez la fonction de comparaison personnalisée sur Aucun pour utiliser la comparaison par défaut, puis transmettez le texte que vous souhaitez comparer.

Utilisez la méthode du ratio pour obtenir la similarité dans un format à virgule flottante que vous pouvez utiliser pour calculer le pourcentage de similarité. Utilisez le get_opcodes() pour récupérer un ensemble d'opérations que vous pouvez utiliser pour mettre en surbrillance des portions de texte similaires et les renvoyer avec le pourcentage de similarité.

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

Définir une méthode, show_similarity(). Utilisez le obtenir() méthode pour extraire le texte des deux zones de texte et les passer dans la compare_text() fonction. Effacez le contenu de la zone de texte qui affichera le résultat et insérez le pourcentage de similarité. Retirer le "même" balise de la surbrillance précédente (le cas échéant).

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)

Le get_opcode() La méthode renvoie cinq tuples: la chaîne d'opcode, l'index de début de la première séquence, l'index de fin de la première séquence, l'indice de début de la seconde séquence et l'indice de fin de la seconde séquence.

La chaîne d'opcode peut être l'une des quatre valeurs possibles: replace, delete, insert et equal. Tu auras remplacer lorsqu'une partie du texte dans les deux séquences est différente et que quelqu'un a remplacé une partie par une autre. Tu auras supprimer lorsqu'une partie du texte existe dans la première séquence mais pas dans la seconde.

Vous obtenez insérer lorsqu'une partie du texte est absente dans la première séquence mais présente dans la seconde. Vous obtenez l'égalité lorsque les parties du texte sont les mêmes. Stockez toutes ces valeurs dans des variables appropriées. Si la chaîne d'opcode est égal, ajouter le même balise à la séquence de texte.

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")

Initialisez la fenêtre racine de Tkinter. Définissez le titre de la fenêtre et définissez un cadre à l'intérieur. Organisez le cadre avec un rembourrage approprié dans les deux sens. Définir deux étiquettes à afficher Texte 1 et Texte 2. Définissez l'élément parent dans lequel il doit résider et le texte qu'il doit afficher.

Définissez trois zones de texte, deux pour les textes que vous souhaitez comparer et une pour afficher le résultat. Déclarez l'élément parent, la largeur et la hauteur, et définissez l'option wrap sur tk. MOT pour s'assurer que le programme enveloppe les mots à la limite la plus proche et ne coupe aucun mot entre les deux.

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)

Définissez trois boutons, deux pour charger les fichiers et un pour la comparaison. Définissez l'élément parent, le texte qu'il doit afficher et la fonction qu'il doit exécuter lorsqu'il est cliqué. Créez deux widgets d'entrée pour entrer le chemin du fichier et définir l'élément parent avec sa largeur.

Organisez tous ces éléments en lignes et en colonnes à l'aide du gestionnaire de grille. Utilisez pack pour organiser le comparer_bouton et le text_textbox_diff. Ajoutez un rembourrage approprié si nécessaire.

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)

Mettez en surbrillance le texte marqué comme identique avec un fond jaune et une couleur de police rouge.

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

Le boucle principale() La fonction indique à Python d'exécuter la boucle d'événements Tkinter et d'écouter les événements jusqu'à ce que vous fermiez la fenêtre.

root.mainloop()

Rassemblez tout et exécutez le code pour détecter le plagiat.

Exemple de sortie du détecteur de plagiat

Lorsque vous exécutez le programme, il affiche une fenêtre. En frappant le Charger le fichier 1, une boîte de dialogue de fichier s'ouvre et vous demande de choisir un fichier. Lors du choix d'un fichier, le programme affiche le contenu à l'intérieur de la première zone de texte. En entrant dans le chemin et en frappant Charger le fichier 2, le programme affiche le contenu dans la deuxième zone de texte. En frappant le Comparer bouton, vous obtenez la similarité à 100%, et il met en surbrillance le texte entier pour une similarité de 100%.

Si vous ajoutez une autre ligne à l'une des zones de texte et appuyez sur Comparer, le programme met en évidence la partie similaire et omet le reste.

S'il y a peu ou pas de similitude, le programme met en évidence certaines lettres ou certains mots, mais le pourcentage de similitude est assez faible.

Utilisation de la PNL pour la détection de plagiat

Bien que Difflib soit une méthode puissante de comparaison de texte, elle est sensible aux modifications mineures, a une compréhension limitée du contexte et est souvent inefficace pour les textes volumineux. Vous devriez envisager d'explorer le traitement du langage naturel car il peut effectuer une analyse sémantique du texte, extraire des caractéristiques significatives et avoir une compréhension contextuelle.

De plus, vous pouvez entraîner votre modèle pour différentes langues et l'optimiser pour plus d'efficacité. Parmi les techniques que vous pouvez utiliser pour la détection du plagiat, citons la similarité Jaccard, la similarité cosinus, les incorporations de mots, l'analyse de séquence latente et les modèles séquence à séquence.