Fix JSON serialization error: Convert all numpy types to Python native types for clinical analysis

clinical_analysis.py

@@ -126,23 +126,27 @@ def extract_clinical_from_probabilities(probs: np.ndarray) -> Dict[str, Any]:
         # Calculate confidence metrics
         confidence_metrics = calculate_confidence_metrics(probs, thresholds)
         
+        # Ensure all numpy types are converted to Python native types for JSON serialization
+        probabilities_list = [float(p) for p in probs]
+        label_probs_dict = {str(label): float(prob) for label, prob in zip(labels, probs)}
+        
         return {
-            "rhythm": rhythm,
+            "rhythm": str(rhythm),
             "heart_rate": None,  # Will be calculated from features if available
             "qrs_duration": None,  # Will be calculated from features if available
             "qt_interval": None,  # Will be calculated from features if available
             "pr_interval": None,  # Will be calculated from features if available
             "axis_deviation": "Normal",  # Will be calculated from features if available
-            "abnormalities": abnormalities,
-            "confidence": confidence_metrics["overall_confidence"],
-            "confidence_level": confidence_metrics["confidence_level"],
-            "review_required": confidence_metrics["review_required"],
-            "probabilities": probs.tolist(),
-            "label_probabilities": dict(zip(labels, probs.tolist())),
+            "abnormalities": [str(abnormality) for abnormality in abnormalities],
+            "confidence": float(confidence_metrics["overall_confidence"]),
+            "confidence_level": str(confidence_metrics["confidence_level"]),
+            "review_required": bool(confidence_metrics["review_required"]),
+            "probabilities": probabilities_list,
+            "label_probabilities": label_probs_dict,
             "method": "clinical_predictions",
             "warning": None,
-            "labels_used": labels,
-            "thresholds_used": thresholds
+            "labels_used": [str(label) for label in labels],
+            "thresholds_used": {str(k): float(v) for k, v in thresholds.items()}
         }
         
     except Exception as e:
