Update app.py

app.py

@@ -1,418 +1,1489 @@
-# app.py - Advanced Deep Humanizer for Hugging Face Spaces
-# Compatible with Gradio 4.0.0 and Python 3.13
-# Optimized for Zero-GPU / GPU hybrid deployment
+"""
+🧬 Advanced AI Text Humanizer
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Multi-model ensemble humanization pipeline for Hugging Face Spaces.
+Uses state-of-the-art LLMs with multiple rewriting strategies,
+style transfer, readability optimization, and AI-detection evasion.
+
+Models Used (in ensemble pipeline):
+  1. meta-llama/Llama-3.3-70B-Instruct  — Primary rewriter
+  2. mistralai/Mistral-7B-Instruct-v0.3  — Secondary rewriter
+  3. HuggingFaceH4/zephyr-7b-beta        — Style transfer
+  4. facebook/bart-large-cnn             — Paraphrase refinement
+  5. SentenceTransformers for similarity scoring
+
+Author: Advanced Humanizer Pipeline
+Space Hardware: GPU A100 (paid config)
+"""
+
+import os
+import re
+import json
+import time
+import random
+import logging
+import hashlib
+import textwrap
+import difflib
+from typing import Optional, List, Dict, Tuple, Any
+from dataclasses import dataclass, field
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from collections import Counter
 
 import gradio as gr
+import numpy as np
 import torch
-import random
-import re
-import os
-import gc
 from transformers import (
-    AutoModelForCausalLM, 
-    AutoTokenizer, 
-    BitsAndBytesConfig
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    pipeline,
+    TextGenerationPipeline,
+    set_seed,
 )
-from typing import Dict, Tuple
-import numpy as np
-from dataclasses import dataclass
+from transformers.generation.utils import GenerationConfig
+from huggingface_hub import InferenceClient
+import requests
+from sentence_transformers import SentenceTransformer
+import nltk
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.corpus import stopwords
+from readability import Readability
+
+# ─────────────────────────────────────────────
+# Download NLTK data
+# ─────────────────────────────────────────────
+for nltk_resource in ["punkt", "punkt_tab", "stopwords", "averaged_perceptron_tagger"]:
+    try:
+        nltk.data.find(f"tokenizers/{nltk_resource}")
+    except LookupError:
+        nltk.download(nltk_resource, quiet=True)
+
+# ─────────────────────────────────────────────
+# Configuration
+# ─────────────────────────────────────────────
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger("humanizer")
 
+# ─────────────────────────────────────────────
+# Data Classes
+# ─────────────────────────────────────────────
 @dataclass
-class HumanizationConfig:
-    temperature: float = 0.8
-    top_p: float = 0.92
-    repetition_penalty: float = 1.15
-    style_intensity: str = "medium"
+class HumanizationResult:
+    original: str
+    humanized: str
+    model_used: str
+    mode: str
+    changes_made: int
+    similarity_score: float
+    readability_before: Dict[str, float]
+    readability_after: Dict[str, float]
+    ai_probability_before: float
+    ai_probability_after: float
+    processing_time: float
+    strategies_applied: List[str]
+    word_count_before: int
+    word_count_after: int
+    perplexity_before: float
+    perplexity_after: float
+
+
+@dataclass
+class PipelineConfig:
+    mode: str = "balanced"
+    intensity: float = 0.5
     preserve_meaning: bool = True
     add_imperfections: bool = True
+    vary_sentence_length: bool = True
+    add_transitions: bool = True
+    remove_patterns: bool = True
+    add_personal_touch: bool = True
+    temperature: float = 0.7
+    top_p: float = 0.9
+    max_tokens: int = 2048
+    ensemble: bool = True
+    use_all_models: bool = True
+
+
+# ─────────────────────────────────────────────
+# Model Registry
+# ─────────────────────────────────────────────
+MODEL_REGISTRY = {
+    "llama_3_70b": {
+        "id": "meta-llama/Llama-3.3-70B-Instruct",
+        "name": "Llama 3.3 70B Instruct",
+        "type": "chat",
+        "max_length": 8192,
+        "description": "Primary powerhouse model for deep rewriting",
+    },
+    "mistral_7b": {
+        "id": "mistralai/Mistral-7B-Instruct-v0.3",
+        "name": "Mistral 7B Instruct v0.3",
+        "type": "chat",
+        "max_length": 32768,
+        "description": "Fast and creative secondary model",
+    },
+    "zephyr_7b": {
+        "id": "HuggingFaceH4/zephyr-7b-beta",
+        "name": "Zephyr 7B Beta",
+        "type": "chat",
+        "max_length": 4096,
+        "description": "Excellent style transfer capabilities",
+    },
+    "phi_3_mini": {
+        "id": "microsoft/Phi-3-mini-128k-instruct",
+        "name": "Phi-3 Mini 128K",
+        "type": "chat",
+        "max_length": 128000,
+        "description": "Lightweight model for quick passes",
+    },
+    "bart_paraphrase": {
+        "id": "facebook/bart-large-cnn",
+        "name": "BART Large CNN",
+        "type": "seq2seq",
+        "max_length": 1024,
+        "description": "Specialized paraphrasing model",
+    },
+    "gemma_2_27b": {
+        "id": "google/gemma-2-27b-it",
+        "name": "Gemma 2 27B IT",
+        "type": "chat",
+        "max_length": 8192,
+        "description": "Google's instruction-tuned model",
+    },
+}
+
+
+# ─────────────────────────────────────────────
+# AI Detection Model
+# ─────────────────────────────────────────────
+class AIDetector:
+    """Estimates probability that text is AI-generated."""
 
-class DeepHumanizer:
     def __init__(self):
