Upload 3 files

app.py

@@ -1,143 +1,82 @@
-import gradio as gr
-import numpy as np
-import pandas as pd
-import yfinance as yf
-from datetime import datetime
-from tensorflow.keras.models import load_model
-from joblib import load
+## libraries for data preprocessing
+import numpy as np 
+import pandas as pd 
 
-# Load the saved LSTM model and scaler
-lstm_model = load_model('lstm_model.h5')
-scaler = load('scaler.joblib')
+## libraries for training dl models
+import tensorflow as tf
+from tensorflow import keras
 
-# Define the list of stocks
-stock_list = ['GOOG', 'AAPL', 'TSLA', 'AMZN', 'MSFT']
+## libraries for reading audio files 
+import librosa as lib 
 
-# Function to get the last row of stock data
-def get_last_stock_data(ticker):
-    try:
-        start_date = '2010-01-01'
-        end_date = datetime.now().strftime('%Y-%m-%d')
-        data = yf.download(ticker, start=start_date, end=end_date)
-        last_row = data.iloc[-1]
-        return last_row.to_dict()
-    except Exception as e:
-        return str(e)
 
-# Function to make predictions
-def predict_stock_price(ticker, open_price, close_price):
-    try:
-        start_date = '2010-01-01'
-        end_date = datetime.now().strftime('%Y-%m-%d')
-        data = yf.download(ticker, start=start_date, end=end_date)
+import gradio as gr 
 
-        # Prepare the data
-        data = data[['Close']]
-        dataset = data.values
-        scaled_data = scaler.transform(dataset)
+  
+## lets load the model 
+model = keras.models.load_model('best_heartbeatsound_classification.h5')
 
-        # Append the user inputs as the last row in the data
-        user_input = np.array([[close_price]])
-        user_input_scaled = scaler.transform(user_input)
-        scaled_data = np.vstack([scaled_data, user_input_scaled])
-
-        # Prepare the data for LSTM
-        x_test_lstm = []
-        for i in range(60, len(scaled_data)):
-            x_test_lstm.append(scaled_data[i-60:i])
+def loading_sound_file(sound_file, sr=22050, duration=10):
+    input_length = sr * duration
+    X, sr = lib.load(sound_file, sr=sr, duration=duration) 
+    dur = lib.get_duration(y=X, sr=sr)
+    
+    # # pad audio file same duration
+    # if (round(dur) < duration):
+    #     print ("fixing audio lenght :", file_name)
+    #     y = lib.util.fix_length(X, input_length) 
+    # extract normalized mfcc feature from data
+    
+    # ## pad audio to same duration 
+    # if round(dur) < duration:
+    #     X = lib.util.fix_length(X, input_length)
 
-        x_test_lstm = np.array(x_test_lstm)
-        x_test_lstm = np.reshape(x_test_lstm, (x_test_lstm.shape[0], x_test_lstm.shape[1], 1))
+    # Pad or truncate audio file to the same duration
+    if round(dur) < duration:
+        pad_amount = input_length - len(X)
+        X = np.pad(X, (0, pad_amount), mode='constant')
+    elif round(dur) > duration:
+        X = X[:input_length]
 
-        # LSTM Predictions
-        lstm_predictions = lstm_model.predict(x_test_lstm)
-        lstm_predictions = scaler.inverse_transform(lstm_predictions)
-        next_day_lstm_price = lstm_predictions[-1][0]
         
-        result = f"Predicted future price for {ticker}: ${next_day_lstm_price:.2f}"
-
-        return result
-    except Exception as e:
-        return str(e)
-
-# Function to predict next month's price
-def predict_next_month_price(ticker, close_price):
-    try:
-        start_date = '2010-01-01'
-        end_date = datetime.now().strftime('%Y-%m-%d')
-        data = yf.download(ticker, start=start_date, end=end_date)
-
-        # Prepare the data
-        data = data[['Close']]
-        dataset = data.values
-        scaled_data = scaler.transform(dataset)
-
-        # Append the user inputs as the last row in the data
-        user_input = np.array([[close_price]])
-        user_input_scaled = scaler.transform(user_input)
-        scaled_data = np.vstack([scaled_data, user_input_scaled])
+    mfccs = np.mean(lib.feature.mfcc(y=X, sr=sr, n_mfcc=25).T,axis=0)
 
