app v.1.py

import gradio as gr
import random
import nltk
import re
import spacy
from nltk.corpus import wordnet, stopwords
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
from sentence_transformers import SentenceTransformer
import torch
import numpy as np
from typing import List, Dict, Tuple
import logging
from transformers import pipeline


# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

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


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:
        logger.warning(f"Paraphrasing failed: {e}. Returning original text.")
        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)

# ============================================================================
# STAGE 2: SYNONYM REPLACEMENT
# ============================================================================
def get_synonyms(word: str, pos: str, max_synonyms: int = 3) -> List[str]:
    """Get WordNet synonyms"""
    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()[:5]:
            syn = lemma.name().replace('_', ' ')
            if len(syn.split()) == 1 and syn.lower() != word.lower():
                synonyms.append(syn)
    
    return list(set(synonyms))

def synonym_replace(text: str, prob: float = 0.3, min_word_length: int = 3, 
                   max_synonyms: int = 3) -> str:
    """Replace words with synonyms"""
    from nltk import pos_tag, word_tokenize
    
    stop_words = set(stopwords.words('english'))
    words = word_tokenize(text)
    pos_tags = pos_tag(words)
    new_words = []
    
    for word, pos in pos_tags:
        if not word.isalpha():
            new_words.append(word)
            continue
        
        if word.lower() in stop_words or len(word) <= min_word_length:
            new_words.append(word)
            continue
        
        if random.random() > prob:
            new_words.append(word)
            continue
        
        synonyms = get_synonyms(word, pos, max_synonyms)
        candidates = [s for s in synonyms if s.lower() != word.lower()]
        
        if candidates:
            replacement = random.choice(candidates)
            new_words.append(replacement)
        else:
            new_words.append(word)
    
    return ' '.join(new_words)

# ============================================================================
# STAGE 3: ACADEMIC DISCOURSE
# ============================================================================
def add_academic_discourse(text: str, hedge_prob: float = 0.2, booster_prob: float = 0.15,
                          connector_prob: float = 0.25, starter_prob: float = 0.1) -> str:
    """Add academic discourse elements"""
    
    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"
    }
    
    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"
    ]
    
    boosters = [
        "clearly", "indeed", "in fact", "undoubtedly",
        "without doubt", "it is evident that", "there is no question that"
    ]
    
    connectors = {
        "contrast": ["however", "on the other hand", "in contrast", "nevertheless"],
        "addition": ["moreover", "furthermore", "in addition", "what is more"],
        "cause_effect": ["therefore", "thus", "as a result", "consequently", "hence"],
        "example": ["for instance", "for example", "to illustrate"],
        "conclusion": ["in conclusion", "overall", "in summary", "to sum up"]
    }
    
    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"
    ]
    
    # Expand contractions
    for contraction, expansion in contractions.items():
        pattern = re.compile(r'\b' + re.escape(contraction) + r'\b', re.IGNORECASE)
        text = pattern.sub(expansion, text)
    
    sentences = nltk.sent_tokenize(text)
    modified = []
    
    for i, sent in enumerate(sentences):
        # Add hedge
        if random.random() < hedge_prob and i > 0:
            hedge = random.choice(hedges)
            sent = f"{hedge}, {sent[0].lower() + sent[1:]}"
        
        # Add booster
        elif random.random() < booster_prob:
            booster = random.choice(boosters)
            sent = f"{booster.capitalize()}, {sent}"
        
        # Add starter
        elif random.random() < starter_prob and i > 0:
            starter = random.choice(sentence_starters)
            sent = f"{starter} {sent[0].lower() + sent[1:]}"
        
        # Add connector
        if i > 0 and random.random() < connector_prob:
            conn_type = random.choice(list(connectors.keys()))
            connector = random.choice(connectors[conn_type])
            sent = f"{connector.capitalize()}, {sent[0].lower() + sent[1:]}"
        
        modified.append(sent)
    
    return ' '.join(modified)

# ============================================================================
# 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:
    """Vary sentence structure"""
    
    connectors = {
        "contrast": ["however", "nevertheless", "nonetheless", "in contrast"],
        "addition": ["moreover", "furthermore", "in addition", "what is more"],
        "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(sentence: str) -> bool:
        lower_sent = sentence.strip().lower()
        return any(lower_sent.startswith(conn) for conn in all_connectors)
    
    def choose_connector_type(prev_sent: str, curr_sent: str) -> str:
        curr_lower = curr_sent.lower()
        
        if any(phrase in curr_lower for phrase in ["such as", "including", "for instance"]):
            return "example"
        elif curr_lower.startswith(("but", "although", "however")):
            return "contrast"
        elif any(phrase in curr_lower for phrase in ["because", "due to", "as a result"]):
            return "cause_effect"
        
        # Semantic similarity fallback
        if prev_sent:
            emb = similarity_model.encode([prev_sent, curr_sent])
            score = np.dot(emb[0], emb[1]) / (np.linalg.norm(emb[0]) * np.linalg.norm(emb[1]))
            return "addition" if score > 0.6 else "contrast"
        
        return "addition"
    
    doc = nlp(text)
    sentences = list(doc.sents)
    modified = []
    
    for idx, sent in enumerate(sentences):
        sent_text = sent.text.strip()
        words = sent_text.split()
        
        # Split long sentences
        if len(words) > min_split_length and random.random() < split_prob:
            split_points = [tok.i - sent.start for tok in sent if tok.dep_ in ("cc", "mark")]
            if split_points:
                split_point = random.choice(split_points)
                tokens = list(sent)
                if 0 < split_point < len(tokens):
                    first = ' '.join([t.text for t in tokens[:split_point]]).strip()
                    second = ' '.join([t.text for t in tokens[split_point+1:]]).strip()
                    if first and second and len(second.split()) > 3:
                        if random.random() < 0.5 and not already_has_connector(second):
                            conn_type = choose_connector_type(first, second)
                            connector = random.choice(connectors[conn_type])
                            second = f"{connector.capitalize()}, {second[0].lower() + second[1:]}"
                        modified.extend([first + '.', second])
                        continue
        
        # Merge short sentences
        if (modified and len(words) < max_merge_length and 
            len(modified[-1].split()) < max_merge_length and random.random() < merge_prob):
            prev_sent = modified[-1]
            if not already_has_connector(sent_text):
                conn_type = choose_connector_type(prev_sent, sent_text)
                connector = random.choice(connectors[conn_type])
                combined = f"{prev_sent.rstrip('.')}; {connector}, {sent_text[0].lower() + sent_text[1:]}"
                modified[-1] = combined
                continue
        
        modified.append(sent_text)
    
    return ' '.join(modified)

# ============================================================================
# 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:
        logger.error(f"Similarity calculation failed: {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"""
    
    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:
            result = synonym_replace(result, synonym_prob, min_word_length, max_synonyms)
            stages_applied.append("Synonym Replacement")
        
        # Stage 3: Academic Discourse
        if enable_stage3:
            result = add_academic_discourse(result, hedge_prob, booster_prob, 
                                           connector_prob, starter_prob)
            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")
        
        # 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:
        logger.error(f"Error in humanization: {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)

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