@@ -310,9 +314,9 @@ def calculate_confidence_metrics(probs: np.ndarray, thresholds: Dict[str, float]
     review_required = max_prob < 0.6 or mean_prob < 0.4
     
     return {
-        "overall_confidence": overall_confidence,
-        "confidence_level": confidence_level,
-        "review_required": review_required,
+        "overall_confidence": float(overall_confidence),
+        "confidence_level": str(confidence_level),
+        "review_required": bool(review_required),
         "mean_probability": float(mean_prob),
         "max_probability": float(max_prob)
     }

comprehensive_ecg_test.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""
+Comprehensive Multi-ECG Testing and Evaluation
+Tests multiple ECG samples and analyzes results systematically
+"""
+
+import requests
+import numpy as np
+import pandas as pd
+import json
+import time
+import os
+from typing import Dict, Any, List
+from datetime import datetime
+
+# Configuration
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"
+ECG_DIR = "../ecg_uploads_greenwich/"
+INDEX_FILE = "../Greenwichschooldata.csv"
+
+def load_ecg_data(csv_file: str) -> List[List[float]]:
+    """Load ECG data from CSV file"""
+    try:
+        df = pd.read_csv(csv_file)
+        ecg_data = []
+        for lead in df.columns:
+            ecg_data.append(df[lead].astype(float).tolist())
+        return ecg_data
+    except Exception as e:
+        print(f"❌ Error loading ECG data: {e}")
+        return None
+
+def test_individual_endpoints(ecg_data: List[List[float]], patient_info: Dict[str, Any]) -> Dict[str, Any]:
+    """Test all individual endpoints with comprehensive analysis"""
+    results = {}
+    
+    print(f"🧪 Testing individual endpoints for {patient_info.get('Patient Name', 'Unknown')}")
+    
+    # Test 1: Extract Features (Physiological measurements)
+    print("1️⃣ Testing /extract_features endpoint...")
+    try:
+        payload = {"signal": ecg_data, "fs": 500}
+        response = requests.post(f"{API_BASE_URL}/extract_features", json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            result = response.json()
+            physio = result.get('physiological_parameters', {})
+            
+            print(f"   ✅ Features extracted successfully")
+            print(f"   📊 Feature count: {result.get('features', {}).get('count', 'Unknown')}")
+            print(f"   📊 Feature dimension: {result.get('features', {}).get('dimension', 'Unknown')}")
+            print(f"   💓 Heart Rate: {physio.get('heart_rate')} BPM")
+            print(f"   📏 QRS Duration: {physio.get('qrs_duration')} ms")
+            print(f"   ⏱️  QT Interval: {physio.get('qt_interval')} ms")
+            print(f"   🔗 PR Interval: {physio.get('pr_interval')} ms")
+            print(f"   🧭 QRS Axis: {physio.get('qrs_axis')}°")
+            
+            results['extract_features'] = {"status": "success", "data": result}
+        else:
+            print(f"   ❌ Failed: {response.status_code}")
+            results['extract_features'] = {"status": "error", "error": response.text}
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        results['extract_features'] = {"status": "error", "error": str(e)}
+    
+    # Test 2: Assess Quality
+    print("2️⃣ Testing /assess_quality endpoint...")
+    try:
+        payload = {"signal": ecg_data, "fs": 500}
+        response = requests.post(f"{API_BASE_URL}/assess_quality", json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"   ✅ Quality assessment completed")
+            print(f"   🔍 Overall Quality: {result.get('quality', 'Unknown')}")
+            metrics = result.get('metrics', {})
+            print(f"   📊 SNR: {metrics.get('signal_to_noise_ratio', 'Unknown')}")
+            print(f"   📊 Baseline Wander: {metrics.get('baseline_wander', 'Unknown')}")
+            print(f"   📊 Standard Deviation: {metrics.get('standard_deviation', 'Unknown')}")
+            
+            results['assess_quality'] = {"status": "success", "data": result}
+        else:
+            print(f"   ❌ Failed: {response.status_code}")
+            results['assess_quality'] = {"status": "error", "error": response.text}
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        results['assess_quality'] = {"status": "error", "error": str(e)}
+    
+    # Test 3: Predict endpoint
+    print("3️⃣ Testing /predict endpoint...")
+    try:
+        payload = {"signal": ecg_data, "fs": 500}
+        response = requests.post(f"{API_BASE_URL}/predict", json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"   ✅ Prediction completed")
+            print(f"   🧬 Model Type: {result.get('model_type', 'Unknown')}")
+            print(f"   📊 Confidence: {result.get('confidence', 'Unknown')}")
+            
+            results['predict'] = {"status": "success", "data": result}
+        else:
+            print(f"   ❌ Failed: {response.status_code}")
+            results['assess_quality'] = {"status": "error", "error": response.text}
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        results['predict'] = {"status": "error", "error": str(e)}
+    
+    return results
+
+def analyze_physiological_consistency(all_results: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze consistency of physiological measurements across samples"""
+    print(f"\n📊 PHYSIOLOGICAL MEASUREMENT CONSISTENCY ANALYSIS")
+    print(f"=" * 70)
+    
+    # Extract all heart rate values
+    hr_values = []
+    qrs_values = []
+    qt_values = []
+    pr_values = []
+    axis_values = []
+    
+    for patient_id, result in all_results.items():
+        if 'endpoint_tests' in result and 'extract_features' in result['endpoint_tests']:
+            physio = result['endpoint_tests']['extract_features'].get('data', {}).get('physiological_parameters', {})
+            
+            if physio.get('heart_rate') is not None:
+                hr_values.append(physio['heart_rate'])
+            if physio.get('qrs_duration') is not None:
+                qrs_values.append(physio['qrs_duration'])
+            if physio.get('qt_interval') is not None:
+                qt_values.append(physio['qt_interval'])
+            if physio.get('pr_interval') is not None:
+                pr_values.append(physio['pr_interval'])
+            if physio.get('qrs_axis') is not None:
+                axis_values.append(physio['qrs_axis'])
+    
+    analysis = {}
+    
+    # Heart Rate Analysis
+    if len(hr_values) > 0:
+        hr_std = np.std(hr_values)
+        hr_range = np.ptp(hr_values)
+        print(f"💓 Heart Rate Analysis:")
+        print(f"   Values: {hr_values}")
+        print(f"   Mean: {np.mean(hr_values):.1f} BPM")
+        print(f"   Standard Deviation: {hr_std:.2f} BPM")
+        print(f"   Range: {hr_range:.1f} BPM")
+        print(f"   Consistency: {'✅ Excellent' if hr_std < 2.0 else '⚠️ Good' if hr_std < 5.0 else '❌ Poor'}")
+        
+        analysis['heart_rate'] = {
+            'values': hr_values,
+            'mean': np.mean(hr_values),
+            'std': hr_std,
+            'range': hr_range,
+            'consistency': 'Excellent' if hr_std < 2.0 else 'Good' if hr_std < 5.0 else 'Poor'
+        }
+    
+    # QRS Duration Analysis
+    if len(qrs_values) > 0:
+        qrs_std = np.std(qrs_values)
+        qrs_range = np.ptp(qrs_values)
+        print(f"\n📏 QRS Duration Analysis:")
+        print(f"   Values: {qrs_values}")
+        print(f"   Mean: {np.mean(qrs_values):.1f} ms")
+        print(f"   Standard Deviation: {qrs_std:.2f} ms")
+        print(f"   Range: {qrs_range:.1f} ms")
+        print(f"   Consistency: {'✅ Excellent' if qrs_std < 5.0 else '⚠️ Good' if qrs_std < 10.0 else '❌ Poor'}")
+        
+        analysis['qrs_duration'] = {
+            'values': qrs_values,
+            'mean': np.mean(qrs_values),
+            'std': qrs_std,
+            'range': qrs_range,
+            'consistency': 'Excellent' if qrs_std < 5.0 else 'Good' if qrs_std < 10.0 else 'Poor'
+        }
+    
+    # Overall Assessment
+    print(f"\n🎯 OVERALL PHYSIOLOGICAL ASSESSMENT:")
+    working_params = len([k for k in analysis.keys() if analysis[k]['consistency'] in ['Excellent', 'Good']])
+    total_params = len(analysis)
+    
+    print(f"   Working Parameters: {working_params}/{total_params}")
+    print(f"   Success Rate: {(working_params/total_params)*100:.1f}%")
+    
+    if working_params == total_params:
+        print(f"   🎉 All physiological parameters working consistently!")
+    elif working_params > total_params // 2:
+        print(f"   ⚠️  Most parameters working - some inconsistencies")
+    else:
+        print(f"   ❌ Many parameters showing inconsistencies")
+    
+    return analysis
+
+def main():
+    """Main test function"""
+    print("🚀 COMPREHENSIVE MULTI-ECG TESTING AND EVALUATION")
+    print("=" * 80)
+    print(f"🌐 API URL: {API_BASE_URL}")
+    print(f"📁 ECG Directory: {ECG_DIR}")
+    print(f"📋 Index File: {INDEX_FILE}")
+    print()
+    
+    # Check if files exist
+    if not os.path.exists(INDEX_FILE):
+        print(f"❌ Index file not found: {INDEX_FILE}")
+        return
+    
+    if not os.path.exists(ECG_DIR):
+        print(f"❌ ECG directory not found: {ECG_DIR}")
+        return
+    
+    # Load index file
+    try:
+        print("📁 Loading patient index file...")
+        index_df = pd.read_csv(INDEX_FILE)
+        print(f"✅ Loaded {len(index_df)} patient records")
+    except Exception as e:
+        print(f"❌ Error loading index file: {e}")
+        return
+    
+    # Select multiple ECG files for testing
+    test_files = [
+        "ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv",  # Bharathi M K Teacher, 31, F
+        "ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv",  # Sayida thasmiya Bhanu Teacher, 29, F
+        "ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv",  # Afzal, 46, M
+        # Add more files if available
+    ]
+    
+    print(f"\n🚀 Testing with {len(test_files)} ECG samples...")
+    print("=" * 80)
+    
+    all_results = {}
+    
+    for i, ecg_file in enumerate(test_files, 1):
+        try:
+            print(f"\n📊 Processing {i}/{len(test_files)}: {ecg_file}")
+            
+            # Find patient info in index
+            patient_row = index_df[index_df['ECG File Path'].str.contains(ecg_file, na=False)]
+            if len(patient_row) == 0:
+                print(f"   ⚠️  Patient info not found for {ecg_file}")
+                continue
+            
+            patient_info = patient_row.iloc[0]
+            print(f"   👤 Patient: {patient_info['Patient Name']} ({patient_info['Age']} {patient_info['Gender']})")
+            
+            # Check if ECG file exists
+            ecg_path = os.path.join(ECG_DIR, ecg_file)
+            if not os.path.exists(ecg_path):
+                print(f"   ❌ ECG file not found: {ecg_path}")
+                continue
+            
+            # Load ECG data
+            ecg_data = load_ecg_data(ecg_path)
+            if ecg_data is None:
+                print(f"   ❌ Failed to load ECG data")
+                continue
+            
+            # Test individual endpoints
+            endpoint_results = test_individual_endpoints(ecg_data, patient_info)
+            
+            # Store results
+            all_results[ecg_file] = {
+                "patient_info": patient_info.to_dict(),
+                "endpoint_tests": endpoint_results
+            }
+            
+            print(f"   ✅ Completed analysis for {ecg_file}")
+            
+        except Exception as e:
+            print(f"   ❌ Error processing {ecg_file}: {e}")
+            all_results[ecg_file] = {"error": str(e)}
+    
+    # Analyze physiological consistency
+    if len(all_results) > 0:
+        physiological_analysis = analyze_physiological_consistency(all_results)
+        
+        # Summary report
+        print(f"\n📊 COMPREHENSIVE TEST SUMMARY")
+        print(f"=" * 80)
+        
+        successful_tests = 0
+        total_tests = len(test_files)
+        
+        for ecg_file, result in all_results.items():
+            if "error" not in result:
+                endpoint_status = result.get("endpoint_tests", {})
+                working_endpoints = sum(1 for ep in endpoint_status.values() if ep.get("status") == "success")
+                total_endpoints = len(endpoint_status)
+                
+                if working_endpoints == total_endpoints:
+                    successful_tests += 1
+                    print(f"✅ {ecg_file}: All endpoints working")
+                else:
+                    print(f"⚠️  {ecg_file}: {working_endpoints}/{total_endpoints} endpoints working")
+            else:
+                print(f"❌ {ecg_file}: {result['error']}")
+        
+        print(f"\n🎯 OVERALL RESULTS:")
+        print(f"   Successful ECG Analysis: {successful_tests}/{total_tests}")
+        print(f"   Success Rate: {(successful_tests/total_tests)*100:.1f}%")
+        
+        # Save detailed results
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        results_file = f"comprehensive_ecg_test_results_{timestamp}.json"
+        
+        try:
+            with open(results_file, 'w') as f:
+                json.dump(all_results, f, indent=2, default=str)
+            print(f"\n💾 Detailed results saved to: {results_file}")
+        except Exception as e:
+            print(f"\n⚠️  Could not save results: {e}")
+    
+    print(f"\n🎉 Comprehensive ECG testing completed!")
+    print(f"💡 Check the results above to evaluate system performance")
+
+if __name__ == "__main__":
+    main()

comprehensive_ecg_test_results_20250828_151718.json

@@ -0,0 +1,233 @@
+{
+  "ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Bharathi M K Teacher",
+      "Age": 31,
+      "Gender": "Female",
+      "Created At": "2025-07-21T10:10:05.716Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv",
+      "Ai Result": "No abnormality detected"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 335.99,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 150.8,
+            "qt_interval": 413.3,
+            "pr_interval": 159.1,
+            "qrs_axis": 30.1,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 6.51,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 36.6422,
+            "signal_to_noise_ratio": 0.6119,
+            "baseline_wander": 5.6589,
+            "peak_to_peak": 411.0937,
+            "mean_amplitude": 22.4223
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "success",
+        "data": {
+          "prediction": "ECG analysis completed",
+          "confidence": 0.8,
+          "features": {},
+          "model_type": "ECG-FM Pretrained (fairseq_signals)",
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  },
+  "ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Sayida thasmiya Bhanu Teacher",
+      "Age": 29,
+      "Gender": "Female",
+      "Created At": "2025-07-21T07:22:38.484Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv",
+      "Ai Result": "ST(29.1%)"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 302.79,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 59.7,
+            "qrs_duration": 157.0,
+            "qt_interval": 415.0,
+            "pr_interval": 160.9,
+            "qrs_axis": 28.3,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 4.11,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 46.0951,
+            "signal_to_noise_ratio": 0.364,
+            "baseline_wander": 9.0349,
+            "peak_to_peak": 837.1298,
+            "mean_amplitude": 16.7801
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "success",
+        "data": {
+          "prediction": "ECG analysis completed",
+          "confidence": 0.8,
+          "features": {},
+          "model_type": "ECG-FM Pretrained (fairseq_signals)",
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  },
+  "ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Afzal",
+      "Age": 46,
+      "Gender": "Male",
+      "Created At": "2025-07-21T07:40:50.401Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv",
+      "Ai Result": "RBBB(0.0%)"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 633.98,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 80.2,
+            "qt_interval": 408.5,
+            "pr_interval": 160.7,
+            "qrs_axis": 29.6,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 5.76,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 66.1427,
+            "signal_to_noise_ratio": 0.4547,
+            "baseline_wander": 9.3757,
+            "peak_to_peak": 1103.498,
+            "mean_amplitude": 30.0723
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "success",
+        "data": {
+          "prediction": "ECG analysis completed",
+          "confidence": 0.8,
+          "features": {},
+          "model_type": "ECG-FM Pretrained (fairseq_signals)",
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  }
+}

finetuned_clinical_test_results_20250828_152404.json

@@ -0,0 +1,176 @@
+{
+  "ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Bharathi M K Teacher",
+      "Age": 31,
+      "Gender": "Female",
+      "Created At": "2025-07-21T10:10:05.716Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv",
+      "Ai Result": "No abnormality detected"
+    },
+    "endpoint_tests": {
+      "clinical_analysis": {
+        "status": "error",
+        "error": "Internal Server Error"
+      },
+      "direct_clinical": {
+        "status": "not_available"
+      },
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 671.05,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 150.8,
+            "qt_interval": 413.3,
+            "pr_interval": 159.1,
+            "qrs_axis": 30.1,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  },
+  "ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Sayida thasmiya Bhanu Teacher",
+      "Age": 29,
+      "Gender": "Female",
+      "Created At": "2025-07-21T07:22:38.484Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv",
+      "Ai Result": "ST(29.1%)"
+    },
+    "endpoint_tests": {
+      "clinical_analysis": {
+        "status": "error",
+        "error": "Internal Server Error"
+      },
+      "direct_clinical": {
+        "status": "not_available"
+      },
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 519.92,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 59.7,
+            "qrs_duration": 157.0,
+            "qt_interval": 415.0,
+            "pr_interval": 160.9,
+            "qrs_axis": 28.3,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  },
+  "ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Afzal",
+      "Age": 46,
+      "Gender": "Male",
+      "Created At": "2025-07-21T07:40:50.401Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv",
+      "Ai Result": "RBBB(0.0%)"
+    },
+    "endpoint_tests": {
+      "clinical_analysis": {
+        "status": "error",
+        "error": "Internal Server Error"
+      },
+      "direct_clinical": {
+        "status": "not_available"
+      },
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 501.82,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 80.2,
+            "qt_interval": 408.5,
+            "pr_interval": 160.7,
+            "qrs_axis": 29.6,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  }
+}

