Update app.py

app.py

@@ -1,109 +1,134 @@
-import numpy as np
-import librosa
-import tensorflow as tf
-import streamlit as st
-
-window_length = 0.02  # 20ms window length
-hop_length = 0.0025  # 2.5ms hop length
-sample_rate = 22050  # Standard audio sample rate
-n_mels = 128  # Number of mel filter banks
-threshold_zcr = 0.1  # Adjust this threshold to detect breath based on ZCR
-threshold_rmse = 0.1  # Adjust this threshold to detect breath based on RMSE
-
-def extract_breath_features(y, sr):
-    frame_length = int(window_length * sr)
-    hop_length_samples = int(hop_length * sr)
-    
-    zcr = librosa.feature.zero_crossing_rate(y=y, frame_length=frame_length, hop_length=hop_length_samples)
-    rmse = librosa.feature.rms(y=y, frame_length=frame_length, hop_length=hop_length_samples)
-    
-    zcr = zcr.T.flatten()
-    rmse = rmse.T.flatten()
-    
-    # Calculate breath events
-    breaths = (zcr > threshold_zcr) & (rmse > threshold_rmse)
-    
-    # Create a breath feature: 1 if breath is present, else 0
-    breath_feature = np.where(breaths, 1, 0)
-    
-    return breath_feature
-
-def extract_features(file_path, n_mels=128, n_cqt=84, max_len=500, n_mfcc=13):
-    try:
-        y, sr = librosa.load(file_path, sr=None)
-        
-        # Compute MFCC
-        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=n_mfcc)
-        mfcc = librosa.util.fix_length(mfcc, size=max_len, axis=1)  # Fix length
-        
-        # Compute log-mel spectrogram
-        logspec = librosa.amplitude_to_db(librosa.feature.melspectrogram(y=y, sr=sr, n_mels=n_mels))
-        logspec = librosa.util.fix_length(logspec, size=max_len, axis=1)  # Fix length
-        
-        # Extract breath features
-        breath_feature = extract_breath_features(y, sr)
-        breath_feature = librosa.util.fix_length(breath_feature, size=max_len)  # Fix length
-        
-        # Stack features vertically
-        return np.vstack((mfcc,logspec, breath_feature))
-    except Exception as e:
-        print(f"Error loading {file_path}: {e}")
-        return None
-
-# Function to prepare the features for prediction
-def prepare_single_data(features, max_len=500):
-    features = librosa.util.fix_length(features, size=max_len, axis=1)
-    features = features[np.newaxis, ..., np.newaxis]  # Add batch and channel dimensions
-    return features
-
-# Load the saved TensorFlow Lite model
-interpreter = tf.lite.Interpreter(model_path=r"model_breath_logspec_mfcc_cnn.tflite")
-interpreter.allocate_tensors()
-
-# Get input and output details
-input_details = interpreter.get_input_details()
-output_details = interpreter.get_output_details()
-
-# Function to predict audio class
-def predict_audio(file_path):
-    features = extract_features(file_path)
-    if features is not None:
-        prepared_features = prepare_single_data(features)
-        # Ensure the prepared features are of type FLOAT32
-        prepared_features = prepared_features.astype(np.float32)  # Convert to FLOAT32
-        # Set the tensor to the prepared input data
-        interpreter.set_tensor(input_details[0]['index'], prepared_features)
-        interpreter.invoke()
-        # Get the prediction result
-        prediction = interpreter.get_tensor(output_details[0]['index'])
-        predicted_class = np.argmax(prediction, axis=1)
-        predicted_prob = prediction[0]  # Get the probabilities for EER calculation
-        return predicted_class[0], predicted_prob  # Return class index and probabilities
-    else:
-        return None, None
-
-# Streamlit app
-st.title('Audio Classification: Real vs Fake')
-st.write('Upload an audio file to classify it as real or fake.')
-
-# File uploader
-uploaded_file = st.file_uploader('Choose an audio file', type=['wav', 'mp3'])
-
-if uploaded_file is not None:
-    # Save the uploaded file temporarily
-    with open('temp_audio_file.wav', 'wb') as f:
-        f.write(uploaded_file.getbuffer())
-
-
-    # Predict using the loaded model
-    prediction,probablity = predict_audio('temp_audio_file.wav')
-    st.write(f'Predicted class is {prediction} \n')
-    st.write(f'Probability of being real: {probablity[0]*100:.2f}% \n')
-    st.write(f'Probability of being fake: {probablity[1]*100:.2f}% \n')
-    
-
-    
-    
-    
-
- 
+import numpy as np
+import librosa
+import tensorflow as tf
+import streamlit as st
+import plotly.express as px
+import pandas as pd
+import soundfile as sf
+from pydub import AudioSegment
+import matplotlib.pyplot as plt
+import time
+
+# Parameters for audio processing
+window_length = 0.02  # 20ms
+hop_length = 0.0025  # 2.5ms
+sample_rate = 22050
+global inference_time
+inference_time=1
+# Load TFLite model
+interpreter = tf.lite.Interpreter(model_path=r"model_breath_logspec_mfcc_cnn.tflite")
+interpreter.allocate_tensors()
+input_details, output_details = interpreter.get_input_details(), interpreter.get_output_details()
+
+def convert_mp3_to_wav(mp3_path):
+    audio = AudioSegment.from_mp3(mp3_path)
+    wav_path = mp3_path.replace(".mp3", ".wav")
+    audio.export(wav_path, format="wav")
+    return wav_path
+
+def extract_breath_features(y, sr):
+    frame_length = int(window_length * sr)
+    hop_length_samples = int(hop_length * sr)
+    zcr = librosa.feature.zero_crossing_rate(y=y, frame_length=frame_length, hop_length=hop_length_samples)
+    rmse = librosa.feature.rms(y=y, frame_length=frame_length, hop_length=hop_length_samples)
+    breaths = (zcr.flatten() > 0.1) & (rmse.flatten() > 0.1)
+    return np.where(breaths, 1, 0)
+
+def extract_features(y, sr, n_mels=128, n_mfcc=13):
+    try:
+     
+        # Extract MFCC & Log-Mel Spectrogram
+        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=n_mfcc)
+        logspec = librosa.power_to_db(librosa.feature.melspectrogram(y=y, sr=sr, n_mels=n_mels))
+        breath_feature = extract_breath_features(y, sr)
+
+        # Dynamically adjust length based on the shortest feature
+        min_len = min(mfcc.shape[1], logspec.shape[1], len(breath_feature))
+
+        # Resize instead of fix_length for better visualization
+        mfcc = librosa.util.fix_length(mfcc, size=min_len, axis=1)
+        logspec = librosa.util.fix_length(logspec, size=min_len, axis=1)
+        breath_feature = librosa.util.fix_length(breath_feature, size=min_len)
+
+        return np.vstack((mfcc, logspec, breath_feature))
+    except Exception as e:
+        st.error(f"Error processing")
+        return None
+def prepare_single_data(features, max_len=500):
+    features = librosa.util.fix_length(features, size=max_len, axis=1)
+    return features[np.newaxis, ..., np.newaxis].astype(np.float32)
+
+def predict_audio(features):
+    global inference_time
+    start_time=time.time()
+    prepared_features = prepare_single_data(features)
+    interpreter.set_tensor(input_details[0]['index'], prepared_features)
+    interpreter.invoke()
+    prediction = interpreter.get_tensor(output_details[0]['index'])
+    end_time = time.time()
+    inference_time=start_time-end_time
+    return np.argmax(prediction, axis=1)[0], prediction[0]
+
+def plot_waveform(y, sr, start_time, end_time):
+    start_sample, end_sample = int(start_time * sr), int(end_time * sr)
+    y_trimmed = y[start_sample:end_sample]
+    times = np.linspace(start_time, end_time, num=len(y_trimmed))
+    df = pd.DataFrame({"Time (s)": times, "Amplitude": y_trimmed})
+    st.plotly_chart(px.line(df, x="Time (s)", y="Amplitude", title="Waveform"), use_container_width=True)
+    return y_trimmed, sr
+
+def visualize_features(features, duration):
+    time_axis = np.linspace(0, duration, features.shape[1])
+    df_breath = pd.DataFrame({"Time (s)": time_axis, "Breath Feature": features[-1]})
+    st.plotly_chart(px.line(df_breath, x="Time (s)", y="Breath Feature", title="Breath Feature Over Time"), use_container_width=True)
+
+def plot_mfcc_and_logspec(y, sr):
+    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
+    logspec = librosa.amplitude_to_db(librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128))
+    #logspec = librosa.power_to_db(librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128))
+    with st.sidebar:
+        st.write("### MFCC and Log-Spectrogram")
+
+        # Plot MFCC
+        fig, ax = plt.subplots(figsize=(5, 3))
+        librosa.display.specshow(mfcc, sr=sr, x_axis='time')
+        plt.colorbar()
+        plt.title("MFCC")
+        st.pyplot(fig)
+
+        # Plot Log-Spectrogram
+        fig, ax = plt.subplots(figsize=(5, 3))
+        librosa.display.specshow(logspec, sr=sr, x_axis='time')
+        plt.colorbar()
+        plt.title("Log-Mel Spectrogram")
+        st.pyplot(fig)
+
+st.title('Audio Integrity Net')
+st.subheader('Documentation to be added')
+uploaded_file = st.file_uploader('Upload an audio file', type=['wav', 'mp3'])
+
+if uploaded_file:
+    with open('temp_audio.wav', 'wb') as f:
+        f.write(uploaded_file.getbuffer())
+    
+    y, sr = librosa.load('temp_audio.wav', sr=sample_rate)
+    duration = librosa.get_duration(y=y, sr=sr)
+    start_time, end_time = st.slider("Select time range", 0.0, duration, (0.0, duration))
+    y_trimmed, sr = plot_waveform(y, sr, start_time, end_time)
+    
+    if st.sidebar.button("Show MFCC & Log-Spectrogram"):
+        plot_mfcc_and_logspec(y_trimmed, sr)
+    
+    features = extract_features(y_trimmed, sr)
+    if features is not None:
+        st.success("Feature Extraction Completed!")
+        visualize_features(features, end_time - start_time)
+        prediction, probability = predict_audio(features)
+        if prediction==0:
+            st.subheader(f' Predicted class is Real ')
+        else:
+            st.subheader(f'Predicted class is Fake')
+        st.write(f'Probability of being real: {probability[0] * 100:.2f}%')
+        st.write(f'Probability of being fake: {probability[1] * 100:.2f}%')
+        inference_time=abs(inference_time)
+        st.write(f"Inference Time: {inference_time:.6f} seconds")