Update app.py

app.py

@@ -10,12 +10,19 @@ import time
 import tempfile
 import streamlit.components.v1 as components
 
-# Ensure setup.sh is executable and then run it using bash
-subprocess.run(['chmod', '+x', 'setup.sh'])
-subprocess.run(['bash', 'setup.sh'], check=True)
+# Attempt to set GPU memory growth
+try:
+    from tensorflow.compat.v1 import ConfigProto
+    from tensorflow.compat.v1 import InteractiveSession
 
-# Load the model from TensorFlow Hub
-m = hub.KerasLayer('https://tfhub.dev/google/nonsemantic-speech-benchmark/trillsson4/1')
+    config = ConfigProto()
+    config.gpu_options.allow_growth = True
+    session = InteractiveSession(config=config)
+except Exception as e:
+    st.warning(f"Could not set GPU memory growth: {e}")
+
+model_path = 'TrillsonFeature_model'
+m = hub.load(model_path)
 
 class TransformerEncoder(tf.keras.layers.Layer):
     def __init__(self, embed_dim, num_heads, ff_dim, rate=0.01, **kwargs):
@@ -49,7 +56,14 @@ class TransformerEncoder(tf.keras.layers.Layer):
         })
         return config
 
-model = load_model('autism_detection_model3.h5', custom_objects={'TransformerEncoder': TransformerEncoder})
+def load_autism_model():
+    try:
+        return load_model('autism_detection_model3.h5', custom_objects={'TransformerEncoder': TransformerEncoder})
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None
+
+model = load_autism_model()
 
 def extract_features(path):
     sample_rate = 16000
@@ -59,6 +73,9 @@ def extract_features(path):
     if array.shape[0] > 1:
         array = np.mean(array, axis=0, keepdims=True)
 
+    # Truncate the audio to 10 seconds for reducing memory usage
+    array = array[:, :sample_rate * 10]
+
     embeddings = m(array)['embedding']
     embeddings.shape.assert_is_compatible_with([None, 1024])
     embeddings = np.squeeze(np.array(embeddings), axis=0)
@@ -69,20 +86,44 @@ st.markdown('<span style="color:black; font-size: 48px; font-weight: bold;">Neu<
 
 option = st.radio("**Choose an option:**", ["Upload an audio file", "Record audio"])
 
-if option == "Upload an audio file":
-    uploaded_file = st.file_uploader("Upload an audio file (.wav)", type=["wav"])
-    if uploaded_file is not None:
-        start_time = time.time()  # Record start time
-        with st.spinner('Extracting features...'):
-            # Save the uploaded file temporarily
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
-                temp_file.write(uploaded_file.getbuffer())
-                temp_file_path = temp_file.name
-            
-            features = extract_features(temp_file_path)
-            os.remove(temp_file_path)
-
-            # Display prediction probabilities
+def run_prediction(features):
+    try:
+        prediction = model.predict(np.expand_dims(features, axis=0))
+        autism_probability = prediction[0][1]
+        normal_probability = prediction[0][0]
+
+        st.subheader("Prediction Probabilities:")
+
+        if autism_probability > normal_probability:
+            st.markdown(
+                f'<div style="background-color:#658EA9;padding:20px;border-radius:10px;margin-bottom:40px;">'
+                f'<h3 style="color:black;">Autism: {autism_probability}</h3>'
+                '</div>',
+                unsafe_allow_html=True
+            )
+            st.markdown(
+                f'<div style="background-color:#ADD8E6;padding:20px;border-radius:10px;margin-bottom:40px;">'
+                f'<h3 style="color:black;">Normal: {normal_probability}</h3>'
+                '</div>',
+                unsafe_allow_html=True
+            )
+        else:
+            st.markdown(
+                f'<div style="background-color:#658EA9;padding:20px;border-radius:10px;margin-bottom:40px;">'
+                f'<h3 style="color:black;">Normal: {normal_probability}</h3>'
+                '</div>',
+                unsafe_allow_html=True
+            )
+            st.markdown(
+                f'<div style="background-color:#ADD8E6;padding:20px;border-radius:10px;margin-bottom:40px;">'
+                f'<h3 style="color:black;">Autism: {autism_probability}</h3>'
+                '</div>',
+                unsafe_allow_html=True
+            )
+
+    except tf.errors.ResourceExhaustedError as e:
+        st.error("Resource exhausted error: switching to CPU.")
+        with tf.device('/cpu:0'):
             prediction = model.predict(np.expand_dims(features, axis=0))
             autism_probability = prediction[0][1]
             normal_probability = prediction[0][0]
@@ -116,67 +157,181 @@ if option == "Upload an audio file":
                     unsafe_allow_html=True
                 )
 