-        # Using Qwen2.5-7B for best quality/speed on HF Spaces
-        # This works on T4 (16GB) GPU or CPU with quantization
-        self.model_id = "Qwen/Qwen2.5-7B-Instruct"
-        
-        self.tokenizer = None
-        self.model = None
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        
-        if self.device == "cuda":
-            print(f"🚀 GPU available: {torch.cuda.get_device_name(0)}")
-            print(f"📊 VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
-        else:
-            print("⚠️ Running on CPU - will use lighter quantization")
-            
-        self.initialize_model()
-        
-    def initialize_model(self):
-        """Initialize with robust memory management"""
-        print(f"Loading {self.model_id}...")
-        
+        # Use a lightweight detector
+        self.model_name = "roberta-base-openai-detector"
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name, device_map="auto"
+            )
+            self.loaded = True
+            logger.info(f"AI Detector loaded: {self.model_name}")
+        except Exception as e:
+            logger.warning(f"AI Detector failed to load: {e}")
+            self.loaded = False
+
+    def detect(self, text: str) -> float:
+        """Returns probability (0-1) that text is AI-generated."""
+        if not self.loaded or not text.strip():
+            return self._heuristic_detect(text)
+
+        try:
+            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+
+            # Get probabilities for human (0) vs AI (1)
+            probs = torch.softmax(logits[0], dim=-1)
+            ai_prob = probs[0][1].item() if probs.shape[-1] > 1 else 0.5
+            return min(max(ai_prob, 0.0), 1.0)
+        except Exception as e:
+            logger.error(f"Detection error: {e}")
+            return self._heuristic_detect(text)
+
+    def _heuristic_detect(self, text: str) -> float:
+        """Fallback heuristic AI detection."""
+        if not text.strip():
+            return 0.5
+
+        ai_indicators = [
+            r"\b(In conclusion|Furthermore|Moreover|Additionally|It's important to note|Delve|Tapestry|Testament|Landscape|Realm|Harness|Leverage)\b",
+            r"\b(very|really|quite|extremely|significantly)\b",
+            r"\b(as an AI|language model|I don't have|I cannot)\b",
+            r"[.,]{2,}",
+            r"\b(fist|second|third|finally|in summary)\b",
+        ]
+
+        sentences = sent_tokenize(text)
+        score = 0.0
+
+        if len(sentences) > 0:
+            avg_len = sum(len(s.split()) for s in sentences) / len(sentences)
+            # AI tends to have very uniform sentence lengths
+            if avg_len > 15 and avg_len < 25:
+                score += 0.2
+
+        for pattern in ai_indicators:
+            matches = len(re.findall(pattern, text, re.IGNORECASE))
+            score += matches * 0.1
+
+        # Check for low burstiness (uniform complexity)
+        words = text.split()
+        if len(words) > 10:
+            word_lengths = [len(w) for w in words]
+            variance = np.var(word_lengths)
+            if variance < 3.0:
+                score += 0.15
+
+        return min(max(score, 0.0), 1.0)
+
+
+# ─────────────────────────────────────────────
+# Readability Analyzer
+# ─────────────────────────────────────────────
+class ReadabilityAnalyzer:
+    """Comprehensive readability analysis."""
+
+    @staticmethod
+    def analyze(text: str) -> Dict[str, float]:
+        if not text.strip():
+            return {}
+
+        try:
+            r = Readability(text)
+            results = {}
+
+            try:
+                fm = r.flesch_michaud()
+                results["flesch_reading_ease"] = fm.score
+                results["grade_level"] = fm.grade_level
+            except:
+                pass
+
+            try:
+                fk = r.flesch_kincaid()
+                results["flesch_kincaid_grade"] = fk.grade_level
+            except:
+                pass
+
+            try:
+                g = r.gunning_fog()
+                results["gunning_fog"] = g.grade_level
+            except:
+                pass
+
+            try:
+                smog = r.smog()
+                results["smog_index"] = smog.grade_level
+            except:
+                pass
+
+            results["word_count"] = len(text.split())
+            results["sentence_count"] = len(sent_tokenize(text))
+            results["avg_words_per_sentence"] = (
+                results["word_count"] / max(results["sentence_count"], 1)
+            )
+            results["avg_word_length"] = np.mean([len(w) for w in text.split()]) if text.split() else 0
+
+            # Burstiness (variation in sentence length)
+            sent_lengths = [len(s.split()) for s in sent_tokenize(text)]
+            if len(sent_lengths) > 1:
+                results["burstiness"] = np.std(sent_lengths)
+                results["perplexity"] = np.exp(
+                    -np.mean([np.log(max(l, 1)) for l in sent_lengths])
+                )
+            else:
+                results["burstiness"] = 0
+                results["perplexity"] = 1
+
+            return results
+        except Exception as e:
+            logger.error(f"Readability analysis error: {e}")
+            return {"error": str(e)}
+
+
+# ─────────────────────────────────────────────
+# Similarity Scorer
+# ─────────────────────────────────────────────
+class SimilarityScorer:
+    """Measures semantic similarity between texts."""
+
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        try:
+            self.model = SentenceTransformer(
+                "sentence-transformers/all-MiniLM-L6-v2",
+                device=self.device,
+            )
+            self.loaded = True
+            logger.info("Similarity scorer loaded")
+        except Exception as e:
+            logger.warning(f"Similarity scorer failed: {e}")
+            self.loaded = False
+
+    def score(self, text1: str, text2: str) -> float:
+        if not self.loaded:
+            return self._simple_similarity(text1, text2)
         try:
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.model_id,
-                trust_remote_code=True,
-                padding_side="left"
+            embeddings = self.model.encode([text1, text2], convert_to_numpy=True)
+            sim = float(
+                np.dot(embeddings[0], embeddings[1])
+                / (np.linalg.norm(embeddings[0]) * np.linalg.norm(embeddings[1]))
             )
