ai detector enhanced

app.py

@@ -1,8 +1,7 @@
 
 """
-Advanced AI Text Detector - 4-Category Classification
-Enhanced accuracy with nuanced detection categories for Hugging Face Spaces
-Renamed to app.py for Hugging Face Spaces deployment
+Advanced AI Text Detector - Enhanced Results Display & API
+4-Category Classification with improved UX and JSON API support
 """
 
 import gradio as gr
@@ -15,6 +14,11 @@ 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:
     """
@@ -39,9 +43,7 @@ class ImprovedAIDetector:
             self.model = None
 
     def extract_linguistic_features(self, text: str) -> Dict[str, float]:
-        """
-        Extract comprehensive linguistic features for detection
-        """
+        """Extract comprehensive linguistic features for detection"""
         if len(text.strip()) < 10:
             return {}
 
@@ -90,7 +92,7 @@ class ImprovedAIDetector:
         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 (AI tends to be more repetitive)
+        # 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
@@ -98,16 +100,12 @@ class ImprovedAIDetector:
         return features
 
     def calculate_perplexity_score(self, text: str) -> float:
-        """
-        Calculate a simplified perplexity-like score
-        """
+        """Calculate a simplified perplexity-like score"""
         if not self.model or not self.tokenizer:
-            # Fallback heuristic
             words = text.split()
             if len(words) < 5:
                 return 0.5
 
-            # Simple heuristic: longer, more complex sentences = higher perplexity
             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)
@@ -117,21 +115,16 @@ class ImprovedAIDetector:
             inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
             with torch.no_grad():
                 outputs = self.model(**inputs)
-                # Use model confidence as perplexity proxy
                 probs = torch.softmax(outputs.logits, dim=-1)
                 confidence = torch.max(probs).item()
-                # Invert confidence to get perplexity-like score
                 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
-        """
+        """Detect patterns indicating AI refinement/editing"""
         refinement_indicators = {}
 
-        # Perfect grammar/structure indicators (suggests AI refinement)
         sentences = re.split(r'[.!?]+', text)
         sentences = [s.strip() for s in sentences if s.strip()]
 
@@ -148,21 +141,19 @@ class ImprovedAIDetector:
         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 (AI refinement often removes contractions)
+        # 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 overly perfect punctuation
+        # Check for punctuation patterns
         punct_perfect_score = 0.5
         if ',' in text and '.' in text:
-            # Simple heuristic for punctuation correctness
             comma_count = text.count(',')
             period_count = text.count('.')
             if comma_count > 0 and period_count > 0:
                 punct_ratio = comma_count / (comma_count + period_count)
-                # Refined text often has more balanced punctuation
                 if 0.3 <= punct_ratio <= 0.7:
                     punct_perfect_score = 0.8
 
@@ -171,9 +162,7 @@ class ImprovedAIDetector:
         return refinement_indicators
 
     def classify_text_category(self, text: str) -> Tuple[str, Dict[str, float], float]:
