app.py

import gradio as gr
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification, GPT2LMHeadModel, GPT2TokenizerFast
import numpy as np
from scipy import stats
import re
from collections import Counter
import math
import warnings
warnings.filterwarnings('ignore')

class AdvancedAITextDetector:
    def __init__(self):
        """Initialize the AI Text Detector with multiple detection methods"""
        self.models_loaded = {}
        
        # Load multiple models for ensemble detection
        self.load_models()
        
    def load_models(self):
        """Load multiple detection models for ensemble approach"""
        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
            
        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
        except:
            print("Warning: Could not load alternative detector")
            self.models_loaded['alt'] = False
            
        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
        except:
            print("Warning: Could not load GPT-2 for perplexity")
            self.models_loaded['gpt2'] = False
    
    def calculate_gpt2_perplexity(self, text):
        """Calculate perplexity using GPT-2 - lower perplexity suggests AI text"""
        if not self.models_loaded.get('gpt2', False):
            return None
            
        try:
            encodings = self.gpt2_tokenizer(text, return_tensors='pt', truncation=True, max_length=512)
            max_length = encodings.input_ids.size(1)
            
            with torch.no_grad():
                outputs = self.gpt2_model(**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:
            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):
            return None
            
        try:
            inputs = self.roberta_tokenizer(text, return_tensors="pt", truncation=True, 
                                           max_length=512, padding=True)
            
            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()
                
            return ai_probability
        except:
            return None
    
    def detect_alternative(self, text):
        """Use alternative detector model"""
        if not self.models_loaded.get('alt', False):
            return None
            
        try:
            inputs = self.alt_tokenizer(text, return_tensors="pt", truncation=True, 
                                       max_length=512, padding=True)
            
            with torch.no_grad():
                outputs = self.alt_model(**inputs)
                predictions = torch.softmax(outputs.logits, dim=-1)
                ai_probability = predictions[0][1].item()
                
            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
        }
    
    def detect(self, text):
        """Main detection method with ensemble approach"""
        if not text or len(text.strip()) < 20:
            return {
                "ai_probability": 50.0,
                "classification": "Undetermined",
                "confidence": "Low",
                "explanation": "Text too short for accurate analysis. Please provide at least 50 characters.",
                "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:
            # Normalize weights
            weights = [w / sum(weights) for w in weights]
            final_score = sum(s * w for s, w in zip(scores, weights))
        else:
            final_score = 0.5
        
        # Adjust classification thresholds for better ChatGPT detection
        if final_score >= 0.75:
            classification = "AI-Generated (Likely ChatGPT)"
            confidence = "High"
        elif final_score >= 0.55:
            classification = "Probably 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"
        else:
            classification = "Human-Written"
            confidence = "High"
        
        # Generate detailed explanation
        explanation = self._generate_explanation(final_score, stat_details, {
            'roberta': roberta_score,
            'alternative': alt_score,
            'perplexity': perplexity_score
        })
        
        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
            }
        }
    
    def _generate_explanation(self, score, stat_details, model_scores):
        """Generate detailed explanation of the detection result"""
        explanations = []
        
        # Overall assessment
        if score >= 0.75:
            explanations.append("🤖 Strong indicators of AI generation detected, consistent with ChatGPT patterns.")
        elif score >= 0.55:
            explanations.append("⚠️ Multiple AI characteristics detected, suggesting probable AI 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.")
        else:
            explanations.append("👤 Strong human writing characteristics detected.")
        
        # 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")
        
        # Pattern analysis
        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)")
        
        return " ".join(explanations)

# Initialize detector
detector = AdvancedAITextDetector()

def analyze_text(text):
    """Gradio interface function"""
    result = detector.detect(text)
    
    # Format output for Gradio
    output = f"""
## 🔍 Detection Result

**Classification:** {result['classification']}
**AI Probability:** {result['ai_probability']}%
**Confidence Level:** {result['confidence']}

### 📊 Analysis Details
{result['explanation']}

### 📈 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"
    
    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"
    
    # Create visual probability bar
    ai_prob = result['ai_probability']
    human_prob = 100 - ai_prob
    
    bar_chart = f"""
### 📊 Probability Distribution
```
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}%
```
"""
    
    # Add warning for edge cases
    if result['confidence'] == "Low":
        bar_chart += "\n⚠️ **Note:** Low confidence - results may be unreliable. Consider additional verification."
    
    return output + bar_chart

# 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"
    ),
    outputs=gr.Markdown(label="Analysis Result"),
    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:
    
    ### 🚀 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
    
    ### 📝 Usage Tips:
    - Provide at least 100 words for best results
    - The detector is specifically tuned for ChatGPT/GPT-4 content
    - Works best with English text
    - Longer texts generally yield more reliable results
    
    ### ⚠️ Important:
    This tool provides probabilistic analysis, not absolute certainty. Use it as one of multiple factors in your assessment.
    """,
    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."]
    ],
    theme=gr.themes.Soft(),
    analytics_enabled=False
)

if __name__ == "__main__":
    interface.launch()