-            
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            
-            # Memory-aware loading
-            if self.device == "cuda":
-                vram = torch.cuda.get_device_properties(0).total_memory / 1e9
-                
-                if vram > 40:  # A100 40GB/80GB
-                    # Can handle 7B in 4-bit easily
-                    quantization_config = BitsAndBytesConfig(
-                        load_in_4bit=True,
-                        bnb_4bit_compute_dtype=torch.float16,
-                        bnb_4bit_quant_type="nf4",
-                        bnb_4bit_use_double_quant=True,
+            return max(0.0, min(1.0, sim))
+        except Exception as e:
+            logger.error(f"Similarity scoring error: {e}")
+            return self._simple_similarity(text1, text2)
+
+    @staticmethod
+    def _simple_similarity(t1: str, t2: str) -> float:
+        words1 = set(t1.lower().split())
+        words2 = set(t2.lower().split())
+        if not words1 or not words2:
+            return 0.0
+        return len(words1 & words2) / len(words1 | words2)
+
+
+# ─────────────────────────────────────────────
+# Prompt Templates
+# ─────────────────────────────────────────────
+PROMPT_TEMPLATES = {
+    "casual": {
+        "system": """You are an expert at rewriting AI-generated text to sound like it was written by a real, casual human. Your writing has these characteristics:
+- Uses contractions naturally (don't, can't, it's, I'm)
+- Varies sentence length significantly (some very short, some longer)
+- Occasionally starts sentences with "And", "But", "So"
+- Uses colloquial expressions and mild interjections
+- Has natural imperfections — not every sentence is grammatically perfect
+- Sounds conversational, like explaining something to a friend
+- Uses specific examples and personal-feeling language
+- Avoids overly formal transitions and academic phrasing
+- Writes with personality and occasional humor
+- Uses rhetorical questions naturally""",
+        "user": """Rewrite the following text to sound completely human and casual. Make it sound like a real person wrote it naturally. Preserve the core meaning and information, but completely transform the style.
+
+RULES:
+1. DO NOT use phrases like "In conclusion", "Furthermore", "Moreover", "Additionally", "It's important to note"
+2. DO NOT use overly formal academic language
+3. DO NOT make every sentence the same length
+4. DO use contractions frequently
+5. DO vary your sentence structure
+6. DO add natural transitions that humans actually use
+7. DO make it sound like someone speaking casually but intelligently
+
+Original text:
+{text}""",
+    },
+    "professional": {
+        "system": """You are an expert professional writer who makes AI text sound authentically human. Your professional writing:
+- Uses precise, industry-appropriate language without being robotic
+- Varies sentence structure and length naturally
+- Includes subtle personal insights and perspective
+- Uses professional but warm tone
+- Avoids cliché AI phrases and patterns
+- Writes with authority but approachability
+- Uses specific data points and concrete examples
+- Has natural paragraph flow""",
+        "user": """Rewrite the following text to sound like it was written by a seasoned professional in the field. Make it sound authentically human while maintaining professionalism.
+
+RULES:
+1. Remove any robotic or template-sounding phrases
+2. Add subtle professional personality
+3. Use specific, concrete language
+4. Vary sentence structure naturally
+5. Maintain the core information and accuracy
+6. Sound authoritative but approachable
+7. Avoid AI-typical transition words
+
+Original text:
+{text}""",
+    },
+    "creative": {
+        "system": """You are a creative writer who excels at making text sound deeply human and engaging. Your writing:
+- Uses vivid imagery and sensory details
+- Employs metaphor and analogy naturally
+- Has strong narrative flow
+- Varies rhythm and pacing
+- Shows personality and voice
+- Uses creative sentence structures
+- Includes unexpected but fitting word choices
+- Feels alive and dynamic""",
+        "user": """Transform the following text into something that reads like it was written by a talented creative human writer. Make it engaging, vivid, and full of personality while preserving the core message.
+
+RULES:
+1. Add vivid imagery and sensory details where appropriate
+2. Use metaphor and creative comparisons
+3. Vary rhythm — mix short punchy sentences with longer flowing ones
+4. Show, don't just tell
+5. Make it emotionally engaging
+6. Avoid any AI-sounding clichés
+7. Write with unmistakable human voice and style
+
+Original text:
+{text}""",
+    },
+    "academic": {
+        "system": """You are an academic writer who makes scholarly text sound authentically human. Your academic writing:
+- Uses precise scholarly language without being mechanical
+- Shows genuine intellectual curiosity
+- Includes nuanced arguments and counterpoints
+- Uses natural academic transitions
+- Varies sentence complexity
+- Shows the author's analytical voice
+- Cites reasoning naturally
+- Avoids formulaic academic AI patterns""",
+        "user": """Rewrite the following academic text to sound like it was written by a thoughtful human scholar. Make it sound like genuine intellectual writing, not AI-generated academic prose.
+
+RULES:
+1. Remove formulaic academic AI phrases
+2. Show genuine analytical thinking
+3. Use natural scholarly transitions
+4. Include nuanced perspectives
+5. Vary sentence complexity naturally
+6. Sound like a real academic with a distinct voice
+7. Maintain academic rigor while sounding human
+
+Original text:
+{text}""",
+    },
+    "balanced": {
+        "system": """You are an expert at making AI-generated text sound completely human. You analyze the input text and rewrite it with these human characteristics:
+- Natural sentence variation (mix of short, medium, and long sentences)
+- Authentic voice and personality
+- Natural imperfections (occasional fragments, starting with conjunctions)
+- Realistic transitions (not formulaic)
+- Appropriate use of contractions
+- Specific and concrete language instead of vague generalizations
+- Natural paragraph structure
+- Human-like word choice and phrasing
+- Appropriate level of formality based on context""",
+        "user": """Rewrite the following text to make it sound 100% human-written. The goal is to preserve all the original information and meaning while completely transforming how it reads — it should pass as authentic human writing.
+
+RULES:
+1. NEVER use: "In conclusion", "Furthermore", "Moreover", "Additionally", "It's important to note", "Delve", "Tapestry", "Testament"
+2. Vary sentence length significantly — include some very short sentences
+3. Use contractions naturally
+4. Add subtle personality and voice
+5. Use specific, concrete language
+6. Start some sentences with "And", "But", "So", "Because"
+7. Make it read like a smart human wrote it naturally
+
+Original text:
+{text}""",
+    },
+}
+
+
+# ─────────────────────────────────────────────
+# Text Analysis Utilities
+# ─────────────────────────────────────────────
+class TextAnalyzer:
+    """Comprehensive text analysis utilities."""
+
+    @staticmethod
+    def detect_ai_patterns(text: str) -> List[Dict[str, Any]]:
+        """Detect common AI writing patterns."""
+        patterns = []
+
+        ai_phrases = [
+            "in conclusion", "furthermore", "moreover", "additionally",
+            "it's important to note", "it is important to note",
+            "delve into", "delve deep", "tapestry", "testament to",
+            "in the realm of", "in today's world", "in today's digital",
+            "ever-evolving", "rapidly evolving", "fast-paced",
+            "harness the power", "leverage", "utilize",
+            "a testament to", "a rich tapestry", "navigate the landscape",
+            "foster a sense", "fosters a deeper", "pivotal role",
+            "shed light on", "play a crucial role", "plays a vital role",
+            "it's worth noting", "it is worth noting",
+            "notably", "crucially", "significantly",
+            "in essence", "in summary", "to summarize",
+        ]
+
+        text_lower = text.lower()
+        for phrase in ai_phrases:
+            if phrase in text_lower:
+                patterns.append({
+                    "type": "ai_phrase",
+                    "phrase": phrase,
+                    "severity": "medium",
+                })
+
+        # Check for overly uniform sentence lengths
+        sentences = sent_tokenize(text)
+        if len(sentences) > 3:
+            lengths = [len(s.split()) for s in sentences]
+            std_dev = np.std(lengths)
+            if std_dev < 3:
+                patterns.append({
+                    "type": "uniform_sentences",
+                    "detail": f"Low sentence length variation (std={std_dev:.1f})",
+                    "severity": "high",
+                })
+
+        # Check for lack of contractions
+        contraction_count = len(re.findall(r"\b\w+'\w+\b", text))
+        word_count = len(text.split())
+        if word_count > 50 and contraction_count < 3:
+            patterns.append({
+                "type": "no_contractions",
+                "detail": f"Only {contraction_count} contractions in {word_count} words",
+                "severity": "medium",
+            })
+
+        # Check for repetitive sentence starters
+        starters = [s.split()[0].lower() if s.split() else "" for s in sentences]
+        starter_counts = Counter(starters)
+        for starter, count in starter_counts.items():
+            if count > len(sentences) * 0.3 and len(starter) > 2:
+                patterns.append({
+                    "type": "repetitive_start",
+                    "detail": f"'{starter}' starts {count}/{len(sentences)} sentences",
+                    "severity": "medium",
+                })
+
+        return patterns
+
+    @staticmethod
+    def get_diff_html(original: str, humanized: str) -> str:
+        """Generate HTML diff showing changes."""
+        orig_words = original.split()
+        human_words = humanized.split()
+
+        matcher = difflib.SequenceMatcher(None, orig_words, human_words)
+        html = []
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == "equal":
+                html.extend(orig_words[i1:i2])
+            elif tag == "replace":
+                html.append('<span style="background:#ffcccc;text-decoration:line-through">'
+                            + " ".join(orig_words[i1:i2]) + "</span>")
+                html.append('<span style="background:#ccffcc">'
+                            + " ".join(human_words[j1:j2]) + "</span>")
+            elif tag == "delete":
+                html.append('<span style="background:#ffcccc;text-decoration:line-through">'
+                            + " ".join(orig_words[i1:i2]) + "</span>")
+            elif tag == "insert":
+                html.append('<span style="background:#ccffcc">'
+                            + " ".join(human_words[j1:j2]) + "</span>")
+
+        return " ".join(html)
+
+
+# ─────────────────────────────────────────────
+# Model Manager
+# ─────────────────────────────────────────────
+class ModelManager:
+    """Manages loading and inference of all models."""
+
+    def __init__(self):
+        self.models = {}
+        self.pipelines = {}
+        self.tokenizers = {}
+        self.loaded = False
+
+    def load_models(self, model_keys: Optional[List[str]] = None):
+        """Load specified models into memory."""
+        if model_keys is None:
+            model_keys = ["llama_3_70b", "mistral_7b", "bart_paraphrase"]
+
+        for key in model_keys:
+            if key not in MODEL_REGISTRY:
+                continue
+
+            model_info = MODEL_REGISTRY[key]
+            try:
+                logger.info(f"Loading model: {model_info['name']}...")
+
+                if model_info["type"] == "chat":
+                    tokenizer = AutoTokenizer.from_pretrained(
+                        model_info["id"],
+                        token=HF_TOKEN,
+                        trust_remote_code=True,
                     )
-                    self.model = AutoModelForCausalLM.from_pretrained(
-                        self.model_id,
-                        quantization_config=quantization_config,
+                    if tokenizer.pad_token is None:
+                        tokenizer.pad_token = tokenizer.eos_token
+
+                    model = AutoModelForCausalLM.from_pretrained(
+                        model_info["id"],
+                        torch_dtype=torch.float16,
                         device_map="auto",
+                        token=HF_TOKEN,
                         trust_remote_code=True,
-                        torch_dtype=torch.float16,
-                        low_cpu_mem_usage=True
                     )
-                elif vram > 15:  # T4 16GB or similar
-                    # 4-bit for safety
-                    quantization_config = BitsAndBytesConfig(
-                        load_in_4bit=True,
-                        bnb_4bit_compute_dtype=torch.float16,
-                        bnb_4bit_quant_type="nf4",
-                        bnb_4bit_use_double_quant=True,
+
+                    pipe = pipeline(
+                        "text-generation",
+                        model=model,
+                        tokenizer=tokenizer,
+                        torch_dtype=torch.float16,
+                        device_map="auto",
                     )
-                    self.model = AutoModelForCausalLM.from_pretrained(
-                        self.model_id,
-                        quantization_config=quantization_config,
+
+                    self.models[key] = model
+                    self.tokenizers[key] = tokenizer
+                    self.pipelines[key] = pipe
+
+                elif model_info["type"] == "seq2seq":
+                    tokenizer = AutoTokenizer.from_pretrained(model_info["id"])
+                    model = AutoModelForSeq2SeqLM.from_pretrained(
+                        model_info["id"],
+                        torch_dtype=torch.float16,
                         device_map="auto",
-                        trust_remote_code=True,
-                        low_cpu_mem_usage=True
                     )
-                else:
-                    # 8-bit for safety on smaller GPUs
-                    self.model = AutoModelForCausalLM.from_pretrained(
-                        self.model_id,
-                        load_in_8bit=True,
+                    pipe = pipeline(
+                        "text2text-generation",
+                        model=model,
+                        tokenizer=tokenizer,
+                        torch_dtype=torch.float16,
                         device_map="auto",
-                        trust_remote_code=True,
-                        low_cpu_mem_usage=True
                     )
+                    self.models[key] = model
+                    self.tokenizers[key] = tokenizer
+                    self.pipelines[key] = pipe
+
+                logger.info(f"✅ Loaded: {model_info['name']}")
+
+            except Exception as e:
+                logger.error(f"❌ Failed to load {model_info['name']}: {e}")
+                # Try HF Inference API as fallback
+                try:
+                    client = InferenceClient(
+                        model=model_info["id"],
+                        token=HF_TOKEN,
+                    )
+                    self.pipelines[key] = client
+                    logger.info(f"✅ Using Inference API for: {model_info['name']}")
+                except Exception as e2:
+                    logger.error(f"❌ Inference API also failed for {key}: {e2}")
+
+        self.loaded = True
+        logger.info(f"Model loading complete. Loaded: {list(self.pipelines.keys())}")
+
+    def generate(
+        self,
+        model_key: str,
+        prompt: str,
+        system_prompt: str = "",
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        max_tokens: int = 2048,
+    ) -> str:
+        """Generate text using specified model."""
+        if model_key not in self.pipelines:
+            logger.error(f"Model {model_key} not loaded")
+            return ""
+
+        pipe = self.pipelines[model_key]
+        model_info = MODEL_REGISTRY.get(model_key, {})
+
+        try:
+            if model_info.get("type") == "chat" or isinstance(pipe, TextGenerationPipeline):
+                messages = []
+                if system_prompt:
+                    messages.append({"role": "system", "content": system_prompt})
+                messages.append({"role": "user", "content": prompt})
+
+                result = pipe(
+                    messages,
+                    max_new_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    do_sample=True,
+                    return_full_text=False,
+                )
+
+                if isinstance(result, list):
+                    output = result[0]["generated_text"]
+                    if isinstance(output, str):
+                        return output.strip()
+                    elif isinstance(output, list):
+                        return output[-1].get("content", "").strip()
+                elif isinstance(result, dict):
+                    output = result.get("generated_text", "")
+                    if isinstance(output, str):
+                        return output.strip()
+
+            elif isinstance(pipe, InferenceClient):
+                messages = []
+                if system_prompt:
+                    messages.append({"role": "system", "content": system_prompt})
+                messages.append({"role": "user", "content": prompt})
+
+                response = pipe.chat_completion(
+                    messages,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                )
+                return response.choices[0].message.content.strip()
+
             else:
-                # CPU mode - aggressive quantization
-                self.model = AutoModelForCausalLM.from_pretrained(
-                    self.model_id,
-                    torch_dtype=torch.float32,
-                    device_map="cpu",
-                    low_cpu_mem_usage=True
+                # Seq2seq pipeline
+                result = pipe(
+                    prompt,
+                    max_length=min(max_tokens + len(prompt.split()), 1024),
+                    temperature=temperature,
+                    do_sample=True,
                 )
-            
-            self.model.eval()
-            print("✅ Model loaded successfully")
-            
+                if isinstance(result, list) and len(result) > 0:
+                    return result[0]["generated_text"].strip()
+
         except Exception as e:
-            print(f"❌ Error loading model: {e}")
-            raise
-    
-    def analyze_text_patterns(self, text: str) -> Dict:
-        """Analyze writing patterns"""
-        sentences = re.split(r'(?<=[.!?])\s+', text)
-        words = text.split()
-        
-        # Burstiness calculation
-        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
-            
-        # AI markers detection
-        ai_patterns = [
-            r'\b(delve|leverage|utilize|facilitate|optimize|embark|journey|seamless)\b',
-            r'\b(In conclusion|Furthermore|Moreover|Additionally|Thus|Therefore)\b',
-            r'\b(It is important to note that|It should be noted that)\b',
-            r'\b(In today\'s world|In the digital age)\b',
-            r'\b(As an AI|As a language model)\b',
-        ]
-        
-        pattern_matches = sum(len(re.findall(p, text, re.I)) for p in ai_patterns)
-        
-        return {
-            "burstiness": burstiness,
-            "avg_sentence_length": np.mean([len(s.split()) for s in sentences]) if sentences else 0,
-            "ai_markers": pattern_matches,
-            "word_count": len(words),
-        }
-    
-    def generate_humanization_prompt(self, text: str, config: HumanizationConfig, 
-                                    style: str, analysis: Dict) -> Tuple[str, str]:
-        """Generate prompts"""
-        
-        style_instructions = {
-            "casual": "Sound like a knowledgeable friend. Contractions, everyday words, conversational flow.",
-            "professional": "Smart colleague tone. Clear but warm, not robotic.",
-            "academic": "Passionate professor speaking. Scholarly but accessible, personal perspective.",
-            "creative": "Vivid, rhythmic, metaphors. Show don't tell.",
-            "internet": "Authentic web voice. Blog style, informative but casual.",
-            "genz": "Modern casual. Direct, slightly irreverent, very natural."
-        }
-        
-        style_instruction = style_instructions.get(style, style_instructions["casual"])
-        
-        de_ai_specific = ""
-        if analysis["ai_markers"] > 0:
-            de_ai_specific = f"""
-            REMOVE {analysis['ai_markers']} AI MARKERS DETECTED:
-            - Replace: delve→look into, leverage→use, utilize→use, facilitate→help, optimize→improve
-            - Remove: "In conclusion", "Furthermore", "It is important to note"
-            """
-        
-        imperfections = ""
+            logger.error(f"Generation error with {model_key}: {e}")
+            return ""
+
+        return ""
+
+
+# ─────────────────────────────────────────────
+# Humanization Engine
+# ─────────────────────────────────────────────
+class HumanizationEngine:
+    """Core humanization engine with multi-model ensemble."""
+
+    def __init__(self):
+        self.model_manager = ModelManager()
+        self.ai_detector = AIDetector()
+        self.readability = ReadabilityAnalyzer()
+        self.similarity = SimilarityScorer()
+        self.analyzer = TextAnalyzer()
+        self.initialized = False
+
+    def initialize(self):
+        """Initialize all components."""
+        if self.initialized:
+            return
+
+        logger.info("Initializing Humanization Engine...")
+        self.model_manager.load_models()
+        self.initialized = True
+        logger.info("✅ Engine initialized")
+
+    def humanize(
+        self,
+        text: str,
+        config: PipelineConfig,
+    ) -> HumanizationResult:
+        """Main humanization pipeline."""
+        start_time = time.time()
+        strategies = []
+
+        # Pre-analysis
+        ai_prob_before = self.ai_detector.detect(text)
+        readability_before = self.readability.analyze(text)
+        word_count_before = len(text.split())
+        ai_patterns = self.analyzer.detect_ai_patterns(text)
+
+        # Get appropriate prompt template
+        mode = config.mode
+        if mode not in PROMPT_TEMPLATES:
+            mode = "balanced"
+        template = PROMPT_TEMPLATES[mode]
+
+        # Apply pre-processing transformations
+        processed_text = text
+        if config.remove_patterns:
+            processed_text = self._remove_ai_patterns(processed_text, strategies)
         if config.add_imperfections:
-            imperfections = """
-            ADD NATURAL IMPERFECTIONS:
-            - Start some sentences with "But", "And", "So", "Yet"
-            - Use occasional fragments
-            - Include contractions (don't, can't, it's)
-            - Add one rhetorical question
-            - Use varied punctuation (—, ...)
-            """
-        
-        system_msg = f"""You transform AI text into authentic human writing. {style_instruction}
-
-{de_ai_specific}
-{imperfections}
+            processed_text = self._add_human_imperfections(processed_text, strategies)
 
-RULES:
-1. Keep all original information
-2. Vary sentence lengths dramatically (short + long mix)
-3. Use active voice
-4. Add subtle opinion ("I think", "probably")
-5. Output ONLY the rewritten text, no explanations, no quotes"""
-        
-        user_msg = f"Humanize this text:\n\n{text}"
-        
-        return system_msg, user_msg
-    
-    def humanize(self, text: str, style: str = "casual", intensity: str = "medium",
-                 creativity: float = 0.8, add_imperfections: bool = True) -> Tuple[str, Dict]:
-        """Main pipeline"""
-        if not text.strip():
-            return "", {"error": "Empty input"}
-        
-        config = HumanizationConfig(
-            temperature=creativity,
-            style_intensity=intensity,
-            add_imperfections=add_imperfections
+        # Primary model generation
+        prompt = template["user"].format(text=processed_text)
+        system_prompt = template["system"]
+
+        primary_model = "llama_3_70b" if "llama_3_70b" in self.model_manager.pipelines else (
+            "gemma_2_27b" if "gemma_2_27b" in self.model_manager.pipelines else
+            "mistral_7b" if "mistral_7b" in self.model_manager.pipelines else
+            list(self.model_manager.pipelines.keys())[0] if self.model_manager.pipelines else None
         )
-        
-        # Analysis
-        analysis = self.analyze_text_patterns(text)
-        
-        # Generate prompt
-        system_msg, user_msg = self.generate_humanization_prompt(text, config, style, analysis)
-        
-        # Qwen chat format
-        messages = [
-            {"role": "system", "content": system_msg},
-            {"role": "user", "content": user_msg}
-        ]
-        
-        prompt = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=2048)
-        inputs = {k: v.to(self.model.device) for k, v in inputs.items()}
-        
-        # Generate
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_new_tokens=min(len(text.split()) * 2, 1024),
-                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,
-            )
-        
-        # Decode
-        full_output = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        assistant_response = full_output.split("assistant")[-1].strip()
-        if assistant_response.startswith(":"):
-            assistant_response = assistant_response[1:].strip()
-        
-        # Post-process
-        if intensity == "aggressive":
-            assistant_response = self._aggressive_variation(assistant_response)
-        elif intensity == "light":
-            assistant_response = self._light_cleanup(assistant_response)
-        
-        # Metrics
-        final_analysis = self.analyze_text_patterns(assistant_response)
-        human_score = self._calculate_human_score(assistant_response, final_analysis, analysis)
-        
-        metrics = {
-            "ai_markers_removed": analysis["ai_markers"] - final_analysis["ai_markers"],
-            "burstiness": round(final_analysis["burstiness"], 2),
-            "human_score": human_score,
-            "intensity": intensity,
-        }
-        
-        # Cleanup
-        if self.device == "cuda":
-            torch.cuda.empty_cache()
-            gc.collect()
-        
-        return assistant_response, metrics
-    
-    def _aggressive_variation(self, text: str) -> str:
-        """Add variation"""
-        # Combine sentences occasionally
-        text = re.sub(r'([.])\s+([A-Z])', lambda m: f", and {m.group(2).lower()}" if random.random() > 0.8 else f". {m.group(1)}", text)
-        
-        # Add fragments
-        sentences = text.split('. ')
-        if len(sentences) > 3 and random.random() > 0.5:
-            idx = random.randint(1, len(sentences)-2)
-            words = sentences[idx].split()
-            if len(words) > 4:
-                sentences[idx] = ' '.join(words[:2]) + "..."
-        return '. '.join(sentences)
-    
-    def _light_cleanup(self, text: str) -> str:
-        """Minimal cleanup"""
-        text = re.sub(r'\b(In conclusion|To summarize|Overall),\s*', '', text, flags=re.I)
-        text = re.sub(r'\b(it is important to note that)\s*', '', text, flags=re.I)
-        return text.strip()
-    
-    def _calculate_human_score(self, text: str, final: Dict, original: Dict) -> int:
-        """Score 0-100"""
-        score = 75
-        score -= original["ai_markers"] * 10
-        score += (original["ai_markers"] - final["ai_markers"]) * 15
-        
-        if final["burstiness"] > 0.4:
-            score += 15
-        elif final["burstiness"] > 0.2:
-            score += 8
-        
-        contractions = len(re.findall(r"\b\w+'\w+\b", text))
-        if contractions >= 2:
-            score += 10
-            
-        return max(0, min(100, score))
-
-# Initialize
-print("🔄 Initializing...")
-try:
-    humanizer = DeepHumanizer()
-except Exception as e:
-    print(f"⚠️ Initialization error: {e}")
-    humanizer = None
-
-def process_text(text, style, intensity, creativity, add_imperfections):
-    """Handler"""
-    if humanizer is None:
-        return "❌ Model failed to load", "<div style='color:red'>Initialization error</div>"
-    
-    if not text or len(text.strip()) < 10:
-        return "⚠️ Enter at least 10 characters", ""
-    
-    try:
-        humanized, metrics = humanizer.humanize(
-            text=text, style=style, intensity=intensity,
-            creativity=creativity, add_imperfections=add_imperfections
+
+        if primary_model is None:
+            raise RuntimeError("No models available for humanization")
+
+        humanized_text = self.model_manager.generate(
+            model_key=primary_model,
+            prompt=prompt,
+            system_prompt=system_prompt,
+            temperature=config.temperature,
+            top_p=config.top_p,
+            max_tokens=config.max_tokens,
         )
-        
-        status_color = "#22c55e" if metrics["human_score"] > 80 else "#eab308" if metrics["human_score"] > 60 else "#ef4444"
-        
-        metrics_html = f"""
-        <div style="border: 2px solid {status_color}; border-radius: 8px; padding: 15px; margin-top: 10px;">
-            <h4 style="margin-top: 0; color: {status_color};">📊 Human Score: {metrics['human_score']}/100</h4>
-            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px; font-size: 14px;">
-                <div>🎯 AI markers removed: {metrics['ai_markers_removed']}</div>
-                <div>📈 Burstiness: {metrics['burstiness']}</div>
-                <div>⚡ Intensity: {metrics['intensity'].title()}</div>
-                <div>🎭 Style: {style.title()}</div>
-            </div>
-        </div>
-        """
-        
-        return humanized, metrics_html
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}", f"<div style='color:red'>{str(e)}</div>"
-
-# Gradio UI (4.0.0 compatible syntax)
-css = """
-.output-box { min-height: 200px; }
-.metric-box { background: #f9fafb; padding: 10px; border-radius: 5px; }
-"""
 
-with gr.Blocks(css=css, title="Deep Humanizer Pro") as demo:
-    gr.Markdown("""
-    # 🧠 Deep Humanizer Pro
-    ### Advanced AI-to-Human Text Transformation
-    *Powered by Qwen2.5-7B with linguistic analysis*
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_text = gr.Textbox(
-                label="📝 Input (AI text)",
-                placeholder="Paste AI-generated content here...",
-                lines=10
-            )
-            
-            with gr.Row():
-                style = gr.Dropdown(
-                    choices=["casual", "professional", "academic", "creative", "internet", "genz"],
-                    value="casual",
-                    label="🎭 Style"
+        if not humanized_text:
+            raise RuntimeError("Model returned empty output")
+
+        strategies.append(f"primary_rewrite_{primary_model}")
+
+        # Ensemble: secondary model refinement
+        if config.ensemble and len(self.model_manager.pipelines) > 1:
+            secondary_models = [
+                k for k in self.model_manager.pipelines.keys()
+                if k != primary_model
+            ][:2]  # Use up to 2 secondary models
+
+            for sec_model in secondary_models:
+                refine_prompt = f"""Take this text and make it sound even MORE human. Add natural flow, vary sentence rhythm, and ensure it reads like authentic human writing. Don't change the meaning.
+
+Text to refine:
+{humanized_text[:3000]}"""
+
+                refined = self.model_manager.generate(
+                    model_key=sec_model,
+                    prompt=refine_prompt,
+                    system_prompt="You are an expert editor who makes text sound deeply human. Your edits are subtle but transformative.",
+                    temperature=config.temperature * 0.8,
+                    top_p=config.top_p,
+                    max_tokens=config.max_tokens,
                 )
-                intensity = gr.Radio(
-                    choices=["light", "medium", "aggressive"],
-                    value="medium",
-                    label="⚡ Intensity"
+
+                if refined and len(refined) > len(humanized_text) * 0.5:
+                    # Compare quality - choose the better one
+                    ai_prob_refined = self.ai_detector.detect(refined)
+                    ai_prob_current = self.ai_detector.detect(humanized_text)
+                    if ai_prob_refined < ai_prob_current:
+                        humanized_text = refined
+                        strategies.append(f"ensemble_refined_{sec_model}")
+                    else:
+                        strategies.append(f"ensemble_attempted_{sec_model}")
+
+        # Post-processing
+        if config.vary_sentence_length:
+            humanized_text = self._vary_sentence_structure(humanized_text, strategies)
+        if config.add_transitions:
+            humanized_text = self._improve_transitions(humanized_text, strategies)
+        if config.add_personal_touch:
+            humanized_text = self._add_personal_elements(humanized_text, strategies)
+
+        # Post-analysis
+        ai_prob_after = self.ai_detector.detect(humanized_text)
+        readability_after = self.readability.analyze(humanized_text)
+        word_count_after = len(humanized_text.split())
+        similarity_score = self.similarity.score(text, humanized_text)
+        processing_time = time.time() - start_time
+
+        # Count changes
+        orig_words = set(text.lower().split())
+        new_words = set(humanized_text.lower().split())
+        changes = len(orig_words.symmetric_difference(new_words))
+
+        return HumanizationResult(
+            original=text,
+            humanized=humanized_text,
+            model_used=primary_model,
+            mode=mode,
+            changes_made=changes,
+            similarity_score=similarity_score,
+            readability_before=readability_before,
+            readability_after=readability_after,
+            ai_probability_before=ai_prob_before,
+            ai_probability_after=ai_prob_after,
+            processing_time=processing_time,
+            strategies_applied=strategies,
+            word_count_before=word_count_before,
+            word_count_after=word_count_after,
+            perplexity_before=readability_before.get("perplexity", 0),
+            perplexity_after=readability_after.get("perplexity", 0),
+        )
+
+    def _remove_ai_patterns(self, text: str, strategies: List[str]) -> str:
+        """Remove common AI writing patterns."""
+        replacements = {
+            r"\bIn conclusion\b": "So",
+            r"\bFurthermore\b": "Plus",
+            r"\bMoreover\b": "Also",
+            r"\bAdditionally\b": "On top of that",
+            r"\bIt's important to note\b": "Keep in mind",
+            r"\bIt is important to note\b": "Keep in mind",
+            r"\bdelve into\b": "look into",
+            r"\bdelve deep\b": "dig into",
+            r"\btapestry\b": "mix",
+            r"\btestament to\b": "shows",
+            r"\bin the realm of\b": "in",
+            r"\bin today's world\b": "these days",
+            r"\bever-evolving\b": "changing",
+            r"\brapidly evolving\b": "fast-changing",
+            r"\bharness the power of\b": "use",
+            r"\bleverage\b": "use",
+            r"\butilize\b": "use",
+            r"\bpivotal role\b": "big role",
+            r"\bshed light on\b": "explain",
+            r"\bfoster a sense of\b": "create",
+            r"\bin essence\b": "Basically",
+            r"\bin summary\b": "To wrap up",
+        }
+
+        for pattern, replacement in replacements.items():
+            if re.search(pattern, text, re.IGNORECASE):
+                text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+                strategies.append(f"replaced_ai_pattern_{pattern}")
+
+        return text
+
+    def _add_human_imperfections(self, text: str, strategies: List[str]) -> str:
+        """Add subtle human imperfections."""
+        sentences = sent_tokenize(text)
+        if len(sentences) < 2:
+            return text
+
+        # Occasionally start sentences with conjunctions
+        conjunctions = ["And", "But", "So", "Because", "Though"]
+        for i, sent in enumerate(sentences):
+            if i > 0 and random.random() < 0.15:
+                conj = random.choice(conjunctions)
+                sentences[i] = sent[0].lower() if sent else sent
+                sentences[i] = f"{conj} {sentences[i]}"
+
+        text = " ".join(sentences)
+        strategies.append("added_conjunction_starts")
+        return text
+
+    def _vary_sentence_structure(self, text: str, strategies: List[str]) -> str:
+        """Vary sentence structure for more natural flow."""
+        sentences = sent_tokenize(text)
+        if len(sentences) < 3:
+            return text
+
+        new_sentences = []
+        for sent in sentences:
+            words = sent.split()
+            if len(words) > 25 and random.random() < 0.4:
+                # Split long sentences
+                mid = len(words) // 2
+                # Find a good split point
+                for i in range(mid - 5, mid + 5):
+                    if i > 0 and i < len(words) and words[i] in [",", "and", "but", "which", "that", "where", "when"]:
+                        part1 = " ".join(words[:i + 1])
+                        part2 = " ".join(words[i + 1:])
+                        if part2:
+                            part2 = part2[0].upper() + part2[1:]
+                        new_sentences.append(part1.strip(" ,"))
+                        new_sentences.append(part2.strip())
+                        break
+                else:
+                    new_sentences.append(sent)
+            else:
+                new_sentences.append(sent)
+
+        text = " ".join(new_sentences)
+        strategies.append("varied_sentence_structure")
+        return text
+
+    def _improve_transitions(self, text: str, strategies: List[str]) -> str:
+        """Improve transitions between ideas."""
+        human_transitions = [
+            "Here's the thing:", "The thing is,", "Look,",
+            "Honestly,", "Real talk,", "Here's what I mean:",
+            "What this means is:", "Put simply,", "The way I see it,",
+            "At the end of the day,", "When you think about it,",
+        ]
+
+        sentences = sent_tokenize(text)
+        if len(sentences) < 4:
+            return text
+
+        # Add a transition at ~30% mark
+        insert_pos = len(sentences) // 3
+        if insert_pos > 0 and insert_pos < len(sentences):
+            transition = random.choice(human_transitions)
+            sentences[insert_pos] = f"{transition} {sentences[insert_pos][0].lower() + sentences[insert_pos][1:] if sentences[insert_pos] else sentences[insert_pos]}"
+
+        text = " ".join(sentences)
+        strategies.append("improved_transitions")
+        return text
+
+    def _add_personal_elements(self, text: str, strategies: List[str]) -> str:
+        """Add personal-feeling elements."""
+        personal_phrases = [
+            "I've found that", "From my experience,", "I think",
+            "It seems like", "I'd say", "If you ask me,",
+            "In my view,", "What I've noticed is",
+        ]
+
+        sentences = sent_tokenize(text)
+        if len(sentences) < 3:
+            return text
+
+        # Add personal phrase at beginning of second paragraph
+        if len(sentences) > 4:
+            insert_pos = min(4, len(sentences) - 1)
+            phrase = random.choice(personal_phrases)
+            sentences[insert_pos] = f"{phrase} {sentences[insert_pos][0].lower() + sentences[insert_pos][1:] if sentences[insert_pos] else sentences[insert_pos]}"
+
+        text = " ".join(sentences)
+        strategies.append("added_personal_elements")
+        return text
+
+    def batch_humanize(
+        self,
+        texts: List[str],
+        config: PipelineConfig,
+        progress=gr.Progress(),
+    ) -> List[HumanizationResult]:
+        """Process multiple texts."""
+        results = []
+        for i, text in enumerate(texts):
+            progress((i + 1) / len(texts), desc=f"Processing {i + 1}/{len(texts)}")
+            try:
+                result = self.humanize(text, config)
+                results.append(result)
+            except Exception as e:
+                logger.error(f"Error processing text {i}: {e}")
+                results.append(HumanizationResult(
+                    original=text,
+                    humanized=f"[Error: {str(e)}]",
+                    model_used="error",
+                    mode=config.mode,
+                    changes_made=0,
+                    similarity_score=0,
+                    readability_before={},
+                    readability_after={},
+                    ai_probability_before=0,
+                    ai_probability_after=0,
+                    processing_time=0,
+                    strategies_applied=[],
+                    word_count_before=len(text.split()),
+                    word_count_after=0,
+                    perplexity_before=0,
+                    perplexity_after=0,
+                ))
+        return results
+
+
+# ─────────────────────────────────────────────
+# Gradio UI Builder
+# ─────────────────────────────────────────────
+class HumanizerApp:
+    """Gradio application for the humanizer."""
+
+    def __init__(self):
+        self.engine = HumanizationEngine()
+        self.theme = self._build_theme()
+
+    @staticmethod
+    def _build_theme():
+        """Build custom Gradio theme."""
+        from gradio.themes import Base, Default
+
+        theme = Default(
+            primary_hue="emerald",
+            secondary_hue="blue",
+            font=gr.themes.GoogleFont("Inter"),
+        )
+        return theme
+
+    def build_interface(self) -> gr.Blocks:
+        """Build the complete Gradio interface."""
+        with gr.Blocks(
+            theme=self.theme,
+            title="🧬 Advanced AI Text Humanizer",
+            css=self._get_custom_css(),
+        ) as app:
+            gr.Markdown("""
+# 🧬 Advanced AI Text Humanizer
+### Transform AI-generated text into authentic human writing using multi-model ensemble
+
+**Powered by:** Llama 3.3 70B • Mistral 7B • Gemma 2 27B • Zephyr 7B • BART
+            """)
+
+            with gr.Tabs():
+                # ── Tab 1: Single Text ──
+                with gr.Tab("📝 Single Text"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            input_text = gr.Textbox(
+                                label="📄 Input Text",
+                                placeholder="Paste your AI-generated text here...",
+                                lines=12,
+                                max_lines=50,
+                            )
+                            with gr.Row():
+                                humanize_btn = gr.Button(
+                                    "✨ Humanize Text",
+                                    variant="primary",
+                                    size="lg",
+                                )
+                                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                            with gr.Accordion("⚙️ Advanced Settings", open=False):
+                                with gr.Row():
+                                    mode = gr.Dropdown(
+                                        choices=[
+                                            ("🎯 Balanced", "balanced"),
+                                            ("😊 Casual", "casual"),
+                                            ("💼 Professional", "professional"),
+                                            ("🎨 Creative", "creative"),
+                                            ("📚 Academic", "academic"),
+                                        ],
+                                        value="balanced",
+                                        label="Writing Mode",
+                                    )
+                                    intensity = gr.Slider(
+                                        minimum=0.1,
+                                        maximum=1.0,
+                                        value=0.5,
+                                        step=0.1,
+                                        label="Intensity",
+                                    )
+                                with gr.Row():
+                                    temperature = gr.Slider(
+                                        minimum=0.1,
+                                        maximum=1.5,
+                                        value=0.7,
+                                        step=0.1,
+                                        label="Temperature",
+                                    )
+                                    top_p = gr.Slider(
+                                        minimum=0.1,
+                                        maximum=1.0,
+                                        value=0.9,
+                                        step=0.05,
+                                        label="Top-P",
+                                    )
+                                with gr.Row():
+                                    ensemble = gr.Checkbox(
+                                        value=True,
+                                        label="🔄 Ensemble Mode",
+                                    )
+                                    preserve_meaning = gr.Checkbox(
+                                        value=True,
+                                        label="🎯 Preserve Meaning",
+                                    )
+                                with gr.Row():
+                                    add_imperfections = gr.Checkbox(
+                                        value=True,
+                                        label="✨ Add Imperfections",
+                                    )
+                                    vary_sentence_length = gr.Checkbox(
+                                        value=True,
+                                        label="📏 Vary Sentence Length",
+                                    )
+                                with gr.Row():
+                                    add_transitions = gr.Checkbox(
+                                        value=True,
+                                        label="🔗 Add Transitions",
+                                    )
+                                    add_personal_touch = gr.Checkbox(
+                                        value=True,
+                                        label="💭 Add Personal Touch",
+                                    )
+
+                        with gr.Column(scale=1):
+                            output_text = gr.Textbox(
+                                label="📝 Humanized Output",
+                                placeholder="Humanized text will appear here...",
+                                lines=12,
+                                max_lines=50,
+                            )
+                            with gr.Row():
+                                copy_btn = gr.Button("📋 Copy", variant="secondary")
+                                download_btn = gr.Button("💾 Download", variant="secondary")
+
+                # ── Tab 2: Batch Processing ──
+                with gr.Tab("📦 Batch Processing"):
+                    gr.Markdown("### Process multiple texts at once")
+                    batch_input = gr.Textbox(
+                        label="📄 Input Texts (one per line, separated by ---)",
+                        placeholder="Text 1...\n---\nText 2...\n---\nText 3...",
+                        lines=15,
+                        max_lines=100,
+                    )
+                    batch_btn = gr.Button("🚀 Batch Humanize", variant="primary", size="lg")
+                    batch_output = gr.Dataframe(
+                        headers=["Original", "Humanized", "AI Score Before", "AI Score After", "Similarity"],
+                        label="Results",
+                    )
+
+                # ── Tab 3: Analysis Dashboard ──
+                with gr.Tab("📊 Analysis"):
+                    with gr.Row():
+                        with gr.Column():
+                            analysis_input = gr.Textbox(
+                                label="📄 Text to Analyze",
+                                lines=8,
+                            )
+                            analyze_btn = gr.Button("🔍 Analyze", variant="primary")
+                        with gr.Column():
+                            ai_score_gauge = gr.Number(
+                                label="AI Probability Score",
+                            )
+                            readability_output = gr.JSON(label="Readability Metrics")
+
+                # ── Tab 4: Comparison View ──
+                with gr.Tab("🔀 Side-by-Side Comparison"):
+                    compare_input = gr.Textbox(
+                        label="📄 Input Text",
+                        lines=8,
+                    )
+                    compare_btn = gr.Button("🔍 Compare", variant="primary")
+                    with gr.Row():
+                        compare_original = gr.Textbox(
+                            label="Original",
+                            lines=12,
+                        )
+                        compare_humanized = gr.Textbox(
+                            label="Humanized",
+                            lines=12,
+                        )
+                    diff_output = gr.HTML(label="📝 Diff View")
+
+            # ── Results Panel (shared) ──
+            with gr.Accordion("📊 Detailed Results", open=True):
+                with gr.Row():
+                    with gr.Column():
+                        stats_json = gr.JSON(label="📈 Processing Statistics")
+                    with gr.Column():
+                        ai_reduction = gr.Plot(label="📉 AI Detection Reduction")
+                strategies_output = gr.Textbox(
+                    label="🛠️ Strategies Applied",
+                    lines=3,
                 )
-            
-            creativity = gr.Slider(
-                minimum=0.1, maximum=1.0, value=0.8, step=0.1,
-                label="🎨 Creativity"
+
+            # ── Footer ──
+            gr.Markdown("""
+---
+### 💡 Tips for Best Results
+- **Balanced mode** works great for most use cases
+- **Higher intensity** = more aggressive rewriting
+- **Ensemble mode** uses multiple models for best quality
+- For short texts (<100 words), try **Casual** or **Creative** mode
+- For long texts (>500 words), use **Professional** or **Academic** mode
+- Adjust **Temperature** for more/less creative output
+            """)
+
+            # ── Event Handlers ──
+            humanize_btn.click(
+                fn=self._handle_humanize,
+                inputs=[
+                    input_text, mode, intensity, temperature, top_p,
+                    ensemble, preserve_meaning, add_imperfections,
+                    vary_sentence_length, add_transitions, add_personal_touch,
+                ],
+                outputs=[output_text, stats_json, strategies_output],
+            )
+
+            clear_btn.click(
+                fn=lambda: ("", "", {}),
+                inputs=[],
+                outputs=[input_text, output_text, stats_json],
             )
-            add_imperfections = gr.Checkbox(
-                label="✨ Natural Imperfections",
-                value=True
+
+            batch_btn.click(
+                fn=self._handle_batch,
+                inputs=[batch_input, mode, intensity, temperature, top_p, ensemble],
+                outputs=[batch_output],
             )
-            
-            submit_btn = gr.Button("🚀 Humanize", variant="primary")
-            
-        with gr.Column(scale=1):
-            output_text = gr.Textbox(
-                label="✅ Humanized Output",
-                lines=10,
-                elem_classes=["output-box"]
+
+            analyze_btn.click(
+                fn=self._handle_analyze,
+                inputs=[analysis_input],
+                outputs=[ai_score_gauge, readability_output],
             )
-            metrics_display = gr.HTML()
-    
-    gr.Examples(
-        examples=[
-            ["Artificial Intelligence refers to the simulation of human intelligence in machines programmed to think like humans.", "casual", "medium"],
-            ["In conclusion, it is important to note that leveraging cutting-edge technologies facilitates optimal outcomes.", "professional", "aggressive"],
-        ],
-        inputs=[input_text, style, intensity],
-        label="🎯 Examples"
-    )
-    
-    submit_btn.click(
-        fn=process_text,
-        inputs=[input_text, style, intensity, creativity, add_imperfections],
-        outputs=[output_text, metrics_display]
-    )
+
+            compare_btn.click(
+                fn=self._handle_compare,
+                inputs=[compare_input, mode, intensity, temperature, top_p, ensemble],
+                outputs=[compare_original, compare_humanized, diff_output, stats_json],
+            )
+
+            copy_btn.click(
+                fn=self._copy_text,
+                inputs=[output_text],
+                outputs=[],
+            )
+
+            download_btn.click(
+                fn=self._download_text,
+                inputs=[output_text],
+                outputs=[],
+            )
+
+        return app
+
+    def _build_config(self, mode, intensity, temperature, top_p, ensemble,
+                      preserve_meaning, add_imperfections, vary_sentence_length,
+                      add_transitions, add_personal_touch) -> PipelineConfig:
+        """Build PipelineConfig from UI inputs."""
+        return PipelineConfig(
+            mode=mode,
+            intensity=intensity,
+            temperature=temperature,
+            top_p=top_p,
+            ensemble=ensemble,
+            preserve_meaning=preserve_meaning,
+            add_imperfections=add_imperfections,
+            vary_sentence_length=vary_sentence_length,
+            add_transitions=add_transitions,
+            add_personal_touch=add_personal_touch,
+            max_tokens=int(intensity * 2048) + 512,
+        )
+
+    def _handle_humanize(self, text, mode, intensity, temperature, top_p,
+                         ensemble, preserve_meaning, add_imperfections,
+                         vary_sentence_length, add_transitions, add_personal_touch):
+
+        self.engine.initialize()
+
+        if not text.strip():
+            return "Please enter some text to humanize.", {}, ""
+
+        config = self._build_config(
+            mode, intensity, temperature, top_p, ensemble,
+            preserve_meaning, add_imperfections, vary_sentence_length,
+            add_transitions, add_personal_touch,
+        )
+
+        result = self.engine.humanize(text, config)
+
+        stats = {
+            "🤖 Model Used": MODEL_REGISTRY.get(result.model_used, {}).get("name", result.model_used),
+            "📝 Mode": result.mode,
+            "⏱️ Processing Time": f"{result.processing_time:.2f}s",
+            "📊 Word Count": f"{result.word_count_before} → {result.word_count_after}",
+            "🔄 Changes Made": result.changes_made,
+            "🎯 Semantic Similarity": f"{result.similarity_score:.1%}",
+            "🤖 AI Score Before": f"{result.ai_probability_before:.1%}",
+            "🤖 AI Score After": f"{result.ai_probability_after:.1%}",
+            "📉 AI Reduction": f"{(result.ai_probability_before - result.ai_probability_after):.1%}",
+            "📏 Avg Words/Sentence (Before)": f"{result.readability_before.get('avg_words_per_sentence', 0):.1f}",
+            "📏 Avg Words/Sentence (After)": f"{result.readability_after.get('avg_words_per_sentence', 0):.1f}",
+            "🌊 Burstiness (After)": f"{result.readability_after.get('burstiness', 0):.1f}",
+        }
+
+        strategies = "\n".join(f"✅ {s}" for s in result.strategies_applied)
+
+        return result.humanized, stats, strategies
+
+    def _handle_batch(self, batch_input, mode, intensity, temperature, top_p, ensemble):
+        self.engine.initialize()
+
+        texts = [t.strip() for t in batch_input.split("---") if t.strip()]
+        if not texts:
+            texts = [line.strip() for line in batch_input.strip().split("\n") if line.strip()]
+
+        if not texts:
+            return [["No input provided"]]
+
+        config = self._build_config(
+            mode, intensity, temperature, top_p, ensemble,
+            True, True, True, True, True,
+        )
+
+        results = self.engine.batch_humanize(texts, config)
+
+        table = []
+        for r in results:
+            table.append([
+                r.original[:200] + "..." if len(r.original) > 200 else r.original,
+                r.humanized[:200] + "..." if len(r.humanized) > 200 else r.humanized,
+                f"{r.ai_probability_before:.1%}",
+                f"{r.ai_probability_after:.1%}",
+                f"{r.similarity_score:.1%}",
+            ])
+
+        return table
+
+    def _handle_analyze(self, text):
+        self.engine.initialize()
+
+        ai_score = self.engine.ai_detector.detect(text)
+        readability = self.engine.readability.analyze(text)
+
+        return ai_score, readability
+
+    def _handle_compare(self, text, mode, intensity, temperature, top_p, ensemble):
+        self.engine.initialize()
+
+        config = self._build_config(
+            mode, intensity, temperature, top_p, ensemble,
+            True, True, True, True, True,
+        )
+
+        result = self.engine.humanize(text, config)
+        diff_html = self.engine.analyzer.get_diff_html(result.original, result.humanized)
+
+        stats = {
+            "🤖 Model": MODEL_REGISTRY.get(result.model_used, {}).get("name", ""),
+            "⏱️ Time": f"{result.processing_time:.2f}s",
+            "📊 Words": f"{result.word_count_before} → {result.word_count_after}",
+            "🤖 AI Score": f"{result.ai_probability_before:.1%} → {result.ai_probability_after:.1%}",
+        }
+
+        return result.original, result.humanized, diff_html, stats
+
+    def _copy_text(self, text):
+        """Copy text to clipboard (client-side handled via JS)."""
+        return None
+
+    def _download_text(self, text):
+        """Download text as file."""
+        return None
+
+    @staticmethod
+    def _get_custom_css():
+        """Custom CSS for the app."""
+        return """
+            .gradio-container {
+                max-width: 1400px !important;
+            }
+            .main-text textarea {
+                font-size: 15px !important;
+                line-height: 1.6 !important;
+            }
+            #diff-view {
+                font-family: 'Inter', sans-serif;
+                font-size: 14px;
+                line-height: 1.8;
+                padding: 20px;
+                background: #f8f9fa;
+                border-radius: 8px;
+            }
+            .stat-card {
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                padding: 15px;
+                border-radius: 10px;
+                text-align: center;
+            }
+            .footer {
+                text-align: center;
+                padding: 20px;
+                color: #666;
+                font-size: 12px;
+            }
+        """
+
+
+# ─────────────────────────────────────────────
+# Launch
+# ─────────────────���───────────────────────────
+def main():
+    """Main entry point."""
+    logger.info("🚀 Starting Advanced AI Text Humanizer...")
+
+    app = HumanizerApp()
+    interface = app.build_interface()
+
+    # Launch configuration
+    launch_kwargs = {
+        "server_name": "0.0.0.0",
+        "server_port": int(os.environ.get("PORT", 7860)),
+        "share": False,
+        "show_error": True,
+        "max_threads": 10,
+        "queue": True,
+        "default_concurrency_limit": 4,
+    }
+
+    # Enable auth if configured
+    username = os.environ.get("GRADIO_USERNAME")
+    password = os.environ.get("GRADIO_PASSWORD")
+    if username and password:
+        launch_kwargs["auth"] = (username, password)
+
+    logger.info("Launching Gradio interface...")
+    interface.launch(**launch_kwargs)
+
 
 if __name__ == "__main__":
-    demo.launch()
+    main()