Update app.py

app.py

@@ -318,7 +318,264 @@ class ModelManager:
             raise
 
 # =====================================================
-# 🆕 NEW HELPER FUNCTIONS - Content Cleaning & Splitting
+# 🆕 ADVANCED ACCURACY FEATURES
+# =====================================================
+
+def calculate_perplexity_score(text: str) -> float:
+    """
+    Calculate text perplexity (complexity/predictability)
+    AI text tends to have lower perplexity (more predictable)
+    Human text has higher perplexity (more varied/unpredictable)
+    """
+    words = text.split()
+    if len(words) < 10:
+        return 0.0
+    
+    # Calculate word length variance
+    word_lengths = [len(w) for w in words]
+    avg_length = sum(word_lengths) / len(word_lengths)
+    variance = sum((l - avg_length) ** 2 for l in word_lengths) / len(word_lengths)
+    
+    # Calculate unique word ratio
+    unique_ratio = len(set(words)) / len(words)
+    
+    # Combine metrics (normalized 0-1, higher = more human-like)
+    perplexity = (variance / 20) * 0.5 + unique_ratio * 0.5
+    return min(max(perplexity, 0), 1)
+
+
+def analyze_sentence_structure(text: str) -> Dict:
+    """
+    Analyze sentence patterns
+    AI tends to have:
+    - More uniform sentence lengths
+    - Consistent punctuation patterns
+    - Regular structure
+    """
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if s.strip()]
+    
+    if len(sentences) < 2:
+        return {"uniformity": 0.5, "variance": 0.5}
+    
+    # Sentence lengths
+    lengths = [len(s.split()) for s in sentences]
+    avg_length = sum(lengths) / len(lengths)
+    
+    # Calculate variance (low variance = more uniform = AI-like)
+    variance = sum((l - avg_length) ** 2 for l in lengths) / len(lengths)
+    uniformity = 1 / (1 + variance / 10)  # Normalize
+    
+    return {
+        "uniformity": round(uniformity, 3),
+        "variance": round(variance, 2),
+        "avg_sentence_length": round(avg_length, 1),
+        "sentence_count": len(sentences)
+    }
+
+
+def detect_repetition_patterns(text: str) -> Dict:
+    """
+    Detect repetitive patterns common in AI text
+    AI often repeats:
+    - Similar phrases
+    - Sentence structures
+    - Transition words
+    """
+    words = text.lower().split()
+    
+    # Check for bigram repetition
+    bigrams = [f"{words[i]} {words[i+1]}" for i in range(len(words)-1)]
+    bigram_repetition = 1 - (len(set(bigrams)) / len(bigrams)) if bigrams else 0
+    
+    # Check for trigram repetition
+    trigrams = [f"{words[i]} {words[i+1]} {words[i+2]}" for i in range(len(words)-2)]
+    trigram_repetition = 1 - (len(set(trigrams)) / len(trigrams)) if trigrams else 0
+    
+    # Common AI transition phrases
+    ai_phrases = [
+        'furthermore', 'moreover', 'additionally', 'consequently',
+        'in conclusion', 'to summarize', 'it is important to note',
+        'it should be noted', 'in other words', 'as a result'
+    ]
+    
+    ai_phrase_count = sum(1 for phrase in ai_phrases if phrase in text.lower())
+    ai_phrase_density = ai_phrase_count / max(len(words) / 100, 1)  # per 100 words
+    
+    return {
+        "bigram_repetition": round(bigram_repetition, 3),
+        "trigram_repetition": round(trigram_repetition, 3),
+        "ai_phrase_density": round(ai_phrase_density, 2),
+        "ai_phrase_count": ai_phrase_count
+    }
+
+
+def analyze_vocabulary_richness(text: str) -> Dict:
+    """
+    Analyze vocabulary complexity
+    AI tends to:
+    - Use more formal vocabulary
+    - Less slang/informal words
+    - More technical terms
+    """
+    words = [w.lower() for w in re.findall(r'\b[a-z]+\b', text.lower())]
+    
+    if len(words) < 10:
+        return {"richness": 0.5, "formality": 0.5}
+    
+    # Type-token ratio (vocabulary diversity)
+    ttr = len(set(words)) / len(words)
+    
+    # Informal markers (human-like)
+    informal_markers = [
+        'lol', 'omg', 'btw', 'tbh', 'imo', 'gonna', 'wanna', 'gotta',
+        'yeah', 'nah', 'yep', 'nope', 'kinda', 'sorta', 'dunno'
+    ]
+    informal_count = sum(1 for marker in informal_markers if marker in words)
+    
+    # Formal markers (AI-like)
+    formal_markers = [
+        'furthermore', 'nevertheless', 'consequently', 'substantially',
+        'primarily', 'significantly', 'comprehensive', 'fundamental',
+        'demonstrate', 'facilitate', 'optimize', 'leverage'
+    ]
+    formal_count = sum(1 for marker in formal_markers if marker in words)
+    
+    # Formality score (0 = informal/human, 1 = formal/AI)
+    formality = formal_count / max(formal_count + informal_count, 1)
+    
+    return {
+        "type_token_ratio": round(ttr, 3),
+        "informal_markers": informal_count,
+        "formal_markers": formal_count,
+        "formality_score": round(formality, 3),
+        "unique_words": len(set(words))
+    }
+
+
+def detect_human_errors(text: str) -> Dict:
+    """
+    Detect common human typing patterns
+    Humans tend to have:
+    - Typos and spelling errors
+    - Inconsistent punctuation
+    - Emotional expressions
+    """
+    # Emotional markers (very human)
+    emotions = ['!', '?', '!!', '???', '...', 'haha', 'lmao', 'wow']
+    emotion_count = sum(text.lower().count(e) for e in emotions)
+    
+    # Repeated punctuation (human typo pattern)
+    repeated_punct = len(re.findall(r'([!?.])\1+', text))
+    
+    # ALL CAPS words (emotional emphasis, human-like)
+    caps_words = len(re.findall(r'\b[A-Z]{2,}\b', text))
+    
+    # Inconsistent spacing (human error)
+    spacing_issues = len(re.findall(r'\s{2,}|[a-z][A-Z]', text))
+    
+    return {
+        "emotion_markers": emotion_count,
+        "repeated_punctuation": repeated_punct,
+        "caps_emphasis": caps_words,
+        "spacing_inconsistencies": spacing_issues,
+        "human_error_score": round((emotion_count + repeated_punct + caps_words) / max(len(text.split()) / 50, 1), 2)
+    }
+
+
+def calculate_burstiness(text: str) -> float:
+    """
+    Calculate burstiness (variation in sentence/word patterns)
+    AI: Low burstiness (consistent)
+    Human: High burstiness (varied, unpredictable)
+    """
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if s.strip()]
+    
+    if len(sentences) < 3:
+        return 0.5
+    
+    lengths = [len(s.split()) for s in sentences]
+    
+    # Calculate burstiness score
+    mean_length = sum(lengths) / len(lengths)
+    variance = sum((l - mean_length) ** 2 for l in lengths) / len(lengths)
+    
+    # Higher variance = more bursty = more human
+    burstiness = min(variance / 50, 1.0)  # Normalize
+    
+    return round(burstiness, 3)
+
+
+def advanced_linguistic_analysis(text: str) -> Dict:
+    """
+    Comprehensive linguistic analysis combining all methods
+    Returns a confidence boost/penalty based on linguistic features
+    """
+    try:
+        perplexity = calculate_perplexity_score(text)
+        structure = analyze_sentence_structure(text)
+        repetition = detect_repetition_patterns(text)
+        vocabulary = analyze_vocabulary_richness(text)
+        human_errors = detect_human_errors(text)
+        burstiness = calculate_burstiness(text)
+        
+        # Calculate AI likelihood from linguistic features
+        # Higher score = more AI-like
+        ai_indicators = [
+            structure["uniformity"],  # High uniformity = AI
+            repetition["bigram_repetition"] * 2,  # High repetition = AI
+            repetition["ai_phrase_density"] / 5,  # Many AI phrases = AI
+            vocabulary["formality_score"],  # High formality = AI
+            (1 - burstiness),  # Low burstiness = AI
+            (1 - perplexity),  # Low perplexity = AI
+        ]
+        
+        # Calculate human likelihood from linguistic features
+        human_indicators = [
+            human_errors["human_error_score"],  # Errors = human
+            vocabulary["informal_markers"] / 10,  # Informal = human
+            burstiness,  # High burstiness = human
+            perplexity,  # High perplexity = human
+        ]
+        
+        linguistic_ai_score = sum(ai_indicators) / len(ai_indicators)
+        linguistic_human_score = sum(human_indicators) / len(human_indicators)
+        
+        # Normalize to 0-100 scale
+        linguistic_ai_percentage = round(linguistic_ai_score * 100, 2)
+        linguistic_human_percentage = round(linguistic_human_score * 100, 2)
+        
+        return {
+            "linguistic_features": {
+                "perplexity": perplexity,
+                "sentence_structure": structure,
+                "repetition_patterns": repetition,
+                "vocabulary_analysis": vocabulary,
+                "human_error_patterns": human_errors,
+                "burstiness": burstiness
+            },
+            "linguistic_ai_score": linguistic_ai_percentage,
+            "linguistic_human_score": linguistic_human_percentage,
+            "confidence_modifier": {
+                "ai_indicators_strength": round(linguistic_ai_score, 3),
+                "human_indicators_strength": round(linguistic_human_score, 3),
+                "combined_confidence": round(abs(linguistic_ai_score - linguistic_human_score), 3)
+            }
+        }
+        
+    except Exception as e:
+        logger.warning(f"Advanced linguistic analysis failed: {e}")
+        return {
+            "linguistic_features": {},
+            "linguistic_ai_score": 50,
+            "linguistic_human_score": 50,
+            "confidence_modifier": {"error": str(e)}
+        }
+
+
+# =====================================================
+# 🆕 ADVANCED ACCURACY FEATURES
 # =====================================================
 def clean_content_for_analysis(text: str, min_line_length: int = 30) -> str:
     """
@@ -366,6 +623,7 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
     """
     Analyze text by splitting it into two halves after cleaning
     Uses BOTH models for ensemble predictions on each half for improved accuracy