+if option == "Upload an audio file":
+    uploaded_file = st.file_uploader("Upload an audio file (.wav)", type=["wav"])
+    if uploaded_file is not None:
+        start_time = time.time()  # Record start time
+        with st.spinner('Extracting features...'):
+            # Process the uploaded file
+            with open("temp_audio.wav", "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            features = extract_features("temp_audio.wav")
+            os.remove("temp_audio.wav")
+            run_prediction(features)
         elapsed_time = round(time.time() - start_time, 2)
         st.write(f"Elapsed Time: {elapsed_time} seconds")
 
 else:  # Option is "Record audio"
-    # Load and display the local index.html file
-    with open("index.html", 'r', encoding='utf-8') as f:
-        html_content = f.read()
-    components.html(html_content, height=600)
+    audio_recorder_html = '''
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Audio Recorder</title>
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                background-color: #ffffff;
+                margin: 0;
+                padding: 0;
+                display: flex;
+                justify-content: center;
+                align-items: center;
+                height: 100vh;
+            }
 
-    if st.button("Click to Predict"):
-        # Save the recorded audio file temporarily
-        recorded_audio_path = tempfile.NamedTemporaryFile(delete=False, suffix='.wav').name
-        converted_audio_path = tempfile.NamedTemporaryFile(delete=False, suffix='.wav').name
+            .container {
+                text-align: center;
+                background-color: #ffffff;
+                border-radius: 0%;
+            }
 
-        # Run the ffmpeg command to convert the recorded audio
-        os.system(f'ffmpeg -i {recorded_audio_path} -acodec pcm_s16le -ar 16000 -ac 1 {converted_audio_path}')
-        
-        # Process the converted audio file
-        features = extract_features(converted_audio_path)
+            h1 {
+                color: #000000;
+            }
 
-        # Display prediction probabilities
-        prediction = model.predict(np.expand_dims(features, axis=0))
-        autism_probability = prediction[0][1]
-        normal_probability = prediction[0][0]
+            button {
+                background-color: #40826D;
+                color: rgb(0, 0, 0);
+                border: none;
+                padding: 10px 20px;
+                text-align: center;
+                text-decoration: none;
+                display: inline-block;
+                font-size: 16px;
+                margin: 10px;
+                cursor: pointer;
+                border-radius: 5px;
+            }
 
-        st.subheader("Prediction Probabilities:")
+            button:hover {
+                background-color: #40826D;
+            }
 
-        if autism_probability > normal_probability:
-            st.markdown(
-                f'<div style="background-color:#658EA9;padding:20px;border-radius:10px;margin-bottom:40px;">'
-                f'<h3 style="color:black;">Autism: {autism_probability}</h3>'
-                '</div>',
-                unsafe_allow_html=True
-            )
-            st.markdown(
-                f'<div style="background-color:#ADD8E6;padding:20px;border-radius:10px;margin-bottom:40px;">'
-                f'<h3 style="color:black;">Normal: {normal_probability}</h3>'
-                '</div>',
-                unsafe_allow_html=True
-            )
-        else:
-            st.markdown(
-                f'<div style="background-color:#658EA9;padding:20px;border-radius:10px;margin-bottom:40px;">'
-                f'<h3 style="color:black;">Normal: {normal_probability}</h3>'
-                '</div>',
-                unsafe_allow_html=True
-            )
-            st.markdown(
-                f'<div style="background-color:#ADD8E6;padding:20px;border-radius:10px;margin-bottom:40px;">'
-                f'<h3 style="color:black;">Autism: {autism_probability}</h3>'
-                '</div>',
-                unsafe_allow_html=True
-            )
+            button:disabled {
+                background-color: #df5e5e;  
+                cursor: not-allowed;
+            }
 
-        # Remove temporary audio files
-        try:
-            os.remove(recorded_audio_path)
-        except Exception as e:
-            print(f"Error deleting '{recorded_audio_path}': {e}")
+            #timer {
+                font-size: 20px;
+                margin-top: 20px;
+                color: #000000;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>Audio Recorder</h1>
+            <button id="startRecording">Start Recording</button>
+            <button id="stopRecording" disabled>Stop Recording</button>
+            <div id="timer">00:00</div>
+        </div>
+
+        <script>
+            let recorder;
+            let audioChunks = [];
+            let startTime;
+            let timerInterval;
+
+            function updateTime() {
+                const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
+                const minutes = Math.floor(elapsedTime / 60);
+                const seconds = elapsedTime % 60;
+                const formattedTime = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+                document.getElementById('timer').textContent = formattedTime;
+            }
 
+            navigator.mediaDevices.getUserMedia({ audio: true })
+                .then(stream => {
+                    recorder = new MediaRecorder(stream);
+
+                    recorder.ondataavailable = e => {
+                        audioChunks.push(e.data);
+                    };
+
+                    recorder.onstart = () => {
+                        startTime = Date.now();
+                        timerInterval = setInterval(updateTime, 1000);
+                    };
+
+                    recorder.onstop = () => {
+                        const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
+                        const audioUrl = URL.createObjectURL(audioBlob);
+                        const a = document.createElement('a');
+                        a.href = audioUrl;
+                        a.download = 'recorded_audio.wav';
+                        document.body.appendChild(a);
+                        a.click();
+
+                        // Reset
+                        audioChunks = [];
+                        clearInterval(timerInterval);
+                    };
+                })
+                .catch(err => {
+                    console.error('Permission to access microphone denied:', err);
+                });
+
+            document.getElementById('startRecording').addEventListener('click', () => {
+                recorder.start();
+                document.getElementById('startRecording').disabled = true;
+                document.getElementById('stopRecording').disabled = false;
+                setTimeout(() => {
+                    recorder.stop();
+                    document.getElementById('startRecording').disabled = false;
+                    document.getElementById('stopRecording').disabled = true;
+                }, 15000); // 15 seconds
+            });
+
+            document.getElementById('stopRecording').addEventListener('click', () => {
+                recorder.stop();
+                document.getElementById('startRecording').disabled = false;
+                document.getElementById('stopRecording').disabled = true;
+            });
+        </script>
+    </body>
+    </html>
+    '''
+    st.components.v1.html(audio_recorder_html, height=600)
+
+    if st.button("Click to Predict"):
         try:
-            os.remove(converted_audio_path)
+            # Run the ffmpeg command to convert the recorded audio
+            command = 'ffmpeg -i C:/Users/giris/Downloads/recorded_audio.wav -acodec pcm_s16le -ar 16000 -ac 1 C:/Users/giris/Downloads/recorded_audio2.wav'
+            result = subprocess.run(command, shell=True, capture_output=True, text=True)
+            if result.returncode != 0:
+                st.error(f"Error running ffmpeg: {result.stderr}")
+            else:
+                # Check if the file exists
+                if not os.path.exists("C:/Users/giris/Downloads/recorded_audio2.wav"):
+                    st.error("The converted audio file was not created.")
+                else:
+                    # Process the converted audio file
+                    features = extract_features("C:/Users/giris/Downloads/recorded_audio2.wav")
+                    run_prediction(features)
+
+                    # Try to delete the first audio file
+                    try:
+                        os.remove("recorded_audio.wav")
+                    except Exception as e:
+                        print(f"Error deleting 'recorded_audio.wav': {e}")
+
+                    # Try to delete the second audio file
+                    try:
+                        os.remove("recorded_audio2.wav")
+                    except Exception as e:
+                        print(f"Error deleting 'recorded_audio2.wav': {e}")
         except Exception as e:
-            print(f"Error deleting '{converted_audio_path}': {e}")
+            st.error(f"An error occurred: {e}")