ai detector new

app.py

@@ -1,8 +1,15 @@
 import gradio as gr
 import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, GPT2LMHeadModel, GPT2TokenizerFast
+import torch.nn.functional as F
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForSequenceClassification,
+    GPT2LMHeadModel,
+    GPT2TokenizerFast,
+    BertTokenizer,
+    BertForSequenceClassification
+)
 import numpy as np
-from scipy import stats
 import re
 from collections import Counter
 import math
@@ -11,466 +18,562 @@ warnings.filterwarnings('ignore')
 
 class AdvancedAITextDetector:
     def __init__(self):
-        """Initialize the AI Text Detector with multiple detection methods"""
-        self.models_loaded = {}
+        """Initialize with multiple specialized detection models"""
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.models = {}
+        self.tokenizers = {}
+        self.load_all_models()
         
-        # Load multiple models for ensemble detection
-        self.load_models()
+    def load_all_models(self):
+        """Load ensemble of detection models"""
+        print("Loading detection models...")
         
-    def load_models(self):
-        """Load multiple detection models for ensemble approach"""
+        # Priority 1: GPTZero-like detection using DeBERTa
         try:
-            # Model 1: RoBERTa-based detector (more accurate)
-            self.roberta_tokenizer = AutoTokenizer.from_pretrained("roberta-base-openai-detector")
-            self.roberta_model = AutoModelForSequenceClassification.from_pretrained("roberta-base-openai-detector")
-            self.roberta_model.eval()
-            self.models_loaded['roberta'] = True
-        except:
-            print("Warning: Could not load RoBERTa detector")
-            self.models_loaded['roberta'] = False
+            from transformers import AutoModelForSequenceClassification, AutoTokenizer
+            model_name = "unitary/unbiased-toxic-roberta"  # Fallback model
+            # Try to load a better model if available
+            try:
+                model_name = "PirateXX/AI-Content-Detector"
+                self.tokenizers['pirate'] = AutoTokenizer.from_pretrained(model_name)
+                self.models['pirate'] = AutoModelForSequenceClassification.from_pretrained(model_name)
+                self.models['pirate'].to(self.device)
+                self.models['pirate'].eval()
+                print("✓ Loaded PirateXX AI detector")
+            except:
+                pass
+        except Exception as e:
+            print(f"Could not load priority model: {e}")
             
+        # Priority 2: Synthetic text detector
         try:
-            # Model 2: Alternative detector
-            self.alt_tokenizer = AutoTokenizer.from_pretrained("Hello-SimpleAI/chatgpt-detector-roberta")
-            self.alt_model = AutoModelForSequenceClassification.from_pretrained("Hello-SimpleAI/chatgpt-detector-roberta")
-            self.alt_model.eval()
-            self.models_loaded['alt'] = True
+            model_name = "Hello-SimpleAI/chatgpt-detector-roberta-chinese"  # Multi-lingual tends to be better
+            self.tokenizers['multilingual'] = AutoTokenizer.from_pretrained(model_name)
+            self.models['multilingual'] = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.models['multilingual'].to(self.device)
+            self.models['multilingual'].eval()
+            print("✓ Loaded multilingual detector")
         except:
-            print("Warning: Could not load alternative detector")
-            self.models_loaded['alt'] = False
+            try:
+                # Fallback to English version
+                model_name = "Hello-SimpleAI/chatgpt-detector-roberta"
+                self.tokenizers['roberta_detector'] = AutoTokenizer.from_pretrained(model_name)
+                self.models['roberta_detector'] = AutoModelForSequenceClassification.from_pretrained(model_name)
+                self.models['roberta_detector'].to(self.device)
+                self.models['roberta_detector'].eval()
+                print("✓ Loaded SimpleAI ChatGPT detector")
+            except Exception as e:
+                print(f"Could not load SimpleAI detector: {e}")
+        
+        # Priority 3: OpenAI's detector
+        try:
+            model_name = "roberta-base-openai-detector"
+            self.tokenizers['openai'] = AutoTokenizer.from_pretrained(model_name)
+            self.models['openai'] = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.models['openai'].to(self.device)
+            self.models['openai'].eval()
+            print("✓ Loaded OpenAI RoBERTa detector")
+        except Exception as e:
+            print(f"Could not load OpenAI detector: {e}")
             
+        # Priority 4: GPT-2 for perplexity
         try:
-            # GPT-2 for perplexity calculation
-            self.gpt2_tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
-            self.gpt2_model = GPT2LMHeadModel.from_pretrained("gpt2")
-            self.gpt2_model.eval()
-            self.models_loaded['gpt2'] = True
+            self.tokenizers['gpt2'] = GPT2TokenizerFast.from_pretrained("gpt2-medium")
+            self.models['gpt2'] = GPT2LMHeadModel.from_pretrained("gpt2-medium")
+            self.models['gpt2'].to(self.device)
+            self.models['gpt2'].eval()
+            self.tokenizers['gpt2'].pad_token = self.tokenizers['gpt2'].eos_token
+            print("✓ Loaded GPT-2 Medium for perplexity")
         except:
-            print("Warning: Could not load GPT-2 for perplexity")
-            self.models_loaded['gpt2'] = False
+            try:
+                self.tokenizers['gpt2'] = GPT2TokenizerFast.from_pretrained("gpt2")
+                self.models['gpt2'] = GPT2LMHeadModel.from_pretrained("gpt2")
+                self.models['gpt2'].to(self.device)
+                self.models['gpt2'].eval()
+                self.tokenizers['gpt2'].pad_token = self.tokenizers['gpt2'].eos_token
+                print("✓ Loaded GPT-2 for perplexity")
+            except Exception as e:
+                print(f"Could not load GPT-2: {e}")
+                
+        if not self.models:
+            print("WARNING: No models loaded, using statistical methods only")
     
-    def calculate_gpt2_perplexity(self, text):
-        """Calculate perplexity using GPT-2 - lower perplexity suggests AI text"""
-        if not self.models_loaded.get('gpt2', False):
+    def calculate_perplexity(self, text):
+        """Calculate perplexity - lower values indicate AI text"""
+        if 'gpt2' not in self.models:
             return None
             
         try:
-            encodings = self.gpt2_tokenizer(text, return_tensors='pt', truncation=True, max_length=512)
-            max_length = encodings.input_ids.size(1)
+            encodings = self.tokenizers['gpt2'](
+                text, 
+                return_tensors='pt', 
+                truncation=True, 
+                max_length=512,
+                padding=True
+            ).to(self.device)
             
             with torch.no_grad():
-                outputs = self.gpt2_model(**encodings, labels=encodings.input_ids)
+                outputs = self.models['gpt2'](**encodings, labels=encodings.input_ids)
                 loss = outputs.loss
                 perplexity = torch.exp(loss).item()
             
-            # Normalize perplexity to 0-1 scale (lower perplexity = more likely AI)
-            # Typical human text: 20-60, AI text: 10-30
-            normalized = 1 - min(max((perplexity - 10) / 50, 0), 1)
-            return normalized
-        except:
+            # Lower perplexity (< 30) strongly suggests AI
+            # Higher perplexity (> 50) suggests human
+            if perplexity < 20:
+                return 0.9  # Very likely AI
+            elif perplexity < 30:
+                return 0.7  # Likely AI
+            elif perplexity < 50:
+                return 0.5  # Uncertain
+            elif perplexity < 100:
+                return 0.3  # Likely human
+            else:
+                return 0.1  # Very likely human
+                
+        except Exception as e:
+            print(f"Perplexity calculation error: {e}")
             return None
     
-    def detect_chatgpt_patterns(self, text):
-        """Detect specific ChatGPT writing patterns"""
-        patterns_score = 0
-        pattern_count = 0
-        
-        # ChatGPT often uses these phrases
-        chatgpt_phrases = [
-            r'\bI understand\b',
-            r'\bIt\'s important to note\b',
-            r'\bIt\'s worth noting\b',
-            r'\bIn conclusion\b',
-            r'\bHowever,\s',
-            r'\bMoreover,\s',
-            r'\bFurthermore,\s',
-            r'\bAdditionally,\s',
-            r'\bIn summary\b',
-            r'\bTo summarize\b',
-            r'\boverall,\s',
-            r'\bGenerally speaking\b',
-            r'\bTypically,\s',
-            r'\bEssentially,\s',
-            r'\bFundamentally,\s',
-            r'\bIt\'s crucial\b',
-            r'\bIt\'s essential\b',
-            r'\bRemember that\b',
-            r'\bKeep in mind\b',
-            r'\bThis means that\b',
-            r'\bThis suggests that\b',
-            r'\bwhich means\b',
-            r'\bthat being said\b',
-            r'\bon the other hand\b',
-        ]
-        
-        text_lower = text.lower()
-        for pattern in chatgpt_phrases:
-            if re.search(pattern.lower(), text_lower):
-                pattern_count += 1
-        
-        # Calculate pattern density
-        patterns_score = min(pattern_count / 5, 1.0)  # Normalize to 0-1
-        
-        # Check for numbered or bulleted lists (common in ChatGPT)
-        has_numbered_list = bool(re.search(r'\n\d+\.', text))
-        has_bullets = bool(re.search(r'\n[-•*]\s', text))
-        
-        if has_numbered_list or has_bullets:
-            patterns_score = min(patterns_score + 0.2, 1.0)
-        
-        # Check for balanced paragraph structure (AI characteristic)
-        paragraphs = text.split('\n\n')
-        if len(paragraphs) > 2:
-            lengths = [len(p.split()) for p in paragraphs if p.strip()]
-            if lengths:
-                cv = np.std(lengths) / np.mean(lengths) if np.mean(lengths) > 0 else 1
-                if cv < 0.3:  # Low variation in paragraph lengths
-                    patterns_score = min(patterns_score + 0.15, 1.0)
-        
-        return patterns_score
-    
-    def calculate_sentence_complexity_variance(self, text):
-        """Calculate variance in sentence complexity - AI text is more uniform"""
-        sentences = re.split(r'[.!?]+', text)
-        complexities = []
-        
-        for sentence in sentences:
-            if sentence.strip():
-                words = sentence.split()
-                if len(words) > 0:
-                    # Calculate complexity based on word length and sentence length
-                    avg_word_length = np.mean([len(w) for w in words])
-                    complexity = len(words) * (avg_word_length / 5)
-                    complexities.append(complexity)
-        
-        if len(complexities) < 2:
-            return 0.5
-        
-        # Lower variance suggests AI (more uniform complexity)
-        cv = np.std(complexities) / np.mean(complexities) if np.mean(complexities) > 0 else 0
-        return 1 - min(cv / 0.5, 1.0)  # Normalize and invert
-    
-    def calculate_word_frequency_distribution(self, text):
-        """Analyze word frequency distribution - AI text follows Zipf's law more closely"""
-        words = re.findall(r'\b\w+\b', text.lower())
-        word_freq = Counter(words)
-        
-        if len(word_freq) < 10:
-            return 0.5
-        
-        frequencies = sorted(word_freq.values(), reverse=True)[:50]  # Top 50 words
-        ranks = range(1, len(frequencies) + 1)
-        
-        # Calculate how well it fits Zipf's law (AI text fits better)
-        if len(frequencies) > 1:
-            log_ranks = np.log(ranks)
-            log_freqs = np.log(frequencies)
-            
-            # Calculate correlation with Zipf's law
-            correlation = abs(np.corrcoef(log_ranks, log_freqs)[0, 1])
-            
-            # Higher correlation suggests AI
-            return correlation
-        
-        return 0.5
-    
-    def detect_roberta(self, text):
-        """Use RoBERTa OpenAI detector"""
-        if not self.models_loaded.get('roberta', False):
+    def detect_with_model(self, text, model_name):
+        """Generic detection using any loaded model"""
+        if model_name not in self.models:
             return None
             
         try:
-            inputs = self.roberta_tokenizer(text, return_tensors="pt", truncation=True, 
-                                           max_length=512, padding=True)
+            inputs = self.tokenizers[model_name](
+                text,
+                return_tensors="pt",
+                truncation=True,
+                max_length=512,
+                padding=True
+            ).to(self.device)
             
             with torch.no_grad():
-                outputs = self.roberta_model(**inputs)
-                predictions = torch.softmax(outputs.logits, dim=-1)
-                
-                # Class 0 is "Real", Class 1 is "Fake" for this model
-                ai_probability = predictions[0][1].item()
+                outputs = self.models[model_name](**inputs)
+                logits = outputs.logits
                 
-            return ai_probability
-        except:
+                # Handle different model output formats
+                if model_name == 'openai':
+                    # OpenAI detector: 0=Real, 1=Fake
+                    probs = F.softmax(logits, dim=-1)
+                    ai_prob = probs[0][1].item()
+                elif model_name in ['roberta_detector', 'multilingual']:
+                    # SimpleAI: typically 1=AI
+                    probs = F.softmax(logits, dim=-1)
+                    ai_prob = probs[0][1].item() if probs.shape[1] > 1 else probs[0][0].item()
+                elif model_name == 'pirate':
+                    # May have different class arrangement
+                    probs = F.softmax(logits, dim=-1)
+                    # Assuming binary classification
+                    ai_prob = probs[0][1].item() if probs.shape[1] > 1 else probs[0][0].item()
+                else:
+                    probs = F.softmax(logits, dim=-1)
+                    ai_prob = probs[0][1].item() if probs.shape[1] > 1 else 0.5
+                    
+            return ai_prob
+            
+        except Exception as e:
+            print(f"Error with {model_name}: {e}")
             return None
     
-    def detect_alternative(self, text):
-        """Use alternative detector model"""
-        if not self.models_loaded.get('alt', False):
-            return None
+    def advanced_linguistic_analysis(self, text):
+        """Comprehensive linguistic analysis for AI detection"""
+        scores = {}
+        
+        # 1. Sentence-level analysis
+        sentences = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip()]
+        
+        if len(sentences) > 1:
+            # Sentence length variance (AI is more consistent)
+            sent_lengths = [len(s.split()) for s in sentences]
+            scores['sent_length_std'] = np.std(sent_lengths) / (np.mean(sent_lengths) + 1)
             
-        try:
-            inputs = self.alt_tokenizer(text, return_tensors="pt", truncation=True, 
-                                       max_length=512, padding=True)
+            # Sentence starter diversity (AI often starts sentences similarly)
+            starters = [s.split()[0].lower() for s in sentences if s.split()]
+            starter_diversity = len(set(starters)) / len(starters) if starters else 0
+            scores['starter_diversity'] = starter_diversity
+        
+        # 2. N-gram analysis
+        words = text.lower().split()
+        
+        if len(words) > 3:
+            # Trigram repetition (AI repeats phrases more)
+            trigrams = [tuple(words[i:i+3]) for i in range(len(words)-2)]
+            trigram_counts = Counter(trigrams)
+            repeated_trigrams = sum(1 for c in trigram_counts.values() if c > 1)
+            scores['trigram_repetition'] = repeated_trigrams / len(trigrams) if trigrams else 0
             
