Update src/app.py

src/app.py

@@ -1,197 +1,196 @@
-import streamlit as st
-import json
-import time
-import plotly.graph_objects as go
-from detector import (
-    smart_chunk_text,
-    has_html_or_ai_artifacts,
-    calibrate_threshold,
-    predict_chunks_with_tau,
-    preprocess_text_for_detection,
-)
-
-st.set_page_config(page_title="AI Text Detector Pro", layout="wide", page_icon="🔍")
-
-# --- Professional CSS ---
-st.markdown("""
-<style>
-    .main-header { font-size: 2.5rem; font-weight: 700; color: #1f77b4; text-align: center; margin-bottom: 1rem; }
-    .result-card { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 2rem; border-radius: 15px; color: white; margin: 1rem 0; }
-    .ai-highlight { background-color: #ff6b6b; padding: 4px 8px; border-radius: 4px; color: white; margin: 2px; display: inline-block; }
-    .human-highlight { background-color: #51cf66; padding: 4px 8px; border-radius: 4px; color: white; margin: 2px; display: inline-block; }
-    .metric-card { background: #f8f9fa; padding: 1rem; border-radius: 10px; border-left: 4px solid #1f77b4; margin: 0.5rem 0; }
-    .feature-badge { background: #e9ecef; padding: 0.3rem 0.8rem; border-radius: 20px; font-size: 0.8rem; margin: 0.2rem; display: inline-block; }
-</style>
-""", unsafe_allow_html=True)
-
-st.markdown('<div class="main-header">🔍 AI Text Detector Pro</div>', unsafe_allow_html=True)
-st.caption("Advanced detection using ensemble methods with GPT-5 pattern recognition")
-
-# === Calibration ===
-human_calibration_texts = [
-    "This is a genuine human-written sentence for calibration purposes.",
-    "Another authentic text sample composed by a human author.",
-    "Calibrating detectors with real-world data improves reliability."
+import gradio as gr
+import os
+from detector import analyze_text, get_components
+
+# Pre-load model
+print("Starting AI Text Detector...")
+try:
+    get_components()
+    model_status = "✅ Model loaded successfully!"
+except Exception as e:
+    model_status = f"⚠️ Model loading issue: {str(e)}"
+
+print(model_status)
+
+# Custom CSS for better styling
+css = """
+.gradio-container {
+    max-width: 1200px !important;
+}
+.result-human {
+    padding: 10px;
+    border-radius: 5px;
+    background: #f0f8f0;
+    border-left: 4px solid #4CAF50;
+}
+.result-ai {
+    padding: 10px;
+    border-radius: 5px;
+    background: #fff0f0;
+    border-left: 4px solid #f44336;
+}
+.chunk-human {
+    background: #f8fff8;
+    margin: 5px 0;
+    padding: 8px;
+    border-radius: 3px;
+    border-left: 3px solid #4CAF50;
+}
+.chunk-ai {
+    background: #fff8f8;
+    margin: 5px 0;
+    padding: 8px;
+    border-radius: 3px;
+    border-left: 3px solid #f44336;
+}
+.confidence-high { color: #388E3C; }
+.confidence-medium { color: #F57C00; }
+.confidence-low { color: #D32F2F; }
+"""
+
+def analyze_text_interface(text, threshold, chunk_size):
+    """
+    Interface function for Gradio
+    """
+    if not text or not text.strip():
+        return "❌ Please enter some text to analyze.", "", ""
+    
+    try:
+        result = analyze_text(text, threshold=threshold, chunk_size=chunk_size)
+        
+        if "error" in result:
+            return f"❌ Error: {result['error']}", "", ""
+        
+        # Overall result
+        overall_html = f"""
+        <div class="result-{result['overall_type'].lower()}">
+            <h3>Overall Result: {result['overall_type']}</h3>
+            <p><strong>Confidence:</strong> {result['overall_confidence']:.2%}</p>
+            <p><strong>AI Score:</strong> {result['overall_score']:.3f}</p>
+            <p><strong>AI Artifacts Detected:</strong> {'✅ Yes' if result['has_artifacts'] else '❌ No'}</p>
+            <p><strong>Chunk Analysis:</strong> {result['ai_chunks']} AI / {result['human_chunks']} Human</p>
+        </div>
+        """
+        
+        # Chunk details
+        chunk_html = "<h3>Detailed Chunk Analysis:</h3>"
+        for i, chunk in enumerate(result['chunks']):
+            confidence_class = "confidence-high" if chunk['confidence'] > 0.8 else "confidence-medium" if chunk['confidence'] > 0.6 else "confidence-low"
+            chunk_html += f"""
+            <div class="chunk-{chunk['type'].lower()}">
+                <strong>Chunk {i+1}:</strong> {chunk['type']}
+                <br><small>Confidence: <span class="{confidence_class}">{chunk['confidence']:.2%}</span></small>
+                <br><small>Text: "{chunk['text'][:100]}{'...' if len(chunk['text']) > 100 else ''}"</small>
+            </div>
+            """
+        
+        # Raw data for download
+        raw_data = {
+            "overall_type": result['overall_type'],
+            "overall_confidence": result['overall_confidence'],
+            "overall_score": result['overall_score'],
+            "has_artifacts": result['has_artifacts'],
+            "chunk_analysis": {
+                "ai_chunks": result['ai_chunks'],
+                "human_chunks": result['human_chunks'],
+                "total_chunks": result['total_chunks']
+            },
+            "chunks": result['chunks']
+        }
+        
+        return overall_html, chunk_html, str(raw_data)
+        
+    except Exception as e:
+        return f"❌ Analysis failed: {str(e)}", "", ""
+
+# Example texts
+examples = [
+    ["This is a sample text written by a human. It contains natural variations in writing style and occasional imperfections that make it authentic."],
+    ["The aforementioned textual content exhibits characteristics consistent with AI-generated material, including syntactic patterns and lexical choices commonly associated with large language models."],
+    ["Hello world! This is a test. I hope this works correctly. The weather is nice today."]
 ]
-tau = calibrate_threshold(human_calibration_texts, calibration_proportion=0.05)
-
-# === Sidebar ===
-with st.sidebar:
-    st.header("Settings")
-    detection_mode = st.selectbox(
-        "Detection Mode",
-        ["Standard", "Aggressive", "Conservative"],
-        help="Standard: Balanced approach, Aggressive: Higher AI detection, Conservative: Higher human detection"
-    )
-    show_details = st.checkbox("Show Detailed Analysis", value=True)
-    enable_chunking = st.checkbox("Enable Text Chunking", value=False)
 
-# === Main Interface ===
-col1, col2 = st.columns([2, 1])
-
-with col1:
-    text = st.text_area(
-        "Enter text to analyze:", 
-        height=250, 
-        placeholder="Paste your text here...\n\nTip: For better accuracy, provide text with at least 50 words.",
-        help="The detector works best with longer texts (100+ words)"
+# Create Gradio interface
+with gr.Blocks(css=css, title="AI Text Detector") as demo:
+    gr.Markdown(
+        """
+        # 🔍 AI Text Detector
+        *Detect AI-generated text using advanced machine learning models*
+        
+        **Model Status:** {}
+        """.format(model_status)
     )
-
-with col2:
-    st.info("**💡 Detection Features:**")
-    st.write("• GPT-5 pattern recognition")
-    st.write("• Statistical analysis")
-    st.write("• Sentence structure evaluation")
-    st.write("• Repetition detection")
-    st.write("• HTML/artifact detection")
-
-if st.button("🚀 Analyze Text", type="primary", use_container_width=True):
-    if not text.strip():
-        st.error("⚠️ Please enter some text to analyze!")
-    else:
-        with st.spinner("🔄 Analyzing text with advanced detection..."):
-            time.sleep(1)
-
-            # Preprocess
-            clean_text = preprocess_text_for_detection(text)
-
-            if has_html_or_ai_artifacts(clean_text):
-                st.markdown("""
-                <div class="result-card">
-                    <h2>🔴 AI-Generated Content Detected</h2>
-                    <p>HTML tags or AI artifacts found in the text.</p>
-                </div>
-                """, unsafe_allow_html=True)
-            else:
-                # Process text
-                if enable_chunking and len(clean_text.split()) > 50:
-                    chunks = smart_chunk_text(clean_text)
-                else:
-                    chunks = [clean_text]
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="Input Text",
+                placeholder="Paste or type the text you want to analyze here...",
+                lines=8,
+                max_lines=20
+            )
+            
+            with gr.Row():
+                threshold = gr.Slider(
+                    minimum=0.1,
+                    maximum=0.9,
+                    value=0.5,
+                    step=0.05,
+                    label="Detection Threshold",
+                    info="Higher values = more strict AI detection"
+                )
                 
-                results = predict_chunks_with_tau(chunks, tau)
-
-                # Weighted scoring
-                total_length = sum(len(c["text"]) for c in results)
-                ai_weighted = sum(len(c["text"]) * c["score"] for c in results)
-                human_weighted = total_length - ai_weighted
-
-                ai_percentage = round((ai_weighted / total_length) * 100, 1) if total_length else 0
-                human_percentage = round(100 - ai_percentage, 1)
-
-                # Apply detection mode adjustments
-                if detection_mode == "Aggressive":
-                    ai_percentage = min(ai_percentage * 1.2, 100)
-                    human_percentage = 100 - ai_percentage
-                elif detection_mode == "Conservative":
-                    ai_percentage = ai_percentage * 0.8
-                    human_percentage = 100 - ai_percentage
-
-                # Result text
-                if ai_percentage >= 70:
-                    result_emoji, result_text = "🔴", "HIGH AI PROBABILITY"
-                elif ai_percentage >= 40:
-                    result_emoji, result_text = "🟡", "MIXED CONTENT"
-                else:
-                    result_emoji, result_text = "🟢", "LIKELY HUMAN"
-
-                # Display card
-                st.markdown(f"""
-                <div class="result-card">
-                    <h2>{result_emoji} {result_text}</h2>
-                    <div style="display: flex; justify-content: space-between; align-items: center;">
-                        <div>
-                            <h3>AI: {ai_percentage}%</h3>
-                            <h3>Human: {human_percentage}%</h3>
-                        </div>
-                        <div style="font-size: 3rem;">{result_emoji}</div>
-                    </div>
-                </div>
-                """, unsafe_allow_html=True)
-
-                # Metrics
-                col1, col2, col3 = st.columns(3)
-                with col1: st.metric("AI Probability", f"{ai_percentage}%")
-                with col2: st.metric("Human Probability", f"{human_percentage}%")
-                with col3: st.metric("Confidence", "High" if abs(ai_percentage - human_percentage) > 30 else "Medium")
-
-                st.progress(ai_percentage / 100)
-
-                # Highlighted output
-                st.subheader("📊 Text Analysis")
-                html_output = ""
-                for result in results:
-                    css_class = "ai-highlight" if result["type"] == "AI" else "human-highlight"
-                    html_output += f'<span class="{css_class}" title="Score: {result["score"]:.3f}">{result["text"]}</span> '
-                st.markdown(f'<div style="line-height: 2.5;">{html_output}</div>', unsafe_allow_html=True)
-
-                # Detailed analysis
-                if show_details:
-                    with st.expander("🔍 Detailed Analysis Report", expanded=True):
-                        tab1, tab2, tab3 = st.tabs(["Feature Analysis", "Chunk Details", "Visualization"])
-                        
-                        with tab1:
-                            st.write("**Feature Scores:** Under development.")
-                        with tab2:
-                            for i, result in enumerate(results):
-                                st.write(f"**Chunk {i+1}:** ({result['type']} - Score: {result['score']:.3f})")
-                                st.write(result["text"])
-                                st.divider()
-                        with tab3:
-                            if len(results) > 1:
-                                scores = [r["score"] for r in results]
-                                fig = go.Figure()
-                                fig.add_trace(go.Scatter(
-                                    x=list(range(1, len(scores) + 1)),
-                                    y=scores,
-                                    mode='lines+markers',
-                                    name='AI Probability',
-                                    line=dict(color='red', width=3)
-                                ))
-                                fig.update_layout(
-                                    title="AI Probability Across Text Chunks",
-                                    xaxis_title="Chunk Number",
-                                    yaxis_title="AI Probability",
-                                    showlegend=True
-                                )
-                                st.plotly_chart(fig, use_container_width=True)
-
-                # Download report
-                st.download_button(
-                    "📥 Download Full Report",
-                    data=json.dumps({
-                        "overview": {
-                            "ai_percentage": ai_percentage,
-                            "human_percentage": human_percentage,
-                            "result": result_text,
-                            "detection_mode": detection_mode
-                        },
-                        "detailed_results": results
-                    }, indent=2),
-                    file_name=f"ai_detection_report_{int(time.time())}.json",
-                    mime="application/json",
+                chunk_size = gr.Slider(
+                    minimum=40,
+                    maximum=200,
+                    value=80,
+                    step=10,
+                    label="Chunk Size (tokens)",
+                    info="Smaller chunks = more detailed analysis"
                 )
+            
+            analyze_btn = gr.Button("Analyze Text", variant="primary")
+            
+            gr.Examples(
+                examples=examples,
+                inputs=text_input,
+                label="Try these examples:"
+            )
+        
+        with gr.Column():
+            overall_output = gr.HTML(label="Overall Result")
+            chunk_output = gr.HTML(label="Chunk Details")
+            raw_output = gr.Textbox(
+                label="Raw Data (for download)",
+                lines=4,
+                max_lines=10
+            )
+    
+    # Footer
+    gr.Markdown(
+        """
+        ---
+        **How it works:**
+        - Text is split into meaningful chunks
+        - Each chunk is analyzed by the AI detection model
+        - Results are aggregated for overall classification
+        - Built with `abhi099k/ai-text-detector-v-n4.0` model
+        
+        **Note:** This tool provides probabilistic estimates and should be used as one of several indicators when evaluating text authenticity.
+        """
+    )
+    
+    # Connect the function
+    analyze_btn.click(
+        fn=analyze_text_interface,
+        inputs=[text_input, threshold, chunk_size],
+        outputs=[overall_output, chunk_output, raw_output]
+    )
 
-# Footer
-st.markdown("---")
-st.caption("🔬 **AI Text Detector Pro** v2.0 | Enhanced with GPT-5 pattern recognition and statistical analysis")
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )