Update app.py

app.py

@@ -1,35 +1,45 @@
 import streamlit as st
 from faster_whisper import WhisperModel
 from transformers import pipeline
-import numpy as np
 from pydub import AudioSegment
-from textblob import TextBlob
+import numpy as np
 
+@st.cache_resource
 def initialize_model():
     """Initialize the Whisper model and AI detection pipeline."""
-    if "model" not in st.session_state:
-        st.session_state.model = WhisperModel("small", device="cpu", compute_type="int8")
-    if "ai_detector" not in st.session_state:
-        st.session_state.ai_detector = pipeline("text-classification", model="roberta-base-openai-detector")
+    model = WhisperModel("medium", device="cpu", compute_type="int8")
+    ai_detector = pipeline("text-classification", model="roberta-base-openai-detector")
+    return model, ai_detector
 
-def process_uploaded_audio(uploaded_file, model):
-    """Process uploaded audio file for transcription."""
-    # Convert uploaded file to a WAV file
+def preprocess_audio(uploaded_file):
+    """Preprocess uploaded audio file for transcription."""
     audio = AudioSegment.from_file(uploaded_file)
-    audio = audio.set_frame_rate(16000).set_channels(1)
+    audio = audio.set_frame_rate(16000).set_channels(1).normalize()
     samples = np.array(audio.get_array_of_samples(), dtype=np.float32) / 32768.0
+    return samples
 
-    # Perform transcription
-    segments, _ = model.transcribe(samples, language="en", vad_filter=True)
+def transcribe_audio(samples, model):
+    """Transcribe audio using Whisper."""
+    segments, _ = model.transcribe(samples, language="en", vad_filter=True, beam_size=3)
     return [segment.text for segment in segments]
 
-def advanced_ai_detection(text, ai_detector):
-    """Perform AI detection on transcribed text."""
+def combine_sentences(transcriptions, group_size=3):
+    """Combine 2-3 sentences into a single chunk."""
+    combined = []
+    for i in range(0, len(transcriptions), group_size):
+        chunk = " ".join(transcriptions[i:i + group_size])
+        combined.append(chunk)
+    return combined
+
+def ai_detection(text, ai_detector):
+    """Perform AI detection on combined text."""
     if len(text.split()) < 5:
         return {"classification": "Insufficient Data", "probability": 0.0, "confidence": "Low"}
+
     result = ai_detector(text)[0]
+    label = "Human" if result["label"] == "Real" else "AI"  # Map labels
     return {
-        "classification": result["label"],
+        "classification": label,
         "probability": result["score"],
         "confidence": "High" if result["score"] > 0.7 else "Medium" if result["score"] > 0.5 else "Low"
     }
@@ -43,8 +53,8 @@ def run_app():
     Supported audio formats: **.wav**, **.mp3**.
     """)
 
-    # Initialize models
-    initialize_model()
+    # Load models
+    model, ai_detector = initialize_model()
 
     # File uploader
     uploaded_file = st.file_uploader("Upload an audio file", type=["wav", "mp3"])
@@ -52,15 +62,19 @@ def run_app():
     if uploaded_file:
         st.info("Processing audio... Please wait.")
         try:
-            # Transcription
-            transcription = process_uploaded_audio(uploaded_file, st.session_state.model)
-            full_transcript = "\n".join(transcription)
+            # Preprocess and transcribe
+            samples = preprocess_audio(uploaded_file)
+            transcription = transcribe_audio(samples, model)
+            
+            # Combine sentences
+            combined_transcription = combine_sentences(transcription, group_size=3)
+            full_transcript = "\n".join(combined_transcription)
             st.text_area("Transcription", value=full_transcript, height=300)
 
-            # AI Detection
+            # AI Detection on combined sentences
             st.subheader("AI Detection Results")
-            for text in transcription:
-                detection_result = advanced_ai_detection(text, st.session_state.ai_detector)
+            for text in combined_transcription:
+                detection_result = ai_detection(text, ai_detector)
                 st.write(f"**Text:** {text}")
                 st.write(f"- **Classification:** {detection_result['classification']}")
                 st.write(f"- **Probability:** {detection_result['probability']:.2f}")