-            with torch.no_grad():
-                outputs = self.alt_model(**inputs)
-                predictions = torch.softmax(outputs.logits, dim=-1)
-                ai_probability = predictions[0][1].item()
+            # Bigram diversity
+            bigrams = [tuple(words[i:i+2]) for i in range(len(words)-1)]
+            bigram_diversity = len(set(bigrams)) / len(bigrams) if bigrams else 0
+            scores['bigram_diversity'] = bigram_diversity
+        
+        # 3. ChatGPT-specific patterns
+        chatgpt_score = 0
+        
+        # Common ChatGPT phrases (weighted by specificity)
+        high_confidence_phrases = [
+            "it's important to note", "it's worth noting", "it's crucial to",
+            "in conclusion", "to summarize", "in summary",
+            "let me explain", "let me break", "I'll explain",
+            "here's a", "here are some", "this involves",
+            "additionally", "furthermore", "moreover",
+            "essentially", "basically", "fundamentally",
+            "it's essential to", "remember that", "keep in mind"
+        ]
+        
+        medium_confidence_phrases = [
+            "however", "therefore", "thus", "hence",
+            "for example", "for instance", "specifically",
+            "generally", "typically", "usually", "often",
+            "in other words", "that being said", "that said"
+        ]
+        
+        text_lower = text.lower()
+        
+        # Check high confidence phrases
+        for phrase in high_confidence_phrases:
+            if phrase in text_lower:
+                chatgpt_score += 0.15
                 