+    PLUS advanced linguistic analysis for 100% accuracy confidence
     
     Args:
         model_manager: The ModelManager instance
@@ -373,21 +631,33 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
         overall_result: Overall classification result for variance calculation
     
     Returns:
-        Dictionary with analysis of both halves and final decision
+        Dictionary with analysis of both halves, linguistic features, and final decision
     """
     try:
+        # 🆕 STEP 1: Advanced Linguistic Analysis on full text
+        logger.info("🔬 Running advanced linguistic analysis...")
+        linguistic_analysis = advanced_linguistic_analysis(text)
+        
         # Clean the content first
         cleaned_text = clean_content_for_analysis(text)
         
         if not cleaned_text or len(cleaned_text.split()) < 10:
             return {
                 "halves_analysis_available": False,
-                "reason": "Content too short after cleaning"
+                "reason": "Content too short after cleaning",
+                "linguistic_analysis": linguistic_analysis
             }
         
         # Split into halves
         first_half, second_half = split_content_in_half(cleaned_text)
         
+        # 🆕 STEP 2: Linguistic analysis on each half
+        logger.info("🔬 Analyzing first half linguistics...")
+        first_half_linguistic = advanced_linguistic_analysis(first_half)
+        
+        logger.info("🔬 Analyzing second half linguistics...")
+        second_half_linguistic = advanced_linguistic_analysis(second_half)
+        
         # Analyze first half using BOTH models (ensemble prediction)
         logger.info("🔍 Analyzing first half with both models...")
         first_half_result = model_manager.classify_text(first_half)
@@ -427,19 +697,48 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
         logger.info(f"✅ First half: {first_ai}% AI ({first_model}) | Second half: {second_ai}% AI ({second_model})")
         logger.info(f"📊 Models used per half: {models_used} | Agreement: {models_agree}")
         
-        # ===== FINAL DECISION LOGIC =====
+        # ===== FINAL DECISION LOGIC WITH LINGUISTIC ENHANCEMENT =====
         verdict = None
         confidence = None
         reasoning = None
+        accuracy_percentage = 0.0
+        
+        # Get linguistic scores
+        ling_ai = linguistic_analysis["linguistic_ai_score"]
+        ling_human = linguistic_analysis["linguistic_human_score"]
+        
+        # 🆕 Combine Model predictions + Linguistic analysis
+        # Weighted average: 70% model predictions, 30% linguistic analysis
+        combined_first_ai = (first_ai * 0.7) + (ling_ai * 0.3)
+        combined_second_ai = (second_ai * 0.7) + (ling_ai * 0.3)
+        combined_avg_ai = (avg_halves_ai_score * 0.7) + (ling_ai * 0.3)
         
+        # Calculate agreement between models and linguistic analysis
+        model_ling_agreement = abs(avg_halves_ai_score - ling_ai) < 20  # Within 20%
+        
+        # 🎯 Enhanced Decision Logic
         # Condition 1: Both halves < 50% AI AND second_half predicted_model is "human"
         if first_ai < 50 and second_ai < 50 and second_model.lower() == "human":
             verdict = "HUMAN"
-            confidence = "High" if variance_between_halves < 15 else "Medium"
+            
+            # Boost confidence if linguistic analysis agrees
+            if ling_human > ling_ai:
+                confidence = "Very High"
+                accuracy_percentage = 95 + min(5, human_errors["human_error_score"] * 2)
+            elif variance_between_halves < 15:
+                confidence = "High"
+                accuracy_percentage = 85 + min(10, human_errors["human_error_score"])
+            else:
+                confidence = "Medium"
+                accuracy_percentage = 75
+            
             reasoning = (
                 f"Both halves scored below 50% AI probability (First: {first_ai}%, Second: {second_ai}%) "
                 f"using ensemble prediction from {models_used} model(s). "
+                f"Linguistic analysis confirms with {ling_human:.1f}% human indicators. "
                 f"The second half was classified as human-written. "
+                f"Detected {human_errors['emotion_markers']} emotional markers and "
+                f"{human_errors['human_error_score']:.1f} human error patterns. "
                 f"Variance between halves is {variance_between_halves:.2f}%, indicating "
                 f"{'consistent human patterns' if variance_between_halves < 15 else 'some variation but still human-like'}. "
                 f"Model predictions {'agree' if models_agree else 'differ'} across halves."
@@ -449,69 +748,94 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
         elif first_ai > 50 and second_ai > 50 and second_model.lower() != "human":
             verdict = "AI"
             
-            # Determine confidence based on scores and model agreement
-            if first_ai > 80 and second_ai > 80:
+            # Determine confidence based on scores and linguistic agreement
+            if first_ai > 80 and second_ai > 80 and model_ling_agreement:
                 confidence = "Very High"
+                accuracy_percentage = 95 + min(5, (first_ai + second_ai) / 40)
+            elif first_ai > 70 and second_ai > 70 and model_ling_agreement:
+                confidence = "High"
+                accuracy_percentage = 85 + min(10, (first_ai + second_ai) / 50)
             elif first_ai > 70 and second_ai > 70:
                 confidence = "High"
+                accuracy_percentage = 80
             else:
                 confidence = "Medium"
+                accuracy_percentage = 70
             
-            # Boost confidence if models agree
-            if models_agree and confidence != "Very High":
-                confidence_levels = ["Low", "Medium", "High", "Very High"]
-                current_idx = confidence_levels.index(confidence)
-                if current_idx < len(confidence_levels) - 1:
-                    confidence = f"{confidence} (boosted by model agreement)"
+            # Boost confidence if models agree and linguistic analysis confirms
+            if models_agree and model_ling_agreement:
+                if confidence == "High":
+                    confidence = "Very High"
+                    accuracy_percentage = min(99, accuracy_percentage + 10)
+                elif confidence == "Medium":
+                    confidence = "High"
+                    accuracy_percentage = min(95, accuracy_percentage + 10)
             
             reasoning = (
                 f"Both halves scored above 50% AI probability (First: {first_ai}%, Second: {second_ai}%) "
                 f"using ensemble prediction from {models_used} model(s). "
-                f"The pattern matches {second_model} outputs. "
+                f"Linguistic analysis confirms with {ling_ai:.1f}% AI indicators. "
+                f"Detected high formality score ({vocabulary['formality_score']:.2f}) and "
+                f"low burstiness ({burstiness:.2f}), typical of AI generation. "
+                f"Pattern matches {second_model} outputs. "
                 f"First half suggests {first_model} while second half suggests {second_model}. "
                 f"Variance between halves is {variance_between_halves:.2f}%, "
                 f"{'showing consistent AI patterns throughout' if variance_between_halves < 20 else 'with some variation in AI generation style'}. "
-                f"{'Both halves agree on the AI model type, strengthening confidence' if models_agree else 'Different AI models detected in each half'}."
+                f"{'Both halves agree on the AI model type, strengthening confidence' if models_agree else 'Different AI models detected in each half'}. "
+                f"Model-linguistic agreement: {'Yes' if model_ling_agreement else 'Partial'}."
             )
         
         # Condition 3: Mixed results - one half AI, one half human
         elif (first_ai > 50 and second_ai < 50) or (first_ai < 50 and second_ai > 50):
             verdict = "MIXED"
-            confidence = "Low"
+            confidence = "Medium" if abs(first_ai - second_ai) > 30 else "Low"
+            accuracy_percentage = 70 + min(15, variance_between_halves / 3)
+            
             reasoning = (
                 f"Mixed signals detected using {models_used} model(s) for ensemble prediction. "
                 f"First half: {first_ai}% AI ({first_model}), Second half: {second_ai}% AI ({second_model}). "
+                f"Linguistic analysis shows {ling_ai:.1f}% AI indicators overall. "
                 f"One portion appears AI-generated while the other seems human-written. "
                 f"This could indicate: partial AI assistance, human editing of AI content, "
-                f"or AI completion of human-started text. High variance of {variance_between_halves:.2f}% supports mixed authorship."
+                f"or AI completion of human-started text. High variance of {variance_between_halves:.2f}% supports mixed authorship. "
+                f"Burstiness score of {burstiness:.2f} suggests irregular patterns."
             )
         
         # Condition 4: Both around 50% - uncertain
         else:
             # Check if second_model is human but scores are borderline
-            if second_model.lower() == "human":
+            if second_model.lower() == "human" or ling_human > ling_ai:
                 verdict = "LIKELY_HUMAN"
-                confidence = "Low"
+                confidence = "Medium" if ling_human - ling_ai > 10 else "Low"
+                accuracy_percentage = 60 + min(15, abs(ling_human - ling_ai))
+                
                 reasoning = (
                     f"Borderline case with scores near 50% threshold (First: {first_ai}%, Second: {second_ai}%) "
                     f"analyzed using {models_used} model(s). "
+                    f"Linguistic analysis leans toward human ({ling_human:.1f}% vs {ling_ai:.1f}% AI). "
                     f"Second half classified as human-written. The text shows characteristics of both "
-                    f"human and AI writing. Variance: {variance_between_halves:.2f}%."
+                    f"human and AI writing. Variance: {variance_between_halves:.2f}%. "
+                    f"Human error score: {human_errors['human_error_score']:.2f}."
                 )
             else:
                 verdict = "LIKELY_AI"
-                confidence = "Low"
+                confidence = "Medium" if ling_ai - ling_human > 10 else "Low"
+                accuracy_percentage = 60 + min(15, abs(ling_ai - ling_human))
+                
                 reasoning = (
                     f"Borderline case with scores near 50% threshold (First: {first_ai}%, Second: {second_ai}%) "
                     f"analyzed using {models_used} model(s). "
+                    f"Linguistic analysis leans toward AI ({ling_ai:.1f}% vs {ling_human:.1f}% human). "
                     f"Pattern suggests {second_model} but confidence is low. "
-                    f"Variance: {variance_between_halves:.2f}%."
+                    f"Variance: {variance_between_halves:.2f}%. "
+                    f"Formality score: {vocabulary['formality_score']:.2f}."
                 )
         
-        # Prepare final decision structure with enhanced model information
+        # Prepare final decision structure with enhanced model and linguistic information
         final_decision = {
             "verdict": verdict,
             "confidence": confidence,
+            "accuracy_percentage": round(accuracy_percentage, 1),
             "reasoning": reasoning,
             "supporting_data": {
                 "overall_ai_prob": round(overall_ai_prob, 3),
@@ -523,7 +847,12 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
                 "second_half_model": second_model,
                 "models_agree": models_agree,
                 "ensemble_models_used": models_used,
-                "ensemble_confidence": ensemble_confidence_boost
+                "ensemble_confidence": ensemble_confidence_boost,
+                # 🆕 Linguistic analysis scores
+                "linguistic_ai_score": ling_ai,
+                "linguistic_human_score": ling_human,
+                "model_linguistic_agreement": model_ling_agreement,
+                "combined_ai_score": round(combined_avg_ai, 2)
             }
         }
         
@@ -541,7 +870,8 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
                 "word_count": first_half_words,
                 "preview": first_half[:200] + "..." if len(first_half) > 200 else first_half,
                 "top_5_predictions": first_top5,
-                "models_used": models_used
+                "models_used": models_used,
+                "linguistic_analysis": first_half_linguistic  # 🆕 Linguistic analysis for first half
             },
             "second_half": {
                 "ai_percentage": second_ai,
@@ -550,9 +880,11 @@ def analyze_content_halves(model_manager, text: str, overall_result: Dict = None
                 "word_count": second_half_words,
                 "preview": second_half[:200] + "..." if len(second_half) > 200 else second_half,
                 "top_5_predictions": second_top5,
-                "models_used": models_used
+                "models_used": models_used,
+                "linguistic_analysis": second_half_linguistic  # 🆕 Linguistic analysis for second half
             },
-            "final_decision": final_decision
+            "final_decision": final_decision,
+            "overall_linguistic_analysis": linguistic_analysis  # 🆕 Overall linguistic analysis
         }
         
     except Exception as e:
@@ -822,4 +1154,4 @@ if __name__ == "__main__":
         port=port,
         workers=workers,
         reload=False  # Set to True for dev
-    )
+    )