AI Powered Plagiarism Detector for Assignments

Teachers checking assignments for copying usually have two bad options: reading every submission against every other by hand, or trusting an expensive black-box web service that gives a percentage with no explanation. Students, meanwhile, rarely understand what "similarity" even measures, so the score feels arbitrary. This project takes the transparent route — it builds the detection engine from scratch with classical information-retrieval techniques, so every number on screen can be traced back to a concrete mechanism. A submitted assignment is tokenized, weighted by TF-IDF, and compared against each reference document with cosine similarity; a second layer hashes sliding 5-word shingles to pinpoint the exact copied phrases. The result is a similarity report a teacher can actually interrogate: which documents matched, which passages overlap, and how the score was computed. Because the whole engine runs locally in a single HTML file, the student owns every line of the algorithm and can defend it in the viva.

1. The assignment text is pasted or uploaded; the app lowercases it, splits it into word tokens and removes a built-in stopword list so rare, meaningful words dominate.
2. Every document — the submission plus each corpus document — is converted to a TF-IDF vector: each word's weight is its frequency in the document multiplied by how rare it is across the corpus.
3. Cosine similarity between the submission vector and each corpus vector produces a 0–100% score per reference document; comparing angles (not lengths) keeps short and long essays comparable.
4. In parallel, sliding windows of 5 consecutive words (shingles) are hashed for every document; any shingle appearing in both marks an exact copied phrase.
5. Overlapping shared shingles merge into passages, which are highlighted in the report and in the side-by-side view with character-accurate spans.
6. Scores below the configurable flag threshold are dimmed; the top score sets the verdict band shown on the gauge.
7. Changing shingle size, threshold or stopword handling re-runs the whole pipeline instantly, so the effect of each choice is visible.

Tech stack:

• JavaScript (ES6, zero dependencies)
• TF-IDF vectorization · cosine similarity
• Word-shingle (n-gram) fingerprinting
• HTML5 · CSS3 single-file web app
• FileReader API (.txt uploads)
• SVG similarity gauge
• Built-in English stopword list
• Python 3 (batch folder-check script)

Dataset & model details

• Dataset: Built-in sample corpus of 6 student essays authored for this project (AI in education, AI in classrooms, machine-learning fundamentals, climate and agriculture, smart homes, solar power) — 100–160 content words each after stopword removal. This is a demonstration set, not a public benchmark; the design supports swapping in a real institutional corpus or the public PAN plagiarism-evaluation corpora.
• Task: Document-level similarity scoring. Input = plain-text assignment (pasted or .txt upload, up to 20,000 characters per upload by design). Output = one 0–100% cosine score per reference document plus character-span matched passages.
• Model: Classical information retrieval, not a neural network — TF-IDF weighted vectors compared with cosine similarity, plus 5-word shingle intersection for verbatim-phrase evidence. No training step, no learned weights, no claimed accuracy.
• Metrics: No accuracy is claimed as measured. The honest evaluation for the buyer is a labeled pair set (copied / paraphrased / original pairs they assemble) scored for precision and recall at a chosen threshold, with the procedure documented in the report. Latency is measured: a ~2,200/2,400-word document pair compares in roughly 20 ms in the demo build.

• [Similarity score gauge] Each checked document gets a 0–100% score against every reference document, shown on an animated gauge with an overall verdict band (High, Moderate, Low, Clean).
• [Matched-passage highlighting] Overlapping 5-word shingles merge into highlighted passages, so the exact copied sentences are visible in context instead of just a number.
• [Side-by-side comparison view] The checked document and any reference document render next to each other with shared phrases highlighted in both, making the overlap instantly verifiable.
• [Per-source score breakdown] A ranked bar list shows the similarity against each corpus document separately, so near-misses and the true source are distinguishable.
• [Adjustable detection settings] Shingle size (3–8 words), flag threshold and stopword removal are configurable, and the report re-computes live — useful for demonstrating how each parameter changes the result.
• [Paste, upload and sample corpus] Documents can be pasted, loaded from a built-in sample essay, or uploaded as .txt files; the demo ships with a 6-essay sample corpus the engine compares against.
• [Batch folder checking (optional)] A Python script checks a whole folder of submissions pairwise and writes a similarity matrix CSV, for class-level originality screening.
• [Web-source checking (future scope)] Querying search-engine APIs for web matches is designed but not implemented; the report documents the API and cost considerations for a buyer who wants it.

• Working plagiarism-detector web app (single HTML file, engine source included)
• Built-in 6-essay sample corpus with the overlapping passages documented
• Python batch folder-check script with similarity-matrix CSV output
• Project report PDF (IR background, TF-IDF/cosine/shingle theory, methodology, evaluation procedure)
• PPT presentation for final review
• Viva Q&A preparation document (tokenization, TF-IDF, cosine geometry, shingle trade-offs, paraphrase limits)
• Corpus-extension guide: how to plug in institutional submissions or the PAN evaluation corpora