Update app.py

app.py

@@ -1,3 +1,358 @@
+import streamlit as st
+import os
+import numpy as np
+import torchaudio
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+import tensorflow_hub as hub
+import time
+import subprocess
+st.markdown(
+    """
+    <style>
+    body {
+        background-color: white;
+    }
+    .stApp {
+        background-color: white;
+    }
+    .main {
+        background-color: white;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+# Attempt to set GPU memory growth
+try:
+    from tensorflow.compat.v1 import ConfigProto
+    from tensorflow.compat.v1 import InteractiveSession
+
+    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):
+        super(TransformerEncoder, self).__init__(**kwargs)
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.ff_dim = ff_dim
+        self.rate = rate
+        self.att = tf.keras.layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)
+        self.ffn = tf.keras.Sequential([tf.keras.layers.Dense(ff_dim, activation="relu"), tf.keras.layers.Dense(embed_dim)])
+        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
+        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
+        self.dropout1 = tf.keras.layers.Dropout(rate)
+        self.dropout2 = tf.keras.layers.Dropout(rate)
+
+    def call(self, inputs, training=False):
+        attn_output = self.att(inputs, inputs)
+        attn_output = self.dropout1(attn_output, training=training)
+        out1 = self.layernorm1(inputs + attn_output)
+        ffn_output = self.ffn(out1)
+        ffn_output = self.dropout2(ffn_output, training=training)
+        return self.layernorm2(out1 + ffn_output)
+
+    def get_config(self):
+        config = super(TransformerEncoder, self).get_config()
+        config.update({
+            'embed_dim': self.embed_dim,
+            'num_heads': self.num_heads,
+            'ff_dim': self.ff_dim,
+            'rate': self.rate
+        })
+        return config
+
+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
+    array, fs = torchaudio.load(path)
+
+    array = np.array(array)
+    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)
+
+    return embeddings
+
+st.markdown('<span style="color:black; font-size: 48px; font-weight: bold;">Neu</span> <span style="color:black; font-size: 48px; font-weight: bold;">RO:</span> <span style="color:black; font-size: 48px; font-weight: bold;">An Application for Code-Switched Autism Detection in Children</span>', unsafe_allow_html=True)
+
+option = st.radio("**Choose an option:**", ["Upload an audio file", "Record audio"])
+
+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]
+
+            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
+                )
+
+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"
+    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;
+            }
+
+            .container {
+                text-align: center;
+                background-color: #ffffff;
+                border-radius: 0%;
+            }
+
+            h1 {
+                color: #000000;
+            }
+
+            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;
+            }
+
+            button:hover {
+                background-color: #40826D;
+            }
+
+            button:disabled {
+                background-color: #df5e5e;  
+                cursor: not-allowed;
+            }
+
+            #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:
+            # 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:
+            st.error(f"An error occurred: {e}")
+
+
+
+"""
 import subprocess
 import streamlit as st
 import os
@@ -28,8 +383,8 @@ except Exception as e:
 m = hub.KerasLayer('https://tfhub.dev/google/nonsemantic-speech-benchmark/trillsson4/1')
 
 class TransformerEncoder(tf.keras.layers.Layer):
-    def _init_(self, embed_dim, num_heads, ff_dim, rate=0.01, **kwargs):
-        super(TransformerEncoder, self)._init_(**kwargs)
+    def __init__(self, embed_dim, num_heads, ff_dim, rate=0.01, **kwargs):
+        super(TransformerEncoder, self).__init__(**kwargs)
         self.embed_dim = embed_dim
         self.num_heads = num_heads
         self.ff_dim = ff_dim
@@ -87,7 +442,7 @@ def extract_features(path):
 
 st.markdown('<span style="color:black; font-size: 48px; font-weight: bold;">Neu</span> <span style="color:black; font-size: 48px; font-weight: bold;">RO:</span> <span style="color:black; font-size: 48px; font-weight: bold;">An Application for Code-Switched Autism Detection in Children</span>', unsafe_allow_html=True)
 
-option = st.radio("*Choose an option:*", ["Upload an audio file", "Record audio"])
+option = st.radio("**Choose an option:**", ["Upload an audio file", "Record audio"])
 
 def run_prediction(features):
     try:
@@ -194,14 +549,17 @@ else:  # Option is "Record audio"
                 align-items: center;
                 height: 100vh;
             }
+
             .container {
                 text-align: center;
                 background-color: #ffffff;
                 border-radius: 0%;
             }
+
             h1 {
                 color: #000000;
             }
+
             button {
                 background-color: #40826D;
                 color: rgb(0, 0, 0);
@@ -215,13 +573,16 @@ else:  # Option is "Record audio"
                 cursor: pointer;
                 border-radius: 5px;
             }
+
             button:hover {
                 background-color: #40826D;
             }
+
             button:disabled {
                 background-color: #df5e5e;  
                 cursor: not-allowed;
             }
+
             #timer {
                 font-size: 20px;
                 margin-top: 20px;
@@ -236,28 +597,34 @@ else:  # Option is "Record audio"
             <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')};
+                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);
@@ -266,6 +633,7 @@ else:  # Option is "Record audio"
                         a.download = 'recorded_audio.wav';
                         document.body.appendChild(a);
                         a.click();
+
                         // Reset
                         audioChunks = [];
                         clearInterval(timerInterval);
@@ -274,6 +642,7 @@ else:  # Option is "Record audio"
                 .catch(err => {
                     console.error('Permission to access microphone denied:', err);
                 });
+
             document.getElementById('startRecording').addEventListener('click', () => {
                 recorder.start();
                 document.getElementById('startRecording').disabled = true;
@@ -284,6 +653,7 @@ else:  # Option is "Record audio"
                     document.getElementById('stopRecording').disabled = true;
                 }, 15000); // 15 seconds
             });
+
             document.getElementById('stopRecording').addEventListener('click', () => {
                 recorder.stop();
                 document.getElementById('startRecording').disabled = false;
@@ -323,4 +693,6 @@ else:  # Option is "Record audio"
                     except Exception as e:
                         print(f"Error deleting 'recorded_audio2.wav': {e}")
         except Exception as e:
-            st.error(f"An error occurred: {e}")
+            st.error(f"An error occurred: {e}")
+
+"""