-        """
-        Classify text into 4 categories with confidence scores
-        """
+        """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
 
@@ -190,17 +179,16 @@ class ImprovedAIDetector:
                 with torch.no_grad():
                     outputs = self.model(**inputs)
                     probs = torch.softmax(outputs.logits, dim=-1)
-                    transformer_ai_prob = probs[0][1].item()  # AI probability
+                    transformer_ai_prob = probs[0][1].item()
             except:
                 pass
 
-        # Calculate category probabilities using ensemble approach
+        # Calculate category probabilities
         scores = {}
 
         # AI-generated score
         ai_generated_score = 0.0
         if linguistic_features:
-            # AI tends to have: consistent sentence length, formal language, lower lexical diversity
             ai_generated_score = (
                 transformer_ai_prob * 0.4 +
                 (1.0 - linguistic_features.get('lexical_diversity', 0.5)) * 0.2 +
@@ -257,7 +245,7 @@ class ImprovedAIDetector:
 
         scores['human_written'] = min(max(human_written_score, 0.0), 1.0)
 
-        # Normalize scores to sum to 1
+        # Normalize scores
         total_score = sum(scores.values())
         if total_score > 0:
             scores = {k: v / total_score for k, v in scores.items()}
@@ -278,73 +266,233 @@ class ImprovedAIDetector:
 
         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 analyze_text(text):
-    """
-    Main analysis function for Gradio interface
-    """
+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='<b>%{x}</b><br>%{y:.1f}%<extra></extra>'
+        )
+    ])
+
+    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.",
-            0.0, 0.0, 0.0, 0.0,  # Four category scores
-            0.0, 0.0,  # AI and Human probabilities
-            0.0,  # Confidence
-            "N/A"  # Processing time
+            None,  # Chart
+            "",    # Metrics HTML
+            f"{len(text.strip())}"  # Text length
         )
 
     start_time = time.time()
 
     try:
-        # Get detailed classification
+        # Get analysis results
         primary_category, category_scores, confidence = detector.classify_text_category(text)
 
-        # Calculate traditional AI/Human probabilities
-        ai_probability = category_scores['ai_generated'] + category_scores['ai_refined']
-        human_probability = category_scores['human_ai_refined'] + category_scores['human_written']
+        # 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
 
-        # Format result message
-        result_message = f"""
-## 🎯 **{primary_category}**
+        # Part 1: Summary Score
+        summary_html = f"""
+        <div style="text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+                    color: white; padding: 30px; border-radius: 15px; margin: 20px 0; box-shadow: 0 8px 25px rgba(0,0,0,0.15);">
+            <div style="font-size: 48px; font-weight: bold; margin-bottom: 10px; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">
+                {ai_percentage:.0f}%
+            </div>
+            <div style="font-size: 18px; line-height: 1.4; margin-bottom: 5px;">
+                of this text is likely <strong>AI-generated or AI-refined</strong>
+            </div>
+            <div style="font-size: 14px; opacity: 0.9; font-style: italic;">
+                (This score represents the percentage of words that are likely AI-generated or have been refined using AI tools.)
+            </div>
+        </div>
+        """
+
+        # Part 2: Create bar chart
+        bar_chart = create_bar_chart(ai_percentage, human_percentage)
+
+        # Part 2: Detailed metrics HTML
+        metrics_html = f"""
+        <div style="margin: 20px 0; padding: 20px; background: #f8f9fa; border-radius: 12px; border-left: 5px solid #667eea;">
+            <h4 style="color: #2c3e50; margin-bottom: 15px; font-size: 16px;">📊 Detailed Breakdown</h4>
+
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;">
+
+                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
+                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
+                        <span style="font-size: 20px; margin-right: 8px;">🤖</span>
+                        <span style="font-weight: 600; color: #2c3e50;">AI-generated</span>
+                        <span title="Text likely generated by AI, like ChatGPT or Gemini." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
+                    </div>
+                    <div style="font-size: 24px; font-weight: bold; color: #FF6B6B;">
+                        {category_scores['ai_generated']*100:.0f}%
+                    </div>
+                </div>
+
+                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
+                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
+                        <span style="font-size: 20px; margin-right: 8px;">🛠️</span>
+                        <span style="font-weight: 600; color: #2c3e50;">AI-generated & AI-refined</span>
+                        <span title="Text likely generated by AI, then refined or altered using AI tools." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
+                    </div>
+                    <div style="font-size: 24px; font-weight: bold; color: #FFA07A;">
+                        {category_scores['ai_refined']*100:.0f}%
+                    </div>
+                </div>
+
+                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
+                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
+                        <span style="font-size: 20px; margin-right: 8px;">✍️</span>
+                        <span style="font-weight: 600; color: #2c3e50;">Human-written & AI-refined</span>
+                        <span title="Text likely written by humans, then refined or altered using AI tools." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
+                    </div>
+                    <div style="font-size: 24px; font-weight: bold; color: #98D8C8;">
+                        {category_scores['human_ai_refined']*100:.0f}%
+                    </div>
+                </div>
 
-**Confidence:** {confidence:.1%}
+                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
+                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
+                        <span style="font-size: 20px; margin-right: 8px;">👤</span>
+                        <span style="font-weight: 600; color: #2c3e50;">Human-written</span>
+                        <span title="Text likely written by humans without the help of AI or paraphrasing tools." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
+                    </div>
+                    <div style="font-size: 24px; font-weight: bold; color: #4ECDC4;">
+                        {category_scores['human_written']*100:.0f}%
+                    </div>
+                </div>
 
-### Category Breakdown:
-- **AI-generated:** {category_scores['ai_generated']:.1%}
-- **AI-generated & AI-refined:** {category_scores['ai_refined']:.1%}  
-- **Human-written & AI-refined:** {category_scores['human_ai_refined']:.1%}
-- **Human-written:** {category_scores['human_written']:.1%}
+            </div>
 
-*Analysis completed in {processing_time:.0f}ms*
+            <div style="text-align: center; padding: 10px; background: white; border-radius: 8px; border: 1px solid #e9ecef;">
+                <div style="font-size: 14px; color: #6c757d; margin-bottom: 5px;">Primary Classification</div>
+                <div style="font-size: 18px; font-weight: bold; color: #2c3e50;">{primary_category}</div>
+                <div style="font-size: 14px; color: #6c757d;">Confidence: {confidence*100:.0f}% | Processing: {processing_time:.0f}ms</div>
+            </div>
+        </div>
         """
 
         return (
-            result_message,
-            category_scores['ai_generated'],
-            category_scores['ai_refined'], 
-            category_scores['human_ai_refined'],
-            category_scores['human_written'],
-            ai_probability,
-            human_probability,
-            confidence,
-            f"{processing_time:.0f}ms"
+            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)}",
-            0.0, 0.0, 0.0, 0.0,
-            0.5, 0.5, 0.0,
+            None,
+            "",
             "Error"
         )
 