-        # Prepare the data for LSTM
-        x_test_lstm = []
-        for i in range(60, len(scaled_data)):
-            x_test_lstm.append(scaled_data[i-60:i])
+    ## Reshape to match the model's input shape
+    data = np.array(mfccs).reshape(1, -1, 1)
 
-        x_test_lstm = np.array(x_test_lstm)
-        x_test_lstm = np.reshape(x_test_lstm, (x_test_lstm.shape[0], x_test_lstm.shape[1], 1))
+    return data
 
-        # Predicting the next 30 days
-        predictions = []
-        for _ in range(30):
-            pred = lstm_model.predict(x_test_lstm[-1].reshape(1, 60, 1))
-            predictions.append(pred[0])
-            new_input = np.append(x_test_lstm[-1][1:], pred)
-            x_test_lstm = np.append(x_test_lstm, new_input.reshape(1, 60, 1), axis=0)
 
-        predictions = np.array(predictions)
-        next_month_predictions = scaler.inverse_transform(predictions)
-        next_month_price = next_month_predictions[-1][0]
 
-        result = f"Predicted price for {ticker} next month: ${next_month_price:.2f}"
-
-        return result
-    except Exception as e:
-        return str(e)
-
-# Function to display historical data
-def display_historical_data(ticker):
-    try:
-        start_date = '2010-01-01'
-        end_date = datetime.now().strftime('%Y-%m-%d')
-        data = yf.download(ticker, start=start_date, end=end_date)
-        return data.tail(30)
-    except Exception as e:
-        return str(e)
-
-# Set up Gradio interface
-with gr.Blocks() as app:
-    with gr.Tab("Predict Today's Price"):
-        gr.Markdown("## Predict Today's Price")
-        ticker_input = gr.Dropdown(choices=stock_list, label="Stock Ticker")
-        open_price = gr.Number(label="Open")
-        close_price = gr.Number(label="Close")
-        predict_button = gr.Button("Predict")
-        predict_output = gr.Textbox()
-        predict_button.click(predict_stock_price, inputs=[ticker_input, open_price, close_price], outputs=predict_output)
-        
+def heart_signal_classification(data):
+    X = loading_sound_file(data)
+    pred = model.predict(X)
+    ## Define the threshold
+    threshold = 0.6
+    max_prob = np.max(pred)
     
-    with gr.Tab("Predict Next 30 Days Price"):
-        gr.Markdown("## Predict Next 30 Days Price")
-        next_month_ticker_input = gr.Dropdown(choices=stock_list, label="Stock Ticker")
-        next_month_close_price = gr.Number(label="Close")
-        next_month_predict_button = gr.Button("Predict")
-        next_month_predict_output = gr.Textbox()
-        next_month_predict_button.click(predict_next_month_price, inputs=[next_month_ticker_input, next_month_close_price], outputs=next_month_predict_output)
+    ## Create labels
+    labels = {
+        0: 'artifact',
+        1: 'unlabel',
+        2: 'extrastole',
+        3: 'extrahls',
+        4: 'normal',
+        5: 'murmur'
+    }
     
-    with gr.Tab("View Historical Data"):
-        gr.Markdown("## View Historical Data")
-        historical_ticker_input = gr.Dropdown(choices=stock_list, label="Stock Ticker")
-        historical_view_button = gr.Button("View Data")
-        historical_data_output = gr.Dataframe()
-        historical_view_button.click(display_historical_data, inputs=[historical_ticker_input], outputs=historical_data_output)
-
-app.launch()
+    if max_prob < threshold:
+        label = 'unknown'
+    else:
+        result = pred[0].argmax()
+        label = labels[result]
+    
+    return label
+################### Gradio Web APP ################################ 
+title = "Heart Signal Classification App"   
+Input = gr.Audio(sources=["upload"], type="filepath")
+Output1 = gr.Textbox(label="Type Of Heart Signal")
+description = "Type Of Signal: Artifact, Murmur, Normal, Extrastole, Extrahls"
+iface = gr.Interface(fn=heart_signal_classification, inputs=Input, outputs=Output1, title=title, description=description)
+
+iface.launch(inline=False)

best_heartbeatsound_classification.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b68fb24481fdecdc6c5594acf39fbdd79c0fe53b0d799d97239cfd7937c6be31
+size 1150752

requirements.txt

@@ -1,9 +1,4 @@
-
-gradio
-yfinance
-tensorflow
-joblib
-matplotlib
-numpy
 pandas
-scikit-learn
+numpy
+tensorflow
+librosa