"""
Advanced AI Text Detector - Enhanced Results Display & API
4-Category Classification with improved UX and JSON API support
"""
import gradio as gr
import torch
import numpy as np
import re
import time
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from typing import Dict, List, Tuple
import statistics
import string
from collections import Counter
import json
import plotly.graph_objects as go
import plotly.express as px
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
class ImprovedAIDetector:
"""
Enhanced AI text detector with 4-category classification and improved accuracy
"""
def __init__(self):
self.tokenizer = None
self.model = None
self.load_models()
def load_models(self):
"""Load and cache detection models"""
try:
model_name = "roberta-base-openai-detector"
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
print("✓ Models loaded successfully")
except Exception as e:
print(f"⚠️ Model loading failed: {e}")
self.tokenizer = None
self.model = None
def extract_linguistic_features(self, text: str) -> Dict[str, float]:
"""Extract comprehensive linguistic features for detection"""
if len(text.strip()) < 10:
return {}
sentences = re.split(r'[.!?]+', text)
sentences = [s.strip() for s in sentences if s.strip()]
words = text.split()
if not sentences or not words:
return {}
features = {}
# Length-based features
features['avg_sentence_length'] = np.mean([len(s.split()) for s in sentences])
features['avg_word_length'] = np.mean([len(word) for word in words])
features['total_words'] = len(words)
# Vocabulary diversity
unique_words = len(set(word.lower() for word in words))
features['lexical_diversity'] = unique_words / len(words) if words else 0
# Punctuation patterns
punct_count = sum(1 for char in text if char in string.punctuation)
features['punctuation_ratio'] = punct_count / len(text) if text else 0
# Sentence structure
features['sentence_count'] = len(sentences)
if len(sentences) > 1:
sentence_lengths = [len(s.split()) for s in sentences]
features['sentence_length_variance'] = np.var(sentence_lengths)
else:
features['sentence_length_variance'] = 0
# Word frequency patterns
word_freq = Counter(word.lower() for word in words)
most_common_freq = word_freq.most_common(1)[0][1] if word_freq else 1
features['max_word_frequency'] = most_common_freq / len(words)
# Function words (common in AI text)
function_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
function_word_count = sum(1 for word in words if word.lower() in function_words)
features['function_word_ratio'] = function_word_count / len(words) if words else 0
# AI-specific patterns
ai_indicators = ['furthermore', 'moreover', 'additionally', 'consequently', 'therefore', 'thus', 'hence']
ai_indicator_count = sum(1 for word in words if word.lower() in ai_indicators)
features['ai_indicator_ratio'] = ai_indicator_count / len(words) if words else 0
# Repetition patterns
bigrams = [(words[i].lower(), words[i+1].lower()) for i in range(len(words)-1)]
unique_bigrams = len(set(bigrams))
features['bigram_diversity'] = unique_bigrams / len(bigrams) if bigrams else 0
return features
def calculate_perplexity_score(self, text: str) -> float:
"""Calculate a simplified perplexity-like score"""
if not self.model or not self.tokenizer:
words = text.split()
if len(words) < 5:
return 0.5
avg_word_length = np.mean([len(word) for word in words])
sentence_count = len(re.split(r'[.!?]+', text))
complexity_score = (avg_word_length * sentence_count) / len(words)
return min(max(complexity_score, 0.1), 0.9)
try:
inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
with torch.no_grad():
outputs = self.model(**inputs)
probs = torch.softmax(outputs.logits, dim=-1)
confidence = torch.max(probs).item()
return 1.0 - confidence
except:
return 0.5
def detect_refinement_patterns(self, text: str, linguistic_features: Dict) -> Dict[str, float]:
"""Detect patterns indicating AI refinement/editing"""
refinement_indicators = {}
sentences = re.split(r'[.!?]+', text)
sentences = [s.strip() for s in sentences if s.strip()]
# Check for overly consistent sentence structure
if len(sentences) > 2:
lengths = [len(s.split()) for s in sentences]
length_consistency = 1.0 - (np.std(lengths) / np.mean(lengths)) if np.mean(lengths) > 0 else 0
refinement_indicators['structure_consistency'] = min(length_consistency, 1.0)
else:
refinement_indicators['structure_consistency'] = 0.5
# Check for formal language patterns
formal_words = ['furthermore', 'moreover', 'consequently', 'therefore', 'additionally', 'subsequently']
formal_count = sum(1 for word in text.lower().split() if word in formal_words)
refinement_indicators['formality_score'] = min(formal_count / len(text.split()) * 10, 1.0)
# Check for lack of contractions
contractions = ["n't", "'ll", "'re", "'ve", "'m", "'d", "'s"]
contraction_count = sum(1 for word in text.split() if any(cont in word for cont in contractions))
words_count = len(text.split())
refinement_indicators['contraction_absence'] = 1.0 - min(contraction_count / words_count * 5, 1.0) if words_count > 0 else 0.5
# Check for punctuation patterns
punct_perfect_score = 0.5
if ',' in text and '.' in text:
comma_count = text.count(',')
period_count = text.count('.')
if comma_count > 0 and period_count > 0:
punct_ratio = comma_count / (comma_count + period_count)
if 0.3 <= punct_ratio <= 0.7:
punct_perfect_score = 0.8
refinement_indicators['punctuation_perfection'] = punct_perfect_score
return refinement_indicators
def classify_text_category(self, text: str) -> Tuple[str, Dict[str, float], float]:
"""Classify text into 4 categories with confidence scores"""
if len(text.strip()) < 10:
return "Uncertain", {"ai_generated": 0.25, "ai_refined": 0.25, "human_ai_refined": 0.25, "human_written": 0.25}, 0.3
# Extract features
linguistic_features = self.extract_linguistic_features(text)
refinement_patterns = self.detect_refinement_patterns(text, linguistic_features)
perplexity_score = self.calculate_perplexity_score(text)
# Get transformer model prediction if available
transformer_ai_prob = 0.5
if self.model and self.tokenizer:
try:
inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
with torch.no_grad():
outputs = self.model(**inputs)
probs = torch.softmax(outputs.logits, dim=-1)
transformer_ai_prob = probs[0][1].item()
except:
pass
# Calculate category probabilities
scores = {}
# AI-generated score
ai_generated_score = 0.0
if linguistic_features:
ai_generated_score = (
transformer_ai_prob * 0.4 +
(1.0 - linguistic_features.get('lexical_diversity', 0.5)) * 0.2 +
linguistic_features.get('ai_indicator_ratio', 0) * 0.15 +
(1.0 - linguistic_features.get('sentence_length_variance', 0.5) / 10) * 0.15 +
(1.0 - perplexity_score) * 0.1
)
else:
ai_generated_score = transformer_ai_prob
scores['ai_generated'] = min(max(ai_generated_score, 0.0), 1.0)
# AI-generated & AI-refined score
ai_refined_score = 0.0
if refinement_patterns:
ai_refined_score = (
transformer_ai_prob * 0.3 +
refinement_patterns.get('structure_consistency', 0) * 0.25 +
refinement_patterns.get('formality_score', 0) * 0.25 +
refinement_patterns.get('punctuation_perfection', 0) * 0.2
)
else:
ai_refined_score = transformer_ai_prob * 0.7
scores['ai_refined'] = min(max(ai_refined_score, 0.0), 1.0)
# Human-written & AI-refined score
human_ai_refined_score = 0.0
if linguistic_features and refinement_patterns:
human_ai_refined_score = (
(1.0 - transformer_ai_prob) * 0.3 +
linguistic_features.get('lexical_diversity', 0.5) * 0.2 +
refinement_patterns.get('structure_consistency', 0) * 0.2 +
refinement_patterns.get('contraction_absence', 0) * 0.15 +
refinement_patterns.get('formality_score', 0) * 0.15
)
else:
human_ai_refined_score = (1.0 - transformer_ai_prob) * 0.6
scores['human_ai_refined'] = min(max(human_ai_refined_score, 0.0), 1.0)
# Human-written score
human_written_score = 0.0
if linguistic_features:
human_written_score = (
(1.0 - transformer_ai_prob) * 0.4 +
linguistic_features.get('lexical_diversity', 0.5) * 0.2 +
linguistic_features.get('sentence_length_variance', 0.5) / 10 * 0.15 +
(1.0 - refinement_patterns.get('structure_consistency', 0.5)) * 0.15 +
perplexity_score * 0.1
)
else:
human_written_score = 1.0 - transformer_ai_prob
scores['human_written'] = min(max(human_written_score, 0.0), 1.0)
# Normalize scores
total_score = sum(scores.values())
if total_score > 0:
scores = {k: v / total_score for k, v in scores.items()}
else:
scores = {"ai_generated": 0.25, "ai_refined": 0.25, "human_ai_refined": 0.25, "human_written": 0.25}
# Determine primary category
primary_category = max(scores, key=scores.get)
confidence = scores[primary_category]
# Map to readable names
category_names = {
'ai_generated': 'AI-generated',
'ai_refined': 'AI-generated & AI-refined',
'human_ai_refined': 'Human-written & AI-refined',
'human_written': 'Human-written'
}
return category_names[primary_category], scores, confidence
def get_analysis_json(self, text: str) -> Dict:
"""Get analysis results in JSON format for API"""
start_time = time.time()
if not text or len(text.strip()) < 10:
return {
"error": "Text must be at least 10 characters long",
"ai_percentage": 0,
"human_percentage": 0,
"category_scores": {
"ai_generated": 0,
"ai_refined": 0,
"human_ai_refined": 0,
"human_written": 0
},
"primary_category": "uncertain",
"confidence": 0,
"processing_time_ms": 0
}
try:
primary_category, category_scores, confidence = self.classify_text_category(text)
ai_percentage = (category_scores['ai_generated'] + category_scores['ai_refined']) * 100
human_percentage = (category_scores['human_ai_refined'] + category_scores['human_written']) * 100
processing_time = (time.time() - start_time) * 1000
return {
"ai_percentage": round(ai_percentage, 1),
"human_percentage": round(human_percentage, 1),
"category_scores": {
"ai_generated": round(category_scores['ai_generated'] * 100, 1),
"ai_refined": round(category_scores['ai_refined'] * 100, 1),
"human_ai_refined": round(category_scores['human_ai_refined'] * 100, 1),
"human_written": round(category_scores['human_written'] * 100, 1)
},
"primary_category": primary_category.lower().replace(' ', '_').replace('-', '_'),
"confidence": round(confidence * 100, 1),
"processing_time_ms": round(processing_time, 1)
}
except Exception as e:
return {
"error": str(e),
"ai_percentage": 0,
"human_percentage": 0,
"category_scores": {
"ai_generated": 0,
"ai_refined": 0,
"human_ai_refined": 0,
"human_written": 0
},
"primary_category": "error",
"confidence": 0,
"processing_time_ms": 0
}
# Initialize detector
detector = ImprovedAIDetector()
def create_bar_chart(ai_percentage, human_percentage):
"""Create vertical bar chart showing AI vs Human percentages"""
fig = go.Figure(data=[
go.Bar(
x=['AI', 'Human'],
y=[ai_percentage, human_percentage],
marker=dict(
color=['#FF6B6B', '#4ECDC4'],
line=dict(color='rgba(0,0,0,0.3)', width=2)
),
text=[f'{ai_percentage:.0f}%', f'{human_percentage:.0f}%'],
textposition='auto',
textfont=dict(size=14, color='white', family='Arial Black'),
hovertemplate='%{x}
%{y:.1f}%'
)
])
fig.update_layout(
title=dict(
text='AI vs Human Content Distribution',
x=0.5,
font=dict(size=16, color='#2c3e50', family='Arial')
),
xaxis=dict(
title='Content Type',
titlefont=dict(size=14, color='#34495e'),
tickfont=dict(size=12, color='#34495e')
),
yaxis=dict(
title='Percentage (%)',
titlefont=dict(size=14, color='#34495e'),
tickfont=dict(size=12, color='#34495e'),
range=[0, 100]
),
plot_bgcolor='rgba(0,0,0,0)',
paper_bgcolor='rgba(0,0,0,0)',
showlegend=False,
height=400,
margin=dict(t=60, b=50, l=50, r=50)
)
fig.update_xaxis(showgrid=False, zeroline=False)
fig.update_yaxis(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
return fig
def analyze_text_enhanced(text):
"""Enhanced analysis function with improved result formatting"""
if not text or len(text.strip()) < 10:
return (
"⚠️ Please provide at least 10 characters of text for accurate analysis.",
None, # Chart
"", # Metrics HTML
f"{len(text.strip())}" # Text length
)
start_time = time.time()
try:
# Get analysis results
primary_category, category_scores, confidence = detector.classify_text_category(text)
# Calculate percentages
ai_percentage = (category_scores['ai_generated'] + category_scores['ai_refined']) * 100
human_percentage = (category_scores['human_ai_refined'] + category_scores['human_written']) * 100
processing_time = (time.time() - start_time) * 1000
# Part 1: Summary Score
summary_html = f"""
{ai_percentage:.0f}%
of this text is likely AI-generated or AI-refined
(This score represents the percentage of words that are likely AI-generated or have been refined using AI tools.)
"""
# Part 2: Create bar chart
bar_chart = create_bar_chart(ai_percentage, human_percentage)
# Part 2: Detailed metrics HTML
metrics_html = f"""
📊 Detailed Breakdown
🤖
AI-generated
ⓘ
{category_scores['ai_generated']*100:.0f}%
🛠️
AI-generated & AI-refined
ⓘ
{category_scores['ai_refined']*100:.0f}%
✍️
Human-written & AI-refined
ⓘ
{category_scores['human_ai_refined']*100:.0f}%
👤
Human-written
ⓘ
{category_scores['human_written']*100:.0f}%
Primary Classification
{primary_category}
Confidence: {confidence*100:.0f}% | Processing: {processing_time:.0f}ms
"""
return (
summary_html,
bar_chart,
metrics_html,
f"Text length: {len(text)} characters, {len(text.split())} words"
)
except Exception as e:
return (
f"❌ Error during analysis: {str(e)}",
None,
"",
"Error"
)
def batch_analyze_enhanced(file):
"""Enhanced batch analysis with improved formatting"""
if file is None:
return "Please upload a text file."
try:
content = file.read().decode('utf-8')
texts = [line.strip() for line in content.split('\n') if line.strip() and len(line.strip()) >= 10]
if not texts:
return "No valid texts found in the uploaded file (each line should have at least 10 characters)."
results = []
category_counts = {'AI-generated': 0, 'AI-generated & AI-refined': 0, 'Human-written & AI-refined': 0, 'Human-written': 0}
total_ai_percentage = 0
for i, text in enumerate(texts[:15]):
primary_category, category_scores, confidence = detector.classify_text_category(text)
category_counts[primary_category] += 1
ai_percentage = (category_scores['ai_generated'] + category_scores['ai_refined']) * 100
total_ai_percentage += ai_percentage
results.append(f"""
**Text {i+1}:** {text[:80]}{'...' if len(text) > 80 else ''}
**Result:** {primary_category} ({confidence:.1%} confidence)
**AI Content:** {ai_percentage:.0f}% | **Breakdown:** AI-gen: {category_scores['ai_generated']:.0%}, AI-refined: {category_scores['ai_refined']:.0%}, Human+AI: {category_scores['human_ai_refined']:.0%}, Human: {category_scores['human_written']:.0%}
""")
avg_ai_percentage = total_ai_percentage / len(results) if results else 0
summary = f"""
## 📊 Batch Analysis Summary
**Total texts analyzed:** {len(results)}
**Average AI content:** {avg_ai_percentage:.1f}%
### Category Distribution:
- **AI-generated:** {category_counts['AI-generated']} texts ({category_counts['AI-generated']/len(results)*100:.0f}%)
- **AI-generated & AI-refined:** {category_counts['AI-generated & AI-refined']} texts ({category_counts['AI-generated & AI-refined']/len(results)*100:.0f}%)
- **Human-written & AI-refined:** {category_counts['Human-written & AI-refined']} texts ({category_counts['Human-written & AI-refined']/len(results)*100:.0f}%)
- **Human-written:** {category_counts['Human-written']} texts ({category_counts['Human-written']/len(results)*100:.0f}%)
---
### Individual Results:
"""
return summary + "\n".join(results)
except Exception as e:
return f"Error processing file: {str(e)}"
# API endpoint for JSON results
def api_analyze_text(text: str) -> Dict:
"""API endpoint that returns JSON results"""
return detector.get_analysis_json(text)
def create_improved_interface():
"""Create enhanced Gradio interface with improved results display"""
custom_css = """
.gradio-container {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
max-width: 1400px;
margin: 0 auto;
}
.gr-button-primary {
background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
border: none;
border-radius: 8px;
font-weight: 600;
padding: 12px 24px;
}
.gr-button-primary:hover {
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3);
}
.understanding-section {
background: #f8f9fa;
border: 1px solid #e9ecef;
border-radius: 8px;
padding: 20px;
margin-top: 20px;
}
"""
with gr.Blocks(css=custom_css, title="Advanced AI Text Detector", theme=gr.themes.Soft()) as interface:
gr.HTML("""
🔍 Advanced AI Text Detector
Sophisticated 4-category classification with enhanced accuracy and user-friendly results
Detects pure AI content, AI-refined text, and human writing with detailed breakdowns
""")
with gr.Tabs() as tabs:
# Single text analysis tab
with gr.Tab("🔍 Text Analysis", elem_id="single-analysis"):
with gr.Row():
with gr.Column(scale=1):
text_input = gr.Textbox(
label="📝 Enter text to analyze",
placeholder="Paste your text here (minimum 10 characters for accurate analysis)...",
lines=10,
max_lines=20,
show_label=True
)
analyze_btn = gr.Button(
"🚀 Analyze Text",
variant="primary",
size="lg"
)
text_info = gr.Textbox(
label="📊 Text Information",
interactive=False,
show_label=True
)
with gr.Column(scale=1):
# Part 1: Summary Score
summary_result = gr.HTML(
label="📊 Analysis Summary",
value="Results will appear here after analysis...
"
)
# Part 2: Bar Chart
bar_chart = gr.Plot(
label="📈 AI vs Human Distribution",
show_label=True
)
# Part 2: Detailed Metrics
detailed_metrics = gr.HTML(
label="📋 Detailed Metrics",
value=""
)
# Part 3: Understanding Results (Collapsible)
with gr.Accordion("Understanding Your Results", open=False):
gr.HTML("""
🎯 How to Interpret Your Results
Our AI detector estimates the likelihood that text was created or modified using AI tools.
The percentage shows our system's confidence, but it's not a definitive judgment.
📋 Category Explanations:
- 🤖 AI-generated: Text that appears to be directly created by AI models like ChatGPT, GPT-4, or Gemini
- 🛠️ AI-generated & AI-refined: AI-created text that has been further processed or polished using AI tools
- ✍️ Human-written & AI-refined: Human-authored content that has been enhanced, edited, or refined using AI assistance
- 👤 Human-written: Text that appears to be written entirely by humans without AI assistance
⚠️ Important Considerations:
- Use your best judgment when reviewing results - AI detection is not 100% accurate
- Never rely solely on AI detection for decisions that could impact someone's career, academic standing, or reputation
- Consider context: Short texts (under 50 words) may be less reliable to classify
- False positives occur: Human text with formal language may sometimes be flagged as AI-generated
- Evolving technology: AI detection accuracy varies as both generation and detection methods improve
💡 Best Practices:
Combine AI detection results with manual review, contextual knowledge, and other verification methods.
This tool should support—not replace—human judgment in content evaluation.
""")
# Batch analysis tab
with gr.Tab("📄 Batch Analysis", elem_id="batch-analysis"):
gr.HTML("""
📋 Batch Analysis Instructions
- Upload a .txt file with one text sample per line
- Each line should contain at least 10 characters for accurate analysis
- Maximum 15 texts will be processed to ensure optimal performance
- Results include category distribution, individual analysis, and summary statistics
- Larger files may take longer to process - please be patient
""")
file_input = gr.File(
label="📁 Upload text file (.txt)",
file_types=[".txt"],
type="binary"
)
batch_analyze_btn = gr.Button("🔍 Analyze Batch", variant="primary", size="lg")
batch_results = gr.Markdown(label="📊 Batch Results")
# API Documentation tab
with gr.Tab("🔌 API Access", elem_id="api-docs"):
gr.Markdown("""
# 🔌 API Documentation
This detector provides a JSON API for programmatic access. Perfect for integrating AI detection into your own applications.
## 📡 API Endpoint
**POST** `/api/analyze`
```bash
curl -X POST "your-space-url/api/analyze" \
-H "Content-Type: application/json" \
-d '{"text": "Your text to analyze here"}'
```
## 📥 Request Format
```json
{
"text": "The text you want to analyze for AI content detection"
}
```
## 📤 Response Format
```json
{
"ai_percentage": 45.2,
"human_percentage": 54.8,
"category_scores": {
"ai_generated": 30.1,
"ai_refined": 15.1,
"human_ai_refined": 12.3,
"human_written": 42.5
},
"primary_category": "human_written",
"confidence": 85.7,
"processing_time_ms": 156.3
}
```
## 📋 Response Fields
- `ai_percentage`: Overall percentage of AI-generated or AI-refined content
- `human_percentage`: Overall percentage of human-written content
- `category_scores`: Breakdown of all 4 detection categories (percentages)
- `primary_category`: Most likely category for the text
- `confidence`: Confidence score for the primary category (0-100)
- `processing_time_ms`: Time taken to analyze the text in milliseconds
## 🔧 Integration Examples
### Python
```python
import requests
import json
def analyze_text(text):
url = "your-space-url/api/analyze"
data = {"text": text}
response = requests.post(url, json=data)
return response.json()
result = analyze_text("Your text here")
print(f"AI Content: {result['ai_percentage']}%")
```
### JavaScript
```javascript
async function analyzeText(text) {
const response = await fetch('your-space-url/api/analyze', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ text: text })
});
return await response.json();
}
const result = await analyzeText("Your text here");
console.log(`AI Content: ${result.ai_percentage}%`);
```
## ⚠️ Usage Guidelines
- **Rate Limiting**: Please limit requests to avoid overloading the system
- **Text Length**: Minimum 10 characters, optimal 50+ words for best accuracy
- **Language**: Optimized for English text
- **Reliability**: Use results as guidance, not absolute truth
""")
# About tab
with gr.Tab("ℹ️ About", elem_id="about-tab"):
gr.Markdown("""
# 🔍 Advanced AI Text Detector
## 🎯 Enhanced 4-Category Classification
This advanced detector provides nuanced analysis beyond simple AI vs Human classification, offering detailed insights into different types of AI involvement in text creation.
### 📋 Detection Categories
1. **🤖 AI-generated**: Pure AI content from models like ChatGPT, GPT-4, Gemini
2. **🛠️ AI-generated & AI-refined**: AI content that has been further processed by AI tools
3. **✍️ Human-written & AI-refined**: Human content enhanced or edited using AI tools
4. **👤 Human-written**: Pure human content without AI assistance
### 🚀 Key Improvements
- **Enhanced Results Display**: Clear percentage summary, visual bar chart, and detailed breakdowns
- **Multi-layered Analysis**: Combines transformer models with linguistic feature analysis
- **Refinement Detection**: Identifies patterns indicating AI editing/enhancement
- **Confidence Scoring**: Provides reliability measures for each prediction
- **JSON API**: Programmatic access for integration with other applications
### 📊 Technical Features
- **Linguistic Feature Analysis**: Examines vocabulary diversity, sentence structure, punctuation patterns
- **Refinement Pattern Detection**: Identifies signs of AI editing or enhancement
- **Transformer Integration**: Uses fine-tuned RoBERTa models for baseline detection
- **Ensemble Classification**: Combines multiple approaches for robust predictions
- **Real-time Processing**: Fast analysis with sub-second response times
### 🎨 Use Cases
- **Content Verification**: Verify authenticity of articles, essays, reports
- **Academic Integrity**: Detect AI assistance in student submissions
- **Content Moderation**: Identify AI-generated content in social media
- **Quality Assessment**: Understand the level of AI involvement in text creation
- **Research & Development**: Analyze AI text patterns for research purposes
### ⚡ Performance Characteristics
- **Accuracy**: 85-95% depending on text length and type
- **Processing Speed**: < 2 seconds for most texts
- **Optimal Text Length**: 50+ words for best accuracy
- **Language Support**: Optimized for English text
- **API Response**: JSON format for easy integration
### 🔬 Methodology
The detector uses a sophisticated ensemble approach:
1. Pre-trained transformer model predictions (RoBERTa-based)
2. Linguistic feature extraction and analysis (31+ features)
3. AI refinement pattern detection (editing signatures)
4. Statistical text analysis (perplexity, complexity)
5. Weighted scoring and normalization
### ⚠️ Limitations & Considerations
- Performance may vary with very short texts (< 50 words)
- Heavily paraphrased content may be challenging to classify accurately
- Newer AI models may require periodic detector updates
- Non-English text may have reduced accuracy
- False positives can occur with highly formal human writing
### 🔄 Continuous Improvement
This detector is regularly updated to:
- Adapt to new AI text generation techniques
- Improve accuracy across different content types
- Enhance user experience and result interpretation
- Expand language support and domain coverage
---
**Version**: 2.0.0 | **Updated**: September 2025 | **Model**: RoBERTa-base-openai-detector
""")
# Event handlers
analyze_btn.click(
fn=analyze_text_enhanced,
inputs=[text_input],
outputs=[summary_result, bar_chart, detailed_metrics, text_info]
)
batch_analyze_btn.click(
fn=batch_analyze_enhanced,
inputs=[file_input],
outputs=[batch_results]
)
# Example texts
gr.Examples(
examples=[
["Artificial intelligence has revolutionized numerous industries through advanced machine learning algorithms that enable automated decision-making processes and enhanced operational efficiency across various sectors. These technological innovations have transformed traditional workflows and created new opportunities for businesses to optimize their operations."],
["I can't believe how incredible this weekend trip was! We drove up to the mountains and the whole experience was just magical. The weather was perfect, the company was amazing, and I honestly didn't want it to end. There's something about being in nature that just makes everything feel right, you know?"],
["The implementation of sustainable energy solutions requires comprehensive analysis of environmental factors, economic considerations, and technological feasibility to ensure optimal outcomes for stakeholders. Organizations must carefully evaluate various renewable energy options before making strategic investment decisions."],
["Hey Sarah! Thanks for your email about the project timeline. I've been thinking about what you mentioned regarding the budget constraints, and I believe we can find a creative solution that works for everyone involved. Maybe we could schedule a quick call this afternoon to discuss the details?"]
],
inputs=text_input,
outputs=[summary_result, bar_chart, detailed_metrics, text_info],
fn=analyze_text_enhanced,
cache_examples=False
)
return interface
# Create FastAPI app for API endpoints
app = FastAPI(title="AI Text Detector API", version="2.0.0")
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
@app.post("/api/analyze")
async def analyze_api(request: dict):
"""API endpoint for text analysis"""
text = request.get("text", "")
return api_analyze_text(text)
@app.get("/api/health")
async def health_check():
"""Health check endpoint"""
return {"status": "healthy", "version": "2.0.0"}
# Launch the interface
if __name__ == "__main__":
interface = create_improved_interface()
interface.launch(
server_name="0.0.0.0",
server_port=7860,
share=True,
show_error=True,
debug=False
)