Update app.py

app.py

@@ -10,11 +10,6 @@ import gradio as gr
 from fastapi.middleware.cors import CORSMiddleware
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
-import time
-import csv
-from datetime import datetime
-import threading
-import random
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -29,160 +24,6 @@ CONFIDENCE_THRESHOLD = 0.65
 BATCH_SIZE = 8  # Reduced batch size for CPU
 MAX_WORKERS = 4  # Number of worker threads for processing
 
-class CSVLogger:
-    def __init__(self, log_dir="."):
-        """Initialize the CSV logger.
-        
-        Args:
-            log_dir: Directory to store CSV log files
-        """
-        self.log_dir = log_dir
-        os.makedirs(log_dir, exist_ok=True)
-        
-        # Create monthly CSV files
-        current_month = datetime.now().strftime('%Y-%m')
-        self.metrics_path = os.path.join(log_dir, f"metrics_{current_month}.csv")
-        self.text_path = os.path.join(log_dir, f"text_data_{current_month}.csv")
-        
-        # Define headers
-        self.metrics_headers = [
-            'entry_id', 'timestamp', 'word_count', 'mode', 'prediction', 
-            'confidence', 'prediction_time_seconds', 'num_sentences'
-        ]
-        
-        self.text_headers = ['entry_id', 'timestamp', 'text']
-        
-        # Initialize the files if they don't exist
-        self._initialize_files()
-        
-        # Create locks for thread safety
-        self.metrics_lock = threading.Lock()
-        self.text_lock = threading.Lock()
-        
-        print(f"CSV logger initialized with files at: {os.path.abspath(self.metrics_path)}")
-    
-    def _initialize_files(self):
-        """Create the CSV files with headers if they don't exist."""
-        # Initialize metrics file
-        if not os.path.exists(self.metrics_path):
-            with open(self.metrics_path, 'w', newline='') as f:
-                writer = csv.writer(f)
-                writer.writerow(self.metrics_headers)
-        
-        # Initialize text data file
-        if not os.path.exists(self.text_path):
-            with open(self.text_path, 'w', newline='') as f:
-                writer = csv.writer(f)
-                writer.writerow(self.text_headers)
-    
-    def log_prediction(self, prediction_data, store_text=True):
-        """Log prediction data to CSV files.
-        
-        Args:
-            prediction_data: Dictionary containing prediction metrics
-            store_text: Whether to store the full text
-        """
-        # Generate a unique entry ID
-        entry_id = f"{datetime.now().strftime('%Y%m%d%H%M%S')}_{random.randint(1000, 9999)}"
-        
-        # Extract text if present
-        text = prediction_data.pop('text', None) if store_text else None
-        
-        # Ensure timestamp is present
-        if 'timestamp' not in prediction_data:
-            prediction_data['timestamp'] = datetime.now().isoformat()
-        
-        # Add entry_id to metrics data
-        metrics_data = prediction_data.copy()
-        metrics_data['entry_id'] = entry_id
-        
-        # Start a thread to write data
-        thread = threading.Thread(
-            target=self._write_to_csv,
-            args=(metrics_data, text, entry_id, store_text)
-        )
-        thread.daemon = True
-        thread.start()
-    
-    def _write_to_csv(self, metrics_data, text, entry_id, store_text):
-        """Write data to CSV files with retry mechanism."""
-        max_retries = 5
-        retry_delay = 0.5
-        
-        # Write metrics data
-        for attempt in range(max_retries):
-            try:
-                with self.metrics_lock:
-                    with open(self.metrics_path, 'a', newline='') as f:
-                        writer = csv.writer(f)
-                        # Prepare row in the correct order based on headers
-                        row = [
-                            metrics_data.get('entry_id', ''),
-                            metrics_data.get('timestamp', ''),
-                            metrics_data.get('word_count', 0),
-                            metrics_data.get('mode', ''),
-                            metrics_data.get('prediction', ''),
-                            metrics_data.get('confidence', 0.0),
-                            metrics_data.get('prediction_time_seconds', 0.0),
-                            metrics_data.get('num_sentences', 0)
-                        ]
-                        writer.writerow(row)
-                    print(f"Successfully wrote metrics to CSV, entry_id: {entry_id}")
-                    break
-            except Exception as e:
-                print(f"Error writing metrics to CSV (attempt {attempt+1}/{max_retries}): {e}")
-                time.sleep(retry_delay * (attempt + 1))
-        else:
-            # If all retries fail, write to backup file
-            backup_path = os.path.join(self.log_dir, f"metrics_backup_{datetime.now().strftime('%Y%m%d%H%M%S')}.csv")
-            try:
-                with open(backup_path, 'w', newline='') as f:
-                    writer = csv.writer(f)
-                    writer.writerow(self.metrics_headers)
-                    row = [
-                        metrics_data.get('entry_id', ''),
-                        metrics_data.get('timestamp', ''),
-                        metrics_data.get('word_count', 0),
-                        metrics_data.get('mode', ''),
-                        metrics_data.get('prediction', ''),
-                        metrics_data.get('confidence', 0.0),
-                        metrics_data.get('prediction_time_seconds', 0.0),
-                        metrics_data.get('num_sentences', 0)
-                    ]
-                    writer.writerow(row)
-                print(f"Wrote metrics backup to {backup_path}")
-            except Exception as e:
-                print(f"Error writing metrics backup: {e}")
-        
-        # Write text data if requested
-        if store_text and text:
-            for attempt in range(max_retries):
-                try:
-                    with self.text_lock:
-                        with open(self.text_path, 'a', newline='') as f:
-                            writer = csv.writer(f)
-                            # Handle potential newlines in text by replacing them
-                            safe_text = text.replace('\n', ' ').replace('\r', ' ') if text else ''
-                            writer.writerow([entry_id, metrics_data.get('timestamp', ''), safe_text])
-                        print(f"Successfully wrote text data to CSV, entry_id: {entry_id}")
-                        break
-                except Exception as e:
-                    print(f"Error writing text data to CSV (attempt {attempt+1}/{max_retries}): {e}")
-                    time.sleep(retry_delay * (attempt + 1))
-            else:
-                # If all retries fail, write to backup file
-                backup_path = os.path.join(self.log_dir, f"text_backup_{datetime.now().strftime('%Y%m%d%H%M%S')}.csv")
-                try:
-                    with open(backup_path, 'w', newline='') as f:
-                        writer = csv.writer(f)
-                        writer.writerow(self.text_headers)
-                        safe_text = text.replace('\n', ' ').replace('\r', ' ') if text else ''
-                        writer.writerow([entry_id, metrics_data.get('timestamp', ''), safe_text])
-                    print(f"Wrote text data backup to {backup_path}")
-                except Exception as e:
-                    print(f"Error writing text data backup: {e}")
-
-
 class TextWindowProcessor:
     def __init__(self):
         try:
@@ -335,6 +176,100 @@ class TextClassifier:
             'num_windows': len(predictions)
         }
 
+    # def detailed_scan(self, text: str) -> Dict:
+    #     """Original prediction method with modified window handling"""
+    #     if self.model is None or self.tokenizer is None:
+    #         self.load_model()
+
+    #     self.model.eval()
+    #     sentences = self.processor.split_into_sentences(text)
+    #     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
+    #     batch_size = 16
+    #     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]
+
+    #         inputs = self.tokenizer(
+    #             batch_windows,
+    #             truncation=True,
+    #             padding=True,
+    #             max_length=MAX_LENGTH,
+    #             return_tensors="pt"
+    #         ).to(self.device)
+
+    #         with torch.no_grad():
+    #             outputs = self.model(**inputs)
+    #             probs = F.softmax(outputs.logits, dim=-1)
+
+    #             # Attribute predictions more carefully
+    #             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
+
+    #                 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()
+
+    #         del inputs, outputs, probs
+    #         if torch.cuda.is_available():
+    #             torch.cuda.empty_cache()
+
+    #     # Calculate final predictions
+    #     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]
+
+    #             # Only 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)
+    #                     ai_prob = (ai_prob * (1 - smooth_factor) + 
+    #                             (prev_ai + next_ai) * smooth_factor / 2)
+
+    #             sentence_predictions.append({
+    #                 'sentence': sentences[i],
+    #                 'human_prob': human_prob,
+    #                 'ai_prob': ai_prob,
+    #                 'prediction': 'human' if human_prob > ai_prob else 'ai',
+    #                 'confidence': max(human_prob, ai_prob)
+    #             })
+
+    #     return {
+    #         'sentence_predictions': sentence_predictions,
+    #         'highlighted_text': self.format_predictions_html(sentence_predictions),
+    #         'full_text': text,
+    #         'overall_prediction': self.aggregate_predictions(sentence_predictions)
+    #     }
+
     def detailed_scan(self, text: str) -> Dict:
         """Perform a detailed scan with improved sentence-level analysis."""
         # Clean up trailing whitespace
@@ -485,23 +420,8 @@ class TextClassifier:
             'num_sentences': num_sentences
         }
 
-# Initialize the logger
-csv_logger = CSVLogger(log_dir=".")
-
-# Add file listing endpoint for debugging
-def list_files():
-    """List all files in the current directory and subdirectories."""
-    all_files = []
-    for root, dirs, files in os.walk('.'):
-        for file in files:
-            all_files.append(os.path.join(root, file))
-    return all_files
-
 def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
     """Analyze text using specified mode and return formatted results."""
