Upload 8 files

src/chatbot.py

@@ -0,0 +1,30 @@
+
+import numpy as np
+from util import load_uploaded_file, segment_signal
+from gemini import query_gemini_rest
+
+CLASSES = ["N", "V", "/", "A", "F", "~"]
+LABEL_MAP = {
+    "N": "Normal sinus beat",
+    "V": "Premature Ventricular Contraction (PVC)",
+    "/": "Paced beat (pacemaker)",
+    "A": "Atrial premature beat",
+    "F": "Fusion of ventricular & normal beat",
+    "~": "Unclassifiable / noise"
+}
+
+def analyze_signal(file, model, gemini_key="", signal_type="ECG"):
+    signal = load_uploaded_file(file, signal_type)
+    segments = segment_signal(signal)          
+
+    preds = model.predict(segments, verbose=0)[0]    
+    idx   = int(np.argmax(preds))
+    conf  = float(preds[idx])                        
+    label = CLASSES[idx]
+    human = LABEL_MAP[label]
+
+    gemini_txt = None
+    if gemini_key:
+        gemini_txt = query_gemini_rest(signal_type, human, conf, gemini_key)
+
+    return label, human, conf, gemini_txt

src/config.py

@@ -0,0 +1,49 @@
+
+import argparse
+
+parser = argparse.ArgumentParser()
+
+def add_argument_group(name):
+    arg = parser.add_argument_group(name)
+    return arg
+
+
+misc_arg = add_argument_group('misc')
+misc_arg.add_argument('--split', type=bool, default = True)
+misc_arg.add_argument('--input_size', type=int, default = 256, 
+                      help='multiplies of 256 by the structure of the model') 
+misc_arg.add_argument('--use_network', type=bool, default = False)
+
+data_arg = add_argument_group('data')
+data_arg.add_argument('--downloading', type=bool, default = False)
+
+graph_arg = add_argument_group('graph')
+graph_arg.add_argument('--filter_length', type=int, default = 32)
+graph_arg.add_argument('--kernel_size', type=int, default = 16)
+graph_arg.add_argument('--drop_rate', type=float, default = 0.2)
+
+train_arg = add_argument_group('train')
+train_arg.add_argument('--feature', type=str, default = "MLII",
+                       help='one of MLII, V1, V2, V4, V5. Favorably MLII or V1')
+train_arg.add_argument('--epochs', type=int, default = 80)
+train_arg.add_argument('--batch', type=int, default = 256)
+train_arg.add_argument('--patience', type=int, default = 10)
+train_arg.add_argument('--min_lr', type=float, default = 0.00005)
+train_arg.add_argument('--checkpoint_path', type=str, default = None)
+train_arg.add_argument('--resume_epoch', type=int)
+train_arg.add_argument('--ensemble', type=bool, default = False)
+train_arg.add_argument('--trained_model', type=str, default = None, 
+                       help='dir and filename of the trained model for usage.')
+
+predict_arg = add_argument_group('predict')
+predict_arg.add_argument('--num', type=int, default = None)
+predict_arg.add_argument('--upload', type=bool, default = False)
+predict_arg.add_argument('--sample_rate', type=int, default = None)
+predict_arg.add_argument('--cinc_download', type=bool, default = False)
+
+
+
+def get_config():
+    config, unparsed = parser.parse_known_args()
+
+    return config

src/download_models.py