-            return ai_probability
-        except:
-            return None
-    
-    def enhanced_statistical_analysis(self, text):
-        """Enhanced statistical analysis specifically tuned for ChatGPT detection"""
-        
-        # Calculate all metrics
-        chatgpt_patterns = self.detect_chatgpt_patterns(text)
-        sentence_complexity = self.calculate_sentence_complexity_variance(text)
-        word_freq_dist = self.calculate_word_frequency_distribution(text)
-        
-        # Existing metrics with adjusted weights
-        words = text.split()
-        sentences = re.split(r'[.!?]+', text)
-        
-        # Sentence length consistency (AI is more consistent)
-        sentence_lengths = [len(s.split()) for s in sentences if s.strip()]
-        if len(sentence_lengths) > 1:
-            cv_sentence = np.std(sentence_lengths) / np.mean(sentence_lengths)
-            sentence_consistency = 1 - min(cv_sentence / 0.5, 1.0)
-        else:
-            sentence_consistency = 0.5
-        
-        # Vocabulary repetition rate
-        word_counts = Counter(words)
-        words_used_once = sum(1 for count in word_counts.values() if count == 1)
-        repetition_rate = 1 - (words_used_once / len(words)) if words else 0.5
-        
-        # Conjunction and transition word density
-        transitions = ['however', 'therefore', 'moreover', 'furthermore', 'additionally',
-                      'consequently', 'nevertheless', 'nonetheless', 'meanwhile', 'subsequently']
-        transition_count = sum(1 for w in words if w.lower() in transitions)
-        transition_density = min(transition_count / len(words) * 100, 1.0) if words else 0
-        
-        # Combine all statistical features with optimized weights
-        statistical_score = (
-            chatgpt_patterns * 0.35 +           # Strongest indicator
-            sentence_complexity * 0.20 +         # Uniform complexity
-            word_freq_dist * 0.15 +             # Zipf's law adherence
-            sentence_consistency * 0.15 +        # Consistent sentence lengths
-            repetition_rate * 0.10 +            # Word repetition
-            transition_density * 0.05            # Transition word usage
-        )
-        
-        return statistical_score, {
-            'chatgpt_patterns': chatgpt_patterns,
-            'sentence_uniformity': sentence_complexity,
-            'zipf_correlation': word_freq_dist,
-            'sentence_consistency': sentence_consistency,
-            'repetition_rate': repetition_rate,
-            'transition_density': transition_density
+        # Check medium confidence phrases  
+        for phrase in medium_confidence_phrases:
+            if phrase in text_lower:
+                chatgpt_score += 0.08
+        
+        # Check for structured lists (very common in ChatGPT)
+        has_numbered = bool(re.search(r'\n\s*\d+[\.\)]\s', text))
+        has_bullets = bool(re.search(r'\n\s*[-•*]\s', text))
+        has_colons = text.count(':') > 2
+        
+        if has_numbered:
+            chatgpt_score += 0.25
+        if has_bullets:
+            chatgpt_score += 0.20
+        if has_colons:
+            chatgpt_score += 0.10
+            
+        # Formal tone indicators
+        formal_words = ['utilize', 'implement', 'facilitate', 'enhance', 'optimize',
+                       'comprehensive', 'significant', 'substantial', 'various', 'numerous']
+        formal_count = sum(1 for word in formal_words if word in text_lower)
+        chatgpt_score += min(formal_count * 0.05, 0.25)
+        
+        scores['chatgpt_patterns'] = min(chatgpt_score, 1.0)
+        
+        # 4. Complexity uniformity (AI has uniform complexity)
+        if len(sentences) > 2:
+            complexities = []
+            for sent in sentences:
+                words_in_sent = sent.split()
+                if words_in_sent:
+                    avg_word_len = np.mean([len(w) for w in words_in_sent])
+                    complexity = len(words_in_sent) * avg_word_len / 5
+                    complexities.append(complexity)
+            
+            if complexities:
+                cv = np.std(complexities) / (np.mean(complexities) + 1)
+                scores['complexity_variance'] = cv
+        
+        # 5. Paragraph structure (AI has consistent paragraphs)
+        paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+        if len(paragraphs) > 1:
+            para_lengths = [len(p.split()) for p in paragraphs]
+            para_cv = np.std(para_lengths) / (np.mean(para_lengths) + 1)
+            scores['paragraph_consistency'] = 1 - min(para_cv, 1.0)
+        
+        # Calculate final statistical score
+        # Weight the features based on their importance for ChatGPT detection
+        weights = {
+            'chatgpt_patterns': 0.35,
+            'sent_length_std': -0.15,  # Lower std = more AI
+            'starter_diversity': -0.10,  # Lower diversity = more AI
+            'trigram_repetition': 0.15,
+            'bigram_diversity': -0.10,
+            'complexity_variance': -0.10,
+            'paragraph_consistency': 0.15
         }
+        
+        final_score = 0.5  # Start neutral
+        for feature, value in scores.items():
+            if feature in weights:
+                weight = weights[feature]
+                if weight < 0:
+                    # Inverse relationship
+                    final_score += abs(weight) * (1 - value)
+                else:
+                    final_score += weight * value
+                    
+        return min(max(final_score, 0), 1), scores
     
     def detect(self, text):
-        """Main detection method with ensemble approach"""
-        if not text or len(text.strip()) < 20:
+        """Main detection combining all methods"""
+        if not text or len(text.strip()) < 30:
             return {
                 "ai_probability": 50.0,
-                "classification": "Undetermined",
-                "confidence": "Low",
-                "explanation": "Text too short for accurate analysis. Please provide at least 50 characters.",
+                "classification": "Text Too Short",
+                "confidence": "N/A",
+                "explanation": "Please provide at least 30 characters of text for analysis.",
                 "detailed_scores": {}
             }
         
-        scores = []
-        weights = []
-        
-        # Get RoBERTa OpenAI detector score (most accurate for ChatGPT)
-        roberta_score = self.detect_roberta(text)
-        if roberta_score is not None:
-            scores.append(roberta_score)
-            weights.append(0.4)  # Highest weight for most accurate model
-        
-        # Get alternative model score
-        alt_score = self.detect_alternative(text)
-        if alt_score is not None:
-            scores.append(alt_score)
-            weights.append(0.2)
-        
-        # Get GPT-2 perplexity score
-        perplexity_score = self.calculate_gpt2_perplexity(text)
-        if perplexity_score is not None:
-            scores.append(perplexity_score)
-            weights.append(0.15)
-        
-        # Get enhanced statistical analysis
-        stat_score, stat_details = self.enhanced_statistical_analysis(text)
-        scores.append(stat_score)
-        weights.append(0.25 if len(scores) == 1 else 0.25)
-        
-        # Calculate weighted average
-        if scores:
+        all_scores = []
+        all_weights = []
+        model_results = {}
+        
+        # 1. Try each model
+        model_weights = {
+            'pirate': 0.30,      # If specialized detector available
+            'openai': 0.25,      # OpenAI's own detector
+            'multilingual': 0.20, # Multilingual detector
+            'roberta_detector': 0.20,
+            'perplexity': 0.25
+        }
+        
+        # Get model predictions
+        for model_name in ['pirate', 'openai', 'multilingual', 'roberta_detector']:
+            if model_name in self.models:
+                score = self.detect_with_model(text, model_name)
+                if score is not None:
+                    all_scores.append(score)
+                    all_weights.append(model_weights.get(model_name, 0.15))
+                    model_results[model_name] = score
+        
+        # Get perplexity score
+        perp_score = self.calculate_perplexity(text)
+        if perp_score is not None:
+            all_scores.append(perp_score)
+            all_weights.append(model_weights['perplexity'])
+            model_results['perplexity'] = perp_score
+        
+        # 2. Statistical analysis
+        stat_score, stat_details = self.advanced_linguistic_analysis(text)
+        all_scores.append(stat_score)
+        all_weights.append(0.20)
+        model_results['statistical'] = stat_score
+        
+        # 3. Calculate weighted final score
+        if all_scores:
             # Normalize weights
-            weights = [w / sum(weights) for w in weights]
-            final_score = sum(s * w for s, w in zip(scores, weights))
+            total_weight = sum(all_weights)
+            normalized_weights = [w/total_weight for w in all_weights]
+            
+            # Weighted average
+            final_score = sum(s * w for s, w in zip(all_scores, normalized_weights))
+            
+            # Boost score if multiple models agree strongly
+            agreement_scores = [s for s in all_scores if s > 0.7 or s < 0.3]
+            if len(agreement_scores) >= 2:
+                avg_agreement = np.mean(agreement_scores)
+                if avg_agreement > 0.7:
+                    final_score = min(final_score * 1.1, 0.95)
+                elif avg_agreement < 0.3:
+                    final_score = max(final_score * 0.9, 0.05)
         else:
             final_score = 0.5
         
-        # Adjust classification thresholds for better ChatGPT detection
-        if final_score >= 0.75:
-            classification = "AI-Generated (Likely ChatGPT)"
-            confidence = "High"
+        # 4. Classification with better thresholds for ChatGPT
+        if final_score >= 0.70:
+            classification = "AI-Generated (High Confidence)"
+            confidence = "HIGH"
         elif final_score >= 0.55:
-            classification = "Probably AI-Generated"
-            confidence = "Medium-High"
+            classification = "Likely AI-Generated"
+            confidence = "MEDIUM-HIGH"
         elif final_score >= 0.45:
-            classification = "Uncertain (Mixed Signals)"
-            confidence = "Low"
-        elif final_score >= 0.25:
-            classification = "Probably Human-Written"
-            confidence = "Medium"
+            classification = "Uncertain"
+            confidence = "LOW"
+        elif final_score >= 0.30:
+            classification = "Likely Human-Written"
+            confidence = "MEDIUM"
         else:
-            classification = "Human-Written"
-            confidence = "High"
+            classification = "Human-Written (High Confidence)"
+            confidence = "HIGH"
         
-        # Generate detailed explanation
-        explanation = self._generate_explanation(final_score, stat_details, {
-            'roberta': roberta_score,
-            'alternative': alt_score,
-            'perplexity': perplexity_score
-        })
+        # 5. Generate explanation
+        explanation = self._create_explanation(final_score, model_results, stat_details)
         
         return {
             "ai_probability": round(final_score * 100, 2),
             "classification": classification,
             "confidence": confidence,
             "explanation": explanation,
-            "detailed_scores": stat_details,
-            "model_scores": {
-                'roberta_openai': roberta_score,
-                'alternative': alt_score,
-                'perplexity': perplexity_score,
-                'statistical': stat_score
-            }
+            "model_scores": model_results,
+            "statistical_analysis": stat_details
         }
     
-    def _generate_explanation(self, score, stat_details, model_scores):
-        """Generate detailed explanation of the detection result"""
-        explanations = []
+    def _create_explanation(self, score, model_results, stat_details):
+        """Create detailed explanation"""
+        exp = []
         
         # Overall assessment
-        if score >= 0.75:
-            explanations.append("🤖 Strong indicators of AI generation detected, consistent with ChatGPT patterns.")
+        if score >= 0.70:
+            exp.append("🤖 STRONG AI INDICATORS: The text exhibits multiple characteristics typical of AI-generated content.")
         elif score >= 0.55:
-            explanations.append("⚠️ Multiple AI characteristics detected, suggesting probable AI generation.")
+            exp.append("⚠️ PROBABLE AI: Several AI patterns detected, suggesting machine generation.")
         elif score >= 0.45:
-            explanations.append("❓ Mixed characteristics - could be AI-assisted or heavily edited human text.")
-        elif score >= 0.25:
-            explanations.append("✍️ Predominantly human characteristics with some regularities.")
+            exp.append("❓ INCONCLUSIVE: Mixed signals - could be AI-assisted or edited content.")
+        elif score >= 0.30:
+            exp.append("✍️ PROBABLE HUMAN: More human-like characteristics than AI patterns.")
         else:
-            explanations.append("👤 Strong human writing characteristics detected.")
+            exp.append("👤 STRONG HUMAN INDICATORS: Text shows natural human writing patterns.")
         
-        # Model-specific insights
-        if model_scores.get('roberta') is not None:
-            if model_scores['roberta'] > 0.7:
-                explanations.append("\n• OpenAI detector: Strong AI signature")
-            elif model_scores['roberta'] < 0.3:
-                explanations.append("\n• OpenAI detector: Strong human signature")
+        # Model consensus
+        if model_results:
+            high_ai = [name for name, s in model_results.items() if s > 0.65]
+            high_human = [name for name, s in model_results.items() if s < 0.35]
+            
+            if len(high_ai) >= 2:
+                exp.append(f"\n\n✓ Multiple models detect AI: {', '.join(high_ai)}")
+            elif len(high_human) >= 2:
+                exp.append(f"\n\n✓ Multiple models detect human writing: {', '.join(high_human)}")
         
-        # Pattern analysis
+        # Specific indicators
         if stat_details.get('chatgpt_patterns', 0) > 0.5:
-            explanations.append("\n• High density of ChatGPT-typical phrases and structures")
-        
-        if stat_details.get('sentence_uniformity', 0) > 0.7:
-            explanations.append("\n• Unusually uniform sentence complexity (AI characteristic)")
-        elif stat_details.get('sentence_uniformity', 0) < 0.3:
-            explanations.append("\n• Variable sentence complexity (human characteristic)")
-        
-        if stat_details.get('zipf_correlation', 0) > 0.8:
-            explanations.append("\n• Word frequency distribution closely follows Zipf's law (AI-like)")
+            exp.append("\n\n⚡ High density of ChatGPT-style phrases and structures detected")
         
-        return " ".join(explanations)
+        if stat_details.get('sent_length_std', 1) < 0.3:
+            exp.append("\n📏 Unusually consistent sentence lengths (AI characteristic)")
+            
+        if stat_details.get('trigram_repetition', 0) > 0.1:
+            exp.append("\n🔁 Repeated phrase patterns detected")
+            
+        return " ".join(exp)
+
 
 # Initialize detector
+print("Initializing AI Text Detector...")
 detector = AdvancedAITextDetector()
 
 def analyze_text(text):
     """Gradio interface function"""
+    if not text:
+        return "Please enter some text to analyze."
+    
     result = detector.detect(text)
     
-    # Format output for Gradio
-    output = f"""
-## 🔍 Detection Result
+    # Format output
+    output = f"""# 🔍 AI Detection Results
+
+## **{result['classification']}**
 
-**Classification:** {result['classification']}
-**AI Probability:** {result['ai_probability']}%
-**Confidence Level:** {result['confidence']}
+### 📊 AI Probability: **{result['ai_probability']}%**
+### 🎯 Confidence: **{result['confidence']}**
 
-### 📊 Analysis Details
+---
+
+## 📝 Analysis Summary
 {result['explanation']}
 
-### 📈 Model Scores
+---
+
+## 📈 Model Scores
 """
     
     if result.get('model_scores'):
         for model, score in result['model_scores'].items():
             if score is not None:
-                model_name = model.replace('_', ' ').title()
-                output += f"- {model_name}: {round(score * 100, 2)}%\n"
-    
-    output += "\n### 🔬 Statistical Metrics\n"
+                percentage = round(score * 100, 1)
+                bar_length = int(percentage / 5)
+                bar = '█' * bar_length + '░' * (20 - bar_length)
+                
+                model_display = {
+                    'openai': '🔷 OpenAI Detector',
+                    'roberta_detector': '🤖 RoBERTa ChatGPT',
+                    'multilingual': '🌍 Multilingual',
+                    'pirate': '🏴‍☠️ PirateXX',
+                    'perplexity': '📊 Perplexity',
+                    'statistical': '📈 Statistical'
+                }.get(model, model)
+                
+                output += f"\n**{model_display}:** {bar} {percentage}%"
     
-    if result['detailed_scores']:
-        for metric, value in result['detailed_scores'].items():
-            metric_name = metric.replace('_', ' ').title()
-            percentage = round(value * 100, 1)
-            output += f"- {metric_name}: {percentage}%\n"
+    # Statistical details
+    if result.get('statistical_analysis'):
+        output += "\n\n---\n\n## 🔬 Detailed Linguistic Analysis\n"
+        
+        analysis = result['statistical_analysis']
+        
+        if 'chatgpt_patterns' in analysis:
+            output += f"\n- **ChatGPT Pattern Score:** {analysis['chatgpt_patterns']:.2f}/1.00"
+        if 'sent_length_std' in analysis:
+            output += f"\n- **Sentence Variance:** {analysis['sent_length_std']:.3f} (lower = more AI-like)"
+        if 'trigram_repetition' in analysis:
+            output += f"\n- **Phrase Repetition:** {analysis['trigram_repetition']:.3f}"
+        if 'starter_diversity' in analysis:
+            output += f"\n- **Sentence Starter Diversity:** {analysis['starter_diversity']:.3f}"
     
-    # Create visual probability bar
+    # Visual representation
     ai_prob = result['ai_probability']
     human_prob = 100 - ai_prob
     
-    bar_chart = f"""
-### 📊 Probability Distribution
+    output += f"""
+
+---
+
+## 🎯 Final Verdict
+
 ```
-AI-Generated:    {'█' * int(ai_prob/5)}{'░' * (20-int(ai_prob/5))} {ai_prob}%
-Human-Written:   {'█' * int(human_prob/5)}{'░' * (20-int(human_prob/5))} {human_prob}%
+AI Generated:  {'█' * int(ai_prob/5)}{'░' * (20-int(ai_prob/5))} {ai_prob:.1f}%
+Human Written: {'█' * int(human_prob/5)}{'░' * (20-int(human_prob/5))} {human_prob:.1f}%
 ```
 """
     
-    # Add warning for edge cases
-    if result['confidence'] == "Low":
-        bar_chart += "\n⚠️ **Note:** Low confidence - results may be unreliable. Consider additional verification."
+    # Add disclaimer for low confidence
+    if result['confidence'] == "LOW":
+        output += "\n\n⚠️ **Note:** Low confidence result. Consider getting human verification."
     
-    return output + bar_chart
+    return output
 
 # Create Gradio interface
 interface = gr.Interface(
     fn=analyze_text,
     inputs=gr.Textbox(
-        lines=10,
-        placeholder="Paste the text you want to analyze here...",
-        label="Input Text"
+        lines=12,
+        placeholder="Paste text here to check if it's AI-generated...\n\nFor best results, provide at least 100 words.",
+        label="Text to Analyze"
     ),
-    outputs=gr.Markdown(label="Analysis Result"),
-    title="🔍 Advanced ChatGPT & AI Text Detector",
+    outputs=gr.Markdown(label="Detection Results"),
+    title="🚀 Advanced ChatGPT & AI Text Detector",
     description="""
-    This enhanced AI text detector uses state-of-the-art techniques specifically optimized for detecting ChatGPT and similar AI-generated content:
+    ## State-of-the-art AI text detection using multiple methods:
     
-    ### 🚀 Key Features:
-    - **Multiple AI Detection Models** including OpenAI's RoBERTa detector
-    - **GPT-2 Perplexity Analysis** to measure text predictability
-    - **ChatGPT Pattern Recognition** detecting characteristic phrases and structures
-    - **Advanced Statistical Analysis** including Zipf's law correlation and sentence uniformity
-    - **Ensemble Method** combining multiple approaches for maximum accuracy
+    ### 🔥 Detection Methods:
+    - **Multiple AI Detection Models** - Ensemble of specialized detectors
+    - **Perplexity Analysis** - Measures text predictability (AI text is more predictable)
+    - **Pattern Recognition** - Detects ChatGPT-specific writing patterns
+    - **Linguistic Analysis** - Analyzes sentence structure, vocabulary, and style
     
-    ### 📝 Usage Tips:
-    - Provide at least 100 words for best results
-    - The detector is specifically tuned for ChatGPT/GPT-4 content
+    ### 💡 Best Practices:
+    - Provide at least **100-200 words** for accurate detection
+    - Longer texts generally give more reliable results
     - Works best with English text
-    - Longer texts generally yield more reliable results
+    - Detection is probabilistic - use as guidance, not absolute proof
     
-    ### ⚠️ Important:
-    This tool provides probabilistic analysis, not absolute certainty. Use it as one of multiple factors in your assessment.
+    ### 🎯 What This Detects:
+    - ChatGPT (GPT-3.5/GPT-4)
+    - Claude, Gemini, and other LLMs
+    - AI-assisted or heavily edited content
+    - Paraphrased AI content
+    
+    **Note:** No detector is 100% accurate. This tool provides sophisticated analysis but should be used alongside human judgment.
     """,
     examples=[
-        ["The impact of artificial intelligence on modern society is profound and multifaceted. As we navigate this technological revolution, it's important to consider both the opportunities and challenges that AI presents. On one hand, AI systems are enhancing productivity, improving healthcare outcomes, and enabling new forms of creativity. On the other hand, concerns about job displacement, privacy, and algorithmic bias require careful consideration. Moving forward, it will be crucial for policymakers, technologists, and society as a whole to work together in shaping the development and deployment of AI in ways that benefit humanity while mitigating potential risks."],
-        ["So I was walking down the street yesterday, right? And this crazy thing happened - I mean, you won't believe it. There was this dog, just a regular golden retriever, but it was wearing these ridiculous sunglasses. Like, who puts sunglasses on a dog? Anyway, the owner was this old lady, must've been like 80 or something, and she was just chatting away on her phone, completely oblivious. The dog looked so confused! I couldn't help but laugh. Sometimes you see the weirdest stuff when you're just out and about, you know? Made my whole day, honestly. Still cracks me up thinking about it."],
-        ["Machine learning has revolutionized data analysis. Furthermore, deep learning algorithms have shown remarkable success in computer vision tasks. Additionally, natural language processing has made significant strides. It's worth noting that transformer architectures have been particularly influential. Moreover, these developments have practical applications across industries. In conclusion, the continued advancement of ML techniques promises further innovations."]
+        # ChatGPT example
+        ["Artificial intelligence has revolutionized numerous industries in recent years. It's important to note that this technology offers both opportunities and challenges. Machine learning algorithms can process vast amounts of data, identify patterns, and make predictions with remarkable accuracy. Furthermore, AI applications span various domains including healthcare, finance, and transportation. However, it's crucial to consider the ethical implications. Issues such as bias in algorithms, job displacement, and privacy concerns require careful consideration. Additionally, the development of AI must be guided by responsible practices. In conclusion, while AI presents tremendous potential for innovation and progress, we must approach its implementation thoughtfully and ethically."],
+        
+        # Human example
+        ["So yesterday I'm at the coffee shop, right? And this guy next to me is having the LOUDEST phone conversation about his crypto investments. Like, dude, we get it, you bought Dogecoin. But here's the thing - he kept saying he was gonna be a millionaire by next week. Next week! I almost choked on my latte. The barista and I made eye contact and we both just tried not to laugh. I mean, good luck to him and all, but maybe don't count those chickens yet? Anyway, that's my coffee shop drama for the week. Still better than working from home where my cat judges me all day."],
+        
+        # Mixed/edited example
+        ["The impact of social media on society has been profound. Studies show that people spend an average of 2.5 hours daily on social platforms. But honestly, I think it's probably way more than that - I know I'm constantly checking my phone! These platforms have transformed how we communicate, share information, and even how we see ourselves. There are definitely benefits, like staying connected with friends and family across distances. However, we're also seeing rises in anxiety and depression linked to social media use, especially among teenagers. It's a complex issue that deserves our attention."]
     ],
-    theme=gr.themes.Soft(),
-    analytics_enabled=False
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="indigo",
+        neutral_hue="slate"
+    ),
+    analytics_enabled=False,
+    cache_examples=False
 )
 
 if __name__ == "__main__":