physiological_parameter_test_results_20250828_145018.json

@@ -0,0 +1,227 @@
+{
+  "ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Bharathi M K Teacher",
+      "Age": 31,
+      "Gender": "Female",
+      "Created At": "2025-07-21T10:10:05.716Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv",
+      "Ai Result": "No abnormality detected"
+    },
+    "physiological_analysis": {
+      "status": "error",
+      "error": "Object of type int64 is not JSON serializable"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 412.11,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 150.8,
+            "qt_interval": 413.3,
+            "pr_interval": 159.1,
+            "qrs_axis": 30.1,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 3.94,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 36.6422,
+            "signal_to_noise_ratio": 0.6119,
+            "baseline_wander": 5.6589,
+            "peak_to_peak": 411.0937,
+            "mean_amplitude": 22.4223
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "error",
+        "error": "{\"detail\":\"Prediction failed: forward() takes 1 positional argument but 2 were given\"}"
+      }
+    }
+  },
+  "ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Sayida thasmiya Bhanu Teacher",
+      "Age": 29,
+      "Gender": "Female",
+      "Created At": "2025-07-21T07:22:38.484Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv",
+      "Ai Result": "ST(29.1%)"
+    },
+    "physiological_analysis": {
+      "status": "error",
+      "error": "Object of type int64 is not JSON serializable"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 446.46,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 59.7,
+            "qrs_duration": 157.0,
+            "qt_interval": 415.0,
+            "pr_interval": 160.9,
+            "qrs_axis": 28.3,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 12.54,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 46.0951,
+            "signal_to_noise_ratio": 0.364,
+            "baseline_wander": 9.0349,
+            "peak_to_peak": 837.1298,
+            "mean_amplitude": 16.7801
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "error",
+        "error": "{\"detail\":\"Prediction failed: forward() takes 1 positional argument but 2 were given\"}"
+      }
+    }
+  },
+  "ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Afzal",
+      "Age": 46,
+      "Gender": "Male",
+      "Created At": "2025-07-21T07:40:50.401Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv",
+      "Ai Result": "RBBB(0.0%)"
+    },
+    "physiological_analysis": {
+      "status": "error",
+      "error": "Object of type int64 is not JSON serializable"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 405.26,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 80.2,
+            "qt_interval": 408.5,
+            "pr_interval": 160.7,
+            "qrs_axis": 29.6,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 7.92,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 66.1427,
+            "signal_to_noise_ratio": 0.4547,
+            "baseline_wander": 9.3757,
+            "peak_to_peak": 1103.498,
+            "mean_amplitude": 30.0723
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "error",
+        "error": "{\"detail\":\"Prediction failed: forward() takes 1 positional argument but 2 were given\"}"
+      }
+    }
+  }
+}

physiological_parameter_test_results_20250828_150828.json

