Update app.py

app.py

@@ -13,18 +13,18 @@ from functools import partial
 import time
 from datetime import datetime
 
-# Configure logging
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Constants
+
 MAX_LENGTH = 512
 MODEL_NAME = "microsoft/deberta-v3-small"
 WINDOW_SIZE = 6
 WINDOW_OVERLAP = 2
 CONFIDENCE_THRESHOLD = 0.65
-BATCH_SIZE = 8  # Reduced batch size for CPU
-MAX_WORKERS = 4  # Number of worker threads for processing
+BATCH_SIZE = 8  
+MAX_WORKERS = 4  
 
 class TextWindowProcessor:
     def __init__(self):
@@ -41,7 +41,7 @@ class TextWindowProcessor:
         disabled_pipes = [pipe for pipe in self.nlp.pipe_names if pipe != 'sentencizer']
         self.nlp.disable_pipes(*disabled_pipes)
         
-        # Initialize thread pool for parallel processing
+        
         self.executor = ThreadPoolExecutor(max_workers=MAX_WORKERS)
 
     def split_into_sentences(self, text: str) -> List[str]:
@@ -60,17 +60,16 @@ class TextWindowProcessor:
         return windows
 
     def create_centered_windows(self, sentences: List[str], window_size: int) -> Tuple[List[str], List[List[int]]]:
-        """Create windows with better boundary handling"""
         windows = []
         window_sentence_indices = []
 
         for i in range(len(sentences)):
-            # Calculate window boundaries centered on current sentence
+            
             half_window = window_size // 2
             start_idx = max(0, i - half_window)
             end_idx = min(len(sentences), i + half_window + 1)
 
-            # Create the window
+            
             window = sentences[start_idx:end_idx]
             windows.append(" ".join(window))
             window_sentence_indices.append(list(range(start_idx, end_idx)))
@@ -79,7 +78,7 @@ class TextWindowProcessor:
 
 class TextClassifier:
     def __init__(self):
-        # Set thread configuration before any model loading or parallel work
+        
         if not torch.cuda.is_available():
             torch.set_num_threads(MAX_WORKERS)
             torch.set_num_interop_threads(MAX_WORKERS)
@@ -119,7 +118,6 @@ class TextClassifier:
         self.model.eval()
 
     def quick_scan(self, text: str) -> Dict:
-        """Perform a quick scan using simple window analysis."""
         if not text.strip():
             return {
                 'prediction': 'unknown',
@@ -132,7 +130,7 @@ class TextClassifier:
 
         predictions = []
         
-        # Process windows in smaller batches for CPU efficiency
+        
         for i in range(0, len(windows), BATCH_SIZE):
             batch_windows = windows[i:i + BATCH_SIZE]
 
@@ -157,7 +155,7 @@ class TextClassifier:
                     }
                     predictions.append(prediction)
 
-            # Clean up GPU memory if available
+            
             del inputs, outputs, probs
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
@@ -179,8 +177,7 @@ class TextClassifier:
         }
 
     def detailed_scan(self, text: str) -> Dict:
-        """Perform a detailed scan with improved sentence-level analysis."""
-        # Clean up trailing whitespace
+        
         text = text.rstrip()
         
         if not text.strip():
@@ -199,14 +196,14 @@ class TextClassifier:
         if not sentences:
             return {}
 
-        # Create centered windows for each sentence
+        
         windows, window_sentence_indices = self.processor.create_centered_windows(sentences, WINDOW_SIZE)
 
-        # Track scores for each sentence
+        
         sentence_appearances = {i: 0 for i in range(len(sentences))}
         sentence_scores = {i: {'human_prob': 0.0, 'ai_prob': 0.0} for i in range(len(sentences))}
 
-        # Process windows in batches
+        
         for i in range(0, len(windows), BATCH_SIZE):
             batch_windows = windows[i:i + BATCH_SIZE]
             batch_indices = window_sentence_indices[i:i + BATCH_SIZE]
@@ -223,45 +220,45 @@ class TextClassifier:
                 outputs = self.model(**inputs)
                 probs = F.softmax(outputs.logits, dim=-1)
 
-                # Attribute predictions with weighted scoring
+                
                 for window_idx, indices in enumerate(batch_indices):
                     center_idx = len(indices) // 2
-                    center_weight = 0.7  # Higher weight for center sentence
-                    edge_weight = 0.3 / (len(indices) - 1)  # Distribute remaining weight
+                    center_weight = 0.7  
+                    edge_weight = 0.3 / (len(indices) - 1)  
 
                     for pos, sent_idx in enumerate(indices):
-                        # Apply higher weight to center sentence
+                        
                         weight = center_weight if pos == center_idx else edge_weight
                         sentence_appearances[sent_idx] += weight
                         sentence_scores[sent_idx]['human_prob'] += weight * probs[window_idx][1].item()
                         sentence_scores[sent_idx]['ai_prob'] += weight * probs[window_idx][0].item()
 