@@ -0,0 +1,57 @@
+import os
+import gdown
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+def extract_file_id_from_url(url):
+    """Extract file ID from Google Drive URL"""
+    if "drive.google.com" in url:
+        if "/file/d/" in url:
+            return url.split("/file/d/")[1].split("/")[0]
+        elif "id=" in url:
+            return url.split("id=")[1].split("&")[0]
+    return url  
+
+def get_model_urls():
+    """Get model URLs from environment variables"""
+    return {
+        "../models/MLII-latest.keras": os.getenv("ECG_MODEL_URL", ""),
+        "../models/pcg_model.h5": os.getenv("PCG_MODEL_URL", ""),
+        "../models/emg_model.h5": os.getenv("EMG_MODEL_URL", ""),
+        "../models/vag_feature_classifier.pkl": os.getenv("VAG_MODEL_URL", "")
+    }
+
+def download_from_gdrive(url, output_path):
+    """Download file from Google Drive using gdown"""
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+   
+    file_id = extract_file_id_from_url(url)
+    
+    
+    download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+    gdown.download(download_url, output_path, quiet=False)
+
+def ensure_models_downloaded():
+    """Download models if they don't exist locally"""
+    model_urls = get_model_urls()
+    
+    for local_path, url in model_urls.items():
+        if not url:
+            print(f"⚠️ No URL found for {local_path}")
+            continue
+            
+        if not os.path.exists(local_path):
+            print(f"Downloading {local_path}...")
+            try:
+                download_from_gdrive(url, local_path)
+                print(f"✅ Downloaded {local_path}")
+            except Exception as e:
+                print(f"❌ Failed to download {local_path}: {e}")
+        else:
+            print(f"✅ {local_path} already exists")
+
+if __name__ == "__main__":
+    ensure_models_downloaded()

src/gemini.py

@@ -0,0 +1,32 @@
+import requests
+
+GEMINI_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+
+def query_gemini_rest(signal_type, label, confidence, api_key):
+    headers = {
+        "Content-Type": "application/json",
+        "X-goog-api-key": api_key,
+    }
+
+    prompt = (
+        f"Explain the meaning of a {signal_type} signal classified as '{label}' "
+        f"with a confidence of {confidence:.1%} in a medical diagnostic context."
+    )
+
+    payload = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": prompt}
+                ]
+            }
+        ]
+    }
+
+    try:
+        response = requests.post(GEMINI_ENDPOINT, headers=headers, json=payload)
+        response.raise_for_status()
+        content = response.json()
+        return content["candidates"][0]["content"]["parts"][0]["text"]
+    except Exception as e:
+        return f"⚠️ Gemini API error: {str(e)}"

src/graph.py

@@ -0,0 +1,111 @@
+from __future__ import division, print_function
+from keras.models import Model
+from keras.layers import Input, Conv1D, Dense, add, Flatten, Dropout,MaxPooling1D, Activation, BatchNormalization, Lambda
+from keras import backend as K
+from keras.optimizers import Adam
+from keras.saving import register_keras_serializable
+import tensorflow as tf
+
+@register_keras_serializable(package="custom")
+def zeropad(x):
+    """ 
+    zeropad and zeropad_output_shapes are from 
+    https://github.com/awni/ecg/blob/master/ecg/network.py
+    """
+    y = tf.zeros_like(x)
+    return tf.concat([x, y], axis=2)
+
+@register_keras_serializable(package="custom")
+def zeropad_output_shape(input_shape):
+    shape = list(input_shape)
+    assert len(shape) == 3
+    shape[2] *= 2
+    return tuple(shape)
+
+
+def ECG_model(config):
+    """ 
+    implementation of the model in https://www.nature.com/articles/s41591-018-0268-3 
+    also have reference to codes at 
+    https://github.com/awni/ecg/blob/master/ecg/network.py 
+    and 
+    https://github.com/fernandoandreotti/cinc-challenge2017/blob/master/deeplearn-approach/train_model.py
+    """
+    def first_conv_block(inputs, config):
+        layer = Conv1D(filters=config.filter_length,
+               kernel_size=config.kernel_size,
+               padding='same',
+               strides=1,
+               kernel_initializer='he_normal')(inputs)
+        layer = BatchNormalization()(layer)
+        layer = Activation('relu')(layer)
+
+        shortcut = MaxPooling1D(pool_size=1,
+                      strides=1)(layer)
+
+        layer =  Conv1D(filters=config.filter_length,
+               kernel_size=config.kernel_size,
+               padding='same',
+               strides=1,
+               kernel_initializer='he_normal')(layer)
+        layer = BatchNormalization()(layer)
+        layer = Activation('relu')(layer)
+        layer = Dropout(config.drop_rate)(layer)
+        layer =  Conv1D(filters=config.filter_length,
+                        kernel_size=config.kernel_size,
+                        padding='same',
+                        strides=1,
+                        kernel_initializer='he_normal')(layer)
+        return add([shortcut, layer])
+
+    def main_loop_blocks(layer, config):
+        filter_length = config.filter_length
+        n_blocks = 15
+        for block_index in range(n_blocks):
+
+            subsample_length = 2 if block_index % 2 == 0 else 1
+            shortcut = MaxPooling1D(pool_size=subsample_length)(layer)
+
+            if block_index % 4 == 0 and block_index > 0 :
+                shortcut = Lambda(zeropad, output_shape=zeropad_output_shape)(shortcut)
+                filter_length *= 2
+
+            layer = BatchNormalization()(layer)
+            layer = Activation('relu')(layer)
+            layer =  Conv1D(filters= filter_length,
+                            kernel_size=config.kernel_size,
+                            padding='same',
+                            strides=subsample_length,
+                            kernel_initializer='he_normal')(layer)
+            layer = BatchNormalization()(layer)
+            layer = Activation('relu')(layer)
+            layer = Dropout(config.drop_rate)(layer)
+            layer =  Conv1D(filters= filter_length,
+                            kernel_size=config.kernel_size,
+                            padding='same',
+                            strides= 1,
+                            kernel_initializer='he_normal')(layer)
+            layer = add([shortcut, layer])
+        return layer
+
+    def output_block(layer, config):
+        layer = BatchNormalization()(layer)
+        layer = Activation('relu')(layer)
+        layer = Flatten()(layer)
+        outputs = Dense(len_classes, activation='softmax')(layer)
+        model = Model(inputs=inputs, outputs=outputs)
+        
+        adam = Adam(learning_rate=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-7, amsgrad=False)
+        model.compile(optimizer= adam,
+                  loss='categorical_crossentropy',
+                  metrics=['accuracy'])
+        model.summary()
+        return model
+
+    classes = ['N','V','/','A','F','~']
+    len_classes = len(classes)
+
+    inputs = Input(shape=(config.input_size, 1), name='input')
+    layer = first_conv_block(inputs, config)
+    layer = main_loop_blocks(layer, config)
+    return output_block(layer, config)

src/model_loader.py

@@ -0,0 +1,45 @@
+
+from keras.models import load_model
+from graph import zeropad, zeropad_output_shape 
+from pathlib import Path
+import joblib
+from download_models import ensure_models_downloaded
+
+def load_mitbih_model():
+    ensure_models_downloaded()
+    return load_model(
+        "models/MLII-latest.keras",
+        custom_objects={
+            "zeropad": zeropad,
+            "zeropad_output_shape": zeropad_output_shape
+        },
+        compile=False
+    )
+
+def load_pcg_model():
+    ensure_models_downloaded()
+    model_path = Path("models/pcg_model.h5")
+    if not model_path.exists():
+        raise FileNotFoundError(f"PCG model not found at {model_path.resolve()}")
+    
+    model = load_model(model_path, compile=False)
+    model.compile()
+    return model
+
+def load_emg_model():
+    ensure_models_downloaded()
+    model_path = Path("models/emg_classifier_txt.h5")
+    if not model_path.exists():
+        raise FileNotFoundError(f"EMG model not found at {model_path.resolve()}")
+    model = load_model(model_path, compile=False)
+    model.compile()         
+    return model
+
+
+def load_vag_model():
+    ensure_models_downloaded()
+    p = Path("models/vag_feature_classifier.pkl")
+    if not p.exists():
+        raise FileNotFoundError(f"No VAG model at {p.resolve()}")
+    return joblib.load(p)    
+    

src/util.py

@@ -0,0 +1,213 @@
+
+import numpy as np
+import pandas as pd
+from scipy.signal import resample
+from sklearn.preprocessing import scale
+import soundfile as sf
+from gemini import query_gemini_rest
+import librosa
+import tempfile
+
+
+EXPECTED_LEN = 256
+STEP = 128
+
+PCG_LABELS = [
+    "Normal",
+    "Aortic Stenosis",
+    "Mitral Stenosis",
+    "Mitral Valve Prolapse",
+    "Pericardial Murmurs"
+]
+
+LABELS_EMG = ["healthy", "myopathy", "neuropathy"]
+
+def load_uploaded_file(file, signal_type="ECG") -> np.ndarray:
+    name = file.name.lower()
+
+ 
+    if signal_type in ("ECG", "EMG"):
+        text = file.read().decode("utf-8").strip()
+        if "," in text:
+            vals = [float(x) for x in text.split(",") if x.strip()]
+        else:
+            vals = [float(x) for x in text.splitlines() if x.strip()]
+        return np.array(vals, dtype=np.float32)
+
+ 
+    if signal_type == "VAG":
+        if name.endswith(".csv"):
+            df = pd.read_csv(file)
+            features = [
+                "rms_amplitude",
+                "peak_frequency",
+                "spectral_entropy",
+                "zero_crossing_rate",
+                "mean_frequency",
+            ]
+            return df[features].iloc[0].values.astype(np.float32)
+
+        elif name.endswith(".npy"):
+            return np.load(file)
+
+        elif name.endswith(".wav"):
+            data, _ = sf.read(file)
+            return data.astype(np.float32)
+
+        raise ValueError("Unsupported VAG file format.")
+
+  
+    if signal_type == "PCG" and name.endswith((".wav", ".flac", ".mp3")):
+        data, _ = sf.read(file)
+        if data.ndim > 1:         
+            data = data[:, 0]
+        return data.astype(np.float32)
+
+    raise ValueError("Unsupported file format.")
+
+
+def preprocess_signal(x: np.ndarray) -> np.ndarray:
+    if x.size != EXPECTED_LEN:
+        x = resample(x, EXPECTED_LEN)
+    return scale(x).astype(np.float32)   
+
+
+def segment_signal(raw: np.ndarray) -> np.ndarray:
+    raw = preprocess_signal(raw)        
+    seg = raw.reshape(EXPECTED_LEN, 1)    
+    return seg[np.newaxis, ...]            
+
+
+
+PCG_INPUT_LEN = 995        
+
+def preprocess_pcg_waveform(wave: np.ndarray) -> np.ndarray:
+
+    if wave.ndim > 1:
+        wave = wave.mean(axis=1)
+
+  
+    if len(wave) < PCG_INPUT_LEN:
+        wave = np.pad(wave, (0, PCG_INPUT_LEN - len(wave)))
+    else:
+        wave = wave[:PCG_INPUT_LEN]
+
+    
+    wave = (wave - np.mean(wave)) / (np.std(wave) + 1e-8)
+    return wave.astype(np.float32)
+
+def analyze_pcg_signal(file, model, gemini_key=None):
+    
+    signal, _ = sf.read(file)                      
+    signal = preprocess_pcg_waveform(signal)       
+
+    input_data = signal.reshape(1, PCG_INPUT_LEN, 1)  
+    preds = model.predict(input_data, verbose=0)[0]
+
+    labels = [
+        "Normal",
+        "Aortic Stenosis",
+        "Mitral Stenosis",
+        "Mitral Valve Prolapse",
+        "Pericardial Murmurs",
+    ]
+    idx = int(np.argmax(preds))
+    confidence = float(preds[idx])
+    label = labels[idx]
+
+    gem_txt = None
+    if gemini_key:
+        gem_txt = query_gemini_rest("PCG", label, confidence, gemini_key)
+
+    return label, label, confidence, gem_txt
+
+
+
+
+def pcg_to_features(file_obj, target_sr=16000, n_mels=128, n_frames=112):
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
+        tmp.write(file_obj.read())
+        tmp_path = tmp.name
+
+   
+    y, sr = librosa.load(tmp_path, sr=target_sr, mono=True)
+
+    
+    mel = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=512, hop_length=256, n_mels=n_mels)
+    logmel = librosa.power_to_db(mel, ref=np.max) 
+    if logmel.shape[1] < n_frames:
+        
+        pad_width = n_frames - logmel.shape[1]
+        pad = np.zeros((n_mels, pad_width))
+        logmel = np.hstack((logmel, pad))
+    else:
+        logmel = logmel[:, :n_frames]
+
+    
+    feat = logmel.flatten().astype(np.float32)
+
+    return feat[np.newaxis, ...]
+
+
+def analyze_emg_signal(file, model, gemini_key=""):
+    raw  = load_uploaded_file(file, signal_type="EMG")    
+    
+    WINDOW = 1000
+
+    wins = []
+    if len(raw) < WINDOW:                                
+        pad = np.pad(raw, (0, WINDOW - len(raw)))
+        wins.append(((pad - pad.mean()) / (pad.std()+1e-6)).reshape(WINDOW, 1))
+    else:                                                 
+        for i in range(0, len(raw) - WINDOW + 1, WINDOW):
+            win = raw[i:i+WINDOW]
+            win = (win - win.mean()) / (win.std() + 1e-6)
+            wins.append(win.reshape(WINDOW, 1))
+    X = np.array(wins, dtype=np.float32)
+
+    preds = model.predict(X, verbose=0)
+    classes = np.argmax(preds, axis=1)
+    final   = int(np.bincount(classes).argmax())          
+    conf    = float(preds[:, final].mean())               
+    human   = LABELS_EMG[final]
+
+    gemini_txt = None
+    if gemini_key:
+        gemini_txt = query_gemini_rest("EMG", human, conf, gemini_key)
+
+    return human, conf, gemini_txt
+
+
+
+FEATURE_COLS = [
+    "rms_amplitude",
+    "peak_frequency",
+    "spectral_entropy",
+    "zero_crossing_rate",
+    "mean_frequency",
+]
+
+def vag_to_features(file_obj) -> np.ndarray:
+    df = pd.read_csv(file_obj)
+    x = df[FEATURE_COLS].iloc[0].values.astype(np.float32)
+    return x.reshape(1, -1)
+
+
+def predict_vag_from_features(file_obj, model_bundle, gemini_key=""):
+    model   = model_bundle["model"]
+    scaler  = model_bundle["scaler"]
+    encoder = model_bundle["encoder"]
+
+    x   = vag_to_features(file_obj)
+    x_s = scaler.transform(x)
+    prob = model.predict_proba(x_s)[0]
+    idx  = int(np.argmax(prob))
+    conf = float(prob[idx])
+    label = encoder.inverse_transform([idx])[0].title()
+
+    gem_note = (
+        query_gemini_rest("VAG", label, conf, gemini_key)
+        if gemini_key else None
+    )
+    return label, label, conf, gem_note

src/vag_util.py

@@ -0,0 +1,29 @@
+
+
+import pandas as pd
+import numpy as np
+
+def predict_vag_from_features(file, model, gemini_key=None):
+    df = pd.read_csv(file)
+    required_features = [
+        "rms_amplitude",
+        "peak_frequency",
+        "spectral_entropy",
+        "zero_crossing_rate",
+        "mean_frequency"
+    ]
+
+    x = df[required_features].values.astype(np.float32)
+    preds = model.predict_proba(x)[0]
+    idx = int(np.argmax(preds))
+    confidence = float(preds[idx])
+
+    labels = ["normal", "osteoarthritis", "ligament_injury"]
+    label = labels[idx]
+
+    gem_txt = None
+    if gemini_key:
+        from gemini import query_gemini_rest
+        gem_txt = query_gemini_rest("VAG", label, confidence, gemini_key)
+
+    return label, label, confidence, gem_txt