Update app.py

app.py

@@ -1,117 +1,53 @@
-import gradio as gr
-import sounddevice as sd
-import numpy as np
-import librosa
+from transformers import pipeline
 import torch
-from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2ForSequenceClassification
-import logging
+import soundfile as sf
+from datetime import datetime
+import requests
+
+# Initialize the classifier pipeline
+classifier = pipeline(
+    "audio-classification",
+    model="padmalcom/wav2vec2-large-nonverbalvocalization-classification",
+)
+
+def detect_scream(audio_path: str):
+    audio, sr = sf.read(audio_path)
+    # Resample to expected sampling rate if needed
+    if sr != classifier.feature_extractor.sampling_rate:
+        import librosa
+        audio = librosa.resample(audio, orig_sr=sr, target_sr=classifier.feature_extractor.sampling_rate)
+    results = classifier(audio)
+    top = results[0]
+    label = top["label"]
+    score = float(top["score"]) * 100  # as percentage
+    # Map to your Detection_Result and Alert_Level
+    if label.lower() == "scream" and score > 80:
+        alert = "High-Risk"
+    elif label.lower() == "scream" and score > 50:
+        alert = "Medium-Risk"
+    else:
+        alert = "None"
+    return label, score, alert
+
+def log_to_salesforce(sf_instance, audio_url, label, score, alert):
+    # Create Scream_Detection__c record
+    sf_instance.Scream_Detection__c.create({
+        "Audio_File_URL__c": audio_url,
+        "Detection_Result__c": label,
+        "Confidence_Score__c": score,
+        "Alert_Level__c": alert,
+        "Timestamp__c": datetime.utcnow().isoformat(),
+        # add User__c if available
+    })
+    # trigger Salesforce alert automation (email/SMS/in‑app)
+
+def main():
+    audio_path = "input.wav"
+    audio_url = "https://my.blob/storage/input.wav"
+    label, score, alert = detect_scream(audio_path)
+    print(f"Detected: {label}, {score:.1f}%, Level: {alert}")
+    # Optional: Push to Salesforce using simple-salesforce, requests, etc.
+    # log_to_salesforce(sf, audio_url, label, score, alert)
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Load Hugging Face model
-MODEL_NAME = "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
-feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(MODEL_NAME)
-model = Wav2Vec2ForSequenceClassification.from_pretrained(MODEL_NAME)
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model.to(device)
-model.eval()
-logger.info(f"Loaded model {MODEL_NAME} on {device}")
-
-# Audio settings
-SAMPLE_RATE = 16000  # Model expects 16kHz
-DURATION = 5  # Seconds for real-time audio chunks
-recording = None
-is_recording = False
-
-# Function to process audio and detect screams
-def process_audio(audio_data, sample_rate=SAMPLE_RATE):
-    try:
-        inputs = feature_extractor(audio_data, sampling_rate=sample_rate, return_tensors="pt", padding=True)
-        inputs = {key: val.to(device) for key, val in inputs.items()}
-        
-        with torch.no_grad():
-            outputs = model(**inputs)
-            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-            confidence, predicted_label = torch.max(probabilities, dim=-1)
-            confidence = confidence.item() * 100
-            label = model.config.id2label[predicted_label.item()]
-        
-        # Check for scream-like emotions (e.g., fear, surprise)
-        scream_detected = label in ["fear", "surprise"]
-        risk_level = None
-        if scream_detected:
-            if confidence > 80:
-                risk_level = "High-Risk"
-            elif 50 <= confidence <= 80:
-                risk_level = "Medium-Risk"
-        
-        return scream_detected, confidence, label, risk_level
-    except Exception as e:
-        logger.error(f"Error processing audio: {e}")
-        return False, 0, "error", None
-
-# Real-time audio capture
-def start_recording():
-    global recording, is_recording
-    is_recording = True
-    recording = []
-    
-    def callback(indata, frames, time, status):
-        if status:
-            logger.error(f"Recording error: {status}")
-        recording.append(indata.copy())
-    
-    logger.info("Starting real-time audio capture")
-    with sd.InputStream(samplerate=SAMPLE_RATE, channels=1, callback=callback, blocksize=int(SAMPLE_RATE * DURATION)):
-        while is_recording:
-            sd.sleep(1000)
-    
-    return "Recording started"
-
-def stop_recording():
-    global is_recording, recording
-    is_recording = False
-    if recording:
-        audio_data = np.concatenate(recording, axis=0).flatten()
-        scream_detected, confidence, label, risk_level = process_audio(audio_data)
-        return f"Detection: {scream_detected}, Confidence: {confidence:.2f}%, Label: {label}, Risk: {risk_level}"
-    return "No audio recorded"
-
-# Process uploaded audio file
-def process_uploaded_audio(audio_file):
-    try:
-        audio_data, sr = librosa.load(audio_file, sr=SAMPLE_RATE)
-        scream_detected, confidence, label, risk_level = process_audio(audio_data, sr)
-        return f"Detection: {scream_detected}, Confidence: {confidence:.2f}%, Label: {label}, Risk: {risk_level}"
-    except Exception as e:
-        logger.error(f"Error processing uploaded audio: {e}")
-        return f"Error: {e}"
-
-# Gradio interface
-def create_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("# Scream Detection System")
-        
-        with gr.Row():
-            start_btn = gr.Button("Start Recording")
-            stop_btn = gr.Button("Stop Recording")
-        
-        # Audio upload component (no 'source' parameter)
-        upload = gr.Audio(type="filepath", label="Upload Audio File")
-        output = gr.Textbox(label="Detection Results")
-        
-        with gr.Accordion("Settings"):
-            confidence_threshold = gr.Slider(50, 100, value=80, label="High-Risk Confidence Threshold")
-        
-        start_btn.click(start_recording, outputs=output)
-        stop_btn.click(stop_recording, outputs=output)
-        upload.change(process_uploaded_audio, inputs=upload, outputs=output)
-    
-    return demo
-
-# Launch the interface
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    main()