-            # Clean up memory
+            
             del inputs, outputs, probs
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
 
-        # Calculate final predictions with boundary smoothing
+        
         sentence_predictions = []
         for i in range(len(sentences)):
             if sentence_appearances[i] > 0:
                 human_prob = sentence_scores[i]['human_prob'] / sentence_appearances[i]
                 ai_prob = sentence_scores[i]['ai_prob'] / sentence_appearances[i]
 
-                # Apply minimal smoothing at prediction boundaries
+                
                 if i > 0 and i < len(sentences) - 1:
                     prev_human = sentence_scores[i-1]['human_prob'] / sentence_appearances[i-1]
                     prev_ai = sentence_scores[i-1]['ai_prob'] / sentence_appearances[i-1]
                     next_human = sentence_scores[i+1]['human_prob'] / sentence_appearances[i+1]
                     next_ai = sentence_scores[i+1]['ai_prob'] / sentence_appearances[i+1]
 
-                    # Check if we're at a prediction boundary
+                    
                     current_pred = 'human' if human_prob > ai_prob else 'ai'
                     prev_pred = 'human' if prev_human > prev_ai else 'ai'
                     next_pred = 'human' if next_human > next_ai else 'ai'
 
                     if current_pred != prev_pred or current_pred != next_pred:
-                        # Small adjustment at boundaries
+                        
                         smooth_factor = 0.1
                         human_prob = (human_prob * (1 - smooth_factor) + 
                                     (prev_human + next_human) * smooth_factor / 2)
@@ -284,7 +281,6 @@ class TextClassifier:
         }
 
     def format_predictions_html(self, sentence_predictions: List[Dict]) -> str:
-        """Format predictions as HTML with color-coding."""
         html_parts = []
         
         for pred in sentence_predictions:
@@ -293,21 +289,20 @@ class TextClassifier:
             
             if confidence >= CONFIDENCE_THRESHOLD:
                 if pred['prediction'] == 'human':
-                    color = "#90EE90"  # Light green
+                    color = "
                 else:
-                    color = "#FFB6C6"  # Light red
+                    color = "
             else:
                 if pred['prediction'] == 'human':
-                    color = "#E8F5E9"  # Very light green
+                    color = "
                 else:
-                    color = "#FFEBEE"  # Very light red
+                    color = "
                     
             html_parts.append(f'<span style="background-color: {color};">{sentence}</span>')
             
         return " ".join(html_parts)
 
     def aggregate_predictions(self, predictions: List[Dict]) -> Dict:
-        """Aggregate predictions from multiple sentences into a single prediction."""
         if not predictions:
             return {
                 'prediction': 'unknown',
@@ -329,14 +324,13 @@ class TextClassifier:
         }
 
 def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
-    """Analyze text using specified mode and return formatted results."""
-    # Start timing for normal analysis
+    
     start_time = time.time()
     
-    # Count words in the text
+    
     word_count = len(text.split())
     
-    # If text is less than 200 words and detailed mode is selected, switch to quick mode
+    
     original_mode = mode
     if word_count < 200 and mode == "detailed":
         mode = "quick"
@@ -350,15 +344,15 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
         Windows analyzed: {result['num_windows']}
         """
         
-        # Add note if mode was switched
+        
         if original_mode == "detailed":
             quick_analysis += f"\n\nNote: Switched to quick mode because text contains only {word_count} words. Minimum 200 words required for detailed analysis."
         
-        # Calculate execution time in milliseconds
+        
         execution_time = (time.time() - start_time) * 1000
         
         return (
-            text,  # No highlighting in quick mode
+            text,  
             "Quick scan mode - no sentence-level analysis available",
             quick_analysis
         )
@@ -380,7 +374,7 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
         Number of sentences analyzed: {final_pred['num_sentences']}
         """
         
-        # Calculate execution time in milliseconds
+        
         execution_time = (time.time() - start_time) * 1000
         
         return (
@@ -389,10 +383,10 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
             overall_result
         )
 
-# Initialize the classifier globally
+
 classifier = TextClassifier()
 
-# Create Gradio interface
+
 demo = gr.Interface(
     fn=lambda text, mode: analyze_text(text, mode, classifier),
     inputs=[
@@ -419,19 +413,17 @@ demo = gr.Interface(
     flagging_mode="never"
 )
 
-# Get the FastAPI app from Gradio
+
 app = demo.app
 
-# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # For development
+    allow_origins=["*"],  
     allow_credentials=True,
     allow_methods=["GET", "POST", "OPTIONS"],
     allow_headers=["*"],
 )
 
-# Ensure CORS is applied before launching
 if __name__ == "__main__":
     demo.queue()
     demo.launch(