@@ -0,0 +1,245 @@
+{
+  "ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Bharathi M K Teacher",
+      "Age": 31,
+      "Gender": "Female",
+      "Created At": "2025-07-21T10:10:05.716Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv",
+      "Ai Result": "No abnormality detected"
+    },
+    "physiological_analysis": {
+      "status": "error",
+      "error": "Object of type int64 is not JSON serializable"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 778.07,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 150.8,
+            "qt_interval": 413.3,
+            "pr_interval": 159.1,
+            "qrs_axis": 30.1,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 6.66,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 36.6422,
+            "signal_to_noise_ratio": 0.6119,
+            "baseline_wander": 5.6589,
+            "peak_to_peak": 411.0937,
+            "mean_amplitude": 22.4223
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "success",
+        "data": {
+          "prediction": "ECG analysis completed",
+          "confidence": 0.8,
+          "features": {},
+          "model_type": "ECG-FM Pretrained (fairseq_signals)",
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  },
+  "ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Sayida thasmiya Bhanu Teacher",
+      "Age": 29,
+      "Gender": "Female",
+      "Created At": "2025-07-21T07:22:38.484Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv",
+      "Ai Result": "ST(29.1%)"
+    },
+    "physiological_analysis": {
+      "status": "error",
+      "error": "Object of type int64 is not JSON serializable"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 402.7,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 59.7,
+            "qrs_duration": 157.0,
+            "qt_interval": 415.0,
+            "pr_interval": 160.9,
+            "qrs_axis": 28.3,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 8.91,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 46.0951,
+            "signal_to_noise_ratio": 0.364,
+            "baseline_wander": 9.0349,
+            "peak_to_peak": 837.1298,
+            "mean_amplitude": 16.7801
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "success",
+        "data": {
+          "prediction": "ECG analysis completed",
+          "confidence": 0.8,
+          "features": {},
+          "model_type": "ECG-FM Pretrained (fairseq_signals)",
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  },
+  "ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv": {
+    "patient_info": {
+      "Organization": "Greenberg international school",
+      "Department": "General",
+      "Patient Name": "Afzal",
+      "Age": 46,
+      "Gender": "Male",
+      "Created At": "2025-07-21T07:40:50.401Z",
+      "ECG File Path": "ecg_uploads_greenwich/ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv",
+      "Ai Result": "RBBB(0.0%)"
+    },
+    "physiological_analysis": {
+      "status": "error",
+      "error": "Object of type int64 is not JSON serializable"
+    },
+    "endpoint_tests": {
+      "extract_features": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 376.8,
+          "features": {
+            "count": 79872,
+            "dimension": 256,
+            "extraction_method": "ECG-FM pretrained model"
+          },
+          "physiological_parameters": {
+            "heart_rate": 60.0,
+            "qrs_duration": 80.2,
+            "qt_interval": 408.5,
+            "pr_interval": 160.7,
+            "qrs_axis": 29.6,
+            "extraction_method": "ECG-FM validated feature analysis",
+            "confidence": "High",
+            "feature_dimension": 79872,
+            "clinical_ranges": {
+              "heart_rate": "30-200 BPM",
+              "qrs_duration": "40-200 ms",
+              "qt_interval": "300-600 ms",
+              "pr_interval": "100-300 ms",
+              "qrs_axis": "-180\u00b0 to +180\u00b0"
+            },
+            "extraction_confidence": {
+              "heart_rate": "High",
+              "qrs_duration": "High",
+              "qt_interval": "High",
+              "pr_interval": "High",
+              "qrs_axis": "High"
+            }
+          },
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      },
+      "assess_quality": {
+        "status": "success",
+        "data": {
+          "status": "success",
+          "processing_time_ms": 4.79,
+          "quality": "Poor",
+          "metrics": {
+            "standard_deviation": 66.1427,
+            "signal_to_noise_ratio": 0.4547,
+            "baseline_wander": 9.3757,
+            "peak_to_peak": 1103.498,
+            "mean_amplitude": 30.0723
+          },
+          "assessment_method": "Statistical analysis + ECG-FM feature validation"
+        }
+      },
+      "predict": {
+        "status": "success",
+        "data": {
+          "prediction": "ECG analysis completed",
+          "confidence": 0.8,
+          "features": {},
+          "model_type": "ECG-FM Pretrained (fairseq_signals)",
+          "model_source": "wanglab/ecg-fm/mimic_iv_ecg_physionet_pretrained.pt"
+        }
+      }
+    }
+  }
+}

