Upload 3 files

README.md

@@ -1,19 +1,196 @@
----
-title: MHI
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# 🏥 Health Parameter Transition Dashboard
+
+A comprehensive interactive dashboard for analyzing health parameter transitions between old and new measurements, with location-based filtering capabilities.
+
+## 📊 Features
+
+### Health Parameters Analyzed
+- **HbA1c** - Blood glucose control indicator
+- **LDL** - Low-density lipoprotein cholesterol
+- **BMI** - Body Mass Index
+- **BP** - Blood Pressure
+- **Biometrics** - Overall biometric assessment
+- **MHI** - Mental Health Index
+
+### Dashboard Capabilities
+- **Transition Analysis**: Compare old vs new health parameter tags (Red/Orange/Green)
+- **Location Filtering**: Filter analysis by shared location
+- **Interactive Visualizations**: 
+  - Transition heatmaps
+  - Sankey flow diagrams
+  - Summary bar charts
+- **Key Metrics**:
+  - Improvement rates
+  - Decline rates
+  - Stability rates
+  - User counts per parameter
+- **Export Functionality**: Download summary reports as CSV files
+
+### Tag Classification System
+- 🟢 **Green**: Optimal/Good health status
+- 🟡 **Orange**: Sub-optimal/Warning status  
+- 🔴 **Red**: Alert/Poor health status
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Python 3.7 or higher
+- pip package manager
+
+### Installation
+
+1. **Clone or download the project files**
+   ```bash
+   # Ensure you have these files in your directory:
+   # - health_dashboard.py
+   # - run_dashboard.py
+   # - requirements.txt
+   # - Combines 2,3,7,9,11(Sheet1).csv
+   ```
+
+2. **Install required packages**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Run the dashboard**
+   ```bash
+   python run_dashboard.py
+   ```
+   
+   Or directly with Streamlit:
+   ```bash
+   streamlit run health_dashboard.py
+   ```
+
+4. **Access the dashboard**
+   - Open your web browser and go to: `http://localhost:8501`
+   - The dashboard will automatically load with your data
+
+## 📈 Using the Dashboard
+
+### 1. Location Filter
+- Use the sidebar to select a specific location or view "All Locations"
+- The dashboard will update all visualizations based on your selection
+
+### 2. Overall Summary
+- View key metrics at the top: total users, average improvement/decline rates
+- See the summary chart showing transition rates across all parameters
+
+### 3. Parameter-wise Analysis
+- Navigate through tabs for each health parameter
+- Each tab shows:
+  - **Metrics**: User counts and transition statistics
+  - **Heatmap**: Visual transition matrix
+  - **Sankey Diagram**: Flow visualization of transitions
+  - **Detailed Table**: Raw transition data
+
+### 4. Key Insights
+- Automatically generated insights based on the data
+- Highlights parameters with excellent improvement or concerning decline rates
+
+### 5. Export Data
+- Click "Generate Summary Report" to create downloadable CSV files
+- Reports include all transition statistics by parameter
+
+## 📊 Understanding the Visualizations
+
+### Transition Heatmap
+- **Rows**: Old health status
+- **Columns**: New health status  
+- **Values**: Number of users who transitioned
+- **Colors**: Intensity indicates frequency of transitions
+
+### Sankey Diagram
+- **Left side**: Old status distribution
+- **Right side**: New status distribution
+- **Flows**: Show movement between statuses
+- **Width**: Proportional to number of users
+
+### Summary Charts
+- **Stacked bars**: Show percentage breakdown of improvements/declines/stable
+- **Colors**: Green (improved), Red (declined), Orange (stable)
+
+## 🔍 Data Requirements
+
+The dashboard expects a CSV file with the following columns:
+- `Location Shared`: Location information for filtering
+- Health parameter columns (old and new tags):
+  - `Hba1c tag old`, `Hba1c tag`
+  - `LDLtag old`, `LDLtag`  
+  - `BMItag old`, `BMItag`
+  - `Bptag old`, `Bptag`
+  - `biometric tag old`, `biometric tag`
+  - `MHI old`, `MHI NEW`
+
+## 🛠️ Technical Details
+
+### Dependencies
+- **Streamlit**: Web application framework
+- **Pandas**: Data manipulation and analysis
+- **Plotly**: Interactive visualizations
+- **NumPy**: Numerical computations
+
+### Performance Features
+- Data caching for faster load times
+- Responsive design for various screen sizes
+- Efficient transition calculations
+
+## 📝 Interpreting Results
+
+### Improvement Indicators
+- **Green → Green**: Maintained optimal status
+- **Orange → Green**: Improved from sub-optimal to optimal
+- **Red → Orange/Green**: Improved from alert status
+
+### Decline Indicators  
+- **Green �� Orange/Red**: Declined from optimal status
+- **Orange → Red**: Declined from sub-optimal to alert
+
+### Key Metrics
+- **Improvement Rate**: Percentage of users who moved to better health status
+- **Decline Rate**: Percentage of users who moved to worse health status
+- **Stable Rate**: Percentage of users who maintained the same status
+
+## 🎯 Use Cases
+
+1. **Health Program Evaluation**: Assess effectiveness of health interventions
+2. **Location-based Analysis**: Compare health outcomes across different locations
+3. **Parameter-specific Insights**: Identify which health areas need attention
+4. **Trend Monitoring**: Track health improvements or declines over time
+5. **Resource Allocation**: Focus resources on parameters with high decline rates
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+1. **Data file not found**
+   - Ensure `Combines 2,3,7,9,11(Sheet1).csv` is in the same directory
+   - Check file name spelling and extension
+
+2. **Missing packages**
+   - Run: `pip install -r requirements.txt`
+   - Ensure you have Python 3.7+ installed
+
+3. **Dashboard won't load**
+   - Check if port 8501 is available
+   - Try: `streamlit run health_dashboard.py --server.port 8502`
+
+4. **No data showing**
+   - Verify your CSV has the required columns
+   - Check that location filter includes your data
+
+## 📞 Support
+
+For issues or questions:
+1. Check the troubleshooting section above
+2. Verify your data format matches the requirements
+3. Ensure all dependencies are properly installed
+
+## 📄 License
+
+This dashboard is provided as-is for health data analysis purposes.
+
+---
+
+**Made with ❤️ for better health outcomes** 