-def batch_analyze(file):
-    """
-    Analyze multiple texts from uploaded file
-    """
+def batch_analyze_enhanced(file):
+    """Enhanced batch analysis with improved formatting"""
     if file is None:
         return "Please upload a text file."
 
@@ -357,27 +505,36 @@ def batch_analyze(file):
 
         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]):  # Limit to 15 texts for performance
+        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)
-**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%}
+**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)}
+**Total texts analyzed:** {len(results)}  
+**Average AI content:** {avg_ai_percentage:.1f}%
 
 ### Category Distribution:
-- **AI-generated:** {category_counts['AI-generated']} texts
-- **AI-generated & AI-refined:** {category_counts['AI-generated & AI-refined']} texts  
-- **Human-written & AI-refined:** {category_counts['Human-written & AI-refined']} texts
-- **Human-written:** {category_counts['Human-written']} texts
+- **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:
         """
@@ -387,14 +544,18 @@ def batch_analyze(file):
     except Exception as e:
         return f"Error processing file: {str(e)}"
 
-# Create improved Gradio interface
+# 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 4-category classification"""
+    """Create enhanced Gradio interface with improved results display"""
 
     custom_css = """
     .gradio-container {
         font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-        max-width: 1200px;
+        max-width: 1400px;
         margin: 0 auto;
     }
     .gr-button-primary {
@@ -402,29 +563,32 @@ def create_improved_interface():
         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);
     }
-    .category-score {
-        padding: 8px;
-        margin: 4px;
-        border-radius: 6px;
-        border-left: 4px solid #667eea;
+    .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("""
-        <div style="text-align: center; padding: 20px; background: linear-gradient(45deg, #f0f2f6, #e8eaf6); border-radius: 12px; margin-bottom: 20px;">
-            <h1 style="color: #2c3e50; margin-bottom: 10px;">🔍 Advanced AI Text Detector</h1>
-            <p style="font-size: 18px; color: #555; margin: 0;">
-                Sophisticated 4-category classification for precise AI detection
+        <div style="text-align: center; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+                    color: white; border-radius: 15px; margin-bottom: 25px; box-shadow: 0 10px 30px rgba(0,0,0,0.2);">
+            <h1 style="margin-bottom: 10px; font-size: 2.2em; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">🔍 Advanced AI Text Detector</h1>
+            <p style="font-size: 1.1em; margin: 0; opacity: 0.95;">
+                Sophisticated 4-category classification with enhanced accuracy and user-friendly results
             </p>
