Spaces:
Running
Running
| import gradio as gr | |
| import random | |
| import nltk | |
| import re | |
| import spacy | |
| from nltk.corpus import wordnet, stopwords | |
| from nltk import pos_tag, word_tokenize | |
| from sklearn.metrics.pairwise import cosine_similarity | |
| from transformers import AutoTokenizer, AutoModelForSeq2SeqLM | |
| from sentence_transformers import SentenceTransformer,util | |
| import torch | |
| import numpy as np | |
| from typing import List, Dict, Tuple,Optional | |
| from transformers import pipeline | |
| import google.generativeai as genai | |
| import json | |
| from dotenv import load_dotenv | |
| import os | |
| # Load environment variables | |
| load_dotenv() | |
| # Configure Gemini API Key | |
| GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") | |
| genai.configure(api_key=GEMINI_API_KEY) | |
| model = genai.GenerativeModel("gemini-2.5-flash-lite") | |
| # Download NLTK data | |
| print("Downloading NLTK data...") | |
| for data in ['punkt','punkt_tab', 'wordnet', 'averaged_perceptron_tagger', 'stopwords', 'omw-1.4', 'averaged_perceptron_tagger_eng']: | |
| try: | |
| nltk.data.find(f'{data}') | |
| except: | |
| nltk.download(data, quiet=True) | |
| # Load models globally | |
| print("Loading models...") | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| print(f"Using device: {device}") | |
| t5_tokenizer = AutoTokenizer.from_pretrained("Vamsi/T5_Paraphrase_Paws") | |
| t5_model = AutoModelForSeq2SeqLM.from_pretrained("Vamsi/T5_Paraphrase_Paws") | |
| t5_model.to(device) | |
| nli_model = SentenceTransformer("cross-encoder/nli-deberta-v3-base") | |
| similarity_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2", device=device) | |
| nlp = spacy.load("en_core_web_sm") | |
| ai_detector_pipe = pipeline("text-classification", model="Hello-SimpleAI/chatgpt-detector-roberta") | |
| print("Models loaded successfully!") | |
| # ============================================================================ | |
| # STAGE 1: PARAPHRASING WITH T5 MODEL | |
| # ============================================================================ | |
| def paraphrase_text(text: str, max_length: int = 512, num_beams: int = 4, | |
| temperature: float = 0.7, top_p: float = 0.9, | |
| repetition_penalty: float = 1.2, length_penalty: float = 1.0) -> str: | |
| """Paraphrase text using T5 model""" | |
| try: | |
| input_text = f"paraphrase: {text.strip()}" | |
| inputs = t5_tokenizer(input_text, return_tensors="pt", | |
| max_length=512, truncation=True, padding=True).to(device) | |
| with torch.no_grad(): | |
| outputs = t5_model.generate( | |
| **inputs, | |
| max_length=max_length, | |
| num_beams=num_beams, | |
| num_return_sequences=1, | |
| temperature=temperature, | |
| do_sample=True if temperature > 0 else False, | |
| top_p=top_p, | |
| repetition_penalty=repetition_penalty, | |
| length_penalty=length_penalty, | |
| early_stopping=True | |
| ) | |
| result = t5_tokenizer.decode(outputs[0], skip_special_tokens=True) | |
| return result.strip() | |
| except Exception as e: | |
| return text | |
| def paraphrase_long_text(text: str, max_length: int = 512, num_beams: int = 4, | |
| temperature: float = 0.7, top_p: float = 0.9, | |
| repetition_penalty: float = 1.2, length_penalty: float = 1.0) -> str: | |
| """Handle long texts by breaking them into chunks""" | |
| sentences = nltk.sent_tokenize(text) | |
| paraphrased_sentences = [] | |
| current_chunk = "" | |
| for sentence in sentences: | |
| if len((current_chunk + " " + sentence).split()) > 80: | |
| if current_chunk: | |
| paraphrased = paraphrase_text(current_chunk, max_length, num_beams, | |
| temperature, top_p, repetition_penalty, length_penalty) | |
| paraphrased_sentences.append(paraphrased) | |
| current_chunk = sentence | |
| else: | |
| current_chunk += " " + sentence if current_chunk else sentence | |
| if current_chunk: | |
| paraphrased = paraphrase_text(current_chunk, max_length, num_beams, | |
| temperature, top_p, repetition_penalty, length_penalty) | |
| paraphrased_sentences.append(paraphrased) | |
| return " ".join(paraphrased_sentences) | |
| # ============================================================================ | |
| # CONTEXTUAL SYNONYM REPLACEMENT | |
| # ============================================================================ | |
| class ContextualSynonymReplacer: | |
| def __init__(self, model_name: str = 'all-MiniLM-L6-v2'): | |
| """Initialize with sentence transformer for contextual similarity""" | |
| self.model = SentenceTransformer(model_name) | |
| self.stop_words = set(stopwords.words('english')) | |
| def get_synonyms(self, word: str, pos: str, max_synonyms: int = 5) -> List[str]: | |
| """Get WordNet synonyms with POS filtering""" | |
| pos_mapping = { | |
| 'NN': wordnet.NOUN, 'NNS': wordnet.NOUN, 'NNP': wordnet.NOUN, 'NNPS': wordnet.NOUN, | |
| 'VB': wordnet.VERB, 'VBD': wordnet.VERB, 'VBG': wordnet.VERB, 'VBN': wordnet.VERB, | |
| 'VBP': wordnet.VERB, 'VBZ': wordnet.VERB, | |
| 'JJ': wordnet.ADJ, 'JJR': wordnet.ADJ, 'JJS': wordnet.ADJ, | |
| 'RB': wordnet.ADV, 'RBR': wordnet.ADV, 'RBS': wordnet.ADV | |
| } | |
| wn_pos = pos_mapping.get(pos, wordnet.NOUN) | |
| synsets = wordnet.synsets(word.lower(), pos=wn_pos) | |
| if not synsets: | |
| synsets = wordnet.synsets(word.lower()) | |
| synonyms = [] | |
| for synset in synsets[:max_synonyms]: | |
| for lemma in synset.lemmas(): | |
| syn = lemma.name().replace('_', ' ') | |
| # Only single words, different from original | |
| if len(syn.split()) == 1 and syn.lower() != word.lower(): | |
| synonyms.append(syn) | |
| return list(set(synonyms)) | |
| def get_contextual_similarity(self, original_sentence: str, | |
| modified_sentences: List[str]) -> np.ndarray: | |
| """Calculate semantic similarity between original and modified sentences""" | |
| all_sentences = [original_sentence] + modified_sentences | |
| embeddings = self.model.encode(all_sentences) | |
| # Compute similarity between original and all modified versions | |
| similarities = cosine_similarity([embeddings[0]], embeddings[1:])[0] | |
| return similarities | |
| def select_best_synonym(self, word: str, synonyms: List[str], | |
| context: str, word_idx: int, | |
| words: List[str]) -> str: | |
| """Select synonym that maintains contextual meaning""" | |
| if not synonyms: | |
| return word | |
| # Create original sentence | |
| original_sentence = ' '.join(words) | |
| # Create candidate sentences with each synonym | |
| candidate_sentences = [] | |
| for syn in synonyms: | |
| modified_words = words.copy() | |
| modified_words[word_idx] = syn | |
| candidate_sentences.append(' '.join(modified_words)) | |
| # Calculate contextual similarities | |
| similarities = self.get_contextual_similarity(original_sentence, candidate_sentences) | |
| # Filter synonyms with high similarity (> threshold) | |
| similarity_threshold = 0.85 | |
| valid_candidates = [ | |
| (syn, sim) for syn, sim in zip(synonyms, similarities) | |
| if sim >= similarity_threshold | |
| ] | |
| if not valid_candidates: | |
| # If no candidates meet threshold, return original word | |
| return word | |
| # Return synonym with highest similarity | |
| best_synonym = max(valid_candidates, key=lambda x: x[1])[0] | |
| return best_synonym | |
| def synonym_replace(self, text: str, prob: float = 0.3, | |
| min_word_length: int = 3, | |
| max_synonyms: int = 5) -> str: | |
| """Replace words with contextually appropriate synonyms""" | |
| words = word_tokenize(text) | |
| pos_tags = pos_tag(words) | |
| new_words = words.copy() | |
| for idx, (word, pos) in enumerate(pos_tags): | |
| # Skip non-alphabetic tokens | |
| if not word.isalpha(): | |
| continue | |
| # Skip stopwords and short words | |
| if word.lower() in self.stop_words or len(word) <= min_word_length: | |
| continue | |
| # Random probability check | |
| if random.random() > prob: | |
| continue | |
| # Get candidate synonyms | |
| synonyms = self.get_synonyms(word, pos, max_synonyms) | |
| if synonyms: | |
| # Select best contextual synonym | |
| best_syn = self.select_best_synonym( | |
| word, synonyms, text, idx, words | |
| ) | |
| new_words[idx] = best_syn | |
| return ' '.join(new_words) | |
| # ============================================================================ | |
| # IMPROVED ACADEMIC DISCOURSE TRANSFORMATION | |
| # ============================================================================ | |
| class AcademicDiscourseTransformer: | |
| def __init__(self): | |
| self.contractions = { | |
| "don't": "do not", "doesn't": "does not", "didn't": "did not", | |
| "can't": "cannot", "couldn't": "could not", "shouldn't": "should not", | |
| "wouldn't": "would not", "won't": "will not", "aren't": "are not", | |
| "isn't": "is not", "wasn't": "was not", "weren't": "were not", | |
| "haven't": "have not", "hasn't": "has not", "hadn't": "had not", | |
| "I'm": "I am", "I've": "I have", "I'll": "I will", "I'd": "I would", | |
| "you're": "you are", "you've": "you have", "you'll": "you will", | |
| "we're": "we are", "we've": "we have", "we'll": "we will", | |
| "they're": "they are", "they've": "they have", "they'll": "they will", | |
| "it's": "it is", "that's": "that is", "there's": "there is", | |
| "what's": "what is" | |
| } | |
| self.hedges = [ | |
| "it appears that", "it is possible that", "the results suggest", | |
| "it seems that", "there is evidence that", "it may be the case that", | |
| "to some extent", "in general terms", "one could argue that", | |
| "arguably", "potentially" | |
| ] | |
| self.boosters = [ | |
| "clearly", "indeed", "in fact", "undoubtedly", | |
| "without doubt", "it is evident that", "there is no question that", | |
| "certainly", "definitely", "obviously" | |
| ] | |
| self.connectors = { | |
| "contrast": ["however", "on the other hand", "in contrast", | |
| "nevertheless", "nonetheless", "conversely"], | |
| "addition": ["moreover", "furthermore", "in addition", "additionally", | |
| "what is more", "besides"], | |
| "cause_effect": ["therefore", "thus", "as a result", "consequently", | |
| "hence", "accordingly"], | |
| "example": ["for instance", "for example", "to illustrate", "namely"], | |
| "emphasis": ["notably", "particularly", "especially", "significantly"], | |
| "conclusion": ["in conclusion", "overall", "in summary", "to sum up", | |
| "in brief"] | |
| } | |
| self.sentence_starters = [ | |
| "It is important to note that", | |
| "A key implication is that", | |
| "The evidence indicates that", | |
| "The findings suggest that", | |
| "This demonstrates that", | |
| "It should be emphasized that", | |
| "From these observations, it follows that", | |
| "It is worth noting that" | |
| ] | |
| # Sentence classification patterns | |
| self.claim_patterns = [ | |
| r'\b(introduce|present|propose|develop|create|build|design)\b', | |
| r'\b(this (paper|study|work|research))\b', | |
| r'\b(we (introduce|present|propose|develop))\b' | |
| ] | |
| self.evidence_patterns = [ | |
| r'\b(results? (show|indicate|demonstrate|reveal))\b', | |
| r'\b(findings? (suggest|indicate|show))\b', | |
| r'\b(data (show|indicate|demonstrate))\b', | |
| r'\b(experiments? (show|demonstrate|reveal))\b', | |
| r'\b(analysis (shows?|indicates?|demonstrates?))\b' | |
| ] | |
| self.interpretation_patterns = [ | |
| r'\b(implies? that|suggests? that|indicates? that)\b', | |
| r'\b(can be (interpreted|understood|seen))\b', | |
| r'\b(may (be|indicate|suggest))\b' | |
| ] | |
| def classify_sentence(self, sentence: str) -> str: | |
| """Classify sentence by its academic function""" | |
| sent_lower = sentence.lower() | |
| # Check for claims/contributions | |
| if any(re.search(pattern, sent_lower) for pattern in self.claim_patterns): | |
| return 'claim' | |
| # Check for evidence/results | |
| if any(re.search(pattern, sent_lower) for pattern in self.evidence_patterns): | |
| return 'evidence' | |
| # Check for interpretations | |
| if any(re.search(pattern, sent_lower) for pattern in self.interpretation_patterns): | |
| return 'interpretation' | |
| return 'general' | |
| def detect_semantic_relationship(self, prev_sent: str, curr_sent: str) -> Optional[str]: | |
| """Detect semantic relationship between consecutive sentences""" | |
| prev_lower = prev_sent.lower() | |
| curr_lower = curr_sent.lower() | |
| # Contrast indicators | |
| contrast_words = ['however', 'but', 'although', 'while', 'whereas', 'despite'] | |
| if any(word in curr_lower for word in contrast_words): | |
| return 'contrast' | |
| # Addition/continuation indicators | |
| addition_words = ['also', 'additionally', 'moreover', 'furthermore'] | |
| if any(word in curr_lower for word in addition_words): | |
| return 'addition' | |
| # Cause-effect indicators | |
| causal_words = ['therefore', 'thus', 'consequently', 'as a result', 'because'] | |
| if any(word in curr_lower for word in causal_words): | |
| return 'cause_effect' | |
| # Example indicators | |
| example_words = ['for example', 'for instance', 'such as', 'including'] | |
| if any(word in curr_lower for word in example_words): | |
| return 'example' | |
| # Check for negative/positive sentiment shift (basic heuristic) | |
| negative_words = ['not', 'no', 'never', 'without', 'lacking', 'failed', 'limitation'] | |
| positive_words = ['successful', 'effective', 'improved', 'enhanced', 'benefit'] | |
| prev_negative = any(word in prev_lower for word in negative_words) | |
| curr_negative = any(word in curr_lower for word in negative_words) | |
| if prev_negative != curr_negative: | |
| return 'contrast' | |
| return None | |
| def expand_contractions(self, text: str) -> str: | |
| """Expand contractions to formal academic language""" | |
| for contraction, expansion in self.contractions.items(): | |
| pattern = re.compile(r'\b' + re.escape(contraction) + r'\b', re.IGNORECASE) | |
| text = pattern.sub(expansion, text) | |
| return text | |
| def apply_transformation(self, sentence: str, transform_type: str, | |
| connector_type: Optional[str] = None) -> str: | |
| """Apply a single transformation to a sentence""" | |
| # Ensure sentence starts with capital letter | |
| if not sentence[0].isupper(): | |
| sentence = sentence[0].upper() + sentence[1:] | |
| if transform_type == 'hedge': | |
| hedge = random.choice(self.hedges) | |
| # Insert hedge after first word or phrase | |
| return f"{hedge.capitalize()}, {sentence[0].lower() + sentence[1:]}" | |
| elif transform_type == 'booster': | |
| booster = random.choice(self.boosters) | |
| return f"{booster.capitalize()}, {sentence}" | |
| elif transform_type == 'starter': | |
| starter = random.choice(self.sentence_starters) | |
| return f"{starter} {sentence[0].lower() + sentence[1:]}" | |
| elif transform_type == 'connector' and connector_type: | |
| connector = random.choice(self.connectors[connector_type]) | |
| return f"{connector.capitalize()}, {sentence[0].lower() + sentence[1:]}" | |
| return sentence | |
| def add_academic_discourse(self, text: str, | |
| transformation_prob: float = 0.3) -> str: | |
| """ | |
| Add academic discourse markers with context awareness | |
| Args: | |
| text: Input text | |
| transformation_prob: Overall probability of transforming a sentence | |
| """ | |
| # Expand contractions first | |
| text = self.expand_contractions(text) | |
| # Split into sentences | |
| sentences = nltk.sent_tokenize(text) | |
| modified_sentences = [] | |
| for i, sent in enumerate(sentences): | |
| # Classify sentence | |
| sent_type = self.classify_sentence(sent) | |
| # Determine if transformation should be applied | |
| if random.random() > transformation_prob: | |
| modified_sentences.append(sent) | |
| continue | |
| # Choose transformation based on sentence type and position | |
| transform_type = None | |
| connector_type = None | |
| if i == 0: | |
| # First sentence: avoid connectors | |
| if sent_type == 'claim': | |
| transform_type = random.choice(['booster', 'starter', None]) | |
| else: | |
| transform_type = random.choice(['starter', None]) | |
| else: | |
| # Get previous sentence for context | |
| prev_sent = sentences[i-1] | |
| relationship = self.detect_semantic_relationship(prev_sent, sent) | |
| if relationship: | |
| # Use appropriate connector | |
| transform_type = 'connector' | |
| connector_type = relationship | |
| elif sent_type == 'claim': | |
| # Claims: prefer boosters or starters | |
| transform_type = random.choice(['booster', 'starter', None]) | |
| elif sent_type == 'evidence': | |
| # Evidence: avoid hedges (data should be certain) | |
| transform_type = random.choice(['booster', None]) | |
| elif sent_type == 'interpretation': | |
| # Interpretations: can use hedges | |
| transform_type = random.choice(['hedge', 'starter', None]) | |
| else: | |
| # General sentences: balanced approach | |
| transform_type = random.choice([ | |
| 'hedge', 'booster', 'starter', 'connector', None | |
| ]) | |
| if transform_type == 'connector': | |
| connector_type = random.choice(list(self.connectors.keys())) | |
| # Apply transformation | |
| if transform_type: | |
| sent = self.apply_transformation(sent, transform_type, connector_type) | |
| modified_sentences.append(sent) | |
| return ' '.join(modified_sentences) | |
| # ============================================================================ | |
| # STAGE 4: SENTENCE STRUCTURE VARIATION | |
| # ============================================================================ | |
| def vary_sentence_structure( | |
| text: str, | |
| split_prob: float = 0.4, | |
| merge_prob: float = 0.3, | |
| min_split_length: int = 20, | |
| max_merge_length: int = 10 | |
| ) -> str: | |
| """ | |
| Enhance sentence structure variation using NLI inference + | |
| semantic similarity to preserve academic integrity. | |
| """ | |
| connectors = { | |
| "contrast": ["however", "nevertheless", "nonetheless", "in contrast"], | |
| "addition": ["moreover", "furthermore", "in addition", "what is more", "also"], | |
| "cause_effect": ["therefore", "thus", "consequently", "as a result"], | |
| "example": ["for example", "for instance", "to illustrate"], | |
| "conclusion": ["in conclusion", "overall", "in summary"] | |
| } | |
| all_connectors = {c.lower() for group in connectors.values() for c in group} | |
| def already_has_connector(s: str) -> bool: | |
| s = s.strip().lower() | |
| return any(s.startswith(c) for c in all_connectors) | |
| def sentence_is_fragment(s: str) -> bool: | |
| doc = nlp(s) | |
| has_verb = any(t.pos_ in ("VERB", "AUX") for t in doc) | |
| has_subj = any(t.dep_ in ("nsubj", "nsubjpass") for t in doc) | |
| return not (has_verb and has_subj) | |
| def choose_connector_type(prev_sent: str, curr_sent: str) -> str: | |
| curr_lower = curr_sent.lower() | |
| # Rule-based first | |
| if any(x in curr_lower for x in ["such as", "for instance", "including"]): | |
| return "example" | |
| if curr_lower.startswith(("however", "although", "but", "nevertheless")): | |
| return "contrast" | |
| if any(x in curr_lower for x in ["therefore", "thus", "as a result", "because"]): | |
| return "cause_effect" | |
| # === NLI inference === | |
| try: | |
| logits = nli_model.predict([(prev_sent, curr_sent)])[0] | |
| contradiction, neutral, entailment = logits | |
| if contradiction > 0.40: | |
| return "contrast" | |
| if entailment > 0.40: | |
| if "because" in curr_lower: | |
| return "cause_effect" | |
| return "addition" | |
| except: | |
| pass # fail safe | |
| # === Similarity fallback === | |
| emb = similarity_model.encode([prev_sent, curr_sent], convert_to_tensor=True) | |
| sim = util.cos_sim(emb[0], emb[1]).item() | |
| return "addition" if sim >= 0.55 else "contrast" | |
| def add_connector(prev, curr): | |
| ctype = choose_connector_type(prev, curr) | |
| connector = random.choice(connectors[ctype]) | |
| return f"{connector.capitalize()}, {curr[0].lower() + curr[1:]}" | |
| doc = nlp(text) | |
| doc_sents = list(doc.sents) # real spaCy sentence spans | |
| modified = [] | |
| for idx, sent_span in enumerate(doc_sents): | |
| sent = sent_span.text.strip() | |
| words = sent.split() | |
| # SPLIT | |
| if len(words) > min_split_length and random.random() < split_prob: | |
| tokens = list(sent_span) # tokens inside this sentence span | |
| # find split points inside sentence (no sentence-start confusion) | |
| split_positions = [ | |
| j for j, tok in enumerate(tokens) | |
| if tok.dep_ in ("cc", "mark") # coordinating conj / subordinate clause marker | |
| ] | |
| if split_positions: | |
| sp = random.choice(split_positions) | |
| tokens = list(nlp(sent)) | |
| if 0 < sp < len(tokens): | |
| first = " ".join(t.text for t in tokens[:sp]).strip() | |
| second = " ".join(t.text for t in tokens[sp+1:]).strip() | |
| if first and second and not sentence_is_fragment(second): | |
| if not already_has_connector(second) and random.random() < 0.5: | |
| second = add_connector(first, second) | |
| modified.extend([first + ".", second]) | |
| continue | |
| # MERGE | |
| if (modified | |
| and len(words) < max_merge_length | |
| and len(modified[-1].split()) < max_merge_length | |
| and random.random() < merge_prob): | |
| prev = modified[-1] | |
| if not already_has_connector(sent): | |
| merged_clause = add_connector(prev, sent) | |
| if prev.endswith("."): | |
| merged = prev[:-1] + f"; {merged_clause[0].lower() + merged_clause[1:]}" | |
| else: | |
| merged = prev + f", {merged_clause.lower()}" | |
| if not sentence_is_fragment(sent): | |
| modified[-1] = merged | |
| continue | |
| modified.append(sent) | |
| # Clean + Capitalize sentences | |
| out = " ".join(modified) | |
| out = re.sub(r"\s+", " ", out).strip() | |
| out = ". ".join(s.strip().capitalize() for s in out.split(".") if s.strip()) + "." | |
| return out | |
| # ============================================================================ | |
| # LLM Refinement with Gemini | |
| # ============================================================================ | |
| GEMINI_VALIDATION_PROMPT = """ | |
| You will be given two texts: an 'Original' text and a 'Transformed' text. The 'Transformed' text is a poor modification of the 'Original', containing grammatical errors, misspellings, and inappropriate synonyms. | |
| Your task is to: | |
| 1. Compare the 'Transformed' text word-by-word against the 'Original' text. | |
| 2. Identify every word in the 'Transformed' text that is incorrect or a poor substitute. | |
| 3. Categorize these into: | |
| - "irrelevant_incorrect" | |
| - "inappropriate_synonyms" | |
| 4. For each, return a JSON dictionary with | |
| "transformed_word" : "correct_word_from_original" | |
| ### Output Format ### | |
| { | |
| "irrelevant_incorrect": { "bad_word": "correct_word", ... }, | |
| "inappropriate_synonyms": { "bad_word": "correct_word", ... } | |
| } | |
| ### Text ### | |
| Original: | |
| <<<ORIGINAL_TEXT>>> | |
| Transformed: | |
| <<<TRANSFORMED_TEXT>>> | |
| """ | |
| def validateText(original,transformed): | |
| # ------------------- Build Prompt ------------------- | |
| prompt = GEMINI_VALIDATION_PROMPT \ | |
| .replace("<<<ORIGINAL_TEXT>>>", original) \ | |
| .replace("<<<TRANSFORMED_TEXT>>>", transformed) | |
| # ------------------- Query Gemini ------------------- | |
| response = model.generate_content(prompt) | |
| result = response.text | |
| print("\n\n### Gemini Output ###\n", result) | |
| try: | |
| corrections = json.loads(result) | |
| except: | |
| # sometimes model adds markdown, brackets etc. optional cleaning | |
| cleaned = re.sub(r"```json|```", "", result).strip() | |
| corrections = json.loads(cleaned) | |
| irrelevant = corrections.get("irrelevant_incorrect", {}) | |
| synonyms = corrections.get("inappropriate_synonyms", {}) | |
| # ------------------- Update Transformed Text ------------------- | |
| updated_text = transformed | |
| for wrong, right in {**irrelevant, **synonyms}.items(): | |
| updated_text = re.sub(rf"\b{wrong}\b", right, updated_text) | |
| print("\n\n### Updated Text After Gemini ###\n", updated_text) | |
| return updated_text | |
| # ============================================================================ | |
| # QUALITY CHECK | |
| # ============================================================================ | |
| def calculate_similarity(text1: str, text2: str) -> float: | |
| """Calculate semantic similarity between two texts""" | |
| try: | |
| embeddings = similarity_model.encode([text1.strip(), text2.strip()]) | |
| similarity = float(np.dot(embeddings[0], embeddings[1]) / ( | |
| np.linalg.norm(embeddings[0]) * np.linalg.norm(embeddings[1]) | |
| )) | |
| similarity = round(similarity*100, 2) | |
| return similarity | |
| except Exception as e: | |
| return 0.0 | |
| # ============================================================================ | |
| # AI Detection | |
| # ============================================================================ | |
| def predict_ai_content(text): | |
| if not text or not text.strip(): | |
| return "No input provided", 0.0 | |
| try: | |
| result = ai_detector_pipe(text) | |
| if isinstance(result, list) and len(result) > 0: | |
| res = result[0] | |
| ai_content_label = res.get('label', 'Unknown') | |
| ai_content_score = round(float(res.get('score', 0)) * 100, 2) | |
| return ai_content_label, ai_content_score | |
| else: | |
| return "Invalid response", 0.0 | |
| except Exception as e: | |
| print(f"Error in prediction: {e}") | |
| return "Error", 0.0 | |
| # ============================================================================ | |
| # MAIN HUMANIZER FUNCTION | |
| # ============================================================================ | |
| def humanize_text( | |
| input_text: str, | |
| # Stage toggles | |
| enable_stage1: bool, | |
| enable_stage2: bool, | |
| enable_stage3: bool, | |
| enable_stage4: bool, | |
| # Stage 1 parameters | |
| temperature: float, | |
| top_p: float, | |
| num_beams: int, | |
| max_length: int, | |
| repetition_penalty: float, | |
| length_penalty: float, | |
| # Stage 2 parameters | |
| synonym_prob: float, | |
| min_word_length: int, | |
| max_synonyms: int, | |
| # Stage 3 parameters | |
| hedge_prob: float, | |
| booster_prob: float, | |
| connector_prob: float, | |
| starter_prob: float, | |
| # Stage 4 parameters | |
| split_prob: float, | |
| merge_prob: float, | |
| min_split_length: int, | |
| max_merge_length: int | |
| ): | |
| """Main humanizer function that processes text through all enabled stages""" | |
| original = input_text | |
| if not input_text.strip(): | |
| return "", 0.0, "Please enter some text to humanize." | |
| try: | |
| result = input_text | |
| stages_applied = [] | |
| # Stage 1: Paraphrasing | |
| if enable_stage1: | |
| word_count = len(result.split()) | |
| if word_count > 100: | |
| result = paraphrase_long_text(result, max_length, num_beams, temperature, | |
| top_p, repetition_penalty, length_penalty) | |
| else: | |
| result = paraphrase_text(result, max_length, num_beams, temperature, | |
| top_p, repetition_penalty, length_penalty) | |
| stages_applied.append("Paraphrasing") | |
| # Stage 2: Synonym Replacement | |
| if enable_stage2: | |
| replacer = ContextualSynonymReplacer() | |
| random.seed(42) # For reproducibility | |
| result = replacer.synonym_replace( | |
| result, | |
| prob=0.3, | |
| min_word_length=3, | |
| max_synonyms=5 | |
| ) | |
| stages_applied.append("Synonym Replacement") | |
| # Stage 3: Academic Discourse | |
| if enable_stage3: | |
| transformer = AcademicDiscourseTransformer() | |
| random.seed(42) | |
| result = transformer.add_academic_discourse(result, transformation_prob=0.4) | |
| stages_applied.append("Academic Discourse") | |
| # Stage 4: Sentence Structure | |
| if enable_stage4: | |
| result = vary_sentence_structure(result, split_prob, merge_prob, | |
| min_split_length, max_merge_length) | |
| stages_applied.append("Sentence Structure") | |
| # LLM Review | |
| result = validateText(original,result) | |
| stages_applied.append("LLM Review") | |
| # Calculate similarity | |
| similarity = calculate_similarity(input_text, result) | |
| ai_content_label_generated, ai_content_score_generated = predict_ai_content(result) | |
| ai_content_label_input, ai_content_score_input = predict_ai_content(input_text) | |
| # Generate status message | |
| if not stages_applied: | |
| status = "⚠️ No stages enabled. Please enable at least one stage." | |
| else: | |
| status = f"✅ Successfully applied: {', '.join(stages_applied)}" | |
| return result, similarity, status,ai_content_label_generated, ai_content_score_generated,ai_content_label_input, ai_content_score_input | |
| except Exception as e: | |
| import traceback | |
| traceback.print_exc() | |
| return "", 0.0, f"❌ Error: {str(e)}" | |
| # ============================================================================ | |
| # GRADIO INTERFACE | |
| # ============================================================================ | |
| def create_gradio_interface(): | |
| """Create the Gradio interface""" | |
| with gr.Blocks(theme=gr.themes.Soft(), title="Neural Humanizer") as demo: | |
| gr.Markdown( | |
| """ | |
| # ✍️ Neural Humanizer | |
| Transform AI-generated text into natural, human-like language with precision, style, and control. | |
| """ | |
| ) | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| input_text = gr.Textbox( | |
| label="Input Text", | |
| placeholder="Enter your text here to humanize...", | |
| lines=10 | |
| ) | |
| with gr.Row(): | |
| submit_btn = gr.Button("🚀 Transform Text", variant="primary", size="lg") | |
| clear_btn = gr.Button("🔄 Clear", size="lg") | |
| output_text = gr.Textbox( | |
| label="Humanized Output", | |
| lines=10, | |
| interactive=False | |
| ) | |
| with gr.Row(): | |
| gr.Markdown("### Semantic Similarity & Status") | |
| with gr.Row(): | |
| similarity_output = gr.Number(label="Content Similarity (%)", precision=2) | |
| status_output = gr.Textbox(label="Status",interactive=False,lines=2, max_lines=10) | |
| with gr.Row(): | |
| gr.Markdown("### Given Input Text Analysis") | |
| with gr.Row(): | |
| ai_content_label_input = gr.Textbox( | |
| label="Detected Content Type", | |
| interactive=False, | |
| lines=2, | |
| max_lines=10 | |
| ) | |
| ai_content_score_input = gr.Number( | |
| label="Model Confidence (%)", | |
| precision=2, | |
| interactive=False | |
| ) | |
| with gr.Row(): | |
| gr.Markdown("### Humanized Text Analysis") | |
| with gr.Row(): | |
| ai_content_label_generated = gr.Textbox( | |
| label="Detected Content Type", | |
| interactive=False, | |
| lines=2, | |
| max_lines=10 | |
| ) | |
| ai_content_score_generated = gr.Number( | |
| label="Model Confidence (%)", | |
| precision=2, | |
| interactive=False | |
| ) | |
| with gr.Column(scale=1): | |
| gr.Markdown("## 🎛️ Pipeline Configuration") | |
| with gr.Accordion("Stage Selection", open=True): | |
| enable_stage1 = gr.Checkbox(label="Stage 1: Paraphrasing (T5)", value=True) | |
| enable_stage2 = gr.Checkbox(label="Stage 2: Lexical Diversification", value=True) | |
| enable_stage3 = gr.Checkbox(label="Stage 3: Discourse Enrichment", value=True) | |
| enable_stage4 = gr.Checkbox(label="Stage 4: Structural Variation", value=True) | |
| gr.HTML("<div style='padding:8px; border-left:4px solid #3b82f6; border-radius:4px;'> ✅ Final Stage: <b>LLM-powered Text Review</b> applied automatically for quality assurance. </div>") | |
| with gr.Accordion("Stage 1: Paraphrasing Parameters", open=False): | |
| temperature = gr.Slider(0.1, 2.0, value=0.7, step=0.1, label="Temperature") | |
| top_p = gr.Slider(0.1, 1.0, value=0.9, step=0.05, label="Top-p") | |
| num_beams = gr.Slider(1, 10, value=4, step=1, label="Num Beams") | |
| max_length = gr.Slider(128, 1024, value=512, step=64, label="Max Length") | |
| repetition_penalty = gr.Slider(1.0, 2.0, value=1.2, step=0.1, label="Repetition Penalty") | |
| length_penalty = gr.Slider(0.5, 2.0, value=1.0, step=0.1, label="Length Penalty") | |
| with gr.Accordion("Stage 2: Synonym Replacement Parameters", open=False): | |
| synonym_prob = gr.Slider(0.0, 1.0, value=0.3, step=0.05, label="Replacement Probability") | |
| min_word_length = gr.Slider(2, 8, value=3, step=1, label="Min Word Length") | |
| max_synonyms = gr.Slider(1, 10, value=3, step=1, label="Max Synonyms") | |
| with gr.Accordion("Stage 3: Academic Discourse Parameters", open=False): | |
| hedge_prob = gr.Slider(0.0, 0.5, value=0.2, step=0.05, label="Hedge Probability") | |
| booster_prob = gr.Slider(0.0, 0.5, value=0.15, step=0.05, label="Booster Probability") | |
| connector_prob = gr.Slider(0.0, 0.5, value=0.25, step=0.05, label="Connector Probability") | |
| starter_prob = gr.Slider(0.0, 0.3, value=0.1, step=0.05, label="Starter Probability") | |
| with gr.Accordion("Stage 4: Sentence Structure Parameters", open=False): | |
| split_prob = gr.Slider(0.0, 1.0, value=0.4, step=0.05, label="Split Probability") | |
| merge_prob = gr.Slider(0.0, 1.0, value=0.3, step=0.05, label="Merge Probability") | |
| min_split_length = gr.Slider(10, 40, value=20, step=5, label="Min Split Length (words)") | |
| max_merge_length = gr.Slider(5, 20, value=10, step=1, label="Max Merge Length (words)") | |
| with gr.Accordion("Final Stage: LLM Review", open=False): | |
| gr.Markdown( | |
| """ | |
| The final stage employs a large language model to review and refine the transformed text. It identifies and corrects any inappropriate word choices, grammatical errors, or inconsistencies to ensure the output is of the highest quality. | |
| """ | |
| ) | |
| with gr.Accordion("About Neural Humanizer", open=False): | |
| gr.Markdown( | |
| """ | |
| **Neural Humanizer** is an advanced text transformation tool designed to convert AI-generated content into natural, human-like language. By leveraging a multi-stage pipeline, it enhances text fluency, diversity, and academic integrity. | |
| ### Key Features: | |
| - **Paraphrasing**: Utilizes state-of-the-art language models to rephrase text while preserving meaning. | |
| - **Lexical Diversification**: Replaces words with contextually appropriate synonyms for richer vocabulary. | |
| - **Discourse Enrichment**: Adds academic discourse markers to improve formality and coherence. | |
| - **Structural Variation**: Modifies sentence structures for enhanced readability. | |
| - **LLM-powered Review**: Employs large language models to validate and refine the final output. | |
| ### Usage: | |
| 1. Input your AI-generated text. | |
| 2. Configure the desired stages and parameters. | |
| 3. Click "Transform Text" to generate humanized content. | |
| ### Note: | |
| The final review stage is always applied to ensure the highest quality output. | |
| """ | |
| ) | |
| # Event handlers | |
| submit_btn.click( | |
| fn=humanize_text, | |
| inputs=[ | |
| input_text, | |
| enable_stage1, enable_stage2, enable_stage3, enable_stage4, | |
| temperature, top_p, num_beams, max_length, repetition_penalty, length_penalty, | |
| synonym_prob, min_word_length, max_synonyms, | |
| hedge_prob, booster_prob, connector_prob, starter_prob, | |
| split_prob, merge_prob, min_split_length, max_merge_length | |
| ], | |
| outputs=[output_text, similarity_output, status_output, ai_content_label_generated, ai_content_score_generated, ai_content_label_input, ai_content_score_input] | |
| ) | |
| clear_btn.click( | |
| fn=lambda: ("", "", 0.0, "","", 0.0, "", 0.0), | |
| inputs=[], | |
| outputs=[input_text, output_text, similarity_output, status_output, ai_content_label_generated, ai_content_score_generated, ai_content_label_input, ai_content_score_input] | |
| ) | |
| return demo | |
| # ============================================================================ | |
| # LAUNCH | |
| # ============================================================================ | |
| if __name__ == "__main__": | |
| demo = create_gradio_interface() | |
| demo.launch(share=True, server_name="0.0.0.0", server_port=7860) |