Update app.py

app.py

@@ -1,1020 +1,10 @@
 import gradio as gr
-from sentence_transformers import SentenceTransformer, util
-from transformers import (
-    AutoTokenizer, AutoModelForSequenceClassification, 
-    GPT2LMHeadModel, pipeline
-)
-import torch
-import torch.nn.functional as F
-import plotly.graph_objects as go
-import plotly.express as px
-from plotly.subplots import make_subplots
-import numpy as np
-import re
-from collections import Counter
-import math
-import warnings
-from sklearn.linear_model import LogisticRegression
-from sklearn.preprocessing import StandardScaler
-from scipy.special import expit  # sigmoid function
-warnings.filterwarnings("ignore")
-
-class AdvancedAIDetector:
-    def __init__(self):
-        print("Initializing AI Detector...")
-        
-        # Use only reliable, well-tested models that work in HF Spaces
-        self.detectors = {}
-        self.tokenizers = {}
-        
-        # Load primary AI detection model (known to work)
-        try:
-            self.detectors['roberta_ai_classifier'] = AutoModelForSequenceClassification.from_pretrained('roberta-base-openai-detector')
-            self.tokenizers['roberta'] = AutoTokenizer.from_pretrained('roberta-base-openai-detector')
-            print("✓ RoBERTa AI classifier loaded successfully")
-        except Exception as e:
-            print(f"✗ Failed to load RoBERTa classifier: {e}")
-            self.detectors['roberta_ai_classifier'] = None
-        
-        # Load secondary classifier (alternative)
-        try:
-            self.detectors['alternative_classifier'] = AutoModelForSequenceClassification.from_pretrained('martin-ha/toxic-comment-model')
-            self.tokenizers['alternative'] = AutoTokenizer.from_pretrained('martin-ha/toxic-comment-model')
-            print("✓ Alternative classifier loaded successfully")
-        except Exception as e:
-            print(f"✗ Failed to load alternative classifier: {e}")
-            self.detectors['alternative_classifier'] = None
-        
-        # Perplexity models - use only GPT-2 base to avoid memory issues
-        self.perplexity_models = {}
-        self.perplexity_tokenizers = {}
-        
-        try:
-            self.perplexity_models['gpt2'] = GPT2LMHeadModel.from_pretrained("gpt2")
-            self.perplexity_tokenizers['gpt2'] = AutoTokenizer.from_pretrained("gpt2")
-            self.perplexity_models['gpt2'].eval()
-            print("✓ GPT-2 perplexity model loaded successfully")
-        except Exception as e:
-            print(f"✗ Failed to load GPT-2: {e}")
-            self.perplexity_models['gpt2'] = None
-        
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Using device: {self.device}")
-        
-        # Initialize ensemble classifier and scaler
-        self.ensemble_classifier = None
-        self.feature_scaler = None
-        self._initialize_ensemble_classifier()
-
-    def _initialize_ensemble_classifier(self):
-        """Initialize a simple ensemble classifier for better confidence scoring"""
-        try:
-            # Create synthetic training data for the ensemble classifier
-            # This is a simplified approach - in production, use real labeled data
-            X_train = []
-            y_train = []
-            
-            # Simulate AI-generated text features
-            for _ in range(100):
-                # AI-like features: high classifier score, low perplexity, low diversity
-                classifier_score = np.random.normal(0.8, 0.1)
-                perplexity_score = np.random.normal(0.3, 0.1)
-                feature_score = np.random.normal(0.7, 0.1)
-                X_train.append([classifier_score, perplexity_score, feature_score])
-                y_train.append(1)  # AI
-            
-            # Simulate human-written text features
-            for _ in range(100):
-                # Human-like features: low classifier score, high perplexity, high diversity
-                classifier_score = np.random.normal(0.3, 0.1)
-                perplexity_score = np.random.normal(0.7, 0.1)
-                feature_score = np.random.normal(0.3, 0.1)
-                X_train.append([classifier_score, perplexity_score, feature_score])
-                y_train.append(0)  # Human
-            
-            X_train = np.array(X_train)
-            y_train = np.array(y_train)
-            
-            # Initialize and train the ensemble classifier
-            self.feature_scaler = StandardScaler()
-            X_train_scaled = self.feature_scaler.fit_transform(X_train)
-            
-            self.ensemble_classifier = LogisticRegression(random_state=42)
-            self.ensemble_classifier.fit(X_train_scaled, y_train)
-            
-            print("✓ Ensemble classifier initialized successfully")
-            
-        except Exception as e:
-            print(f"✗ Failed to initialize ensemble classifier: {e}")
-            self.ensemble_classifier = None
-            self.feature_scaler = None
-
-    def calculate_perplexity(self, text, max_length=512):
-        """Calculate perplexity with robust error handling"""
-        if 'gpt2' not in self.perplexity_models or not self.perplexity_models['gpt2']:
-            return float('inf')
-            
-        try:
-            model = self.perplexity_models['gpt2']
-            tokenizer = self.perplexity_tokenizers['gpt2']
-            
-            # Truncate text to avoid memory issues
-            words = text.split()
-            if len(words) > max_length // 4:  # Rough word-to-token ratio
-                text = ' '.join(words[:max_length // 4])
-            
-            # Add padding token if it doesn't exist
-            if tokenizer.pad_token is None:
-                tokenizer.pad_token = tokenizer.eos_token
-            
-            encodings = tokenizer(text, return_tensors='pt', truncation=True, 
-                                max_length=max_length, padding=True)
-            input_ids = encodings.input_ids
-            
-            # Move to device
-            model.to(self.device)
-            input_ids = input_ids.to(self.device)
-            
-            with torch.no_grad():
-                outputs = model(input_ids, labels=input_ids)
-                loss = outputs.loss
-                perplexity = torch.exp(loss).item()
-                
-            return perplexity if not math.isnan(perplexity) else float('inf')
-            
-        except Exception as e:
-            print(f"Perplexity calculation error: {e}")
-            return float('inf')
-
-    def improved_perplexity_to_probability(self, perplexity):
-        """Convert perplexity to AI probability using calibrated sigmoid function"""
-        if math.isinf(perplexity) or math.isnan(perplexity):
-            return 0.5
-        
-        try:
-            # Calibrated sigmoid transformation based on empirical data
-            # These parameters were tuned for better performance
-            midpoint = 30.0  # Perplexity value that corresponds to 50% probability
-            steepness = -0.1  # Controls the steepness of the sigmoid
-            
-            # Apply sigmoid transformation
-            sigmoid_input = steepness * (perplexity - midpoint)
-            probability = expit(sigmoid_input)  # More stable than manual sigmoid
-            
-            # Ensure reasonable bounds
-            return max(0.05, min(0.95, probability))
-            
-        except Exception as e:
-            print(f"Perplexity conversion error: {e}")
-            return 0.5
-
-    def extract_linguistic_features(self, text):
-        """Extract linguistic features with robust error handling"""
-        try:
-            features = {}
-            
-            # Basic text statistics
-            sentences = re.split(r'[.!?]+', text.strip())
-            sentences = [s.strip() for s in sentences if s.strip()]
-            words = text.split()
-            
-            # Safe calculations with fallbacks
-            features['sentence_count'] = len(sentences)
-            features['word_count'] = len(words)
-            
-            if sentences:
-                sentence_lengths = [len(s.split()) for s in sentences]
-                features['avg_sentence_length'] = np.mean(sentence_lengths)
-                features['sentence_length_std'] = np.std(sentence_lengths) if len(sentences) > 1 else 0
-            else:
-                features['avg_sentence_length'] = 0
-                features['sentence_length_std'] = 0
-            
-            # Lexical diversity
-            if words:
-                unique_words = set(word.lower() for word in words if word.isalpha())
-                features['lexical_diversity'] = len(unique_words) / len(words)
-                features['avg_word_length'] = np.mean([len(word) for word in words])
-            else:
-                features['lexical_diversity'] = 0
-                features['avg_word_length'] = 0
-            
-            # Word frequency analysis (burstiness)
-            alpha_words = [word.lower() for word in words if word.isalpha()]
-            if len(alpha_words) > 1:
-                word_freq = Counter(alpha_words)
-                frequencies = list(word_freq.values())
-                mean_freq = np.mean(frequencies)
-                features['burstiness'] = np.var(frequencies) / mean_freq if mean_freq > 0 else 0
-            else:
-                features['burstiness'] = 0
-            
-            # Repetition patterns
-            if len(words) > 1:
-                bigrams = [' '.join(words[i:i+2]) for i in range(len(words)-1)]
-                features['bigram_repetition'] = 1 - len(set(bigrams)) / len(bigrams) if bigrams else 0
-            else:
-                features['bigram_repetition'] = 0
-            
-            # Punctuation analysis
-            if text:
-                punct_count = len(re.findall(r'[.!?,:;]', text))
-                features['punctuation_ratio'] = punct_count / len(text)
-            else:
-                features['punctuation_ratio'] = 0
-            
-            # Sentence start diversity
-            if len(sentences) > 1:
-                sentence_starts = []
-                for s in sentences:
-                    words_in_sentence = s.split()
-                    if words_in_sentence:
-                        sentence_starts.append(words_in_sentence[0].lower())
-                
-                if sentence_starts:
-                    features['sentence_start_diversity'] = len(set(sentence_starts)) / len(sentence_starts)
-                else:
-                    features['sentence_start_diversity'] = 1
-            else:
-                features['sentence_start_diversity'] = 1
-            
-            return features
-            
-        except Exception as e:
-            print(f"Feature extraction error: {e}")
-            # Return default features if extraction fails
-            return {
-                'sentence_count': 1,
-                'word_count': len(text.split()) if text else 0,
-                'avg_sentence_length': len(text.split()) if text else 0,
-                'sentence_length_std': 0,
-                'lexical_diversity': 0.5,
-                'avg_word_length': 5,
-                'burstiness': 0.5,
-                'bigram_repetition': 0,
-                'punctuation_ratio': 0.05,
-                'sentence_start_diversity': 1
-            }
-
-    def run_classifier_detection(self, text):
-        """Run classifier-based detection with proper error handling"""
-        classifier_results = {}
-        
-        # Try RoBERTa classifier
-        if self.detectors.get('roberta_ai_classifier') and self.tokenizers.get('roberta'):
-            try:
-                model = self.detectors['roberta_ai_classifier']
-                tokenizer = self.tokenizers['roberta']
-                
-                inputs = tokenizer(text, return_tensors="pt", truncation=True, 
-                                 padding=True, max_length=512)
-                
-                # Move to device
-                model.to(self.device)
-                inputs = {k: v.to(self.device) for k, v in inputs.items()}
-                
-                with torch.no_grad():
-                    outputs = model(**inputs)
-                    probs = torch.softmax(outputs.logits, dim=1)[0]
-                    
-                    # Handle different output formats
-                    if len(probs) >= 2:
-                        ai_prob = probs[1].item()  # AI probability
-                        human_prob = probs[0].item()  # Human probability
-                    else:
-                        ai_prob = probs[0].item()
-                        human_prob = 1 - ai_prob
-                    
-                    classifier_results['roberta_ai_prob'] = ai_prob
-                    classifier_results['roberta_human_prob'] = human_prob
-                    
-            except Exception as e:
-                print(f"RoBERTa classifier error: {e}")
-        
-        # If no classifiers worked, provide fallback
-        if not classifier_results:
-            # Simple heuristic fallback based on text characteristics
-            perplexity = self.calculate_perplexity(text)
-            if not math.isinf(perplexity):
-                # Use improved perplexity conversion
-                ai_prob = self.improved_perplexity_to_probability(perplexity)
-            else:
-                ai_prob = 0.5  # Neutral when we can't determine
-            
-            classifier_results['fallback_ai_prob'] = ai_prob
-            classifier_results['fallback_human_prob'] = 1 - ai_prob
-        
-        return classifier_results
-
-    def ensemble_ai_detection(self, text):
-        """Main ensemble detection method with enhanced confidence scoring"""
-        try:
-            results = {}
-            
-            # 1. Classifier predictions
-            classifier_results = self.run_classifier_detection(text)
-            results.update(classifier_results)
-            
-            # Extract AI probabilities for ensemble
-            ai_probs = [v for k, v in classifier_results.items() if '_ai_prob' in k]
-            avg_classifier_score = np.mean(ai_probs) if ai_probs else 0.5
-            
-            # 2. Perplexity analysis with improved conversion
-            perplexity = self.calculate_perplexity(text)
-            results['gpt2_perplexity'] = round(perplexity, 2) if not math.isinf(perplexity) else 999
-            
-            # Use improved perplexity to probability conversion
-            perplexity_score = self.improved_perplexity_to_probability(perplexity)
-            
-            # 3. Linguistic features
-            features = self.extract_linguistic_features(text)
-            results.update({f'feature_{k}': round(v, 4) for k, v in features.items()})
-            
-            # Calculate feature-based score
-            feature_score = self.calculate_feature_score(features)
-            
-            # 4. Enhanced ensemble scoring
-            if self.ensemble_classifier and self.feature_scaler:
-                # Use trained ensemble classifier for better confidence
-                try:
-                    feature_vector = np.array([[avg_classifier_score, perplexity_score, feature_score]])
-                    feature_vector_scaled = self.feature_scaler.transform(feature_vector)
-                    
-                    ensemble_score = self.ensemble_classifier.predict_proba(feature_vector_scaled)[0][1]
-                    confidence = max(self.ensemble_classifier.predict_proba(feature_vector_scaled)[0]) * 0.9
-                    
-                except Exception as e:
-                    print(f"Ensemble classifier error: {e}")
-                    # Fallback to weighted average
-                    ensemble_score = (
-                        avg_classifier_score * 0.5 +    # 50% classifier
-                        perplexity_score * 0.3 +        # 30% perplexity  
-                        feature_score * 0.2             # 20% features
-                    )
-                    confidence = 0.7  # Default confidence
-            else:
-                # Fallback to weighted average with improved weights
-                ensemble_score = (
-                    avg_classifier_score * 0.5 +    # 50% classifier
-                    perplexity_score * 0.3 +        # 30% perplexity  
-                    feature_score * 0.2             # 20% features
-                )
-                
-                # Calculate confidence based on score consistency
-                scores = [avg_classifier_score, perplexity_score, feature_score]
-                score_std = np.std(scores)
-                confidence = max(0.6, min(0.9, 1.0 - score_std))
-            
-            # 5. Generate verdict with improved logic
-            verdict = self.get_enhanced_verdict(ensemble_score, confidence)
-            
-            results['ensemble_score'] = round(ensemble_score, 4)
-            results['final_verdict'] = verdict
-            results['confidence'] = f"{confidence:.1%}"
-            
-            return results
-            
-        except Exception as e:
-            print(f"Ensemble detection error: {e}")
-            # Return safe fallback results
-            return {
-                'ensemble_score': 0.5,
-                'final_verdict': 'Error - Unable to analyze',
-                'confidence': '0.0%',
-                'error': str(e)
-            }
-
-    def calculate_feature_score(self, features):
-        """Calculate AI probability from linguistic features with improved logic"""
-        try:
-            ai_indicators = 0
-            total_indicators = 0
-            
-            # Enhanced feature analysis with better thresholds
-            
-            # Low lexical diversity suggests AI (more strict threshold)
-            if features.get('lexical_diversity', 0.5) < 0.35:
-                ai_indicators += 2  # Weighted higher
-            elif features.get('lexical_diversity', 0.5) < 0.5:
-                ai_indicators += 1
-            total_indicators += 2
-            
-            # Low sentence start diversity suggests AI
-            if features.get('sentence_start_diversity', 1) < 0.7:
-                ai_indicators += 1
-            total_indicators += 1
-            
-            # Low burstiness suggests AI (refined threshold)
-            burstiness = features.get('burstiness', 1)
-            if burstiness < 0.3:
-                ai_indicators += 2
-            elif burstiness < 0.6:
-                ai_indicators += 1
-            total_indicators += 2
-            
-            # Very consistent sentence lengths suggest AI
-            sentence_std = features.get('sentence_length_std', 10)
-            if sentence_std < 2:
-                ai_indicators += 2
-            elif sentence_std < 5:
-                ai_indicators += 1
-            total_indicators += 2
-            
-            # High bigram repetition suggests AI
-            if features.get('bigram_repetition', 0) > 0.3:
-                ai_indicators += 1
-            total_indicators += 1
-            
-            return ai_indicators / total_indicators if total_indicators > 0 else 0.5
-            
-        except Exception as e:
-            print(f"Feature score calculation error: {e}")
-            return 0.5
-
-    def get_enhanced_verdict(self, ensemble_score, confidence):
-        """Generate verdict with improved thresholds and confidence consideration"""
-        try:
-            # Adjust thresholds based on confidence level
-            high_conf_threshold = 0.8
-            medium_conf_threshold = 0.6
-            
-            if confidence > high_conf_threshold:
-                # High confidence - use stricter thresholds
-                if ensemble_score > 0.75:
-                    return "Highly Likely AI-Generated"
-                elif ensemble_score > 0.6:
-                    return "Likely AI-Generated"
-                elif ensemble_score > 0.4:
-                    return "Possibly AI-Generated"
-                elif ensemble_score > 0.25:
-                    return "Likely Human-Written"
-                else:
-                    return "Highly Likely Human-Written"
-                    
-            elif confidence > medium_conf_threshold:
-                # Medium confidence - moderate thresholds
-                if ensemble_score > 0.7:
-                    return "Likely AI-Generated"
-                elif ensemble_score > 0.55:
-                    return "Possibly AI-Generated"
-                elif ensemble_score > 0.45:
-                    return "Unclear - Manual Review Recommended"
-                elif ensemble_score > 0.3:
-                    return "Possibly Human-Written"
-                else:
-                    return "Likely Human-Written"
-            else:
-                # Low confidence - conservative approach
-                if ensemble_score > 0.8:
-                    return "Possibly AI-Generated"
-                elif ensemble_score > 0.2:
-                    return "Unclear - Manual Review Recommended"
-                else:
-                    return "Possibly Human-Written"
-            
-        except Exception as e:
-            print(f"Verdict generation error: {e}")
-            return "Error in Analysis"
-
-# Enhanced Semantic Similarity System with Antonym Detection
-class AdvancedSimilarityDetector:
-    def __init__(self):
-        print("Initializing Similarity Detector...")
-        self.models = {}
-        
-        # Common antonym pairs for penalty detection
-        self.antonym_pairs = {
-            'excellent': ['terrible', 'awful', 'horrible', 'bad', 'poor'],
-            'good': ['bad', 'terrible', 'awful', 'horrible', 'poor'],
-            'great': ['terrible', 'awful', 'horrible', 'bad', 'poor'],
-            'fast': ['slow', 'sluggish', 'gradual'],
-            'quick': ['slow', 'sluggish', 'gradual'],
-            'efficient': ['inefficient', 'slow', 'sluggish'],
-            'high': ['low', 'small', 'little'],
-            'large': ['small', 'tiny', 'little'],
-            'big': ['small', 'tiny', 'little'],
-            'hot': ['cold', 'freezing', 'cool'],
-            'warm': ['cold', 'freezing', 'cool'],
-            'bright': ['dark', 'dim', 'dull'],
-            'light': ['dark', 'heavy'],
-            'easy': ['hard', 'difficult', 'challenging'],
-            'simple': ['complex', 'complicated', 'difficult'],
-            'happy': ['sad', 'unhappy', 'miserable'],
-            'positive': ['negative', 'bad'],
-            'love': ['hate', 'dislike'],
-            'like': ['dislike', 'hate'],
-            'beautiful': ['ugly', 'hideous'],
-            'strong': ['weak', 'fragile'],
-            'rich': ['poor', 'broke'],
-            'smart': ['stupid', 'dumb', 'ignorant'],
-            'clean': ['dirty', 'messy', 'filthy'],
-            'safe': ['dangerous', 'risky', 'unsafe'],
-            'healthy': ['unhealthy', 'sick'],
-            'new': ['old', 'ancient', 'outdated'],
-            'modern': ['old', 'ancient', 'outdated'],
-            'young': ['old', 'elderly', 'aged'],
-            'early': ['late', 'delayed'],
-            'first': ['last', 'final'],
-            'begin': ['end', 'finish', 'conclude'],
-            'start': ['end', 'finish', 'stop'],
-            'open': ['closed', 'shut'],
-            'win': ['lose', 'fail'],
-            'success': ['failure', 'defeat'],
-            'increase': ['decrease', 'reduce', 'lower'],
-            'more': ['less', 'fewer'],
-            'always': ['never', 'rarely'],
-            'all': ['none', 'nothing'],
-            'yes': ['no'],
-            'agree': ['disagree', 'oppose'],
-            'accept': ['reject', 'refuse', 'deny'],
-            'include': ['exclude', 'omit'],
-            'remember': ['forget']
-        }
-        
-        # Load primary model
-        try:
-            self.models['sentence_bert'] = SentenceTransformer('all-mpnet-base-v2')
-            print("✓ Sentence-BERT loaded successfully")
-        except Exception as e:
-            print(f"✗ Failed to load Sentence-BERT: {e}")
-            # Fallback to smaller model
-            try:
-                self.models['sentence_bert'] = SentenceTransformer('all-MiniLM-L6-v2')
-                print("✓ Fallback model loaded successfully")
-            except Exception as e2:
-                print(f"✗ Failed to load fallback model: {e2}")
-        
-        # Load secondary model if resources allow
-        try:
-            self.models['multilingual'] = SentenceTransformer('paraphrase-multilingual-mpnet-base-v2')
-            print("✓ Multilingual model loaded successfully")
-        except Exception as e:
-            print(f"✗ Multilingual model not loaded: {e}")
-    
-    def detect_antonym_penalty(self, text1, text2):
-        """Detect antonym pairs and calculate penalty"""
-        try:
-            # Tokenize and clean texts
-            words1 = set(re.findall(r'\b\w+\b', text1.lower()))
-            words2 = set(re.findall(r'\b\w+\b', text2.lower()))
-            
-            penalty = 0.0
-            antonym_found = False
-            detected_pairs = []
-            
-            # Check for antonym pairs
-            for word1 in words1:
-                if word1 in self.antonym_pairs:
-                    antonyms = self.antonym_pairs[word1]
-                    for antonym in antonyms:
-                        if antonym in words2:
-                            # Check context similarity (simple approach)
-                            context_penalty = self.calculate_context_penalty(text1, text2, word1, antonym)
-                            penalty += context_penalty
-                            antonym_found = True
-                            detected_pairs.append((word1, antonym))
-            
-            # Also check reverse direction
-            for word2 in words2:
-                if word2 in self.antonym_pairs:
-                    antonyms = self.antonym_pairs[word2]
-                    for antonym in antonyms:
-                        if antonym in words1:
-                            # Avoid double counting
-                            if (antonym, word2) not in detected_pairs and (word2, antonym) not in detected_pairs:
-                                context_penalty = self.calculate_context_penalty(text1, text2, antonym, word2)
-                                penalty += context_penalty
-                                antonym_found = True
-                                detected_pairs.append((antonym, word2))
-            
-            return penalty, antonym_found, detected_pairs
-            
-        except Exception as e:
-            print(f"Antonym detection error: {e}")
-            return 0.0, False, []
-    
-    def calculate_context_penalty(self, text1, text2, word1, word2):
-        """Calculate penalty based on context similarity around antonym pairs"""
-        try:
-            # Simple context analysis - check if surrounding words are similar
-            def get_context(text, target_word, window=3):
-                words = re.findall(r'\b\w+\b', text.lower())
-                try:
-                    idx = words.index(target_word)
-                    start = max(0, idx - window)
-                    end = min(len(words), idx + window + 1)
-                    return set(words[start:end]) - {target_word}
-                except ValueError:
-                    return set()
-            
-            context1 = get_context(text1, word1)
-            context2 = get_context(text2, word2)
-            
-            if context1 and context2:
-                # Calculate Jaccard similarity of contexts
-                intersection = len(context1.intersection(context2))
-                union = len(context1.union(context2))
-                context_similarity = intersection / union if union > 0 else 0
-                
-                # Higher context similarity means higher penalty
-                # Base penalty of 0.3, scaled by context similarity
-                penalty = 0.3 + (context_similarity * 0.4)
-                return min(penalty, 0.7)  # Cap at 0.7
-            else:
-                # Default penalty when context can't be analyzed
-                return 0.3
-                
-        except Exception as e:
-            print(f"Context penalty calculation error: {e}")
-            return 0.3
-
-    def calculate_multi_metric_similarity(self, text1, text2, threshold=0.4):
-        """Calculate similarity with antonym detection and penalty"""
-        try:
-            results = {}
-            similarity_scores = []
-            
-            # 1. Detect antonyms first
-            antonym_penalty, antonym_found, detected_pairs = self.detect_antonym_penalty(text1, text2)
-            results['antonym_penalty'] = round(antonym_penalty, 4)
-            results['antonym_detected'] = antonym_found
-            if detected_pairs:
-                results['detected_antonym_pairs'] = detected_pairs
-            
-            # 2. Calculate embeddings and similarities
-            for name, model in self.models.items():
-                if model:
-                    try:
-                        emb1, emb2 = model.encode([text1, text2], convert_to_tensor=True)
-                        
-                        # Cosine similarity
-                        cos_sim = util.pytorch_cos_sim(emb1, emb2).item()
-                        
-                        # Apply antonym penalty specifically to sentence_bert model
-                        if name == 'sentence_bert' and antonym_found:
-                            cos_sim_adjusted = max(0.0, cos_sim - antonym_penalty)
-                            results[f'{name}_cosine_original'] = round(cos_sim, 4)
-                            results[f'{name}_cosine'] = round(cos_sim_adjusted, 4)
-                            results[f'{name}_penalty_applied'] = round(antonym_penalty, 4)
-                            similarity_scores.append(cos_sim_adjusted)
-                        else:
-                            results[f'{name}_cosine'] = round(cos_sim, 4)
-                            similarity_scores.append(cos_sim)
-                        
-                        # Additional metrics
-                        dot_sim = torch.dot(emb1, emb2).item()
-                        results[f'{name}_dot_product'] = round(dot_sim, 4)
-                        
-                        euclidean_dist = torch.dist(emb1, emb2).item()
-                        euclidean_sim = 1 / (1 + euclidean_dist)
-                        results[f'{name}_euclidean_sim'] = round(euclidean_sim, 4)
-                        
-                    except Exception as e:
-                        print(f"Error with {name}: {e}")
-                        continue
-            
-            # 3. Enhanced ensemble score calculation
-            if similarity_scores:
-                # Weight the sentence_bert model higher if no antonyms detected
-                # Weight multilingual model higher if antonyms are detected
-                if len(similarity_scores) >= 2 and antonym_found:
-                    # When antonyms detected, trust multilingual model more
-                    weights = [0.4, 0.6]  # sentence_bert, multilingual
-                else:
-                    # Normal case, trust sentence_bert more
-                    weights = [0.6, 0.4] if len(similarity_scores) >= 2 else [1.0]
-                
-                # Ensure weights match number of scores
-                weights = weights[:len(similarity_scores)]
-                if len(weights) < len(similarity_scores):
-                    weights.extend([1.0] * (len(similarity_scores) - len(weights)))
-                
-                # Normalize weights
-                weight_sum = sum(weights)
-                weights = [w / weight_sum for w in weights]
-                
-                ensemble_score = sum(score * weight for score, weight in zip(similarity_scores, weights))
-            else:
-                ensemble_score = 0
-            
-            results['ensemble_similarity'] = round(ensemble_score, 4)
-            
-            # 4. Enhanced interpretation
-            interpretation = self.get_enhanced_interpretation(ensemble_score, threshold, antonym_found)
-            results['interpretation'] = interpretation
-            
-            return results, ensemble_score
-            
-        except Exception as e:
-            print(f"Similarity calculation error: {e}")
-            return {"error": str(e)}, 0
-
-    def get_enhanced_interpretation(self, score, threshold, antonym_detected=False):
-        """Generate interpretation with antonym consideration"""
-        try:
-            base_interpretation = ""
-            
-            if score > 0.90:
-                base_interpretation = "Nearly Identical (Potential Direct Copy)"
-            elif score > 0.80:
-                base_interpretation = "Very High Similarity (Likely Plagiarism)"
-            elif score > 0.70:
-                base_interpretation = "High Similarity (Suspicious - Needs Review)"
-            elif score > threshold:
-                base_interpretation = "Moderate Similarity (Possible Paraphrasing)"
-            elif score > 0.2:
-                base_interpretation = "Low Similarity (Different Content)"
-            else:
-                base_interpretation = "Very Low Similarity (Unrelated Content)"
-            
-            # Add antonym context if detected
-            if antonym_detected:
-                base_interpretation += " - Antonym penalty applied due to opposing meanings"
-            
-            return base_interpretation
-            
-        except:
-            return "Unable to interpret similarity"
 
-# Initialize detectors with error handling
-try:
-    ai_detector = AdvancedAIDetector()
-    similarity_detector = AdvancedSimilarityDetector()
-    print("✓ All detectors initialized successfully")
-except Exception as e:
-    print(f"✗ Detector initialization error: {e}")
-    ai_detector = None
-    similarity_detector = None
-
-# Enhanced Gradio functions with comprehensive error handling
-def enhanced_similarity_check(text1, text2, threshold):
-    """Enhanced similarity checking with antonym detection"""
-    try:
-        if not text1.strip() or not text2.strip():
-            return {"error": "Please provide both texts"}, "Error: Empty text provided", go.Figure()
-        
-        if not similarity_detector:
-            return {"error": "Similarity detector not available"}, "Error: Detector initialization failed", go.Figure()
-        
-        results, ensemble_score = similarity_detector.calculate_multi_metric_similarity(text1, text2, threshold)
-        
-        if "error" in results:
-            return results, f"Error: {results['error']}", go.Figure()
-        
-        explanation = f"""
-## Enhanced Similarity Analysis Results
-
-**Ensemble Similarity Score:** {results.get('ensemble_similarity', 'N/A')} ({results.get('interpretation', 'N/A')})
-
-### Antonym Detection:
-- **Antonyms Detected:** {'Yes' if results.get('antonym_detected', False) else 'No'}
-- **Penalty Applied:** {results.get('antonym_penalty', 0.0)}
-"""
-        
-        if results.get('detected_antonym_pairs'):
-            explanation += f"- **Detected Pairs:** {', '.join([f'{p[0]}↔{p[1]}' for p in results['detected_antonym_pairs']])}\n"
-        
-        explanation += f"""
-### Individual Model Scores:
-"""
-        
-        for key, value in results.items():
-            if '_cosine' in key and not key.endswith('_original'):
-                model_name = key.replace('_cosine', '').replace('_', ' ').title()
-                explanation += f"- **{model_name}:** {value}\n"
-                
-                # Show original score if penalty was applied
-                original_key = key + '_original'
-                if original_key in results:
-                    explanation += f"  - Original Score: {results[original_key]}\n"
-                    explanation += f"  - Penalty Applied: {results.get(key.replace('_cosine', '_penalty_applied'), 0)}\n"
-        
-        explanation += f"""
-**Threshold:** {threshold}
-**Analysis:** Enhanced multi-model ensemble with antonym detection and context-aware penalties.
-"""
-        
-        # Create enhanced visualization
-        fig = make_subplots(
-            rows=1, cols=2,
-            subplot_titles=('Similarity Score', 'Model Comparison'),
-            specs=[[{"type": "indicator"}, {"type": "bar"}]]
-        )
-        
-        # Gauge chart
-        fig.add_trace(go.Indicator(
-            mode="gauge+number",
-            value=ensemble_score,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "Ensemble Score"},
-            gauge={
-                'axis': {'range': [None, 1]},
-                'bar': {'color': "darkblue"},
-                'steps': [
-                    {'range': [0, threshold], 'color': "lightgray"},
-                    {'range': [threshold, 0.7], 'color': "yellow"},
-                    {'range': [0.7, 0.9], 'color': "orange"},
-                    {'range': [0.9, 1], 'color': "red"}],
-                'threshold': {
-                    'line': {'color': "red", 'width': 4},
-                    'thickness': 0.75,
-                    'value': threshold}}), row=1, col=1)
-        
-        # Model comparison bar chart
-        model_names = []
-        model_scores = []
-        for key, value in results.items():
-            if '_cosine' in key and not key.endswith('_original'):
-                model_name = key.replace('_cosine', '').replace('_', ' ').title()
-                model_names.append(model_name)
-                model_scores.append(value)
-        
-        if model_names and model_scores:
-            colors = ['red' if results.get('antonym_detected') and 'Sentence Bert' in name else 'blue' for name in model_names]
-            fig.add_trace(go.Bar(
-                x=model_names,
-                y=model_scores,
-                marker_color=colors,
-                name="Model Scores"
-            ), row=1, col=2)
-        
-        fig.update_layout(height=400, showlegend=False)
-        
-        return results, explanation, fig
-        
-    except Exception as e:
-        error_msg = f"Unexpected error in similarity check: {str(e)}"
-        return {"error": error_msg}, error_msg, go.Figure()
-
-def enhanced_ai_detection(text):
-    """Enhanced AI detection with improved confidence scoring"""
-    try:
-        if not text.strip():
-            return {"error": "Please provide text to analyze"}, "Error: Empty text provided", go.Figure()
-        
-        if not ai_detector:
-            return {"error": "AI detector not available"}, "Error: Detector initialization failed", go.Figure()
-        
-        results = ai_detector.ensemble_ai_detection(text)
-        
-        if "error" in results:
-            return results, f"Error: {results.get('error', 'Unknown error')}", go.Figure()
-        
-        explanation = f"""
-## Enhanced AI Detection Analysis
-
-**Final Verdict:** {results.get('final_verdict', 'N/A')} 
-**Confidence:** {results.get('confidence', 'N/A')}
-**Ensemble Score:** {results.get('ensemble_score', 'N/A')}
-
-### Classifier Results:
-"""
-        
-        for key, value in results.items():
-            if '_ai_prob' in key:
-                model_name = key.replace('_ai_prob', '').replace('_', ' ').title()
-                explanation += f"- **{model_name}:** {value:.1%} AI probability\n"
-        
-        explanation += f"""
-### Advanced Perplexity Analysis:
-- **GPT-2 Perplexity:** {results.get('gpt2_perplexity', 'N/A')} (lower = more AI-like)
-- **Calibrated Sigmoid Conversion:** Applied for better probability estimation
-
-### Key Linguistic Features:
-- **Lexical Diversity:** {results.get('feature_lexical_diversity', 'N/A')} (lower suggests AI)
-- **Sentence Length Std:** {results.get('feature_sentence_length_std', 'N/A')} (lower suggests AI)
-- **Burstiness:** {results.get('feature_burstiness', 'N/A')} (lower suggests AI)
-- **Sentence Start Diversity:** {results.get('feature_sentence_start_diversity', 'N/A')} (lower suggests AI)
-- **Bigram Repetition:** {results.get('feature_bigram_repetition', 'N/A')} (higher suggests AI)
-
-### Enhancement Notes:
-- Uses trained ensemble classifier for improved confidence
-- Sigmoid-calibrated perplexity conversion
-- Enhanced feature weighting and thresholds
-"""
-        
-        # Create enhanced visualization
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=('Confidence Level', 'Ensemble Score', 'Feature Analysis', 'Model Breakdown'),
-            specs=[[{"type": "indicator"}, {"type": "indicator"}],
-                   [{"type": "bar"}, {"type": "pie"}]]
-        )
-        
-        # Confidence gauge
-        confidence_val = float(results.get('confidence', '50%').strip('%')) / 100
-        fig.add_trace(go.Indicator(
-            mode="gauge+number",
-            value=confidence_val,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "Confidence"},
-            gauge={
-                'axis': {'range': [None, 1]},
-                'bar': {'color': "green"},
-                'steps': [
-                    {'range': [0, 0.6], 'color': "lightgray"},
-                    {'range': [0.6, 0.8], 'color': "yellow"},
-                    {'range': [0.8, 1], 'color': "green"}]}), row=1, col=1)
-        
-        # Ensemble score gauge
-        ensemble_score = results.get('ensemble_score', 0.5)
-        fig.add_trace(go.Indicator(
-            mode="gauge+number",
-            value=ensemble_score,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "AI Probability"},
-            gauge={
-                'axis': {'range': [None, 1]},
-                'bar': {'color': "red" if ensemble_score > 0.6 else "blue"},
-                'steps': [
-                    {'range': [0, 0.3], 'color': "lightblue"},
-                    {'range': [0.3, 0.7], 'color': "yellow"},
-                    {'range': [0.7, 1], 'color': "lightcoral"}]}), row=1, col=2)
-        
-        # Feature analysis bar chart
-        feature_names = []
-        feature_values = []
-        for key, value in results.items():
-            if key.startswith('feature_') and key in ['feature_lexical_diversity', 'feature_burstiness', 
-                                                     'feature_sentence_start_diversity']:
-                clean_name = key.replace('feature_', '').replace('_', ' ').title()
-                feature_names.append(clean_name)
-                feature_values.append(value)
-        
-        if feature_names:
-            fig.add_trace(go.Bar(
-                x=feature_names,
-                y=feature_values,
-                marker_color='lightblue',
-                name="Features"
-            ), row=2, col=1)
-        
-        # Model breakdown pie chart
-        model_probs = []
-        model_names = []
-        for key, value in results.items():
-            if '_ai_prob' in key:
-                model_name = key.replace('_ai_prob', '').replace('_', ' ').title()
-                model_names.append(model_name)
-                model_probs.append(value)
-        
-        if model_names and model_probs:
-            fig.add_trace(go.Pie(
-                labels=model_names,
-                values=model_probs,
-                name="Model Scores"
-            ), row=2, col=2)
-        
-        fig.update_layout(height=600, showlegend=False)
-        
-        return results, explanation, fig
-        
-    except Exception as e:
-        error_msg = f"Unexpected error in AI detection: {str(e)}"
-        return {"error": error_msg}, error_msg, go.Figure()
-
-# Create enhanced Gradio interfaces
-similarity_interface = gr.Interface(
-    fn=enhanced_similarity_check,
-    inputs=[
-        gr.Textbox(label="Text 1", lines=5, placeholder="Enter first text..."),
-        gr.Textbox(label="Text 2", lines=5, placeholder="Enter second text..."),
-        gr.Slider(0.2, 0.8, 0.4, step=0.01, label="Similarity Threshold")
-    ],
-    outputs=[
-        gr.JSON(label="Detailed Results"),
-        gr.Markdown(label="Analysis"),
-        gr.Plot(label="Visualization")
-    ],
-    title="🔍 Enhanced Semantic Similarity Detector with Antonym Detection",
-    description="Advanced multi-model ensemble similarity detection with context-aware antonym penalty system",
-    examples=[
-        ["The customer service was excellent and efficient.", "The customer service was terrible and slow.", 0.4],
-        ["The quick brown fox jumps over the lazy dog.", "A fast brown fox leaps over a sleepy dog.", 0.4],
-        ["Machine learning is transforming industries.", "AI technology is revolutionizing business sectors.", 0.4],
-        ["The weather is beautiful today.", "The weather is horrible today.", 0.4]
-    ]
-)
-
-ai_detection_interface = gr.Interface(
-    fn=enhanced_ai_detection,
-    inputs=gr.Textbox(label="Text to Analyze", lines=8, placeholder="Enter text to check for AI generation..."),
-    outputs=[
-        gr.JSON(label="Detailed Results"),
-        gr.Markdown(label="Analysis"),
-        gr.Plot(label="Visualization")
-    ],
-    title="🤖 Professional AI Text Detector with Enhanced Confidence",
-    description="Advanced ensemble system with trained classifier, calibrated perplexity, and enhanced feature analysis",
-    examples=[
-        ["The implementation of artificial intelligence in modern business processes has significantly enhanced operational efficiency and decision-making capabilities across various industry sectors."],
-        ["I love pizza! It's my favorite food ever. Yesterday I went to this amazing Italian restaurant downtown and had the best margherita pizza of my life."],
-        ["According to recent studies, machine learning algorithms have demonstrated remarkable performance improvements in natural language processing tasks, particularly in the areas of sentiment analysis and text classification."],
-        ["Honestly, I can't believe how good this movie was! The acting was incredible, the plot had so many unexpected twists, and don't even get me started on the cinematography - absolutely stunning!"]
-    ]
-)
+# Import the individual interfaces
+from semantic_similarity_app import similarity_interface
+from ai_detection_app import ai_detection_interface
 
-# Launch enhanced application
+# Create the combined tabbed interface
 app = gr.TabbedInterface(
     [similarity_interface, ai_detection_interface], 
     ["Enhanced Similarity Detection", "Enhanced AI Detection"],