-            <p style="font-size: 14px; color: #666; margin-top: 8px;">
-                Detects pure AI content, AI-refined text, and human writing with enhanced accuracy
+            <p style="font-size: 0.9em; margin-top: 8px; opacity: 0.8;">
+                Detects pure AI content, AI-refined text, and human writing with detailed breakdowns
             </p>
         </div>
         """)
@@ -434,75 +598,93 @@ def create_improved_interface():
             # Single text analysis tab
             with gr.Tab("🔍 Text Analysis", elem_id="single-analysis"):
                 with gr.Row():
-                    with gr.Column(scale=3):
+                    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=8,
-                            max_lines=15,
+                            lines=10,
+                            max_lines=20,
                             show_label=True
                         )
 
                         analyze_btn = gr.Button(
                             "🚀 Analyze Text", 
                             variant="primary", 
-                            size="lg",
-                            scale=1
+                            size="lg"
                         )
 
-                    with gr.Column(scale=2):
-                        result_output = gr.Markdown(
-                            label="📊 Analysis Results",
-                            value="Results will appear here after analysis..."
+                        text_info = gr.Textbox(
+                            label="📊 Text Information",
+                            interactive=False,
+                            show_label=True
                         )
 
-                # Detailed metrics section
-                gr.HTML("<hr style='margin: 20px 0;'><h3>📈 Detailed Metrics</h3>")
-
-                with gr.Row():
-                    with gr.Column():
-                        ai_generated_score = gr.Number(
-                            label="🤖 AI-generated", 
-                            precision=3,
-                            info="Text likely generated by AI, like ChatGPT or Gemini."
-                        )
-                        ai_refined_score = gr.Number(
-                            label="🛠️ AI-generated & AI-refined", 
-                            precision=3,
-                            info="Text likely generated by AI, then refined or altered using AI tools."
+                    with gr.Column(scale=1):
+                        # Part 1: Summary Score
+                        summary_result = gr.HTML(
+                            label="📊 Analysis Summary",
+                            value="<div style='text-align: center; padding: 20px; color: #6c757d;'>Results will appear here after analysis...</div>"
                         )
 
-                    with gr.Column():
-                        human_ai_refined_score = gr.Number(
-                            label="✍️ Human-written & AI-refined", 
-                            precision=3,
-                            info="Text likely written by humans, then refined or altered using AI tools."
-                        )
-                        human_written_score = gr.Number(
-                            label="👤 Human-written", 
-                            precision=3,
-                            info="Text likely written by humans without the help of AI or paraphrasing tools."
+                        # Part 2: Bar Chart
+                        bar_chart = gr.Plot(
+                            label="📈 AI vs Human Distribution",
+                            show_label=True
                         )
 
-                with gr.Row():
-                    with gr.Column():
-                        ai_probability = gr.Number(label="🎯 Overall AI Probability", precision=3)
-                        human_probability = gr.Number(label="👥 Overall Human Probability", precision=3)
+                        # Part 2: Detailed Metrics
+                        detailed_metrics = gr.HTML(
+                            label="📋 Detailed Metrics",
+                            value=""
+                        )
 
-                    with gr.Column():
-                        confidence_score = gr.Number(label="📊 Confidence Score", precision=3)
-                        processing_time = gr.Textbox(label="⚡ Processing Time", interactive=False)
+                # Part 3: Understanding Results (Collapsible)
+                with gr.Accordion("Understanding Your Results", open=False):
+                    gr.HTML("""
+                    <div style="padding: 20px; line-height: 1.6;">
+                        <h4 style="color: #2c3e50; margin-bottom: 15px;">🎯 How to Interpret Your Results</h4>
+
+                        <p><strong>Our AI detector estimates the likelihood that text was created or modified using AI tools.</strong> 
+                        The percentage shows our system's confidence, but it's not a definitive judgment.</p>
+
+                        <h5 style="color: #34495e; margin-top: 20px; margin-bottom: 10px;">📋 Category Explanations:</h5>
+                        <ul style="margin-left: 20px;">
+                            <li><strong>🤖 AI-generated:</strong> Text that appears to be directly created by AI models like ChatGPT, GPT-4, or Gemini</li>
+                            <li><strong>🛠️ AI-generated & AI-refined:</strong> AI-created text that has been further processed or polished using AI tools</li>
+                            <li><strong>✍️ Human-written & AI-refined:</strong> Human-authored content that has been enhanced, edited, or refined using AI assistance</li>
+                            <li><strong>👤 Human-written:</strong> Text that appears to be written entirely by humans without AI assistance</li>
+                        </ul>
+
+                        <h5 style="color: #34495e; margin-top: 20px; margin-bottom: 10px;">⚠️ Important Considerations:</h5>
+                        <ul style="margin-left: 20px;">
+                            <li><strong>Use your best judgment</strong> when reviewing results - AI detection is not 100% accurate</li>
+                            <li><strong>Never rely solely on AI detection</strong> for decisions that could impact someone's career, academic standing, or reputation</li>
+                            <li><strong>Consider context:</strong> Short texts (under 50 words) may be less reliable to classify</li>
+                            <li><strong>False positives occur:</strong> Human text with formal language may sometimes be flagged as AI-generated</li>
+                            <li><strong>Evolving technology:</strong> AI detection accuracy varies as both generation and detection methods improve</li>
+                        </ul>
+
+                        <div style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; padding: 15px; margin-top: 20px;">
+                            <h5 style="color: #856404; margin-bottom: 10px;">💡 Best Practices:</h5>
+                            <p style="margin: 0; color: #856404;">
+                                Combine AI detection results with manual review, contextual knowledge, and other verification methods. 
+                                This tool should support—not replace—human judgment in content evaluation.
+                            </p>
+                        </div>
+                    </div>
+                    """)
 
             # Batch analysis tab  
             with gr.Tab("📄 Batch Analysis", elem_id="batch-analysis"):
                 gr.HTML("""
