Update app.py

app.py

@@ -1,103 +1,73 @@
 import streamlit as st
 from faster_whisper import WhisperModel
 from transformers import pipeline
-from textblob import TextBlob
 import numpy as np
-import queue
-import threading
-import time
-
-# Initialize shared state
-audio_queue = queue.Queue()
-transcription_results = []
-ai_detection_results = []
-
-# Global stop event for threads
-stop_event = threading.Event()
+from pydub import AudioSegment
+from textblob import TextBlob
 
 def initialize_model():
-    """Initialize Whisper model and AI detectors."""
-    try:
+    """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")
-        st.session_state.ai_detector = pipeline('text-classification', model='roberta-base-openai-detector')
-    except Exception as e:
-        st.error(f"Error initializing models: {str(e)}")
+    if "ai_detector" not in st.session_state:
+        st.session_state.ai_detector = pipeline("text-classification", model="roberta-base-openai-detector")
+
+def process_uploaded_audio(uploaded_file, model):
+    """Process uploaded audio file for transcription."""
+    # Convert uploaded file to a WAV file
+    audio = AudioSegment.from_file(uploaded_file)
+    audio = audio.set_frame_rate(16000).set_channels(1)
+    samples = np.array(audio.get_array_of_samples(), dtype=np.float32) / 32768.0
+
+    # Perform transcription
+    segments, _ = model.transcribe(samples, language="en", vad_filter=True)
+    return [segment.text for segment in segments]
 
 def advanced_ai_detection(text, ai_detector):
-    """Perform AI detection on the text."""
-    if len(text.split()) < 5:  # Skip short texts
-        return "Insufficient Data"
-
+    """Perform AI detection on transcribed text."""
+    if len(text.split()) < 5:
+        return {"classification": "Insufficient Data", "probability": 0.0, "confidence": "Low"}
     result = ai_detector(text)[0]
-    return result
-
-def analyze_text_linguistics(text):
-    """Perform linguistic analysis on the text."""
-    blob = TextBlob(text)
     return {
-        "sentiment": blob.sentiment.polarity,
-        "subjectivity": blob.sentiment.subjectivity
+        "classification": result["label"],
+        "probability": result["score"],
+        "confidence": "High" if result["score"] > 0.7 else "Medium" if result["score"] > 0.5 else "Low"
     }
 
-def transcribe_audio(audio_chunk, model):
-    """Transcribe audio using the Whisper model."""
-    segments, _ = model.transcribe(audio_chunk, language="en")
-    return [segment.text for segment in segments]
-
 def run_app():
-    """Main Streamlit app function."""
+    """Main Streamlit app."""
     st.title("AI Speech Detector")
-    st.subheader("Real-Time Speech Transcription and AI Detection")
-    st.text("This app transcribes audio input and detects if the text is AI-generated.")
+    st.subheader("Upload an audio file for transcription and AI analysis.")
+    st.markdown("""
+    This app uses the Whisper model for speech-to-text transcription and AI detection to classify the text. 
+    Supported audio formats: **.wav**, **.mp3**.
+    """)
 
-    # Sidebar for controls
-    st.sidebar.title("Controls")
-    start_button = st.sidebar.button("Start Recording")
-    stop_button = st.sidebar.button("Stop Recording")
+    # Initialize models
+    initialize_model()
 
-    if "model" not in st.session_state:
-        st.text("Loading AI models...")
-        initialize_model()
-        st.text("Models loaded successfully!")
-
-    # Display transcript
-    st.text_area("Real-Time Transcript", height=200, key="transcript")
-
-    # Display AI detection results
-    st.text_area("AI Detection Results", height=200, key="ai_detection")
-
-    if start_button:
-        st.session_state.is_recording = True
-        threading.Thread(target=process_audio_stream).start()
-
-    if stop_button:
-        st.session_state.is_recording = False
-        stop_event.set()
+    # File uploader
+    uploaded_file = st.file_uploader("Upload an audio file", type=["wav", "mp3"])
 
-def process_audio_stream():
-    """Simulated audio capture and processing."""
-    model = st.session_state.model
-    ai_detector = st.session_state.ai_detector
-
-    while not stop_event.is_set():
+    if uploaded_file:
+        st.info("Processing audio... Please wait.")
         try:
-            # Simulate real-time audio input
-            fake_audio_chunk = np.random.rand(16000 * 3).astype(np.float32)  # 3 seconds of fake audio
-            transcription = transcribe_audio(fake_audio_chunk, model)
+            # Transcription
+            transcription = process_uploaded_audio(uploaded_file, st.session_state.model)
+            full_transcript = "\n".join(transcription)
+            st.text_area("Transcription", value=full_transcript, height=300)
 
-            # Update real-time transcript
+            # AI Detection
+            st.subheader("AI Detection Results")
             for text in transcription:
-                st.session_state.transcript += text + "\n"
-
-                # Perform AI detection
-                ai_result = advanced_ai_detection(text, ai_detector)
-                st.session_state.ai_detection += f"Text: {text}\nResult: {ai_result}\n\n"
-
+                detection_result = advanced_ai_detection(text, st.session_state.ai_detector)
+                st.write(f"**Text:** {text}")
+                st.write(f"- **Classification:** {detection_result['classification']}")
+                st.write(f"- **Probability:** {detection_result['probability']:.2f}")
+                st.write(f"- **Confidence:** {detection_result['confidence']}")
+                st.markdown("---")
         except Exception as e:
-            st.error(f"Error during transcription: {str(e)}")
-            break
-
-    stop_event.clear()
+            st.error(f"Error processing audio: {str(e)}")
 
 if __name__ == "__main__":
     run_app()