Update app.py

app.py

@@ -1,425 +1,1275 @@
-# app.py - Advanced Deep Humanizer for Hugging Face Spaces
-# Optimized for A100/H100 GPUs - Premium Configuration
+# app.py — Advanced AI Text Humanizer
+# Hugging Face Spaces | Paid GPU Config
 
-import gradio as gr
-import torch
-import random
+import os
 import re
 import json
+import math
+import random
+import time
+import textwrap
+import hashlib
+from collections import Counter, defaultdict
+from typing import Dict, List, Tuple, Optional
+
+import numpy as np
+import torch
+import gradio as gr
 from transformers import (
-    AutoModelForCausalLM, 
-    AutoTokenizer, 
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    AutoModelForSequenceClassification,
+    AutoModelForSeq2SeqLM,
     pipeline,
-    BitsAndBytesConfig
+    set_seed,
 )
-from typing import List, Dict, Tuple
-import numpy as np
-from dataclasses import dataclass
-import spaces  # Hugging Face Spaces utility for GPU management
-
-@dataclass
-class HumanizationConfig:
-    temperature: float = 0.8
-    top_p: float = 0.92
-    repetition_penalty: float = 1.15
-    max_length: int = 4096
-    style_intensity: str = "medium"  # light, medium, aggressive
-    preserve_meaning: bool = True
-    add_imperfections: bool = True
-    burstiness_factor: float = 0.3  # Variation in sentence length
-    perplexity_target: float = 25.0  # Human text usually 15-30
-
-class DeepHumanizer:
-    def __init__(self):
-        self.model_id = "meta-llama/Llama-3.3-70B-Instruct"  # Premium model
-        # Alternative: "Qwen/Qwen2.5-72B-Instruct" or "deepseek-ai/DeepSeek-V3"
-        
-        self.tokenizer = None
-        self.model = None
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.initialize_model()
-        
-    def initialize_model(self):
-        """Initialize 70B model with 4-bit quantization for single A100 80GB"""
-        print(f"Initializing {self.model_id} on {self.device}...")
-        
-        # 4-bit quantization config for 70B on single A100 80GB
-        quantization_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_compute_dtype=torch.float16,
-            bnb_4bit_quant_type="nf4",
-            bnb_4bit_use_double_quant=True,
-        )
-        
-        self.tokenizer = AutoTokenizer.from_pretrained(
-            self.model_id,
+
+# ============================================================
+# CONFIGURATION
+# ============================================================
+
+class Config:
+    DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+    TORCH_DTYPE = torch.float16 if torch.cuda.is_available() else torch.float32
+
+    # Primary rewriting models (ensemble)
+    REWRITE_MODEL_1 = "HuggingFaceH4/zephyr-7b-beta"
+    REWRITE_MODEL_2 = "microsoft/phi-2"
+    REWRITE_MODEL_3 = "mistralai/Mistral-7B-Instruct-v0.3"
+
+    # Style transfer model
+    STYLE_MODEL = "humarin/chatgpt_paraphrase_xl_t5_base"
+
+    # Perplexity analysis
+    PERPLEXITY_MODEL = "EleutherAI/gpt-neo-2.7B"
+
+    # AI Detection model
+    AI_DETECT_MODEL = "roberta-base-openai-detector"
+
+    # Sentiment & Tone
+    SENTIMENT_MODEL = "SamLowe/roberta-base-go_emotions"
+
+    MAX_INPUT_LENGTH = 4000
+    MAX_OUTPUT_LENGTH = 4000
+    ENSEMBLE_WEIGHTS = [0.4, 0.35, 0.25]  # weights for each rewrite model
+
+    # Humanization presets
+    PRESETS = {
+        "🟢 Natural (Light)": {
+            "burstiness": 0.2,
+            "perplexity_boost": 0.15,
+            "style_change": 0.2,
+            "idiom_rate": 0.05,
+            "sentence_variation": 0.2,
+            "emotional_depth": 0.15,
+            "vocabulary_richness": 0.1,
+            "imperfection_rate": 0.05,
+            "personal_touch": 0.1,
+        },
+        "🟡 Conversational (Medium)": {
+            "burstiness": 0.4,
+            "perplexity_boost": 0.3,
+            "style_change": 0.4,
+            "idiom_rate": 0.12,
+            "sentence_variation": 0.4,
+            "emotional_depth": 0.35,
+            "vocabulary_richness": 0.25,
+            "imperfection_rate": 0.08,
+            "personal_touch": 0.25,
+        },
+        "🔴 Fully Human (Aggressive)": {
+            "burstiness": 0.6,
+            "perplexity_boost": 0.5,
+            "style_change": 0.6,
+            "idiom_rate": 0.2,
+            "sentence_variation": 0.6,
+            "emotional_depth": 0.5,
+            "vocabulary_richness": 0.4,
+            "imperfection_rate": 0.12,
+            "personal_touch": 0.4,
+        },
+        "🎓 Academic": {
+            "burstiness": 0.3,
+            "perplexity_boost": 0.35,
+            "style_change": 0.5,
+            "idiom_rate": 0.03,
+            "sentence_variation": 0.5,
+            "emotional_depth": 0.1,
+            "vocabulary_richness": 0.5,
+            "imperfection_rate": 0.02,
+            "personal_touch": 0.05,
+        },
+        "💼 Professional": {
+            "burstiness": 0.25,
+            "perplexity_boost": 0.2,
+            "style_change": 0.3,
+            "idiom_rate": 0.06,
+            "sentence_variation": 0.3,
+            "emotional_depth": 0.2,
+            "vocabulary_richness": 0.3,
+            "imperfection_rate": 0.04,
+            "personal_touch": 0.15,
+        },
+        "✍️ Creative": {
+            "burstiness": 0.55,
+            "perplexity_boost": 0.5,
+            "style_change": 0.7,
+            "idiom_rate": 0.18,
+            "sentence_variation": 0.7,
+            "emotional_depth": 0.6,
+            "vocabulary_richness": 0.55,
+            "imperfection_rate": 0.1,
+            "personal_touch": 0.4,
+        },
+    }
+
+
+# ============================================================
+# MODEL LOADER
+# ============================================================
+
+class ModelHub:
+    """Centralized model loading and caching."""
+
+    _instance = None
+    _loaded_models = {}
+    _loaded_pipelines = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @property
+    def device(self):
+        return Config.DEVICE
+
+    def load_model_and_tokenizer(self, model_name: str, model_class=None):
+        cache_key = model_name
+        if cache_key in self._loaded_models:
+            return self._loaded_models[cache_key]
+
+        print(f"[ModelHub] Loading {model_name}...")
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        if model_class is None:
+            model_class = AutoModelForCausalLM
+
+        model = model_class.from_pretrained(
+            model_name,
+            torch_dtype=Config.TORCH_DTYPE,
+            device_map="auto",
             trust_remote_code=True,
-            padding_side="left"
+            low_cpu_mem_usage=True,
         )
-        
-        if self.tokenizer.pad_token is None:
-            self.tokenizer.pad_token = self.tokenizer.eos_token
-            
-        # Load model with acceleration
-        self.model = AutoModelForCausalLM.from_pretrained(
-            self.model_id,
-            quantization_config=quantization_config,
-            device_map="auto",
+        model.eval()
+        self._loaded_models[cache_key] = (model, tokenizer)
+        print(f"[ModelHub] ✓ {model_name} loaded")
+        return model, tokenizer
+
+    def load_pipeline(self, task: str, model_name: str, **kwargs):
+        cache_key = f"{task}_{model_name}"
+        if cache_key in self._loaded_pipelines:
+            return self._loaded_pipelines[cache_key]
+
+        print(f"[ModelHub] Loading pipeline: {task} - {model_name}")
+        pipe = pipeline(
+            task,
+            model=model_name,
+            device=0 if torch.cuda.is_available() else -1,
+            torch_dtype=Config.TORCH_DTYPE,
             trust_remote_code=True,
-            torch_dtype=torch.float16,
-            attn_implementation="flash_attention_2"  # Speed optimization
+            **kwargs,
+        )
+        self._loaded_pipelines[cache_key] = pipe
+        print(f"[ModelHub] ✓ Pipeline ready: {cache_key}")
+        return pipe
+
+    def load_all_models(self):
+        """Pre-load all models at startup."""
+        print("\n" + "=" * 60)
+        print("🚀 LOADING ALL MODELS — Advanced Humanizer Engine")
+        print("=" * 60 + "\n")
+
+        # Rewrite models
+        self.load_model_and_tokenizer(Config.REWRITE_MODEL_1)
+        self.load_model_and_tokenizer(Config.REWRITE_MODEL_2)
+        self.load_model_and_tokenizer(Config.REWRITE_MODEL_3)
+
+        # Style transfer
+        self.load_model_and_tokenizer(
+            Config.STYLE_MODEL, model_class=AutoModelForSeq2SeqLM
         )
-        
-        self.model.eval()
-        print("Model loaded successfully")
-    
+
+        # Perplexity
+        self.load_model_and_tokenizer(Config.PERPLEXITY_MODEL)
+
+        # AI Detector
+        self.load_model_and_tokenizer(
+            Config.AI_DETECT_MODEL,
+            model_class=AutoModelForSequenceClassification,
+        )
+
+        # Sentiment
+        self.load_model_and_tokenizer(
+            Config.SENTIMENT_MODEL,
+            model_class=AutoModelForSequenceClassification,
+        )
+
+        print("\n" + "=" * 60)
+        print("✅ ALL MODELS LOADED SUCCESSFULLY")
+        print("=" * 60 + "\n")
+
+
+# ============================================================
+# TEXT ANALYZER
+# ============================================================
+
+class TextAnalyzer:
+    """Deep text analysis with multiple metrics."""
+
+    def __init__(self, hub: ModelHub):
+        self.hub = hub
+
     def calculate_perplexity(self, text: str) -> float:
-        """Calculate perplexity score (lower is more predictable/AI-like)"""
-        encodings = self.tokenizer(text, return_tensors="pt")
-        input_ids = encodings.input_ids.to(self.device)
-        
-        with torch.no_grad():
-            outputs = self.model(input_ids, labels=input_ids)
-            loss = outputs.loss
-            
-        perplexity = torch.exp(loss).item()
-        return perplexity
-    
-    def analyze_text_patterns(self, text: str) -> Dict:
-        """Analyze writing patterns to identify AI characteristics"""
-        sentences = re.split(r'(?<=[.!?])\s+', text)
-        words = text.split()
-        
-        # Calculate burstiness (variation in sentence length)
-        if len(sentences) > 1:
-            sent_lengths = [len(s.split()) for s in sentences]
-            burstiness = np.std(sent_lengths) / (np.mean(sent_lengths) + 1e-8)
-        else:
-            burstiness = 0
-            
-        # Common AI patterns
-        ai_patterns = [
-            r'\b(delve|leverage|utilize|facilitate|optimize)\b',
-            r'\b(In conclusion|Furthermore|Moreover|Additionally)\b',
-            r'\b(It is important to note that|It should be noted that)\b',
-            r'(\b\w+\b)\s+\1',  # Repetition
-        ]
-        
-        pattern_matches = sum(len(re.findall(p, text, re.I)) for p in ai_patterns)
-        
+        """Calculate perplexity using a language model."""
+        try:
+            model, tokenizer = self.hub.load_model_and_tokenizer(
+                Config.PERPLEXITY_MODEL
+            )
+            encodings = tokenizer(text, return_tensors="pt").to(self.hub.device)
+            max_length = model.config.max_position_embeddings
+            seq_len = encodings.input_ids.size(1)
+
+            nlls = []
+            prev_end_loc = 0
+            stride = 512
+
+            for begin_loc in range(0, seq_len, stride):
+                end_loc = min(begin_loc + max_length, seq_len)
+                trg_len = end_loc - prev_end_loc
+                input_ids = encodings.input_ids[:, begin_loc:end_loc]
+                target_ids = input_ids.clone()
+                target_ids[:, :-trg_len] = -100
+
+                with torch.no_grad():
+                    outputs = model(input_ids, labels=target_ids)
+                    neg_log_likelihood = outputs.loss
+                nlls.append(neg_log_likelihood)
+                prev_end_loc = end_loc
+                if end_loc == seq_len:
+                    break
+
+            ppl = torch.exp(torch.stack(nlls).mean()).item()
+            return ppl
+        except Exception as e:
+            print(f"[Perplexity Error] {e}")
+            return 0.0
+
+    def detect_ai_probability(self, text: str) -> Dict:
+        """Detect AI-generated text probability."""
+        try:
+            model, tokenizer = self.hub.load_model_and_tokenizer(
+                Config.AI_DETECT_MODEL,
+                model_class=AutoModelForSequenceClassification,
+            )
+            inputs = tokenizer(
+                text, return_tensors="pt", truncation=True, max_length=512
+            ).to(self.hub.device)
+
+            with torch.no_grad():
+                outputs = model(**inputs)
+                probs = torch.softmax(outputs.logits, dim=-1)[0]
+
+            # Label 0 = Real (Human), Label 1 = Fake (AI)
+            human_score = probs[0].item()
+            ai_score = probs[1].item()
+
+            return {
+                "human_probability": round(human_score, 4),
+                "ai_probability": round(ai_score, 4),
+                "verdict": "Likely Human" if human_score > ai_score else "Likely AI",
+                "confidence": round(max(human_score, ai_score), 4),
+            }
+        except Exception as e:
+            print(f"[AI Detection Error] {e}")
+            return {
+                "human_probability": 0.5,
+                "ai_probability": 0.5,
+                "verdict": "Unknown",
+                "confidence": 0.0,
+            }
+
+    def analyze_sentiment_and_tone(self, text: str) -> Dict:
+        """Analyze emotional tone of text."""
+        try:
+            pipe = self.hub.load_pipeline(
+                "text-classification", Config.SENTIMENT_MODEL
+            )
+            results = pipe(text[:1000], top_k=5)
+            emotions = {
+                r["label"]: round(r["score"], 4) for r in results
+            }
+            return {
+                "emotions": emotions,
+                "dominant_emotion": results[0]["label"] if results else "neutral",
+                "dominant_score": (
+                    round(results[0]["score"], 4) if results else 0.0
+                ),
+            }
+        except Exception as e:
+            print(f"[Sentiment Error] {e}")
+            return {
+                "emotions": {"neutral": 1.0},
+                "dominant_emotion": "neutral",
+                "dominant_score": 1.0,
+            }
+
+    def calculate_burstiness(self, text: str) -> float:
+        """Measure sentence length variation (burstiness)."""
+        sentences = re.split(r"[.!?]+", text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        if len(sentences) < 2:
+            return 0.0
+
+        lengths = [len(s.split()) for s in sentences]
+        mean_len = np.mean(lengths)
+        std_len = np.std(lengths)
+        cv = std_len / mean_len if mean_len > 0 else 0  # coefficient of variation
+        return round(cv, 4)
+
+    def calculate_vocabulary_richness(self, text: str) -> float:
+        """Type-Token Ratio (lexical diversity)."""
+        words = re.findall(r"\b\w+\b", text.lower())
+        if not words:
+            return 0.0
+        unique_words = set(words)
+        return round(len(unique_words) / len(words), 4)
+
+    def calculate_readability(self, text: str) -> Dict:
+        """Flesch Reading Ease and related metrics."""
+        words = re.findall(r"\b\w+\b", text)
+        sentences = re.split(r"[.!?]+", text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+
+        if not words or not sentences:
+            return {"flesch_ease": 0, "grade_level": 0}
+
+        num_words = len(words)
+        num_sentences = len(sentences)
+        num_syllables = sum(self._count_syllables(w) for w in words)
+
+        if num_sentences == 0 or num_words == 0:
+            return {"flesch_ease": 0, "grade_level": 0}
+
+        flesch_ease = (
+            206.835
+            - 1.015 * (num_words / num_sentences)
+            - 84.6 * (num_syllables / num_words)
+        )
+        flesch_ease = max(0, min(100, flesch_ease))
+
+        grade_level = (
+            0.39 * (num_words / num_sentences)
+            + 11.8 * (num_syllables / num_words)
+            - 15.59
+        )
+
         return {
-            "burstiness": burstiness,
-            "avg_sentence_length": np.mean([len(s.split()) for s in sentences]) if sentences else 0,
-            "ai_markers": pattern_matches,
-            "formality_score": self._estimate_formality(text)
+            "flesch_ease": round(flesch_ease, 2),
+            "grade_level": round(max(0, grade_level), 1),
+            "avg_words_per_sentence": round(num_words / num_sentences, 1),
+            "avg_syllables_per_word": round(num_syllables / num_words, 2),
         }
-    
-    def _estimate_formality(self, text: str) -> float:
-        """Estimate formality level 0-1"""
-        formal_words = r'\b(therefore|thus|hence|consequently|furthermore|moreover|nevertheless)\b'
-        informal_words = r'\b(so|but|anyway|actually|basically|like|you know)\b'
-        
-        formal_count = len(re.findall(formal_words, text, re.I))
-        informal_count = len(re.findall(informal_words, text, re.I))
-        
-        total = formal_count + informal_count
-        if total == 0:
-            return 0.5
-        return formal_count / total
-    
-    def generate_humanization_prompt(self, text: str, config: HumanizationConfig, 
-                                    style: str, analysis: Dict) -> str:
-        """Generate sophisticated system prompt based on analysis"""
-        
-        imperfections_guide = ""
-        if config.add_imperfections:
-            imperfections_guide = """
-            - Include natural imperfections: occasional fragments, starting sentences with conjunctions (But, And, So)
-            - Vary punctuation usage naturally (em-dashes, occasional ellipses...)
-            - Add conversational fillers where appropriate (well, actually, you know what I mean)
-            - Break formal structure with rhetorical questions or personal asides
-            """
-        
-        style_prompts = {
-            "casual": "Make it sound like a knowledgeable friend explaining over coffee. Use contractions, everyday vocabulary, personal anecdotes potential.",
-            "professional": "Keep it business-appropriate but warm. Like a smart colleague in a Slack message—not too stiff, not too loose.",
-            "academic": "Scholarly but accessible. Reduce robotic transitions but keep the rigor. Like a passionate professor speaking, not writing a textbook.",
-            "creative": "Vivid, varied sentence structures, rhythmic flow. Occasional metaphors, emotional undertones, unpredictable phrasing.",
-            "reddit": "Authentic internet voice. Like a high-karma r/depthhub or r/explainlikeimfive comment. Informative but colloquial.",
-            "twitter": "Sharp, punchy, tweet-thread style. Short sentences mixed with longer explanatory ones. Personality-forward."
+
+    def _count_syllables(self, word: str) -> int:
+        word = word.lower()
+        if len(word) <= 3:
+            return 1
+        word = re.sub(r"(?:[^laeiouy]es|ed|[^laeiouy]e)$", "", word)
+        word = re.sub(r"^y", "", word)
+        syllables = len(re.findall(r"[aeiouy]{1,2}", word))
+        return max(1, syllables)
+
+    def full_analysis(self, text: str) -> Dict:
+        """Run complete text analysis."""
+        return {
+            "perplexity": self.calculate_perplexity(text),
+            "ai_detection": self.detect_ai_probability(text),
+            "sentiment": self.analyze_sentiment_and_tone(text),
+            "burstiness": self.calculate_burstiness(text),
+            "vocabulary_richness": self.calculate_vocabulary_richness(text),
+            "readability": self.calculate_readability(text),
+            "word_count": len(re.findall(r"\b\w+\b", text)),
+            "sentence_count": len(
+                [s for s in re.split(r"[.!?]+", text) if s.strip()]
+            ),
         }
-        
-        style_instruction = style_prompts.get(style, style_prompts["casual"])
-        
-        # Adjust based on detected patterns
-        if analysis["ai_markers"] > 3:
-            de_ai_instruction = "CRITICAL: Remove all AI-signaling phrases (delve, leverage, moreover, it is important to note). "
-        else:
-            de_ai_instruction = ""
-            
-        prompt = f"""<|im_start|>system
-You are an elite linguistic surgeon specializing in humanization of AI-generated text. Your task is to transform robotic, predictable text into authentic human writing that bypasses AI detection through natural variation and cognitive authenticity.
-
-{style_instruction}
-{de_ai_instruction}{imperfections_guide}
-
-TECHNICAL REQUIREMENTS:
-- Target perplexity: {config.perplexity_target} (human range)
-- Burstiness factor: Inject {int(config.burstiness_factor * 100)}% variation in sentence length
-- Maintain core meaning: {config.preserve_meaning}
-- Output ONLY the rewritten text, no explanations, no markdown code blocks
-
-HUMANIZATION LAYERS:
-1. Lexical variation: Replace generic AI terms with context-specific vocabulary
-2. Syntactic diversity: Mix simple, compound, complex sentences irregularly
-3. Semantic noise: Add slight ambiguity or subjective framing where appropriate
-4. Pragmatic markers: Include hesitation, self-correction, natural flow disruptions
-5. Cognitive fingerprint: Inject personal stance or mild opinion<|im_end|>
-<|im_start|>user
-Transform this text into deeply human writing:
-
-{text}<|im_end|>
-<|im_start|>assistant"""
-        
-        return prompt
-    
-    @spaces.GPU(duration=120)  # HF Spaces GPU decorator
-    def humanize(self, text: str, style: str = "casual", intensity: str = "medium",
-                 creativity: float = 0.8, add_typos: bool = False, 
-                 target_reading_level: str = "default") -> Tuple[str, Dict]:
-        """
-        Main humanization pipeline with multi-step refinement
-        """
-        config = HumanizationConfig(
-            temperature=creativity,
-            style_intensity=intensity,
-            add_imperfections=intensity in ["medium", "aggressive"]
+
+
+# ============================================================
+# HUMANIZATION ENGINE
+# ============================================================
+
+class HumanizationEngine:
+    """Multi-strategy text humanization."""
+
+    def __init__(self, hub: ModelHub):
+        self.hub = hub
+
+    # ---- STRATEGIC PROMPTS ----
+
+    HUMANIZATION_PROMPTS = {
+        "general": """You are an expert human writer. Rewrite the following text to sound completely natural, human, and authentic. Use these techniques:
+1. Vary sentence lengths dramatically (mix very short with longer ones)
+2. Use contractions naturally (don't, can't, it's, we're)
+3. Add subtle personal opinions or hedging ("I think", "in my experience", "it seems")
+4. Include transitional phrases ("That said", "On the flip side", "Here's the thing")
+5. Occasionally use colloquialisms or idioms
+6. Add mild imperfections (slight redundancy, conversational asides)
+7. Use active voice predominantly
+8. Vary paragraph structure
+9. Include rhetorical questions occasionally
+10. Make it sound like a real person wrote it — not a robot
+
+TEXT TO HUMANIZE:
+{text}
+
+Rewritten version (same meaning, but fully human-sounding):""",
+
+        "academic": """Rewrite this text in a natural academic style that sounds like a real researcher wrote it:
+- Use sophisticated but natural academic vocabulary
+- Include appropriate hedging ("suggests that", "it appears", "may indicate")
+- Vary sentence structure with complex and simple sentences
+- Use natural transitions between ideas
+- Avoid repetitive patterns typical of AI
+- Sound like an experienced academic, not a textbook
+
+TEXT:
+{text}
+
+Rewritten:""",
+
+        "professional": """Rewrite this text in a natural professional/business tone:
+- Sound like an experienced professional writing to colleagues
+- Use natural business language without being overly formal
+- Include practical insights and real-world framing
+- Use contractions appropriately
+- Vary sentence structure naturally
+- Add subtle personal experience markers
+
+TEXT:
+{text}
+
+Rewritten:""",
+
+        "creative": """Rewrite this text in a vivid, creative, and engaging style:
+- Use rich, varied vocabulary
+- Employ metaphors and analogies naturally
+- Mix short punchy sentences with flowing longer ones
+- Add personality and voice
+- Include sensory or emotional language
+- Make it captivating and unique
+
+TEXT:
+{text}
+
+Rewritten:""",
+    }
+
+    def generate_with_model(
+        self,
+        model_name: str,
+        prompt: str,
+        max_new_tokens: int = 1024,
+        temperature: float = 0.8,
+        top_p: float = 0.9,
+        top_k: int = 50,
+        repetition_penalty: float = 1.2,
+    ) -> str:
+        """Generate text using a specific model."""
+        try:
+            model, tokenizer = self.hub.load_model_and_tokenizer(model_name)
+            inputs = tokenizer(prompt, return_tensors="pt").to(self.hub.device)
+
+            input_len = inputs.input_ids.shape[1]
+
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=max_new_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    top_k=top_k,
+                    repetition_penalty=repetition_penalty,
+                    do_sample=True,
+                    num_return_sequences=1,
+                    pad_token_id=tokenizer.eos_token_id,
+                    eos_token_id=tokenizer.eos_token_id,
+                )
+
+            generated = tokenizer.decode(
+                outputs[0][input_len:], skip_special_tokens=True
+            )
+            return generated.strip()
+        except Exception as e:
+            print(f"[Generation Error - {model_name}] {e}")
+            return ""
+
+    def generate_with_t5(self, text: str, max_length: int = 512) -> str:
+        """Paraphrase using T5-based model."""
+        try:
+            model, tokenizer = self.hub.load_model_and_tokenizer(
+                Config.STYLE_MODEL, model_class=AutoModelForSeq2SeqLM
+            )
+            input_text = f"paraphrase: {text}"
+            inputs = tokenizer(
+                input_text,
+                return_tensors="pt",
+                max_length=512,
+                truncation=True,
+                padding=True,
+            ).to(self.hub.device)
+
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_length=max_length,
+                    num_beams=4,
+                    temperature=0.9,
+                    top_p=0.9,
+                    do_sample=True,
+                    num_return_sequences=1,
+                )
+
+            return tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
+        except Exception as e:
+            print(f"[T5 Paraphrase Error] {e}")
+            return text
+
+    def ensemble_rewrite(
+        self, text: str, prompt_template: str, settings: Dict
+    ) -> List[Tuple[str, float]]:
+        """Generate multiple rewrites and score them."""
+        prompt = prompt_template.format(text=text)
+        results = []
+
+        models = [
+            (Config.REWRITE_MODEL_1, Config.ENSEMBLE_WEIGHTS[0]),
+            (Config.REWRITE_MODEL_2, Config.ENSEMBLE_WEIGHTS[1]),
+            (Config.REWRITE_MODEL_3, Config.ENSEMBLE_WEIGHTS[2]),
+        ]
+
+        for model_name, base_weight in models:
+            rewritten = self.generate_with_model(
+                model_name,
+                prompt,
+                temperature=0.7 + settings.get("burstiness", 0.3),
+                top_p=0.85 + settings.get("style_change", 0.15) * 0.15,
+                repetition_penalty=1.1 + settings.get("vocabulary_richness", 0.2) * 0.5,
+                max_new_tokens=Config.MAX_OUTPUT_LENGTH,
+            )
+            if rewritten:
+                results.append((rewritten, base_weight))
+
+        return results
+
+    def apply_linguistic_transforms(self, text: str, settings: Dict) -> str:
+        """Apply rule-based linguistic transformations."""
+
+        # Sentence splitting
+        sentences = re.split(r"(?<=[.!?])\s+", text)
+        transformed = []
+
+        for i, sent in enumerate(sentences):
+            sent = sent.strip()
+            if not sent:
+                continue
+
+            words = sent.split()
+
+            # Add contractions
+            if settings.get("imperfection_rate", 0) > 0.05:
+                contractions = {
+                    "do not": "don't",
+                    "does not": "doesn't",
+                    "did not": "didn't",
+                    "cannot": "can't",
+                    "could not": "couldn't",
+                    "would not": "wouldn't",
+                    "should not": "shouldn't",
+                    "will not": "won't",
+                    "is not": "isn't",
+                    "are not": "aren't",
+                    "was not": "wasn't",
+                    "were not": "weren't",
+                    "has not": "hasn't",
+                    "have not": "haven't",
+                    "had not": "hadn't",
+                    "it is": "it's",
+                    "that is": "that's",
+                    "there is": "there's",
+                    "they are": "they're",
+                    "we are": "we're",
+                    "you are": "you're",
+                    "I am": "I'm",
+                    "I will": "I'll",
+                    "I would": "I'd",
+                    "I had": "I'd",
+                    "I have": "I've",
+                }
+                for formal, contracted in contractions.items():
+                    if re.search(rf"\b{re.escape(formal)}\b", sent, re.IGNORECASE):
+                        if random.random() < 0.7:
+                            sent = re.sub(
+                                rf"\b{re.escape(formal)}\b",
+                                contracted,
+                                sent,
+                                flags=re.IGNORECASE,
+                                count=1,
+                            )
+
+            # Add sentence starters for variety
+            if settings.get("personal_touch", 0) > 0.2 and random.random() < settings[
+                "personal_touch"
+            ]:
+                starters = [
+                    "Honestly, ",
+                    "Look, ",
+                    "Here's the thing: ",
+                    "The way I see it, ",
+                    "Truth be told, ",
+                    "From my perspective, ",
+                    "In my experience, ",
+                    "I think ",
+                    "I believe ",
+                    "It seems to me that ",
+                ]
+                if not any(
+                    sent.lower().startswith(s.lower().rstrip()) for s in starters
+                ):
+                    sent = random.choice(starters) + sent[0].lower() + sent[1:]
+
+            # Add hedging
+            if settings.get("emotional_depth", 0) > 0.2 and random.random() < settings[
+                "emotional_depth"
+            ] * 0.3:
+                hedging = [
+                    "I think",
+                    "It seems like",
+                    "From what I can tell",
+                    "I'd say",
+                    "It appears that",
+                ]
+                if not any(h.lower() in sent.lower() for h in hedging):
+                    sent = f"{random.choice(hedging)} {sent[0].lower()}{sent[1:]}"
+
+            # Add colloquialisms
+            if settings.get("idiom_rate", 0) > 0.05 and random.random() < settings[
+                "idiom_rate"
+            ]:
+                idioms = [
+                    "at the end of the day",
+                    "in the grand scheme of things",
+                    "when it comes down to it",
+                    "for the most part",
+                    "by and large",
+                    "in a nutshell",
+                    "the bottom line is",
+                    "all things considered",
+                ]
+                if random.random() < 0.5 and len(words) > 8:
+                    insert_pos = random.randint(
+                        min(3, len(words) - 1), len(words) - 1
+                    )
+                    idiom = random.choice(idioms)
+                    words.insert(insert_pos, f", {idiom},")
+                    sent = " ".join(words)
+
+            # Add transitional phrases
+            if settings.get("sentence_variation", 0) > 0.3 and random.random() < 0.3:
+                transitions = [
+                    "That said,",
+                    "On the flip side,",
+                    "Having said that,",
+                    "At the same time,",
+                    "In other words,",
+                    "Put differently,",
+                    "To put it simply,",
+                ]
+                if i > 0 and not any(
+                    sent.lower().startswith(t.lower().replace(",", ""))
+                    for t in transitions
+                ):
+                    if random.random() < 0.4:
+                        sent = f"{random.choice(transitions)} {sent[0].lower()}{sent[1:]}"
+
+            # Vary sentence length — occasionally split long sentences
+            if (
+                len(words) > 25
+                and settings.get("burstiness", 0) > 0.3
+                and random.random() < settings["burstiness"] * 0.5
+            ):
+                split_points = [",", ";", "and", "but", "which", "that"]
+                for sp in split_points:
+                    idx = sent.lower().find(f" {sp} ")
+                    if idx > len(sent) // 3 and idx < len(sent) * 2 // 3:
+                        part1 = sent[:idx].strip() + "."
+                        part2 = sp.capitalize() + sent[idx + len(sp) + 1 :].strip()
+                        sent = f"{part1} {part2}"
+                        break
+
+            # Occasionally merge short sentences
+            if (
+                i > 0
+                and len(words) < 8
+                and settings.get("burstiness", 0) > 0.3
+                and random.random() < settings["burstiness"] * 0.3
+            ):
+                if transformed:
+                    prev = transformed[-1]
+                    prev_words = prev.split()
+                    if len(prev_words) > 10:
+                        merged = prev.rstrip(".") + ", " + sent[0].lower() + sent[1:]
+                        transformed[-1] = merged
+                        continue
+
+            transformed.append(sent)
+
+        return " ".join(transformed)
+
+    def humanize(
+        self, text: str, preset_name: str = "🟡 Conversational (Medium)", steps: int = 2
+    ) -> Dict:
+        """Main humanization pipeline."""
+        settings = Config.PRESETS.get(
+            preset_name, Config.PRESETS["🟡 Conversational (Medium)"]
+        )
+        prompt_template = self.HUMANIZATION_PROMPTS.get(
+            "general", self.HUMANIZATION_PROMPTS["general"]
         )
-        
-        # Step 1: Analysis
-        analysis = self.analyze_text_patterns(text)
-        
-        # Step 2: Initial rewrite
-        prompt = self.generate_humanization_prompt(text, config, style, analysis)
-        
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
-        
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_new_tokens=len(text.split()) * 3,  # Generous buffer
-                temperature=config.temperature,
-                top_p=config.top_p,
-                repetition_penalty=config.repetition_penalty,
-                do_sample=True,
-                pad_token_id=self.tokenizer.pad_token_id,
-                eos_token_id=self.tokenizer.eos_token_id,
+
+        # Detect style from preset name
+        if "Academic" in preset_name:
+            prompt_template = self.HUMANIZATION_PROMPTS["academic"]
+        elif "Professional" in preset_name:
+            prompt_template = self.HUMANIZATION_PROMPTS["professional"]
+        elif "Creative" in preset_name:
+            prompt_template = self.HUMANIZATION_PROMPTS["creative"]
+
+        current_text = text
+        pipeline_log = []
+
+        # Step 1: T5 Paraphrase (style transfer)
+        pipeline_log.append("🔄 Step 1: T5 Style Transfer...")
+        t5_result = self.generate_with_t5(current_text)
+        if t5_result and t5_result != current_text:
+            current_text = t5_result
+            pipeline_log.append("   ✓ T5 paraphrase applied")
+        else:
+            pipeline_log.append("   ⚠ T5 skipped (no change)")
+
+        # Step 2-N: LLM Ensemble Rewriting
+        for step_num in range(steps):
+            pipeline_log.append(
+                f"🔄 Step {step_num + 2}: LLM Ensemble Rewrite (round {step_num + 1})..."
             )
-        
-        decoded = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        # Extract only the assistant's response
-        humanized = decoded.split("assistant")[-1].strip()
-        
-        # Step 3: Post-processing based on intensity
-        if intensity == "aggressive":
-            humanized = self._inject_aggressive_variation(humanized)
-        elif intensity == "light":
-            humanized = self._light_touch(humanized)
-            
-        # Step 4: Optional imperfections
-        if add_typos and intensity == "aggressive":
-            humanized = self._add_natural_typos(humanized)
-            
-        # Step 5: Metrics calculation
-        final_analysis = {
-            "original_perplexity": round(self.calculate_perplexity(text), 2),
-            "humanized_perplexity": round(self.calculate_perplexity(humanized), 2),
-            "burstiness_change": round(self.analyze_text_patterns(humanized)["burstiness"] - analysis["burstiness"], 2),
-            "human_score": self._calculate_human_score(humanized),
-            "processing_style": style,
-            "intensity": intensity
+            results = self.ensemble_rewrite(current_text, prompt_template, settings)
+
+            if results:
+                # Weighted selection or blending
+                if len(results) == 1:
+                    current_text = results[0][0]
+                else:
+                    # Score each result and pick the best
+                    scored = []
+                    for rewritten, weight in results:
+                        # Prefer more varied, natural text
+                        richness = self._calc_vocabulary_richness_simple(rewritten)
+                        burstiness = self._calc_burstiness_simple(rewritten)
+                        length_ratio = min(
+                            1.0, len(rewritten.split()) / max(1, len(current_text.split()))
+                        )
+                        score = (
+                            richness * 0.3
+                            + burstiness * 0.3
+                            + length_ratio * 0.2
+                            + weight * 0.2
+                        )
+                        scored.append((rewritten, score))
+
+                    scored.sort(key=lambda x: x[1], reverse=True)
+                    current_text = scored[0][0]
+                    pipeline_log.append(
+                        f"   ✓ Best rewrite selected (score: {scored[0][1]:.3f})"
+                    )
+            else:
+                pipeline_log.append("   ⚠ No results from LLM ensemble")
+
+        # Step N+1: Linguistic Transforms
+        pipeline_log.append("🔄 Applying linguistic transformations...")
+        current_text = self.apply_linguistic_transforms(current_text, settings)
+        pipeline_log.append("   ✓ Linguistic transforms applied")
+
+        # Step N+2: Post-processing cleanup
+        current_text = self._cleanup_text(current_text)
+        pipeline_log.append("   ✓ Post-processing complete")
+
+        return {
+            "original": text,
+            "humanized": current_text,
+            "pipeline_log": "\n".join(pipeline_log),
+            "settings_used": settings,
+            "preset": preset_name,
         }
-        
-        return humanized, final_analysis
-    
-    def _inject_aggressive_variation(self, text: str) -> str:
-        """Add high-level human variation"""
-        # Randomly combine sentences with conjunctions
-        text = re.sub(r'\.\s+([A-Z])', lambda m: f", and {m.group(1).lower()}" if random.random() > 0.7 else f". {m.group(1)}", text)
-        
-        # Add occasional fragments
-        sentences = text.split('. ')
-        if len(sentences) > 3 and random.random() > 0.5:
-            idx = random.randint(1, len(sentences)-2)
-            sentences[idx] = sentences[idx].split(',')[0]  # Make first part a fragment
-        return '. '.join(sentences)
-    
-    def _light_touch(self, text: str) -> str:
-        """Minimal changes, just polish"""
-        # Remove common AI transitions
-        text = re.sub(r'\b(In conclusion|To summarize|Overall),\s*', '', text, flags=re.I)
-        return text
-    
-    def _add_natural_typos(self, text: str) -> str:
-        """Add believable human typos (use sparingly)"""
-        # Very subtle: duplicate letters occasionally
-        words = text.split()
-        for i in range(len(words)):
-            if random.random() > 0.98 and len(words[i]) > 4:
-                words[i] = words[i][:2] + words[i][1] + words[i][2:]
-        return ' '.join(words)
-    
-    def _calculate_human_score(self, text: str) -> int:
-        """Estimate likelihood of passing as human 0-100"""
-        score = 70  # Base
-        
-        # Check for AI markers
-        ai_markers = len(re.findall(r'\b(leverage|delve|utilize|facilitate|optimize)\b', text, re.I))
-        score -= ai_markers * 5
-        
-        # Check variation
-        sentences = re.split(r'(?<=[.!?])\s+', text)
-        if len(sentences) > 1:
-            lengths = [len(s) for s in sentences]
-            variation = np.std(lengths) / np.mean(lengths)
-            if variation > 0.3:  # Good burstiness
-                score += 15
-        
-        # Check contractions
-        if len(re.findall(r"\b\w+'\w+\b", text)) > 0:
-            score += 10
-            
-        return min(100, max(0, score))
-
-# Initialize singleton
-humanizer = DeepHumanizer()
-
-# Gradio Interface
-def process_text(text, style, intensity, creativity, add_imperfections, comparison_mode):
-    if not text.strip():
-        return "", {}, ""
-    
-    humanized, metrics = humanizer.humanize(
-        text=text,
-        style=style,
-        intensity=intensity,
-        creativity=creativity,
-        add_typos=(add_imperfections == "Aggressive")
-    )
-    
-    # Format metrics display
-    metrics_md = f"""
-    ### 📊 Analysis Results
-    
-    | Metric | Value | Status |
-    |--------|-------|--------|
-    | **Human Likelihood Score** | {metrics['human_score']}/100 | {'🟢 Human' if metrics['human_score'] > 80 else '🟡 Unclear' if metrics['human_score'] > 60 else '🔵 AI'} |
-    | **Perplexity Change** | {metrics['original_perplexity']} → {metrics['humanized_perplexity']} | {'🟢 Good Variation' if metrics['humanized_perplexity'] > metrics['original_perplexity'] else '⚠️ Check needed'} |
-    | **Burstiness Delta** | +{metrics['burstiness_change']:.2f} | {'🟢 Natural Flow' if metrics['burstiness_change'] > 0 else '⚠️ Monotonous'} |
-    """
-    
-    if comparison_mode:
-        comparison = f"""
-**Original ({len(text.split())} words):**
-{text[:500]}{'...' if len(text) > 500 else ''}
-
----
-**Humanized ({len(humanized.split())} words):**
-{humanized}
-"""
-        return humanized, metrics_md, comparison
-    
-    return humanized, metrics_md, ""
-
-# Custom CSS for premium feel
-css = """
-.gradio-container {
-    font-family: 'Inter', sans-serif;
-}
-.metric-card {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    border-radius: 8px;
-    padding: 16px;
-    color: white;
-}
-"""
-
-with gr.Blocks(css=css, title="Deep Humanizer Pro", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🧠 Deep Humanizer Pro
-    ### Advanced AI-to-Human Text Transformation using Llama 3.3 70B
-    *Elite-grade humanization with linguistic analysis and adversarial pattern disruption*
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_text = gr.Textbox(
-                label="Input Text (AI-generated)",
-                placeholder="Paste your AI-generated content here...",
-                lines=10
+
+    def _calc_vocabulary_richness_simple(self, text: str) -> float:
+        words = re.findall(r"\b\w+\b", text.lower())
+        if not words:
+            return 0.0
+        return len(set(words)) / len(words)
+
+    def _calc_burstiness_simple(self, text: str) -> float:
+        sentences = re.split(r"[.!?]+", text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        if len(sentences) < 2:
+            return 0.0
+        lengths = [len(s.split()) for s in sentences]
+        mean_len = np.mean(lengths)
+        std_len = np.std(lengths)
+        return (std_len / mean_len) if mean_len > 0 else 0.0
+
+    def _cleanup_text(self, text: str) -> str:
+        """Clean up generated text."""
+        # Remove extra whitespace
+        text = re.sub(r"\s+", " ", text).strip()
+        # Fix double punctuation
+        text = re.sub(r"([.!?])\s*\1+", r"\1", text)
+        # Fix spacing around punctuation
+        text = re.sub(r"\s+([,;:.!?])", r"\1", text)
+        # Capitalize first letter
+        if text:
+            text = text[0].upper() + text[1:]
+        # Remove any obvious artifacts
+        text = re.sub(r"^(Rewritten|Rewritten version|Here is the rewritten text)[:\s]*", "", text, flags=re.IGNORECASE)
+        text = re.sub(r"\n{3,}", "\n\n", text)
+        return text.strip()
+
+
+# ============================================================
+# SCORING & METRICS
+# ============================================================
+
+class HumanizationScorer:
+    """Score how 'human' text appears."""
+
+    @staticmethod
+    def compute_human_score(analysis: Dict) -> float:
+        """Compute overall human-likeness score (0-100)."""
+        scores = []
+
+        # AI detection component (higher human prob = better)
+        ai_det = analysis.get("ai_detection", {})
+        human_prob = ai_det.get("human_probability", 0.5)
+        scores.append(human_prob * 100)
+
+        # Burstiness component (moderate burstiness is good)
+        burstiness = analysis.get("burstiness", 0)
+        burst_score = min(1.0, burstiness / 0.6) * 100  # normalize to 0.6
+        scores.append(burst_score)
+
+        # Vocabulary richness
+        vocab = analysis.get("vocabulary_richness", 0)
+        vocab_score = min(1.0, vocab / 0.7) * 100
+        scores.append(vocab_score)
+
+        # Perplexity (higher = more human-like typically)
+        ppl = analysis.get("perplexity", 0)
+        if ppl > 0:
+            ppl_score = min(100, (math.log(ppl + 1) / math.log(100)) * 100)
+            scores.append(ppl_score)
+
+        # Readability
+        readability = analysis.get("readability", {})
+        flesch = readability.get("flesch_ease", 50)
+        readability_score = flesch  # already 0-100
+        scores.append(readability_score)
+
+        if not scores:
+            return 50.0
+
+        return round(np.mean(scores), 1)
+
+
+# ============================================================
+# GRADIO UI
+# ============================================================
+
+def create_ui():
+    """Build the Gradio interface."""
+
+    hub = ModelHub()
+    analyzer = TextAnalyzer(hub)
+    engine = HumanizationEngine(hub)
+    scorer = HumanizationScorer()
+
+    # Pre-load models
+    hub.load_all_models()
+
+    def process_text(
+        input_text: str,
+        preset: str,
+        steps: int,
+        seed: int,
+    ) -> Tuple:
+        """Main processing function."""
+        if not input_text.strip():
+            return (
+                "⚠️ Please enter some text to humanize.",
+                "",
+                "No analysis available.",
+                "No metrics available.",
+                "📊 Enter text and click Humanize to see results.",
             )
-            
-            with gr.Row():
-                style = gr.Dropdown(
-                    choices=["casual", "professional", "academic", "creative", "reddit", "twitter"],
-                    value="casual",
-                    label="Voice Style"
+
+        if len(input_text) > Config.MAX_INPUT_LENGTH:
+            return (
+                f"⚠️ Text too long. Max {Config.MAX_INPUT_LENGTH} characters.",
+                "",
+                "",
+                "",
+                "",
+            )
+
+        set_seed(seed)
+        random.seed(seed)
+        np.random.seed(seed)
+
+        start_time = time.time()
+
+        # Analyze original
+        orig_analysis = analyzer.full_analysis(input_text)
+        orig_human_score = scorer.compute_human_score(orig_analysis)
+
+        # Humanize
+        result = engine.humanize(input_text, preset, steps)
+
+        # Analyze humanized
+        human_analysis = analyzer.full_analysis(result["humanized"])
+        human_score = scorer.compute_human_score(human_analysis)
+
+        elapsed = time.time() - start_time
+
+        # Format analysis comparison
+        comparison = format_analysis_comparison(orig_analysis, human_analysis, orig_human_score, human_score)
+
+        # Format detailed metrics
+        metrics = format_detailed_metrics(orig_analysis, human_analysis, orig_human_score, human_score)
+
+        # Progress log
+        progress = result["pipeline_log"] + f"\n\n⏱️ Processing time: {elapsed:.1f}s"
+
+        return (
+            result["humanized"],
+            comparison,
+            metrics,
+            progress,
+            f"📊 Human Score: {orig_human_score:.1f} → {human_score:.1f} ({human_score - orig_human_score:+.1f})",
+        )
+
+    def analyze_only(text: str) -> str:
+        """Analyze text without humanizing."""
+        if not text.strip():
+            return "Please enter text to analyze."
+        analysis = analyzer.full_analysis(text)
+        score = scorer.compute_human_score(analysis)
+        return format_detailed_single(analysis, score)
+
+    def format_analysis_comparison(orig, human, orig_score, human_score):
+        """Format comparison for display."""
+        lines = []
+        lines.append("📊 TEXT ANALYSIS COMPARISON")
+        lines.append("=" * 60)
+        lines.append("")
+
+        # Score
+        arrow = "🟢" if human_score > orig_score else "🔴" if human_score < orig_score else "🟡"
+        lines.append(f"  Overall Human Score:")
+        lines.append(f"    Original:   {orig_score:.1f}/100")
+        lines.append(f"    Humanized:  {human_score:.1f}/100")
+        lines.append(f"    Change:     {human_score - orig_score:+.1f} {arrow}")
+        lines.append("")
+
+        # AI Detection
+        lines.append("  🤖 AI Detection:")
+        lines.append(f"    Original:   {orig['ai_detection']['verdict']} ({orig['ai_detection']['ai_probability']:.1%} AI)")
+        lines.append(f"    Humanized:  {human['ai_detection']['verdict']} ({human['ai_detection']['ai_probability']:.1%} AI)")
+        lines.append("")
+
+        # Burstiness
+        lines.append("  📈 Burstiness (sentence variation):")
+        lines.append(f"    Original:   {orig['burstiness']:.3f}")
+        lines.append(f"    Humanized:  {human['burstiness']:.3f}")
+        lines.append("")
+
+        # Vocabulary
+        lines.append("  📚 Vocabulary Richness:")
+        lines.append(f"    Original:   {orig['vocabulary_richness']:.3f}")
+        lines.append(f"    Humanized:  {human['vocabulary_richness']:.3f}")
+        lines.append("")
+
+        # Perplexity
+        lines.append("  🔢 Perplexity:")
+        lines.append(f"    Original:   {orig['perplexity']:.2f}")
+        lines.append(f"    Humanized:  {human['perplexity']:.2f}")
+        lines.append("")
+
+        # Readability
+        lines.append("  📖 Readability:")
+        lines.append(f"    Original:   Flesch Ease {orig['readability']['flesch_ease']:.1f} (Grade {orig['readability']['grade_level']})")
+        lines.append(f"    Humanized:  Flesch Ease {human['readability']['flesch_ease']:.1f} (Grade {human['readability']['grade_level']})")
+        lines.append("")
+
+        # Sentiment
+        lines.append("  😊 Dominant Emotion:")
+        lines.append(f"    Original:   {orig['sentiment']['dominant_emotion']} ({orig['sentiment']['dominant_score']:.1%})")
+        lines.append(f"    Humanized:  {human['sentiment']['dominant_emotion']} ({human['sentiment']['dominant_score']:.1%})")
+        lines.append("")
+
+        # Counts
+        lines.append("  📝 Text Stats:")
+        lines.append(f"    Original:   {orig['word_count']} words, {orig['sentence_count']} sentences")
+        lines.append(f"    Humanized:  {human['word_count']} words, {human['sentence_count']} sentences")
+
+        return "\n".join(lines)
+
+    def format_detailed_metrics(orig, human, orig_score, human_score):
+        """Format detailed metrics table."""
+        import html
+
+        # Create an HTML table
+        html_content = """
+        <div style="background: #1a1a2e; padding: 20px; border-radius: 10px; font-family: monospace;">
+        <h3 style="color: #e94560; margin-top: 0;">📊 Detailed Metrics Comparison</h3>
+        <table style="width: 100%; border-collapse: collapse;">
+        <tr style="background: #16213e;">
+            <th style="padding: 10px; text-align: left; color: #e94560; border-bottom: 2px solid #e94560;">Metric</th>
+            <th style="padding: 10px; text-align: center; color: #0f3460; border-bottom: 2px solid #e94560;">Original</th>
+            <th style="padding: 10px; text-align: center; color: #533483; border-bottom: 2px solid #e94560;">Humanized</th>
+            <th style="padding: 10px; text-align: center; color: #e94560; border-bottom: 2px solid #e94560;">Change</th>
+        </tr>
+        """
+
+        metrics_data = [
+            ("🎯 Human Score", f"{orig_score:.1f}", f"{human_score:.1f}", f"{human_score - orig_score:+.1f}"),
+            ("🤖 AI Probability", f"{orig['ai_detection']['ai_probability']:.1%}", f"{human['ai_detection']['ai_probability']:.1%}", ""),
+            ("📈 Burstiness", f"{orig['burstiness']:.3f}", f"{human['burstiness']:.3f}", ""),
+            ("📚 Vocab Richness", f"{orig['vocabulary_richness']:.3f}", f"{human['vocabulary_richness']:.3f}", ""),
+            ("🔢 Perplexity", f"{orig['perplexity']:.2f}", f"{human['perplexity']:.2f}", ""),
+            ("📖 Flesch Ease", f"{orig['readability']['flesch_ease']:.1f}", f"{human['readability']['flesch_ease']:.1f}", ""),
+            ("📝 Word Count", f"{orig['word_count']}", f"{human['word_count']}", ""),
+            ("📝 Sentence Count", f"{orig['sentence_count']}", f"{human['sentence_count']}", ""),
+        ]
+
+        for metric, orig_val, human_val, change in metrics_data:
+            html_content += f"""
+            <tr>
+                <td style="padding: 8px; color: #eee; border-bottom: 1px solid #333;">{metric}</td>
+                <td style="padding: 8px; text-align: center; color: #aaa; border-bottom: 1px solid #333;">{orig_val}</td>
+                <td style="padding: 8px; text-align: center; color: #4ecca3; border-bottom: 1px solid #333;">{human_val}</td>
+                <td style="padding: 8px; text-align: center; color: {'#4ecca3' if change.startswith('+') else '#e94560' if change.startswith('-') else '#aaa'}; border-bottom: 1px solid #333;">{change}</td>
+            </tr>
+            """
+
+        html_content += """
+        </table>
+        </div>
+        """
+        return html_content
+
+    def format_detailed_single(analysis, score):
+        """Format single text analysis."""
+        lines = []
+        lines.append("📊 TEXT ANALYSIS REPORT")
+        lines.append("=" * 50)
+        lines.append(f"\n  🎯 Overall Human Score: {score:.1f}/100")
+        lines.append(f"\n  🤖 AI Detection:")
+        lines.append(f"     Verdict: {analysis['ai_detection']['verdict']}")
+        lines.append(f"     Human: {analysis['ai_detection']['human_probability']:.1%}")
+        lines.append(f"     AI: {analysis['ai_detection']['ai_probability']:.1%}")
+        lines.append(f"\n  📈 Burstiness: {analysis['burstiness']:.3f}")
+        lines.append(f"  📚 Vocabulary Richness: {analysis['vocabulary_richness']:.3f}")
+        lines.append(f"  🔢 Perplexity: {analysis['perplexity']:.2f}")
+        lines.append(f"\n  📖 Readability:")
+        lines.append(f"     Flesch Ease: {analysis['readability']['flesch_ease']:.1f}")
+        lines.append(f"     Grade Level: {analysis['readability']['grade_level']}")
+        lines.append(f"\n  😊 Emotions:")
+        for emo, sc in analysis['sentiment']['emotions'].items():
+            lines.append(f"     {emo}: {sc:.1%}")
+        lines.append(f"\n  📝 Words: {analysis['word_count']} | Sentences: {analysis['sentence_count']}")
+        return "\n".join(lines)
+
+    # Build UI
+    custom_css = """
+    .gradio-container { max-width: 1400px !important; }
+    textarea { font-size: 15px !important; }
+    #output-text { font-size: 16px !important; line-height: 1.7 !important; }
+    .metric-box { background: #1a1a2e; padding: 15px; border-radius: 8px; }
+    """
+
+    with gr.Blocks(
+        title="🧬 Advanced AI Text Humanizer",
+        css=custom_css,
+        theme=gr.themes.Soft(
+            primary_hue="purple",
+            secondary_hue="blue",
+            neutral_hue="slate",
+        ),
+    ) as demo:
+
+        gr.Markdown(
+            """
+            # 🧬 Advanced AI Text Humanizer
+            ### Multi-Model Ensemble | Deep Linguistic Analysis | Real-Time Metrics
+
+            This tool uses **4+ AI models** working together to transform AI-generated text into natural, human-sounding writing.
+            Powered by **Zephyr-7B**, **Phi-2**, **Mistral-7B**, **T5 Paraphrase**, **GPT-Neo**, **RoBERTa**, and **GoEmotions** models.
+
+            > 💡 **Tip**: Start with "🟡 Conversational (Medium)" preset and adjust based on results.
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📝 Input")
+                input_text = gr.Textbox(
+                    label="Paste AI-generated text here",
+                    placeholder="Enter the text you want to humanize...",
+                    lines=12,
+                    max_lines=30,
+                    value="",
+                )
+
+                preset = gr.Dropdown(
+                    choices=list(Config.PRESETS.keys()),
+                    value="🟡 Conversational (Medium)",
+                    label="🎭 Humanization Preset",
+                    interactive=True,
                 )
-                intensity = gr.Radio(
-                    choices=["light", "medium", "aggressive"],
-                    value="medium",
-                    label="Humanization Intensity"
+
+                steps = gr.Slider(
+                    minimum=1,
+                    maximum=4,
+                    value=2,
+                    step=1,
+                    label="🔄 Rewrite Steps (more = more thorough but slower)",
+                    interactive=True,
                 )
-            
-            with gr.Row():
-                creativity = gr.Slider(
-                    minimum=0.1, maximum=1.0, value=0.8, step=0.1,
-                    label="Creativity (Temperature)"
+
+                seed = gr.Slider(
+                    minimum=0,
+                    maximum=9999,
+                    value=42,
+                    step=1,
+                    label="🎲 Random Seed (change for different outputs)",
+                    interactive=True,
                 )
-                add_imperfections = gr.Checkbox(
-                    label="Add Natural Imperfections",
-                    value=True
+
+                with gr.Row():
+                    humanize_btn = gr.Button(
+                        "🚀 Humanize Text",
+                        variant="primary",
+                        size="lg",
+                    )
+                    analyze_btn = gr.Button(
+                        "🔍 Analyze Only",
+                        variant="secondary",
+                        size="lg",
+                    )
+
+            with gr.Column(scale=1):
+                gr.Markdown("### ✨ Humanized Output")
+                output_text = gr.Textbox(
+                    label="Humanized Text",
+                    lines=12,
+                    max_lines=30,
+                    interactive=False,
+                    elem_id="output-text",
                 )
-            
-            comparison_mode = gr.Checkbox(
-                label="Show Side-by-Side Comparison",
-                value=False
-            )
-            
-            submit_btn = gr.Button("🚀 Humanize Text", variant="primary")
-            
-        with gr.Column(scale=1):
-            output_text = gr.Textbox(
-                label="Humanized Output",
-                lines=10,
-                show_copy_button=True
-            )
-            metrics_display = gr.Markdown()
-            comparison_display = gr.Markdown()
-    
-    # Examples
-    gr.Examples(
-        examples=[
-            ["Artificial Intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think like humans and mimic their actions. The term may also be applied to any machine that exhibits traits associated with a human mind such as learning and problem-solving.", "casual", "medium"],
-            ["In conclusion, it is important to note that leveraging cutting-edge technologies can facilitate optimal outcomes for stakeholders.", "professional", "aggressive"],
-        ],
-        inputs=[input_text, style, intensity],
-        label="Try these examples"
-    )
-    
-    submit_btn.click(
-        fn=process_text,
-        inputs=[input_text, style, intensity, creativity, add_imperfections, comparison_mode],
-        outputs=[output_text, metrics_display, comparison_display]
-    )
-    
-    gr.Markdown("""
-    ### 🛠️ Technical Specifications
-    - **Model**: Llama 3.3 70B Instruct (4-bit quantized)
-    - **Architecture**: Flash Attention 2 + Gradient Checkpointing
-    - **Analysis**: Perplexity scoring, burstiness calculation, AI marker detection
-    - **GPU**: Optimized for A100/H100 (80GB VRAM)
-    """)
+
+                score_display = gr.Textbox(
+                    label="📊 Quick Score",
+                    interactive=False,
+                    lines=1,
+                )
+
+                with gr.Tabs():
+                    with gr.Tab("📊 Analysis"):
+                        analysis_output = gr.Textbox(
+                            label="Comparison Analysis",
+                            lines=15,
+                            interactive=False,
+                        )
+                    with gr.Tab("📈 Metrics"):
+                        metrics_output = gr.HTML(label="Detailed Metrics")
+                    with gr.Tab("⚙️ Pipeline"):
+                        pipeline_output = gr.Textbox(
+                            label="Processing Pipeline Log",
+                            lines=15,
+                            interactive=False,
+                        )
+
+        gr.Markdown(
+            """
+            ---
+            ### 🏗️ Architecture
+            - **T5 Paraphraser** → Initial style transfer and structural changes
+            - **LLM Ensemble** (Zephyr-7B + Phi-2 + Mistral-7B) → Weighted multi-model rewriting
+            - **Linguistic Engine** → Contractions, idioms, hedging, sentence variation, transitions
+            - **Analysis Suite** → Perplexity, burstiness, vocabulary, AI detection, sentiment, readability
+
+            ### 📋 Presets Explained
+            - **🟢 Natural (Light)**: Subtle changes, maintains original structure
+            - **🟡 Conversational (Medium)**: Balanced human-like rewriting
+            - **🔴 Fully Human (Aggressive)**: Maximum humanization with significant restructuring
+            - **🎓 Academic**: Scholarly tone with natural academic phrasing
+            - **💼 Professional**: Business-appropriate natural writing
+            - **✍️ Creative**: Expressive, vivid, personality-rich output
+            """
+        )
+
+        # Event handlers
+        humanize_btn.click(
+            fn=process_text,
+            inputs=[input_text, preset, steps, seed],
+            outputs=[
+                output_text,
+                analysis_output,
+                metrics_output,
+                pipeline_output,
+                score_display,
+            ],
+        )
+
+        analyze_btn.click(
+            fn=analyze_only,
+            inputs=[input_text],
+            outputs=[analysis_output],
+        )
+
+    return demo
+
+
+# ============================================================
+# MAIN ENTRY
+# ============================================================
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = create_ui()
+    demo.queue(
+        max_size=20,
+        default_concurrency_limit=4,
+    ).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+    )