-                <div style="background: #f8f9fa; padding: 15px; border-radius: 8px; margin-bottom: 15px;">
-                    <h4>📋 Instructions for Batch Analysis</h4>
-                    <ul>
-                        <li>Upload a <strong>.txt</strong> file with one text per line</li>
-                        <li>Each line should contain at least 10 characters</li> 
-                        <li>Maximum 15 texts will be processed for performance</li>
-                        <li>Results include category distribution and individual analysis</li>
+                <div style="background: #e8f4fd; padding: 20px; border-radius: 12px; border-left: 5px solid #2196F3; margin-bottom: 20px;">
+                    <h4 style="color: #1565C0; margin-bottom: 15px;">📋 Batch Analysis Instructions</h4>
+                    <ul style="color: #1976D2; line-height: 1.6;">
+                        <li>Upload a <strong>.txt</strong> file with one text sample per line</li>
+                        <li>Each line should contain at least 10 characters for accurate analysis</li> 
+                        <li>Maximum 15 texts will be processed to ensure optimal performance</li>
+                        <li>Results include category distribution, individual analysis, and summary statistics</li>
+                        <li>Larger files may take longer to process - please be patient</li>
                     </ul>
                 </div>
                 """)
@@ -516,6 +698,101 @@ def create_improved_interface():
                 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("""
@@ -523,7 +800,7 @@ def create_improved_interface():
 
                 ## 🎯 Enhanced 4-Category Classification
 
-                This advanced detector provides nuanced analysis beyond simple AI vs Human 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
 
@@ -532,19 +809,21 @@ def create_improved_interface():
                 3. **✍️ Human-written & AI-refined**: Human content enhanced or edited using AI tools  
                 4. **👤 Human-written**: Pure human content without AI assistance
 
-                ### 🚀 Technical Improvements
+                ### 🚀 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
-                - **Enhanced Accuracy**: Ensemble approach reduces false positives and false negatives
                 - **Confidence Scoring**: Provides reliability measures for each prediction
+                - **JSON API**: Programmatic access for integration with other applications
 
-                ### 📊 Key Features
+                ### 📊 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
 
@@ -552,6 +831,7 @@ def create_improved_interface():
                 - **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
 
@@ -559,41 +839,47 @@ def create_improved_interface():
                 - **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 an ensemble approach combining:
-                1. Pre-trained transformer model predictions
-                2. Linguistic feature extraction and analysis
-                3. AI refinement pattern detection
-                4. Statistical text analysis
+                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
+                ### ⚠️ Limitations & Considerations
 
                 - Performance may vary with very short texts (< 50 words)
-                - Heavily paraphrased content may be challenging to classify
-                - Newer AI models may require periodic model updates
+                - 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 and improve accuracy across different content types.
+                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,
+            fn=analyze_text_enhanced,
             inputs=[text_input],
-            outputs=[
-                result_output, 
-                ai_generated_score, ai_refined_score, human_ai_refined_score, human_written_score,
-                ai_probability, human_probability, confidence_score, processing_time
-            ]
+            outputs=[summary_result, bar_chart, detailed_metrics, text_info]
         )
 
         batch_analyze_btn.click(
-            fn=batch_analyze,
+            fn=batch_analyze_enhanced,
             inputs=[file_input],
             outputs=[batch_results]
         )
@@ -601,24 +887,42 @@ def create_improved_interface():
         # 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."],
-                ["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."],
-                ["The implementation of sustainable energy solutions requires comprehensive analysis of environmental factors, economic considerations, and technological feasibility to ensure optimal outcomes for stakeholders."],
-                ["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."]
+                ["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=[
-                result_output, 
-                ai_generated_score, ai_refined_score, human_ai_refined_score, human_written_score,
-                ai_probability, human_probability, confidence_score, processing_time
-            ],
-            fn=analyze_text,
+            outputs=[summary_result, bar_chart, detailed_metrics, text_info],
+            fn=analyze_text_enhanced,
             cache_examples=False
         )
 
     return interface
 
-# Launch the improved 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(

requirements.txt

@@ -1,7 +1,8 @@
-torch
-transformers
 gradio>=4.0.0
-numpy
-datasets
-tokenizers
-accelerate
+torch>=1.13.0
+transformers>=4.25.0
+numpy>=1.21.0
+scikit-learn>=1.2.0
+plotly>=5.0.0
+fastapi>=0.68.0
+uvicorn>=0.15.0