-    # Start timing the prediction
-    start_time = time.time()
-    
     # Count words in the text
     word_count = len(text.split())
     
@@ -512,58 +432,31 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
     
     if mode == "quick":
         result = classifier.quick_scan(text)
-        prediction = result['prediction']
-        confidence = result['confidence']
-        num_windows = result['num_windows']
         
         quick_analysis = f"""
-        PREDICTION: {prediction.upper()}
-        Confidence: {confidence*100:.1f}%
-        Windows analyzed: {num_windows}
+        PREDICTION: {result['prediction'].upper()}
+        Confidence: {result['confidence']*100:.1f}%
+        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."
         
-        output = (
+        return (
             text,  # No highlighting in quick mode
             "Quick scan mode - no sentence-level analysis available",
             quick_analysis
         )
-        
-        # End timing
-        end_time = time.time()
-        prediction_time = end_time - start_time
-        
-        # Log the data
-        log_data = {
-            "timestamp": datetime.now().isoformat(),
-            "word_count": word_count,
-            "mode": mode,
-            "prediction": prediction,
-            "confidence": confidence,
-            "prediction_time_seconds": prediction_time,
-            "num_sentences": 0,  # No sentence analysis in quick mode
-            "text": text
-        }
-        
-        # Log to CSV
-        print(f"Logging prediction data: word_count={word_count}, mode={mode}, prediction={prediction}")
-        csv_logger.log_prediction(log_data)
-        
     else:
         analysis = classifier.detailed_scan(text)
-        prediction = analysis['overall_prediction']['prediction']
-        confidence = analysis['overall_prediction']['confidence']
-        num_sentences = analysis['overall_prediction']['num_sentences']
         
         detailed_analysis = []
         for pred in analysis['sentence_predictions']:
-            pred_confidence = pred['confidence'] * 100
+            confidence = pred['confidence'] * 100
             detailed_analysis.append(f"Sentence: {pred['sentence']}")
             detailed_analysis.append(f"Prediction: {pred['prediction'].upper()}")
-            detailed_analysis.append(f"Confidence: {pred_confidence:.1f}%")
+            detailed_analysis.append(f"Confidence: {confidence:.1f}%")
             detailed_analysis.append("-" * 50)
         
         final_pred = analysis['overall_prediction']
@@ -573,33 +466,11 @@ def analyze_text(text: str, mode: str, classifier: TextClassifier) -> tuple:
         Number of sentences analyzed: {final_pred['num_sentences']}
         """
         
-        output = (
+        return (
             analysis['highlighted_text'],
             "\n".join(detailed_analysis),
             overall_result
         )
-        
-        # End timing
-        end_time = time.time()
-        prediction_time = end_time - start_time
-        
-        # Log the data
-        log_data = {
-            "timestamp": datetime.now().isoformat(),
-            "word_count": word_count,
-            "mode": mode,
-            "prediction": prediction,
-            "confidence": confidence,
-            "prediction_time_seconds": prediction_time,
-            "num_sentences": num_sentences,
-            "text": text
-        }
-        
-        # Log to CSV
-        print(f"Logging prediction data: word_count={word_count}, mode={mode}, prediction={prediction}")
-        csv_logger.log_prediction(log_data)
-    
-    return output
 
 # Initialize the classifier globally
 classifier = TextClassifier()
@@ -626,7 +497,7 @@ demo = gr.Interface(
         gr.Textbox(label="Overall Result", lines=4)
     ],
     title="AI Text Detector",
-    description="Analyze text to detect if it was written by a human or AI. Choose between quick scan and detailed sentence-level analysis. 200+ words suggested for accurate predictions. Note: For testing purposes, text and analysis data will be recorded.",
+    description="Analyze text to detect if it was written by a human or AI. Choose between quick scan and detailed sentence-level analysis. 200+ words suggested for accurate predictions.",
     api_name="predict",
     flagging_mode="never"
 )
@@ -640,26 +511,8 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Add file listing endpoint for debugging
-@app.get("/list_files")
-async def get_files():
-    return {"files": list_files()}
-
 # Ensure CORS is applied before launching
 if __name__ == "__main__":
-    # Create empty CSV files if they don't exist
-    current_month = datetime.now().strftime('%Y-%m')
-    metrics_path = f"metrics_{current_month}.csv"
-    text_path = f"text_data_{current_month}.csv"
-    
-    print(f"Current directory: {os.getcwd()}")
-    print(f"Looking for CSV files: {metrics_path}, {text_path}")
-    
-    if not os.path.exists(metrics_path):
-        print(f"Creating metrics CSV file: {metrics_path}")
-    if not os.path.exists(text_path):
-        print(f"Creating text data CSV file: {text_path}")
-    
     demo.queue()
     demo.launch(
         server_name="0.0.0.0",