Upload Cough Health Analyzer application files

README.md

@@ -1,12 +1,87 @@
----
-title: Cough Health Analyzer
-emoji: 😻
-colorFrom: blue
-colorTo: gray
-sdk: gradio
-sdk_version: 5.25.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Cough Health Analyzer
+
+A Gradio web application for analyzing cough audio to classify health status as 'healthy', 'COVID-19', or 'symptomatic'.
+
+## Features
+
+- **Upload Audio**: Upload audio files containing coughs for analysis
+- **Record Audio**: Record coughs directly in the browser for analysis
+- **Live Cough Detection**: Stream audio in real-time to detect and analyze coughs
+- **API Access**: Make API calls to the model for integration with other applications
+
+## Installation
+
+1. Clone this repository:
+```bash
+git clone <repository-url>
+cd <repository-directory>
+```
+
+2. Install the required dependencies:
+```bash
+pip install -r requirements-gradio.txt
+```
+
+3. Run the application:
+```bash
+python app.py
+```
+
+The application will be available at http://localhost:7860 by default.
+
+## Deploying to Hugging Face Spaces
+
+To deploy this application to Hugging Face Spaces:
+
+1. Create a new Space on [Hugging Face](https://huggingface.co/spaces)
+2. Choose "Gradio" as the SDK
+3. Upload the following files to your Space:
+   - `app.py`
+   - `cough_classification_model.pkl`
+   - `requirements-gradio.txt` (rename to `requirements.txt`)
+
+The Space will automatically build and deploy your application.
+
+## Using the API
+
+You can access the model via API calls. Here's an example using Python:
+
+```python
+import requests
+import json
+
+# For file upload
+files = {'audio': open('your_audio_file.wav', 'rb')}
+response = requests.post('YOUR_GRADIO_URL/api/predict', files=files)
+result = json.loads(response.content)
+print(result)
+```
+
+Replace `YOUR_GRADIO_URL` with the URL of your deployed Gradio app.
+
+## Model Information
+
+The model is a Random Forest classifier trained on audio features extracted from cough recordings. It classifies coughs into three categories:
+
+- **Healthy**: Normal coughs from healthy individuals
+- **COVID-19**: Coughs from individuals with COVID-19
+- **Symptomatic**: Coughs from individuals with respiratory symptoms but not COVID-19
+
+## Live Audio Streaming and Cough Detection
+
+The application includes a feature for streaming live audio and detecting coughs in real-time. When a cough is detected, it is automatically analyzed by the model.
+
+This feature is useful for:
+- Continuous health monitoring
+- Automated cough counting and analysis
+- Real-time health status updates
+
+## Limitations
+
+- The model's accuracy depends on the quality of the audio recording
+- Background noise can affect cough detection and classification
+- The model should not be used as a substitute for professional medical diagnosis
+
+## License
+
+[Specify your license here]

app.py

@@ -0,0 +1,275 @@
+import os
+import pickle
+import numpy as np
+import pandas as pd
+import librosa
+import gradio as gr
+from scipy.io import wavfile
+import soundfile as sf
+import tempfile
+import time
+
+# Load the model
+def load_model(model_path='cough_classification_model.pkl'):
+    with open(model_path, 'rb') as f:
+        components = pickle.load(f)
+    
+    return components
+
+# Extract features from audio
+def extract_all_features(audio_path, sample_rate=None):
+    """Extract comprehensive set of audio features"""
+    # Load audio file
+    y, sr = librosa.load(audio_path, sr=sample_rate)
+    
+    # Basic features
+    features = {}
+    
+    # Duration
+    features['duration'] = librosa.get_duration(y=y, sr=sr)
+    
+    # RMS Energy
+    features['rms_mean'] = np.mean(librosa.feature.rms(y=y)[0])
+    features['rms_std'] = np.std(librosa.feature.rms(y=y)[0])
+    
+    # Zero Crossing Rate
+    zcr = librosa.feature.zero_crossing_rate(y)[0]
+    features['zcr_mean'] = np.mean(zcr)
+    features['zcr_std'] = np.std(zcr)
+    
+    # Spectral Features
+    # Spectral Centroid
+    centroid = librosa.feature.spectral_centroid(y=y, sr=sr)[0]
+    features['spectral_centroid_mean'] = np.mean(centroid)
+    features['spectral_centroid_std'] = np.std(centroid)
+    
+    # Spectral Bandwidth
+    bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)[0]
+    features['spectral_bandwidth_mean'] = np.mean(bandwidth)
+    features['spectral_bandwidth_std'] = np.std(bandwidth)
+    
+    # Spectral Contrast
+    contrast = librosa.feature.spectral_contrast(y=y, sr=sr)
+    features['spectral_contrast_mean'] = np.mean(contrast)
+    features['spectral_contrast_std'] = np.std(contrast)
+    
+    # Spectral Rolloff
+    rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)[0]
+    features['rolloff_mean'] = np.mean(rolloff)
+    features['rolloff_std'] = np.std(rolloff)
+    
+    # MFCCs
+    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
+    for i in range(13):
+        features[f'mfcc{i+1}_mean'] = np.mean(mfccs[i])
+        features[f'mfcc{i+1}_std'] = np.std(mfccs[i])
+    
+    # Chroma Features
+    chroma = librosa.feature.chroma_stft(y=y, sr=sr)
+    features['chroma_mean'] = np.mean(chroma)
+    features['chroma_std'] = np.std(chroma)
+    
+    return features
+
+# Function to segment cough from audio
+def segment_cough(x, fs, cough_padding=0.2, min_cough_len=0.2, th_l_multiplier=0.1, th_h_multiplier=2):
+    """Segment coughs from audio using a hysteresis comparator on the signal power"""
+    cough_mask = np.array([False]*len(x))
+
+    # Define hysteresis thresholds
+    rms = np.sqrt(np.mean(np.square(x)))
+    seg_th_l = th_l_multiplier * rms
+    seg_th_h = th_h_multiplier * rms
+
+    # Segment coughs
+    coughSegments = []
+    padding = round(fs*cough_padding)
+    min_cough_samples = round(fs*min_cough_len)
+    cough_start = 0
+    cough_end = 0
+    cough_in_progress = False
+    tolerance = round(0.01*fs)
+    below_th_counter = 0
+
+    for i, sample in enumerate(x**2):
+        if cough_in_progress:
+            if sample < seg_th_l:
+                below_th_counter += 1
+                if below_th_counter > tolerance:
+                    cough_end = i+padding if (i+padding < len(x)) else len(x)-1
+                    cough_in_progress = False
+                    if (cough_end+1-cough_start-2*padding > min_cough_samples):
+                        coughSegments.append(x[cough_start:cough_end+1])
+                        cough_mask[cough_start:cough_end+1] = True
+            elif i == (len(x)-1):
+                cough_end = i
+                cough_in_progress = False
+                if (cough_end+1-cough_start-2*padding > min_cough_samples):
+                    coughSegments.append(x[cough_start:cough_end+1])
+            else:
+                below_th_counter = 0
+        else:
+            if sample > seg_th_h:
+                cough_start = i-padding if (i-padding >= 0) else 0
+                cough_in_progress = True
+
+    return coughSegments, cough_mask
+
+# Prediction function for uploaded audio
+def predict_cough_health(audio_path, model_components=None):
+    """Predict cough health status from audio file"""
+    if model_components is None:
+        model_components = load_model()
+    
+    model = model_components['model']
+    scaler = model_components['scaler']
+    label_encoder = model_components['label_encoder']
+    feature_names = model_components['feature_names']
+    
+    # Extract features
+    features = extract_all_features(audio_path)
+    
+    # Convert to DataFrame with correct feature order
+    features_df = pd.DataFrame([features])
+    features_df = features_df[feature_names]
+    
+    # Scale features
+    features_scaled = scaler.transform(features_df)
+    
+    # Predict
+    prediction_idx = model.predict(features_scaled)[0]
+    prediction = label_encoder.inverse_transform([prediction_idx])[0]
+    
+    # Get probabilities
+    probs = model.predict_proba(features_scaled)[0]
+    class_probs = {label_encoder.inverse_transform([i])[0]: float(prob) for i, prob in enumerate(probs)}
+    
+    return prediction, class_probs
+
+# Function to process uploaded audio file
+def process_audio_file(audio_file):
+    """Process uploaded audio file and return prediction"""
+    model_components = load_model()
+    prediction, probabilities = predict_cough_health(audio_file, model_components)
+    
+    # Format the output
+    result = f"Prediction: {prediction}\n\nProbabilities:\n"
+    for cls, prob in probabilities.items():
+        result += f"{cls}: {prob:.4f}\n"
+    
+    return result
+
+# Function to process recorded audio
+def process_recorded_audio(audio_array, sample_rate):
+    """Process recorded audio and return prediction"""
+    # Save the recorded audio to a temporary file
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_audio:
+        temp_filename = temp_audio.name
+        sf.write(temp_filename, audio_array, sample_rate)
+    
+    model_components = load_model()
+    prediction, probabilities = predict_cough_health(temp_filename, model_components)
+    
+    # Clean up the temporary file
+    os.unlink(temp_filename)
+    
+    # Format the output
+    result = f"Prediction: {prediction}\n\nProbabilities:\n"
+    for cls, prob in probabilities.items():
+        result += f"{cls}: {prob:.4f}\n"
+    
+    return result
+
+# Function to detect coughs in live audio stream
+def detect_coughs_in_stream(audio_array, sample_rate):
+    """Detect coughs in live audio stream and analyze them"""
+    # Save the audio chunk to a temporary file
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_audio:
+        temp_filename = temp_audio.name
+        sf.write(temp_filename, audio_array, sample_rate)
+    
+    # Load the audio for processing
+    audio, sr = librosa.load(temp_filename, sr=None)
+    
+    # Segment coughs
+    cough_segments, cough_mask = segment_cough(audio, sr)
+    
+    # Clean up the temporary file
+    os.unlink(temp_filename)
+    
+    if len(cough_segments) > 0:
+        # Save the first detected cough segment to a temporary file
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as cough_file:
+            cough_filename = cough_file.name
+            sf.write(cough_filename, cough_segments[0], sr)
+        
+        # Analyze the cough
+        model_components = load_model()
+        prediction, probabilities = predict_cough_health(cough_filename, model_components)
+        
+        # Clean up the temporary file
+        os.unlink(cough_filename)
+        
+        # Format the output
+        result = f"Cough detected! Prediction: {prediction}\n\nProbabilities:\n"
+        for cls, prob in probabilities.items():
+            result += f"{cls}: {prob:.4f}\n"
+        
+        return result
+    else:
+        return "No cough detected in this audio segment."
+
+# Create Gradio interface
+def create_interface():
+    model_components = load_model()
+    
+    with gr.Blocks(title="Cough Health Analyzer") as demo:
+        gr.Markdown("# Cough Health Analyzer")
+        gr.Markdown("Upload an audio file containing a cough or record a cough to analyze its health status.")
+        
+        with gr.Tab("Upload Audio"):
+            with gr.Row():
+                audio_input = gr.Audio(type="filepath", label="Upload Audio File")
+                output_text = gr.Textbox(label="Prediction Result")
+            
+            analyze_btn = gr.Button("Analyze Cough")
+            analyze_btn.click(fn=process_audio_file, inputs=audio_input, outputs=output_text)
+        
+        with gr.Tab("Record Audio"):
+            with gr.Row():
+                audio_recorder = gr.Audio(type="numpy", source="microphone", label="Record Audio")
+                record_output = gr.Textbox(label="Prediction Result")
+            
+            record_btn = gr.Button("Analyze Recording")
+            record_btn.click(fn=process_recorded_audio, inputs=[audio_recorder], outputs=record_output)
+        
+        with gr.Tab("Live Cough Detection"):
+            gr.Markdown("This tab continuously monitors audio for coughs and analyzes them when detected.")
+            
+            with gr.Row():
+                live_audio = gr.Audio(type="numpy", source="microphone", streaming=True, label="Live Audio Stream")
+                live_output = gr.Textbox(label="Detection Result")
+            
+            live_audio.stream(fn=detect_coughs_in_stream, outputs=live_output)
+        
+        gr.Markdown("## API Usage")
+        gr.Markdown("""
+        This Gradio app can be accessed via API calls. Example Python code:
+        ```python
+        import requests
+        import json
+        
+        # For file upload
+        files = {'audio': open('your_audio_file.wav', 'rb')}
+        response = requests.post('YOUR_GRADIO_URL/api/predict', files=files)
+        result = json.loads(response.content)
+        print(result)
+        ```
+        """)
+    
+    return demo
+
+# Main function
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(share=True)

cough_classification_model.pkl

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

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.0.0
+numpy>=1.26.0
+pandas>=2.0.0
+librosa>=0.11.0
+scikit-learn>=1.4.0
+scipy>=1.11.0
+soundfile>=0.13.0
+matplotlib>=3.10.0
+seaborn>=0.13.0