app.py

@@ -0,0 +1,461 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+
+# Set page config
+st.set_page_config(
+    page_title="Health Parameter Transition Dashboard",
+    page_icon="🏥",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    
+    .metric-card {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 4px solid #1f77b4;
+    }
+    
+    .improvement {
+        color: #2ca02c;
+        font-weight: bold;
+    }
+    
+    .decline {
+        color: #d62728;
+        font-weight: bold;
+    }
+    
+    .stable {
+        color: #ff7f0e;
+        font-weight: bold;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_data
+def load_data():
+    """Load and preprocess the health data"""
+    try:
+        df = pd.read_csv("Combines 2,3,7,9,11(Sheet1).csv")
+        return df
+    except Exception as e:
+        st.error(f"Error loading data: {e}")
+        return None
+
+def clean_tag_data(df):
+    """Clean and standardize tag data"""
+    # Define health parameters with their old and new tag columns
+    health_params = {
+        'HbA1c': {'old_tag': 'Hba1c tag old', 'new_tag': 'Hba1c tag'},
+        'LDL': {'old_tag': 'LDLtag old', 'new_tag': 'LDLtag'},
+        'BMI': {'old_tag': 'BMItag old', 'new_tag': 'BMItag'},
+        'BP': {'old_tag': 'Bptag old', 'new_tag': 'Bptag'},
+        'Biometrics': {'old_tag': 'biometric tag old', 'new_tag': 'biometric tag'},
+        'MHI': {'old_tag': 'MHI old', 'new_tag': 'MHI NEW'}
+    }
+    
+    # Clean the data
+    for param, cols in health_params.items():
+        # Fill NaN values with 'Not Available'
+        df[cols['old_tag']] = df[cols['old_tag']].fillna('Not Available')
+        df[cols['new_tag']] = df[cols['new_tag']].fillna('Not Available')
+        
+        # Standardize tag values
+        for col in [cols['old_tag'], cols['new_tag']]:
+            df[col] = df[col].astype(str).str.strip().str.title()
+            # Map common variations
+            df[col] = df[col].replace({
+                'Alert': 'Red',
+                'Sub-Optimal': 'Orange', 
+                'Optimal': 'Green',
+                'Suboptimal': 'Orange',
+                '0': 'Not Available',
+                '': 'Not Available'
+            })
+    
+    return df, health_params
+
+def calculate_transitions(df, health_params, location_filter=None):
+    """Calculate transition matrices for each health parameter"""
+    if location_filter and location_filter != "All Locations":
+        df_filtered = df[df['Location Shared'] == location_filter].copy()
+    else:
+        df_filtered = df.copy()
+    
+    transitions = {}
+    
+    for param, cols in health_params.items():
+        old_col = cols['old_tag']
+        new_col = cols['new_tag']
+        
+        # Create transition matrix
+        transition_df = df_filtered[[old_col, new_col]].copy()
+        transition_df = transition_df[
+            (transition_df[old_col] != 'Not Available') & 
+            (transition_df[new_col] != 'Not Available')
+        ]
+        
+        if len(transition_df) > 0:
+            transition_matrix = pd.crosstab(
+                transition_df[old_col], 
+                transition_df[new_col],
+                margins=True
+            )
+            
+            # Calculate transition summary
+            total_users = len(transition_df)
+            
+            # Count improvements, declines, and stable
+            improved = 0
+            declined = 0
+            stable = 0
+            
+            tag_hierarchy = {'Red': 3, 'Orange': 2, 'Green': 1}
+            
+            for _, row in transition_df.iterrows():
+                old_val = row[old_col]
+                new_val = row[new_col]
+                
+                if old_val in tag_hierarchy and new_val in tag_hierarchy:
+                    old_score = tag_hierarchy[old_val]
+                    new_score = tag_hierarchy[new_val]
+                    
+                    if new_score < old_score:  # Lower score is better
+                        improved += 1
+                    elif new_score > old_score:
+                        declined += 1
+                    else:
+                        stable += 1
+            
+            transitions[param] = {
+                'matrix': transition_matrix,
+                'total_users': total_users,
+                'improved': improved,
+                'declined': declined,
+                'stable': stable,
+                'improvement_rate': (improved / total_users * 100) if total_users > 0 else 0,
+                'decline_rate': (declined / total_users * 100) if total_users > 0 else 0,
+                'stable_rate': (stable / total_users * 100) if total_users > 0 else 0
+            }
+    
+    return transitions
+
+def create_transition_heatmap(transition_matrix, param_name):
+    """Create a heatmap for transition matrix"""
+    # Remove the 'All' row and column for cleaner visualization
+    matrix_clean = transition_matrix.drop('All', axis=0).drop('All', axis=1)
+    
+    fig = px.imshow(
+        matrix_clean.values,
+        x=matrix_clean.columns,
+        y=matrix_clean.index,
+        color_continuous_scale='Blues',
+        aspect="auto",
+        title=f"{param_name} Transition Matrix"
+    )
+    
+    # Add text annotations
+    for i, row in enumerate(matrix_clean.index):
+        for j, col in enumerate(matrix_clean.columns):
+            fig.add_annotation(
+                x=j, y=i,
+                text=str(matrix_clean.loc[row, col]),
+                showarrow=False,
+                font=dict(color="white" if matrix_clean.loc[row, col] > matrix_clean.values.max()/2 else "black")
+            )
+    
+    fig.update_layout(
+        xaxis_title="New Status",
+        yaxis_title="Old Status",
+        height=400
+    )
+    
+    return fig
+
+def create_summary_chart(transitions):
+    """Create summary chart showing improvement/decline rates"""
+    params = list(transitions.keys())
+    improvement_rates = [transitions[p]['improvement_rate'] for p in params]
+    decline_rates = [transitions[p]['decline_rate'] for p in params]
+    stable_rates = [transitions[p]['stable_rate'] for p in params]
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Bar(
+        name='Improved',
+        x=params,
+        y=improvement_rates,
+        marker_color='#2ca02c'
+    ))
+    
+    fig.add_trace(go.Bar(
+        name='Declined',
+        x=params,
+        y=decline_rates,
+        marker_color='#d62728'
+    ))
+    
+    fig.add_trace(go.Bar(
+        name='Stable',
+        x=params,
+        y=stable_rates,
+        marker_color='#ff7f0e'
+    ))
+    
+    fig.update_layout(
+        title="Health Parameter Transition Summary",
+        xaxis_title="Health Parameters",
+        yaxis_title="Percentage of Users",
+        barmode='stack',
+        height=500
+    )
+    
+    return fig
+
+def create_sankey_diagram(df, param, old_col, new_col, location_filter=None):
+    """Create Sankey diagram for parameter transitions"""
+    if location_filter and location_filter != "All Locations":
+        df_filtered = df[df['Location Shared'] == location_filter].copy()
+    else:
+        df_filtered = df.copy()
+    
+    # Filter out 'Not Available' values
+    df_filtered = df_filtered[
+        (df_filtered[old_col] != 'Not Available') & 
+        (df_filtered[new_col] != 'Not Available')
+    ]
+    
+    if len(df_filtered) == 0:
+        return None
+    
+    # Create transition counts
+    transitions = df_filtered.groupby([old_col, new_col]).size().reset_index(name='count')
+    
+    # Create unique labels
+    all_labels = list(set(transitions[old_col].tolist() + transitions[new_col].tolist()))
+    label_map = {label: i for i, label in enumerate(all_labels)}
+    
+    # Prepare data for Sankey
+    source = [label_map[old] for old in transitions[old_col]]
+    target = [label_map[new] + len(set(transitions[old_col])) for new in transitions[new_col]]
+    values = transitions['count'].tolist()
+    
+    # Create color mapping
+    color_map = {'Green': '#2ca02c', 'Orange': '#ff7f0e', 'Red': '#d62728'}
+    node_colors = [color_map.get(label, '#1f77b4') for label in all_labels]
+    
+    fig = go.Figure(data=[go.Sankey(
+        node=dict(
+            pad=15,
+            thickness=20,
+            line=dict(color="black", width=0.5),
+            label=[f"{label} (Old)" if i < len(set(transitions[old_col])) else f"{label} (New)" 
+                   for i, label in enumerate(all_labels + all_labels)],
+            color=node_colors + node_colors
+        ),
+        link=dict(
+            source=source,
+            target=target,
+            value=values
+        )
+    )])
+    
+    fig.update_layout(
+        title_text=f"{param} Parameter Transitions",
+        font_size=10,
+        height=400
+    )
+    
+    return fig
+
+def main():
+    st.markdown('<h1 class="main-header">🏥 Health Parameter Transition Dashboard</h1>', unsafe_allow_html=True)
+    
+    # Add description
+    st.markdown("""
+    This dashboard analyzes health parameter transitions between old and new measurements. 
+    It tracks improvements, declines, and stability across different health metrics with location-based filtering.
+    
+    **Health Parameters Analyzed:**
+    - **HbA1c**: Blood glucose control indicator
+    - **LDL**: Low-density lipoprotein cholesterol  
+    - **BMI**: Body Mass Index
+    - **BP**: Blood Pressure
+    - **Biometrics**: Overall biometric assessment
+    - **MHI**: Mental Health Index
+    """)
+    
+    # Load data
+    df = load_data()
+    if df is None:
+        st.error("Unable to load data. Please check if the data file is available.")
+        st.stop()
+    
+    # Clean data
+    df_clean, health_params = clean_tag_data(df)
+    
+    # Sidebar for filters
+    st.sidebar.header("📊 Dashboard Filters")
+    
+    # Location filter
+    locations = ['All Locations'] + sorted(df_clean['Location Shared'].dropna().unique().tolist())
+    selected_location = st.sidebar.selectbox("Select Location", locations)
+    
+    # Calculate transitions
+    transitions = calculate_transitions(df_clean, health_params, selected_location)
+    
+    # Display summary metrics
+    st.header("📈 Overall Summary")
+    
+    if selected_location != "All Locations":
+        st.info(f"📍 Showing data for: **{selected_location}**")
+    
+    # Create columns for summary metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    total_users = sum([t['total_users'] for t in transitions.values()]) // len(transitions) if transitions else 0
+    avg_improvement = np.mean([t['improvement_rate'] for t in transitions.values()]) if transitions else 0
+    avg_decline = np.mean([t['decline_rate'] for t in transitions.values()]) if transitions else 0
+    avg_stable = np.mean([t['stable_rate'] for t in transitions.values()]) if transitions else 0
+    
+    with col1:
+        st.metric("Total Users Analyzed", f"{total_users:,}")
+    
+    with col2:
+        st.metric("Average Improvement Rate", f"{avg_improvement:.1f}%", 
+                 delta=f"+{avg_improvement:.1f}%" if avg_improvement > 0 else None)
+    
+    with col3:
+        st.metric("Average Decline Rate", f"{avg_decline:.1f}%",
+                 delta=f"-{avg_decline:.1f}%" if avg_decline > 0 else None)
+    
+    with col4:
+        st.metric("Average Stable Rate", f"{avg_stable:.1f}%")
+    
+    # Summary chart
+    if transitions:
+        st.plotly_chart(create_summary_chart(transitions), use_container_width=True)
+    
+    # Parameter-wise analysis
+    st.header("🔍 Parameter-wise Analysis")
+    
+    if transitions:
+        tabs = st.tabs(list(health_params.keys()))
+        
+        for i, (param, cols) in enumerate(health_params.items()):
+            with tabs[i]:
+                if param in transitions and transitions[param]['total_users'] > 0:
+                    col1, col2 = st.columns([1, 1])
+                    
+                    with col1:
+                        # Display metrics for this parameter
+                        st.subheader(f"{param} Metrics")
+                        
+                        metrics_col1, metrics_col2, metrics_col3 = st.columns(3)
+                        
+                        with metrics_col1:
+                            st.metric("Users", transitions[param]['total_users'])
+                        
+                        with metrics_col2:
+                            improvement_rate = transitions[param]['improvement_rate']
+                            st.metric("Improved", f"{transitions[param]['improved']}", 
+                                    f"{improvement_rate:.1f}%")
+                        
+                        with metrics_col3:
+                            decline_rate = transitions[param]['decline_rate']
+                            st.metric("Declined", f"{transitions[param]['declined']}", 
+                                    f"{decline_rate:.1f}%")
+                        
+                        # Transition matrix heatmap
+                        st.plotly_chart(
+                            create_transition_heatmap(transitions[param]['matrix'], param),
+                            use_container_width=True
+                        )
+                    
+                    with col2:
+                        # Sankey diagram
+                        sankey_fig = create_sankey_diagram(
+                            df_clean, param, cols['old_tag'], cols['new_tag'], selected_location
+                        )
+                        if sankey_fig:
+                            st.plotly_chart(sankey_fig, use_container_width=True)
+                        else:
+                            st.info("No transition data available for Sankey diagram")
+                    
+                    # Detailed transition table
+                    st.subheader(f"{param} Detailed Transitions")
+                    transition_table = transitions[param]['matrix']
+                    st.dataframe(transition_table, use_container_width=True)
+                    
+                else:
+                    st.warning(f"No data available for {param} parameter")
+    else:
+        st.warning("No transition data available for the selected location.")
+    
+    # Data insights
+    st.header("💡 Key Insights")
+    
+    insights = []
+    
+    for param, data in transitions.items():
+        if data['total_users'] > 0:
+            if data['improvement_rate'] > 50:
+                insights.append(f"✅ **{param}**: Excellent improvement rate of {data['improvement_rate']:.1f}%")
+            elif data['improvement_rate'] > 30:
+                insights.append(f"🟡 **{param}**: Good improvement rate of {data['improvement_rate']:.1f}%")
+            
+            if data['decline_rate'] > 30:
+                insights.append(f"⚠️ **{param}**: High decline rate of {data['decline_rate']:.1f}% - needs attention")
+    
+    if insights:
+        for insight in insights:
+            st.markdown(insight)
+    else:
+        st.info("No significant insights to highlight at this time.")
+    
+    # Export functionality
+    st.header("📥 Export Data")
+    
+    if st.button("Generate Summary Report"):
+        summary_data = []
+        for param, data in transitions.items():
+            summary_data.append({
+                'Parameter': param,
+                'Total Users': data['total_users'],
+                'Improved': data['improved'],
+                'Declined': data['declined'],
+                'Stable': data['stable'],
+                'Improvement Rate (%)': round(data['improvement_rate'], 2),
+                'Decline Rate (%)': round(data['decline_rate'], 2),
+                'Stable Rate (%)': round(data['stable_rate'], 2)
+            })
+        
+        summary_df = pd.DataFrame(summary_data)
+        
+        st.download_button(
+            label="Download Summary CSV",
+            data=summary_df.to_csv(index=False),
+            file_name=f"health_transitions_summary_{selected_location.replace(' ', '_')}.csv",
+            mime="text/csv"
+        )
+        
+        st.dataframe(summary_df, use_container_width=True)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+streamlit>=1.28.0
+pandas>=2.0.0
+plotly>=5.15.0
+numpy>=1.24.0
+openpyxl>=3.1.0