Spaces:
Sleeping
Sleeping
| import numpy as np | |
| import pandas as pd | |
| import gradio as gr | |
| import matplotlib.pyplot as plt | |
| import seaborn as sns | |
| from typing import Dict, List, Tuple | |
| class HealthStandards: | |
| """Simplified health standards with error handling""" | |
| def get_bmi_status(bmi: float) -> Dict: | |
| try: | |
| if bmi < 18.5: | |
| return {"status": "Underweight", "risk": "High", | |
| "recommendation": "Consult nutritionist for weight gain plan"} | |
| elif bmi < 24.9: | |
| return {"status": "Normal", "risk": "Low", | |
| "recommendation": "Maintain healthy lifestyle"} | |
| elif bmi < 29.9: | |
| return {"status": "Overweight", "risk": "Moderate", | |
| "recommendation": "Consider diet and exercise plan"} | |
| else: | |
| return {"status": "Obese", "risk": "High", | |
| "recommendation": "Seek medical guidance"} | |
| except Exception as e: | |
| return {"status": "Error", "risk": "Unknown", | |
| "recommendation": f"Error processing BMI: {str(e)}"} | |
| def get_bp_status(bp: float) -> Dict: | |
| try: | |
| if bp < 120: | |
| return {"status": "Normal", "risk": "Low", | |
| "recommendation": "Maintain healthy lifestyle"} | |
| elif bp < 130: | |
| return {"status": "Elevated", "risk": "Moderate", | |
| "recommendation": "Monitor regularly"} | |
| elif bp < 140: | |
| return {"status": "Stage 1 Hypertension", "risk": "High", | |
| "recommendation": "Consult healthcare provider"} | |
| else: | |
| return {"status": "Stage 2 Hypertension", "risk": "Very High", | |
| "recommendation": "Immediate medical attention needed"} | |
| except Exception as e: | |
| return {"status": "Error", "risk": "Unknown", | |
| "recommendation": f"Error processing blood pressure: {str(e)}"} | |
| def get_glucose_status(glucose: float) -> Dict: | |
| try: | |
| if glucose < 100: | |
| return {"status": "Normal", "risk": "Low", | |
| "recommendation": "Maintain healthy diet"} | |
| elif glucose < 125: | |
| return {"status": "Prediabetes", "risk": "Moderate", | |
| "recommendation": "Lifestyle modifications needed"} | |
| else: | |
| return {"status": "Diabetes Range", "risk": "High", | |
| "recommendation": "Consult healthcare provider"} | |
| except Exception as e: | |
| return {"status": "Error", "risk": "Unknown", | |
| "recommendation": f"Error processing glucose: {str(e)}"} | |
| class HealthAnalyzer: | |
| """Analyzes health metrics with error handling""" | |
| def __init__(self): | |
| self.standards = HealthStandards() | |
| def analyze_metrics(self, age: float, bmi: float, bp: float, | |
| glucose: float) -> Tuple[Dict, str]: | |
| try: | |
| # Get individual assessments | |
| bmi_assessment = self.standards.get_bmi_status(bmi) | |
| bp_assessment = self.standards.get_bp_status(bp) | |
| glucose_assessment = self.standards.get_glucose_status(glucose) | |
| # Calculate risk score | |
| risk_factors = 0 | |
| if bmi_assessment["risk"] in ["High", "Very High"]: risk_factors += 1 | |
| if bp_assessment["risk"] in ["High", "Very High"]: risk_factors += 1 | |
| if glucose_assessment["risk"] in ["High", "Very High"]: risk_factors += 1 | |
| if age > 60: risk_factors += 1 | |
| risk_score = (risk_factors / 4) * 100 | |
| analysis = { | |
| "metrics": { | |
| "BMI": bmi_assessment, | |
| "Blood Pressure": bp_assessment, | |
| "Glucose": glucose_assessment | |
| }, | |
| "risk_score": risk_score | |
| } | |
| # Generate report | |
| report = self.generate_report(analysis, age) | |
| return analysis, report | |
| except Exception as e: | |
| return {"error": str(e)}, "Error occurred during analysis" | |
| def generate_report(self, analysis: Dict, age: float) -> str: | |
| try: | |
| report = [ | |
| "=== HEALTH ANALYSIS REPORT ===\n", | |
| f"Overall Risk Score: {analysis['risk_score']:.1f}%\n", | |
| f"Risk Level: {self.get_risk_level(analysis['risk_score'])}\n", | |
| "\nDetailed Analysis:" | |
| ] | |
| for metric, assessment in analysis["metrics"].items(): | |
| report.extend([ | |
| f"\n{metric}:", | |
| f"Status: {assessment['status']}", | |
| f"Risk Level: {assessment['risk']}", | |
| f"Recommendation: {assessment['recommendation']}" | |
| ]) | |
| return "\n".join(report) | |
| except Exception as e: | |
| return f"Error generating report: {str(e)}" | |
| def get_risk_level(risk_score: float) -> str: | |
| if risk_score < 33: | |
| return "Low" | |
| elif risk_score < 66: | |
| return "Moderate" | |
| else: | |
| return "High" | |
| def create_visualization(analysis: Dict) -> plt.Figure: | |
| """Create visualization with error handling""" | |
| try: | |
| sns.set_style("whitegrid") # Use seaborn style directly | |
| fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) | |
| # Metrics comparison | |
| metrics = list(analysis["metrics"].keys()) | |
| risk_levels = [assessment["risk"] for assessment in analysis["metrics"].values()] | |
| risk_values = [{"Low": 1, "Moderate": 2, "High": 3, "Very High": 4}.get(r, 0) | |
| for r in risk_levels] | |
| colors = ['green' if r == "Low" else 'yellow' if r == "Moderate" | |
| else 'red' for r in risk_levels] | |
| ax1.bar(metrics, risk_values, color=colors) | |
| ax1.set_title("Health Metrics Risk Levels") | |
| ax1.set_ylim(0, 4) | |
| ax1.set_yticks([1, 2, 3, 4]) | |
| ax1.set_yticklabels(['Low', 'Moderate', 'High', 'Very High']) | |
| # Risk gauge | |
| risk_score = analysis["risk_score"] | |
| colors = ['green', 'yellow', 'red'] | |
| ax2.pie([risk_score, 100-risk_score], | |
| colors=[colors[int(risk_score/33.34)], 'lightgray'], | |
| startangle=90, counterclock=False) | |
| ax2.set_title(f"Overall Risk Score: {risk_score:.1f}%") | |
| plt.tight_layout() | |
| return fig | |
| except Exception as e: | |
| # Create error figure | |
| fig, ax = plt.subplots(figsize=(8, 4)) | |
| ax.text(0.5, 0.5, f"Error creating visualization: {str(e)}", | |
| ha='center', va='center') | |
| ax.axis('off') | |
| return fig | |
| def analyze_health(age: float, bmi: float, bp: float, glucose: float) -> Tuple[plt.Figure, str]: | |
| """Main analysis function with error handling""" | |
| try: | |
| analyzer = HealthAnalyzer() | |
| analysis, report = analyzer.analyze_metrics(age, bmi, bp, glucose) | |
| if "error" in analysis: | |
| raise Exception(analysis["error"]) | |
| fig = create_visualization(analysis) | |
| return fig, report | |
| except Exception as e: | |
| error_fig, ax = plt.subplots(figsize=(8, 4)) | |
| ax.text(0.5, 0.5, f"Error: {str(e)}", ha='center', va='center') | |
| ax.axis('off') | |
| return error_fig, f"An error occurred: {str(e)}" | |
| # Create Gradio interface | |
| def create_gradio_interface(): | |
| interface = gr.Interface( | |
| fn=analyze_health, | |
| inputs=[ | |
| gr.Slider(20, 90, value=50, label="Age"), | |
| gr.Slider(15, 45, value=25, label="BMI"), | |
| gr.Slider(80, 200, value=120, label="Blood Pressure"), | |
| gr.Slider(70, 200, value=100, label="Glucose") | |
| ], | |
| outputs=[ | |
| gr.Plot(label="Health Analysis Dashboard"), | |
| gr.Textbox(label="Health Report", lines=10) | |
| ], | |
| title="Health Analysis System", | |
| description="Enter patient metrics for health analysis." | |
| ) | |
| return interface | |
| if __name__ == "__main__": | |
| # Launch the Gradio interface | |
| interface = create_gradio_interface() | |
| interface.launch() |