quick_test_fix.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Quick Test to Verify JSON Serialization Fix
+Tests the /analyze endpoint with a simple ECG sample
+"""
+
+import requests
+import numpy as np
+import json
+
+# Configuration
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"
+
+def create_test_ecg():
+    """Create a simple test ECG signal"""
+    # Generate a simple 10-second ECG-like signal at 500 Hz
+    t = np.linspace(0, 10, 5000)
+    
+    # Create a simple ECG-like waveform
+    signal = []
+    for lead in range(12):
+        # Basic sine wave with some variation
+        lead_signal = np.sin(2 * np.pi * 1.2 * t) * 0.5  # ~72 BPM
+        lead_signal += np.random.normal(0, 0.1, 5000)  # Add noise
+        signal.append(lead_signal.tolist())
+    
+    return signal
+
+def test_analyze_endpoint():
+    """Test the /analyze endpoint with the fix"""
+    print("🧪 Testing /analyze endpoint with JSON serialization fix...")
+    
+    # Create test ECG data
+    ecg_data = create_test_ecg()
+    
+    payload = {
+        "signal": ecg_data,
+        "fs": 500,
+        "patient_age": 30,
+        "patient_gender": "M"
+    }
+    
+    try:
+        print("📤 Sending test ECG data...")
+        print(f"📊 Input: {len(ecg_data)} leads × {len(ecg_data[0])} samples")
+        
+        response = requests.post(f"{API_BASE_URL}/analyze", json=payload, timeout=120)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ SUCCESS! /analyze endpoint working!")
+            
+            # Check physiological parameters
+            physio = result.get('physiological_parameters', {})
+            print(f"\n📊 PHYSIOLOGICAL PARAMETERS:")
+            print(f"   Heart Rate: {physio.get('heart_rate')} BPM")
+            print(f"   QRS Duration: {physio.get('qrs_duration')} ms")
+            print(f"   QT Interval: {physio.get('qt_interval')} ms")
+            print(f"   PR Interval: {physio.get('pr_interval')} ms")
+            print(f"   QRS Axis: {physio.get('qrs_axis')}°")
+            
+            # Check features
+            features = result.get('features', {})
+            print(f"\n🧬 FEATURES:")
+            print(f"   Count: {features.get('count')}")
+            print(f"   Dimension: {features.get('dimension')}")
+            print(f"   Status: {features.get('extraction_status')}")
+            
+            # Check clinical analysis
+            clinical = result.get('clinical_analysis', {})
+            if clinical:
+                print(f"\n🏥 CLINICAL ANALYSIS:")
+                print(f"   Method: {clinical.get('method')}")
+                print(f"   Confidence: {clinical.get('confidence')}")
+            
+            return True
+            
+        else:
+            print(f"❌ Failed: {response.status_code}")
+            print(f"   Error: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def test_health():
+    """Test API health"""
+    try:
+        response = requests.get(f"{API_BASE_URL}/health", timeout=30)
+        if response.status_code == 200:
+            health_data = response.json()
+            print(f"✅ API Healthy - Models loaded: {health_data.get('models_loaded')}")
+            return True
+        else:
+            print(f"❌ Health check failed: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ Health check error: {e}")
+        return False
+
+def main():
+    """Main test function"""
+    print("🚀 QUICK TEST - JSON Serialization Fix Verification")
+    print("=" * 60)
+    
+    # Test 1: Health check
+    print("\n1️⃣ Testing API health...")
+    if not test_health():
+        print("❌ API not healthy, cannot proceed")
+        return
+    
+    # Test 2: Analyze endpoint
+    print("\n2️⃣ Testing /analyze endpoint...")
+    if test_analyze_endpoint():
+        print("\n🎉 SUCCESS! JSON serialization fix is working!")
+        print("   All endpoints should now function correctly.")
+    else:
+        print("\n❌ /analyze endpoint still has issues")
+        print("   May need to wait for deployment to complete.")
+
+if __name__ == "__main__":
+    main()

simple_finetuned_test.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Simple Test for Finetuned Model Output
+Tests what the finetuned model actually returns
+"""
+
+import requests
+import json
+import numpy as np
+
+# Configuration
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"
+
+def test_finetuned_model_output():
+    """Test what the finetuned model actually returns"""
+    print("🧬 TESTING FINETUNED MODEL OUTPUT FORMAT")
+    print("=" * 60)
+    
+    # Create a very simple test ECG signal
+    test_signal = []
+    for lead in range(12):  # 12 leads
+        samples = []
+        for i in range(1000):  # 2 seconds at 500Hz (shorter for testing)
+            samples.append(np.sin(2 * np.pi * 1.2 * i / 500) * 0.5)
+        test_signal.append(samples)
+    
+    payload = {"signal": test_signal, "fs": 500}
+    
+    print("🧪 Testing with simple ECG signal...")
+    print(f"   Signal shape: {len(test_signal)} leads, {len(test_signal[0])} samples")
+    
+    # Test 1: Check API status
+    print("\n1️⃣ Checking API status...")
+    try:
+        response = requests.get(f"{API_BASE_URL}/health", timeout=30)
+        if response.status_code == 200:
+            print("   ✅ API is healthy")
+        else:
+            print(f"   ❌ API health check failed: {response.status_code}")
+            return
+    except Exception as e:
+        print(f"   ❌ API health check error: {e}")
+        return
+    
+    # Test 2: Check model info
+    print("\n2️⃣ Checking model info...")
+    try:
+        response = requests.get(f"{API_BASE_URL}/info", timeout=30)
+        if response.status_code == 200:
+            info = response.json()
+            print("   ✅ Got model info")
+            
+            # Check model status
+            models = info.get('models', {})
+            pretrained_status = models.get('pretrained', {}).get('status', 'Unknown')
+            finetuned_status = models.get('finetuned', {}).get('status', 'Unknown')
+            
+            print(f"   🧬 Pretrained Model: {pretrained_status}")
+            print(f"   🏥 Finetuned Model: {finetuned_status}")
+            
+            if finetuned_status != 'Loaded':
+                print("   ❌ Finetuned model not loaded - this is the problem!")
+                return
+        else:
+            print(f"   ❌ Failed to get model info: {response.status_code}")
+            return
+    except Exception as e:
+        print(f"   ❌ Error getting model info: {e}")
+        return
+    
+    # Test 3: Test individual endpoints to isolate the issue
+    print("\n3️⃣ Testing individual endpoints...")
+    
+    # Test extract_features (should work)
+    try:
+        response = requests.post(f"{API_BASE_URL}/extract_features", json=payload, timeout=30)
+        print(f"   📊 Extract Features: {response.status_code}")
+        if response.status_code == 200:
+            print("   ✅ Features endpoint working")
+        else:
+            print(f"   ❌ Features endpoint failed: {response.text}")
+    except Exception as e:
+        print(f"   ❌ Features endpoint error: {e}")
+    
+    # Test predict (should work)
+    try:
+        response = requests.post(f"{API_BASE_URL}/predict", json=payload, timeout=30)
+        print(f"   📊 Predict: {response.status_code}")
+        if response.status_code == 200:
+            print("   ✅ Predict endpoint working")
+        else:
+            print(f"   ❌ Predict endpoint failed: {response.text}")
+    except Exception as e:
+        print(f"   ❌ Predict endpoint error: {e}")
+    
+    # Test 4: Try to call analyze with detailed error logging
+    print("\n4️⃣ Testing /analyze endpoint with detailed logging...")
+    try:
+        response = requests.post(f"{API_BASE_URL}/analyze", json=payload, timeout=60)
+        print(f"   📊 Response Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("   ✅ SUCCESS! /analyze endpoint working!")
+            print(f"   🏥 Clinical Analysis: {result.get('clinical_analysis', 'Not found')}")
+            print(f"   📊 Physiological Parameters: {result.get('physiological_parameters', 'Not found')}")
+        else:
+            print(f"   ❌ FAILED: {response.status_code}")
+            print(f"   📝 Error Response: {response.text}")
+            
+            # Try to parse error details
+            try:
+                error_detail = response.json()
+                print(f"   🔍 Parsed Error: {json.dumps(error_detail, indent=2)}")
+            except:
+                print(f"   📝 Raw Error: {response.text}")
+                
+    except Exception as e:
+        print(f"   ❌ Exception during /analyze call: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    test_finetuned_model_output()

test_endpoints_status.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Test All Endpoints Status
+Check the current status of all ECG-FM API endpoints
+"""
+
+import requests
+import json
+
+# Configuration
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"
+
+def test_endpoint(endpoint, method="GET", payload=None):
+    """Test a specific endpoint"""
+    print(f"🧪 Testing {endpoint}...")
+    
+    try:
+        if method == "GET":
+            response = requests.get(f"{API_BASE_URL}{endpoint}", timeout=30)
+        else:
+            response = requests.post(f"{API_BASE_URL}{endpoint}", json=payload, timeout=60)
+        
+        print(f"   Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            try:
+                result = response.json()
+                print(f"   ✅ Success - Response received")
+                
+                # Show key information based on endpoint
+                if endpoint == "/health":
+                    print(f"   Models loaded: {result.get('models_loaded')}")
+                    print(f"   Fairseq available: {result.get('fairseq_signals_available')}")
+                elif endpoint == "/info":
+                    print(f"   Model repo: {result.get('model_repo')}")
+                    print(f"   Loading strategy: {result.get('loading_strategy')}")
+                elif endpoint == "/extract_features":
+                    features = result.get('features', {})
+                    print(f"   Feature count: {features.get('count')}")
+                    print(f"   Feature dimension: {features.get('dimension')}")
+                    physio = result.get('physiological_parameters', {})
+                    if physio.get('heart_rate'):
+                        print(f"   Heart Rate: {physio['heart_rate']} BPM")
+                elif endpoint == "/assess_quality":
+                    print(f"   Quality: {result.get('quality')}")
+                    metrics = result.get('metrics', {})
+                    print(f"   SNR: {metrics.get('signal_to_noise_ratio')}")
+                
+                return True
+                
+            except json.JSONDecodeError:
+                print(f"   ⚠️  Response received but not JSON: {response.text[:100]}...")
+                return True
+        else:
+            print(f"   ❌ Failed: {response.text[:200]}...")
+            return False
+            
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        return False
+
+def main():
+    """Test all endpoints"""
+    print("🚀 TESTING ALL ECG-FM API ENDPOINTS")
+    print("=" * 60)
+    
+    results = {}
+    
+    # Test 1: Health check
+    print("\n1️⃣ Health Check")
+    results['health'] = test_endpoint("/health")
+    
+    # Test 2: Info endpoint
+    print("\n2️⃣ Info Endpoint")
+    results['info'] = test_endpoint("/info")
+    
+    # Test 3: Root endpoint
+    print("\n3️⃣ Root Endpoint")
+    results['root'] = test_endpoint("/")
+    
+    # Test 4: Extract Features (with simple test data)
+    print("\n4️⃣ Extract Features Endpoint")
+    test_payload = {
+        "signal": [[0.1] * 1000] * 12,  # Simple 12-lead, 1000-sample test data
+        "fs": 500
+    }
+    results['extract_features'] = test_endpoint("/extract_features", "POST", test_payload)
+    
+    # Test 5: Assess Quality
+    print("\n5️⃣ Assess Quality Endpoint")
+    results['assess_quality'] = test_endpoint("/assess_quality", "POST", test_payload)
+    
+    # Test 6: Predict endpoint
+    print("\n6️⃣ Predict Endpoint")
+    results['predict'] = test_endpoint("/predict", "POST", test_payload)
+    
+    # Test 7: Analyze endpoint (comprehensive)
+    print("\n7️⃣ Analyze Endpoint (Comprehensive)")
+    results['analyze'] = test_endpoint("/analyze", "POST", test_payload)
+    
+    # Summary
+    print(f"\n📊 ENDPOINT STATUS SUMMARY")
+    print(f"=" * 60)
+    
+    working_endpoints = sum(results.values())
+    total_endpoints = len(results)
+    
+    for endpoint, status in results.items():
+        status_icon = "✅" if status else "❌"
+        print(f"{status_icon} {endpoint}: {'Working' if status else 'Failed'}")
+    
+    print(f"\n🎯 OVERALL STATUS:")
+    print(f"   Working: {working_endpoints}/{total_endpoints}")
+    print(f"   Success Rate: {(working_endpoints/total_endpoints)*100:.1f}%")
+    
+    if working_endpoints == total_endpoints:
+        print(f"\n🎉 ALL ENDPOINTS ARE WORKING!")
+    elif working_endpoints > total_endpoints // 2:
+        print(f"\n⚠️  MOST ENDPOINTS WORKING - Some issues to resolve")
+    else:
+        print(f"\n❌ MANY ENDPOINTS FAILING - Need investigation")
+
+if __name__ == "__main__":
+    main()

test_finetuned_clinical.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Test Finetuned ECG-FM Model for Clinical Abnormality Detection
+Tests the finetuned model to get normal vs abnormal classification results
+"""
+
+import requests
+import numpy as np
+import pandas as pd
+import json
+import os
+from typing import Dict, Any, List
+from datetime import datetime
+
+# Configuration
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"
+ECG_DIR = "../ecg_uploads_greenwich/"
+INDEX_FILE = "../Greenwichschooldata.csv"
+
+def load_ecg_data(csv_file: str) -> List[List[float]]:
+    """Load ECG data from CSV file"""
+    try:
+        df = pd.read_csv(csv_file)
+        ecg_data = []
+        for lead in df.columns:
+            ecg_data.append(df[lead].astype(float).tolist())
+        return ecg_data
+    except Exception as e:
+        print(f"❌ Error loading ECG data: {e}")
+        return None
+
+def test_finetuned_clinical_classification(ecg_data: List[List[float]], patient_info: Dict[str, Any]) -> Dict[str, Any]:
+    """Test the finetuned model for clinical abnormality detection"""
+    results = {}
+    
+    print(f"🧬 Testing FINETUNED MODEL for {patient_info.get('Patient Name', 'Unknown')}")
+    print(f"   👤 Patient: {patient_info.get('Patient Name', 'Unknown')} ({patient_info.get('Age', 'Unknown')} {patient_info.get('Gender', 'Unknown')})")
+    
+    # Test 1: Clinical Analysis (Finetuned Model)
+    print("1️⃣ Testing /analyze endpoint (FINETUNED MODEL)...")
+    try:
+        payload = {"signal": ecg_data, "fs": 500}
+        response = requests.post(f"{API_BASE_URL}/analyze", json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"   ✅ Clinical analysis completed successfully!")
+            
+            # Extract clinical predictions
+            clinical = result.get('clinical_analysis', {})
+            if clinical:
+                print(f"   🏥 CLINICAL RESULTS:")
+                print(f"      📊 Overall Status: {clinical.get('overall_status', 'Unknown')}")
+                print(f"      🎯 Primary Finding: {clinical.get('primary_finding', 'Unknown')}")
+                print(f"      ⚠️  Abnormalities Detected: {clinical.get('abnormalities_detected', 'Unknown')}")
+                print(f"      📋 Labels Used: {clinical.get('labels_used', 'Unknown')}")
+                print(f"      🔍 Confidence Level: {clinical.get('confidence_level', 'Unknown')}")
+                
+                # Show top clinical labels
+                label_probs = clinical.get('label_probabilities', {})
+                if label_probs:
+                    print(f"      🏷️  TOP CLINICAL LABELS:")
+                    sorted_labels = sorted(label_probs.items(), key=lambda x: x[1], reverse=True)[:5]
+                    for label, prob in sorted_labels:
+                        print(f"         • {label}: {prob:.3f}")
+                
+                results['clinical_analysis'] = {"status": "success", "data": result}
+            else:
+                print(f"   ⚠️  No clinical analysis data found")
+                results['clinical_analysis'] = {"status": "warning", "message": "No clinical data"}
+        else:
+            print(f"   ❌ Failed: {response.status_code}")
+            print(f"      Error: {response.text}")
+            results['clinical_analysis'] = {"status": "error", "error": response.text}
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        results['clinical_analysis'] = {"status": "error", "error": str(e)}
+    
+    # Test 2: Direct Clinical Endpoint (if available)
+    print("2️⃣ Testing clinical endpoint directly...")
+    try:
+        # Try to call a clinical-specific endpoint if it exists
+        payload = {"signal": ecg_data, "fs": 500}
+        response = requests.post(f"{API_BASE_URL}/clinical", json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"   ✅ Direct clinical endpoint working!")
+            print(f"      📊 Result: {result}")
+            results['direct_clinical'] = {"status": "success", "data": result}
+        elif response.status_code == 404:
+            print(f"   ℹ️  Direct clinical endpoint not available (using /analyze)")
+            results['direct_clinical'] = {"status": "not_available"}
+        else:
+            print(f"   ❌ Failed: {response.status_code}")
+            results['direct_clinical'] = {"status": "error", "error": response.text}
+    except Exception as e:
+        print(f"   ℹ️  Direct clinical endpoint not available: {e}")
+        results['direct_clinical'] = {"status": "not_available"}
+    
+    # Test 3: Extract Features + Clinical Analysis
+    print("3️⃣ Testing feature extraction + clinical analysis...")
+    try:
+        payload = {"signal": ecg_data, "fs": 500}
+        response = requests.post(f"{API_BASE_URL}/extract_features", json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"   ✅ Features extracted successfully")
+            print(f"   📊 Feature count: {result.get('features', {}).get('count', 'Unknown')}")
+            print(f"   📊 Feature dimension: {result.get('features', {}).get('dimension', 'Unknown')}")
+            
+            # Check if clinical analysis is included
+            clinical_included = result.get('clinical_analysis', {})
+            if clinical_included:
+                print(f"   🏥 Clinical analysis included in features!")
+                print(f"      📊 Status: {clinical_included.get('overall_status', 'Unknown')}")
+            else:
+                print(f"   ℹ️  Clinical analysis not included in features endpoint")
+            
+            results['extract_features'] = {"status": "success", "data": result}
+        else:
+            print(f"   ❌ Failed: {response.status_code}")
+            results['extract_features'] = {"status": "error", "error": response.text}
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        results['extract_features'] = {"status": "error", "error": str(e)}
+    
+    return results
+
+def analyze_clinical_results(all_results: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze clinical classification results across samples"""
+    print(f"\n🏥 CLINICAL CLASSIFICATION ANALYSIS")
+    print(f"=" * 70)
+    
+    clinical_statuses = []
+    primary_findings = []
+    abnormality_counts = []
+    confidence_levels = []
+    
+    for patient_id, result in all_results.items():
+        if 'endpoint_tests' in result and 'clinical_analysis' in result['endpoint_tests']:
+            clinical = result['endpoint_tests']['clinical_analysis'].get('data', {}).get('clinical_analysis', {})
+            
+            if clinical.get('overall_status'):
+                clinical_statuses.append(clinical['overall_status'])
+            if clinical.get('primary_finding'):
+                primary_findings.append(clinical['primary_finding'])
+            if clinical.get('abnormalities_detected') is not None:
+                abnormality_counts.append(clinical['abnormalities_detected'])
+            if clinical.get('confidence_level'):
+                confidence_levels.append(clinical['confidence_level'])
+    
+    analysis = {}
+    
+    # Clinical Status Analysis
+    if len(clinical_statuses) > 0:
+        print(f"🏥 Clinical Status Analysis:")
+        print(f"   Statuses: {clinical_statuses}")
+        
+        normal_count = sum(1 for s in clinical_statuses if 'normal' in s.lower())
+        abnormal_count = sum(1 for s in clinical_statuses if 'abnormal' in s.lower())
+        
+        print(f"   Normal: {normal_count}")
+        print(f"   Abnormal: {abnormal_count}")
+        print(f"   Distribution: Normal {normal_count/len(clinical_statuses)*100:.1f}% vs Abnormal {abnormal_count/len(clinical_statuses)*100:.1f}%")
+        
+        analysis['clinical_status'] = {
+            'statuses': clinical_statuses,
+            'normal_count': normal_count,
+            'abnormal_count': abnormal_count,
+            'normal_percentage': normal_count/len(clinical_statuses)*100 if len(clinical_statuses) > 0 else 0
+        }
+    
+    # Confidence Analysis
+    if len(confidence_levels) > 0:
+        print(f"\n🔍 Confidence Level Analysis:")
+        print(f"   Confidence Levels: {confidence_levels}")
+        avg_confidence = np.mean(confidence_levels)
+        print(f"   Average Confidence: {avg_confidence:.2f}")
+        
+        analysis['confidence'] = {
+            'levels': confidence_levels,
+            'average': avg_confidence
+        }
+    
+    # Overall Assessment
+    print(f"\n🎯 CLINICAL ASSESSMENT SUMMARY:")
+    working_clinical = len([k for k in all_results.keys() if 'endpoint_tests' in all_results[k] and 'clinical_analysis' in all_results[k]['endpoint_tests']])
+    total_patients = len(all_results)
+    
+    print(f"   Patients with Clinical Analysis: {working_clinical}/{total_patients}")
+    print(f"   Clinical Success Rate: {(working_clinical/total_patients)*100:.1f}%")
+    
+    if working_clinical == total_patients:
+        print(f"   🎉 All patients have clinical analysis!")
+    elif working_clinical > total_patients // 2:
+        print(f"   ⚠️  Most patients have clinical analysis")
+    else:
+        print(f"   ❌ Many patients missing clinical analysis")
+    
+    return analysis
+
+def main():
+    """Main test function"""
+    print("🧬 FINETUNED ECG-FM CLINICAL CLASSIFICATION TESTING")
+    print("=" * 80)
+    print(f"🌐 API URL: {API_BASE_URL}")
+    print(f"📁 ECG Directory: {ECG_DIR}")
+    print(f"📋 Index File: {INDEX_FILE}")
+    print()
+    
+    # Check if files exist
+    if not os.path.exists(INDEX_FILE):
+        print(f"❌ Index file not found: {INDEX_FILE}")
+        return
+    
+    if not os.path.exists(ECG_DIR):
+        print(f"❌ ECG directory not found: {ECG_DIR}")
+        return
+    
+    # Load index file
+    try:
+        print("📁 Loading patient index file...")
+        index_df = pd.read_csv(INDEX_FILE)
+        print(f"✅ Loaded {len(index_df)} patient records")
+    except Exception as e:
+        print(f"❌ Error loading index file: {e}")
+        return
+    
+    # Select ECG files for clinical testing
+    test_files = [
+        "ecg_98408931-6f8e-47cc-954a-ba0c058a0f3d.csv",  # Bharathi M K Teacher, 31, F
+        "ecg_fc6d2ecb-7eb3-4eec-9281-17c24b7902b5.csv",  # Sayida thasmiya Bhanu Teacher, 29, F
+        "ecg_022a3f3a-7060-4ff8-b716-b75d8e0637c5.csv",  # Afzal, 46, M
+    ]
+    
+    print(f"\n🧬 Testing FINETUNED MODEL with {len(test_files)} ECG samples...")
+    print("=" * 80)
+    
+    all_results = {}
+    
+    for i, ecg_file in enumerate(test_files, 1):
+        try:
+            print(f"\n📊 Processing {i}/{len(test_files)}: {ecg_file}")
+            
+            # Find patient info in index
+            patient_row = index_df[index_df['ECG File Path'].str.contains(ecg_file, na=False)]
+            if len(patient_row) == 0:
+                print(f"   ⚠️  Patient info not found for {ecg_file}")
+                continue
+            
+            patient_info = patient_row.iloc[0]
+            
+            # Check if ECG file exists
+            ecg_path = os.path.join(ECG_DIR, ecg_file)
+            if not os.path.exists(ecg_path):
+                print(f"   ❌ ECG file not found: {ecg_path}")
+                continue
+            
+            # Load ECG data
+            ecg_data = load_ecg_data(ecg_path)
+            if ecg_data is None:
+                print(f"   ❌ Failed to load ECG data")
+                continue
+            
+            # Test finetuned model for clinical classification
+            clinical_results = test_finetuned_clinical_classification(ecg_data, patient_info)
+            
+            # Store results
+            all_results[ecg_file] = {
+                "patient_info": patient_info.to_dict(),
+                "endpoint_tests": clinical_results
+            }
+            
+            print(f"   ✅ Completed clinical analysis for {ecg_file}")
+            
+        except Exception as e:
+            print(f"   ❌ Error processing {ecg_file}: {e}")
+            all_results[ecg_file] = {"error": str(e)}
+    
+    # Analyze clinical results
+    if len(all_results) > 0:
+        clinical_analysis = analyze_clinical_results(all_results)
+        
+        # Summary report
+        print(f"\n📊 CLINICAL TEST SUMMARY")
+        print(f"=" * 80)
+        
+        successful_clinical = 0
+        total_tests = len(test_files)
+        
+        for ecg_file, result in all_results.items():
+            if "error" not in result:
+                clinical_status = result.get("endpoint_tests", {}).get("clinical_analysis", {}).get("status")
+                if clinical_status == "success":
+                    successful_clinical += 1
+                    print(f"✅ {ecg_file}: Clinical analysis successful")
+                else:
+                    print(f"⚠️  {ecg_file}: Clinical analysis {clinical_status}")
+            else:
+                print(f"❌ {ecg_file}: {result['error']}")
+        
+        print(f"\n🎯 CLINICAL RESULTS:")
+        print(f"   Successful Clinical Analysis: {successful_clinical}/{total_tests}")
+        print(f"   Clinical Success Rate: {(successful_clinical/total_tests)*100:.1f}%")
+        
+        # Save detailed results
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        results_file = f"finetuned_clinical_test_results_{timestamp}.json"
+        
+        try:
+            with open(results_file, 'w') as f:
+                json.dump(all_results, f, indent=2, default=str)
+            print(f"\n💾 Detailed clinical results saved to: {results_file}")
+        except Exception as e:
+            print(f"\n⚠️  Could not save results: {e}")
+    
+    print(f"\n🎉 Finetuned clinical testing completed!")
+    print(f"💡 Check the results above for NORMAL vs ABNORMAL classification")
+
+if __name__ == "__main__":
+    main()

test_measurement_accuracy.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Test Measurement Accuracy
+Demonstrate the issues with current physiological parameter extraction
+"""
+
+import numpy as np
+import requests
+import json
+
+# Configuration
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"
+
+def create_identical_ecg_signals():
+    """Create multiple identical ECG signals to test consistency"""
+    # Generate a simple 10-second ECG-like signal at 500 Hz
+    t = np.linspace(0, 10, 5000)
+    
+    # Create identical signals
+    signals = []
+    for i in range(3):
+        # Basic sine wave with some variation
+        signal = []
+        for lead in range(12):
+            lead_signal = np.sin(2 * np.pi * 1.2 * t) * 0.5  # ~72 BPM
+            lead_signal += np.random.normal(0, 0.1, 5000)  # Add noise
+            signal.append(lead_signal.tolist())
+        signals.append(signal)
+    
+    return signals
+
+def test_measurement_consistency():
+    """Test if identical signals give consistent measurements"""
+    print("🧪 TESTING MEASUREMENT CONSISTENCY")
+    print("=" * 60)
+    
+    # Create 3 identical ECG signals
+    signals = create_identical_ecg_signals()
+    
+    print(f"📊 Created {len(signals)} identical ECG signals")
+    print(f"📊 Each signal: {len(signals[0])} leads × {len(signals[0][0])} samples")
+    
+    results = []
+    
+    for i, signal in enumerate(signals, 1):
+        print(f"\n📤 Testing Signal {i}/3...")
+        
+        payload = {
+            "signal": signal,
+            "fs": 500,
+            "patient_age": 30,
+            "patient_gender": "M"
+        }
+        
+        try:
+            response = requests.post(f"{API_BASE_URL}/extract_features", json=payload, timeout=60)
+            
+            if response.status_code == 200:
+                result = response.json()
+                physio = result.get('physiological_parameters', {})
+                
+                measurements = {
+                    "heart_rate": physio.get('heart_rate'),
+                    "qrs_duration": physio.get('qrs_duration'),
+                    "qt_interval": physio.get('qt_interval'),
+                    "pr_interval": physio.get('pr_interval'),
+                    "qrs_axis": physio.get('qrs_axis')
+                }
+                
+                print(f"   💓 Heart Rate: {measurements['heart_rate']} BPM")
+                print(f"   📏 QRS Duration: {measurements['qrs_duration']} ms")
+                print(f"   ⏱️  QT Interval: {measurements['qt_interval']} ms")
+                print(f"   🔗 PR Interval: {measurements['pr_interval']} ms")
+                print(f"   🧭 QRS Axis: {measurements['qrs_axis']}°")
+                
+                results.append(measurements)
+                
+            else:
+                print(f"   ❌ Failed: {response.status_code}")
+                results.append(None)
+                
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            results.append(None)
+    
+    # Analyze consistency
+    print(f"\n📊 CONSISTENCY ANALYSIS")
+    print(f"=" * 60)
+    
+    if len(results) == 3 and all(r is not None):
+        # Check if measurements are consistent
+        hr_values = [r['heart_rate'] for r in results if r['heart_rate'] is not None]
+        qrs_values = [r['qrs_duration'] for r in results if r['qrs_duration'] is not None]
+        qt_values = [r['qt_interval'] for r in results if r['qt_interval'] is not None]
+        pr_values = [r['pr_interval'] for r in results if r['pr_interval'] is not None]
+        axis_values = [r['qrs_axis'] for r in results if r['qrs_axis'] is not None]
+        
+        print(f"💓 Heart Rate Consistency:")
+        if len(hr_values) == 3:
+            hr_std = np.std(hr_values)
+            print(f"   Values: {hr_values}")
+            print(f"   Standard Deviation: {hr_std:.2f}")
+            print(f"   Consistent: {'✅' if hr_std < 1.0 else '❌'} (should be < 1.0 BPM)")
+        else:
+            print(f"   ❌ Missing values: {hr_values}")
+        
+        print(f"\n📏 QRS Duration Consistency:")
+        if len(qrs_values) == 3:
+            qrs_std = np.std(qrs_values)
+            print(f"   Values: {qrs_values}")
+            print(f"   Standard Deviation: {qrs_std:.2f}")
+            print(f"   Consistent: {'✅' if qrs_std < 5.0 else '❌'} (should be < 5.0 ms)")
+        else:
+            print(f"   ❌ Missing values: {qrs_values}")
+        
+        print(f"\n⏱️  QT Interval Consistency:")
+        if len(qt_values) == 3:
+            qt_std = np.std(qt_values)
+            print(f"   Values: {qt_values}")
+            print(f"   Standard Deviation: {qt_std:.2f}")
+            print(f"   Consistent: {'✅' if qt_std < 10.0 else '❌'} (should be < 10.0 ms)")
+        else:
+            print(f"   ❌ Missing values: {qt_values}")
+        
+        # Overall assessment
+        print(f"\n🎯 OVERALL ASSESSMENT:")
+        print(f"   If measurements are real: Should be nearly identical for identical signals")
+        print(f"   If measurements are fake: Will show random variations")
+        
+    else:
+        print(f"❌ Cannot analyze consistency - some tests failed")
+
+def test_with_different_signals():
+    """Test with different signal characteristics"""
+    print(f"\n🧪 TESTING WITH DIFFERENT SIGNAL CHARACTERISTICS")
+    print(f"=" * 60)
+    
+    # Test 1: Normal signal
+    print(f"📊 Test 1: Normal ECG-like signal")
+    t = np.linspace(0, 10, 5000)
+    normal_signal = []
+    for lead in range(12):
+        lead_signal = np.sin(2 * np.pi * 1.2 * t) * 0.5  # ~72 BPM
+        normal_signal.append(lead_signal.tolist())
+    
+    # Test 2: Fast signal
+    print(f"📊 Test 2: Fast ECG-like signal")
+    fast_signal = []
+    for lead in range(12):
+        lead_signal = np.sin(2 * np.pi * 2.0 * t) * 0.5  # ~120 BPM
+        fast_signal.append(lead_signal.tolist())
+    
+    # Test 3: Slow signal
+    print(f"📊 Test 3: Slow ECG-like signal")
+    slow_signal = []
+    for lead in range(12):
+        lead_signal = np.sin(2 * np.pi * 0.8 * t) * 0.5  # ~48 BPM
+        slow_signal.append(lead_signal.tolist())
+    
+    signals = [normal_signal, fast_signal, slow_signal]
+    expected_hrs = [72, 120, 48]
+    
+    for i, (signal, expected_hr) in enumerate(zip(signals, expected_hrs), 1):
+        print(f"\n📤 Testing Signal {i} (Expected HR: ~{expected_hr} BPM)...")
+        
+        payload = {
+            "signal": signal,
+            "fs": 500,
+            "patient_age": 30,
+            "patient_gender": "M"
+        }
+        
+        try:
+            response = requests.post(f"{API_BASE_URL}/extract_features", json=payload, timeout=60)
+            
+            if response.status_code == 200:
+                result = response.json()
+                physio = result.get('physiological_parameters', {})
+                actual_hr = physio.get('heart_rate')
+                
+                print(f"   Expected HR: ~{expected_hr} BPM")
+                print(f"   Actual HR: {actual_hr} BPM")
+                
+                if actual_hr is not None:
+                    difference = abs(actual_hr - expected_hr)
+                    print(f"   Difference: {difference:.1f} BPM")
+                    print(f"   Reasonable: {'✅' if difference < 20 else '❌'} (should be < 20 BPM)")
+                else:
+                    print(f"   ❌ No HR measurement returned")
+                    
+            else:
+                print(f"   ❌ Failed: {response.status_code}")
+                
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+
+def main():
+    """Main test function"""
+    print("🚨 MEASUREMENT ACCURACY TEST")
+    print("=" * 60)
+    print("This test will reveal if our physiological measurements are:")
+    print("✅ Real clinical measurements")
+    print("❌ Fake/testing values")
+    print()
+    
+    # Test 1: Consistency
+    test_measurement_consistency()
+    
+    # Test 2: Different signals
+    test_with_different_signals()
+    
+    print(f"\n🎯 CONCLUSION:")
+    print(f"   If measurements are consistent and reasonable: They might be real")
+    print(f"   If measurements are inconsistent and random: They are fake/testing values")
+    print(f"   Current implementation likely provides fake values!")
+
+if __name__ == "__main__":
+    main()

test_physiological_parameters.py

@@ -14,7 +14,7 @@ from typing import Dict, Any, List
 from datetime import datetime
 
 # Configuration
-API_BASE_URL = "http://localhost:8000"  # Local server for testing
+API_BASE_URL = "https://mystic-cbk-ecg-fm-api.hf.space"  # Deployed HF Spaces API
 ECG_DIR = "../ecg_uploads_greenwich/"
 INDEX_FILE = "../Greenwichschooldata.csv"