Update app.py

app.py

@@ -1,73 +1,197 @@
 import streamlit as st
+import numpy as np
+import random
 import plotly.graph_objects as go
-import time
 
-# Define the healthcare stages (frames) with corresponding data
-stages = [
-    {"frame": "Stage 1: Initial Diagnosis", "patient_heart_rate": 72, "blood_pressure": "120/80", "status": "Stable"},
-    {"frame": "Stage 2: Test Results Received", "patient_heart_rate": 75, "blood_pressure": "130/85", "status": "Mild Hypertension"},
-    {"frame": "Stage 3: Medication Prescribed", "patient_heart_rate": 78, "blood_pressure": "125/80", "status": "Improving"},
-    {"frame": "Stage 4: Follow-up Visit", "patient_heart_rate": 70, "blood_pressure": "118/78", "status": "Healthy"}
-]
+# Initialize agents (doctors, nurses, clinicians, patients)
+agents = {
+    "Doctors": 5,
+    "Nurses": 10,
+    "Clinicians": 8,
+    "Patients": 200
+}
 
-# Streamlit setup
-st.title("Interactive Healthcare Animation")
+# Define states for patients (health conditions)
+patient_conditions = ["Healthy", "Mild Illness", "Chronic Illness", "Emergency"]
 
-# Function to create interactive graph
-def create_health_graph(heart_rate, blood_pressure, frame_number):
-    fig = go.Figure()
+# Define emotions for healthcare agents (stress, focus, etc.)
+doctor_emotions = ["Calm", "Stressed", "Overwhelmed"]
+nurse_emotions = ["Focused", "Fatigued", "Panicked"]
 
-    # Heart rate graph
-    fig.add_trace(go.Indicator(
-        mode="gauge+number",
-        value=heart_rate,
-        title={'text': f"Heart Rate (BPM) - {stages[frame_number]['frame']}"},
-        domain={'x': [0, 0.5], 'y': [0, 1]},  # Adjusted domain values
-        gauge={'axis': {'range': [60, 120]}}
-    ))
+# Define the actions doctors can take
+doctor_actions = ["Prescribe Medication", "Recommend Tests", "Consult Clinician", "Schedule Surgery"]
+
+# Define the actions nurses can take
+nurse_actions = ["Monitor Vitals", "Administer Medication", "Report to Doctor", "Assist Surgery"]
+
+# Reward and penalty system
+rewards = {
+    "Prescribe Medication": 12,  # Slightly increased reward
+    "Recommend Tests": 7,  # Slightly increased reward
+    "Consult Clinician": 9,
+    "Schedule Surgery": 17,
+    "Monitor Vitals": 4,
+    "Administer Medication": 12,
+    "Review Diagnostic Test": 7,
+    "Recommend Additional Tests": 6
+}
+
+penalties = {
+    "Wrong Medication": -5,  # Reduced penalty
+    "Missed Diagnosis": -10,
+    "Incorrect Test Recommendation": -3,
+    "Stress-Induced Mistake": -7
+}
+
+# Initialize the session state for counting treatments
+if "performance_metrics" not in st.session_state:
+    st.session_state.performance_metrics = {
+        "Doctor": {"successful_treatments": 0, "failed_treatments": 0},
+        "Nurse": {"successful_assists": 0, "failed_assists": 0}
+    }
+if "patient_satisfaction" not in st.session_state:
+    st.session_state.patient_satisfaction = 100
+
+# Define Reinforcement Learning algorithm (basic Q-learning approach)
+class Agent:
+    def __init__(self, agent_type):
+        self.agent_type = agent_type
+        self.q_table = np.zeros((len(patient_conditions), len(doctor_actions if agent_type == "Doctor" else nurse_actions)))
+        self.state = random.choice(patient_conditions)
+    
+    def choose_action(self, exploration_rate=0.03):  # Further reduce exploration rate
+        if random.uniform(0, 1) < exploration_rate:  # Explore
+            return random.randint(0, len(doctor_actions)-1 if self.agent_type == "Doctor" else len(nurse_actions)-1)
+        else:  # Exploit (choose the best action based on Q-values)
+            return np.argmax(self.q_table)
+    
+    def update_q_value(self, state, action, reward, learning_rate=0.25, discount_factor=0.95):  # Increase learning rate
+        old_q_value = self.q_table[state, action]
+        best_future_q_value = np.max(self.q_table)
+        new_q_value = old_q_value + learning_rate * (reward + discount_factor * best_future_q_value - old_q_value)
+        self.q_table[state, action] = new_q_value
+
+# Instantiate agents
+doctor_agent = Agent("Doctor")
+nurse_agent = Agent("Nurse")
+
+# Animation function
+def create_animation(successful_treatments, failed_treatments):
+    fig = go.Figure()
 
-    # Blood pressure (represented as systolic value)
-    systolic_bp = int(blood_pressure.split('/')[0])
-    fig.add_trace(go.Indicator(
-        mode="gauge+number",
-        value=systolic_bp,
-        title={'text': "Systolic Blood Pressure"},
-        domain={'x': [0.5, 1], 'y': [0, 1]},  # Adjusted domain values
-        gauge={'axis': {'range': [90, 180]}}
+    # Add traces for successful and failed treatments
+    fig.add_trace(go.Bar(
+        x=['Successful Treatments', 'Failed Treatments'],
+        y=[successful_treatments, failed_treatments],
+        marker_color=['green', 'red'],
+        name='Doctor Performance'
     ))
 
+    # Animation settings
     fig.update_layout(
-        grid={'rows': 1, 'columns': 2, 'pattern': "independent"},
-        template='plotly_dark'
+        title="Doctor Performance Metrics",
+        xaxis_title="Treatment Type",
+        yaxis_title="Number of Treatments",
+        updatemenus=[dict(type="buttons",
+                          buttons=[dict(label="Play",
+                                        method="animate",
+                                        args=[None, {"frame": {"duration": 500, "redraw": True}, "fromcurrent": True}])])],
+        frames=[go.Frame(data=[go.Bar(y=[successful_treatments + i, failed_treatments + i])], name=str(i))
+                for i in range(1, 10)]  # Example of dynamic range
     )
 
     return fig
 
-# Button to start the animation
-start_button = st.button("Start Animation")
+# Button to run the simulation
+if st.button("Run Simulation"):
+    # Simulate special event (disease outbreak or resource shortage)
+    special_event = random.choice([None, "Disease Outbreak", "Resource Shortage"])
+    if special_event:
+        st.subheader(f"Special Event: {special_event}")
+        if special_event == "Disease Outbreak":
+            st.write("A sudden disease outbreak has flooded the hospital with new patients. Resources are limited!")
+        elif special_event == "Resource Shortage":
+            st.write("A medical supply shortage is impacting the hospital. Staff must prioritize high-risk patients.")
+
+    # Patient Condition Simulation
+    patient_state = random.choice(patient_conditions)
+    st.write(f"Simulated Patient Condition: {patient_state}")
+
+    # Random doctor and nurse emotions (affects performance)
+    doctor_emotion = random.choice(doctor_emotions)
+    nurse_emotion = random.choice(nurse_emotions)
+    st.write(f"Doctor's Emotional State: {doctor_emotion}")
+    st.write(f"Nurse's Emotional State: {nurse_emotion}")
+
+    # Doctor Action Simulation
+    doctor_action = doctor_agent.choose_action()
+    st.write(f"Doctor's Chosen Action: {doctor_actions[doctor_action]}")
+
+    # Nurse Action Simulation
+    nurse_action = nurse_agent.choose_action()
+    st.write(f"Nurse's Chosen Action: {nurse_actions[nurse_action]}")
+
+    # Complications that can arise during treatment
+    complication = random.choices(
+        [None, "Allergic Reaction", "Unexpected Complication"],
+        weights=[0.6, 0.2, 0.2]
+    )[0]
+    
+    if complication:
+        st.subheader(f"Complication: {complication}")
+        if complication == "Allergic Reaction":
+            st.write("The patient has developed an allergic reaction to the prescribed medication!")
+            penalty = penalties.get("Wrong Medication", 0)
+            st.session_state.patient_satisfaction -= 10
+        elif complication == "Unexpected Complication":
+            st.write("An unexpected complication occurred during surgery!")
+            penalty = penalties.get("Stress-Induced Mistake", 0)
+            st.session_state.patient_satisfaction -= 15
+    else:
+        penalty = 0
+
+    # Ensure action constraints for healthy patients
+    if patient_state == "Healthy" and doctor_action == 0:  # 0 corresponds to "Prescribe Medication"
+        penalty = penalties.get("Wrong Medication", 0)
+        st.write("Prescribing medication to a healthy patient is unnecessary! Immediate penalty applied.")
+        st.session_state.patient_satisfaction -= 20
+
+    # Reward or penalty based on action and emotional state
+    reward = rewards.get(doctor_actions[doctor_action], 0)
+    if doctor_emotion in ["Stressed", "Overwhelmed"]:
+        penalty += penalties.get("Stress-Induced Mistake", 0)
+
+    # Update Q-values
+    doctor_agent.update_q_value(patient_conditions.index(patient_state), doctor_action, reward if penalty == 0 else penalty)
 
-if start_button:
-    # Placeholder for dynamic updates
-    placeholder = st.empty()
+    st.write(f"Doctor's Reward: {reward if penalty == 0 else penalty}")
+    st.write(f"Patient Satisfaction: {st.session_state.patient_satisfaction}")
 
-    for i in range(len(stages)):
-        with placeholder.container():
-            col1, col2 = st.columns([1, 2])
+    # Simulated patient feedback and next steps
+    next_step = random.choices(
+        ["Recovery", "Further Treatment Needed", "Complication"],
+        weights=[0.6, 0.3, 0.1]
+    )[0]
+    st.write(f"Patient Status after treatment: {next_step}")
 
-            with col1:
-                # Display patient status for the current stage
-                st.subheader(f"{stages[i]['frame']}")
-                st.write(f"Heart Rate: {stages[i]['patient_heart_rate']} BPM")
-                st.write(f"Blood Pressure: {stages[i]['blood_pressure']}")
-                st.write(f"Patient Status: {stages[i]['status']}")
+    # Increment performance based on outcome
+    if next_step == "Recovery":
+        st.session_state.performance_metrics["Doctor"]["successful_treatments"] += 1
+        st.session_state.performance_metrics["Nurse"]["successful_assists"] += 1
+    else:
+        st.session_state.performance_metrics["Doctor"]["failed_treatments"] += 1
+        st.session_state.performance_metrics["Nurse"]["failed_assists"] += 1
 
-            with col2:
-                # Generate and display the interactive graph
-                fig = create_health_graph(stages[i]["patient_heart_rate"], stages[i]["blood_pressure"], i)
-                st.plotly_chart(fig, use_container_width=True)
+    # Create animation for performance metrics
+    successful_treatments = st.session_state.performance_metrics["Doctor"]["successful_treatments"]
+    failed_treatments = st.session_state.performance_metrics["Doctor"]["failed_treatments"]
 
-        # Pause for a short duration before moving to the next frame
-        time.sleep(2)
+    fig = create_animation(successful_treatments, failed_treatments)
+    st.plotly_chart(fig)
 
-    # Display a final summary
-    st.write("**Animation Complete: Patient's condition has stabilized.**")
+# Display performance metrics
+st.subheader("Performance Metrics:")
+st.write(f"Doctor's Successful Treatments: {st.session_state.performance_metrics['Doctor']['successful_treatments']}")
+st.write(f"Doctor's Failed Treatments: {st.session_state.performance_metrics['Doctor']['failed_treatments']}")
+st.write(f"Nurse's Successful Assists: {st.session_state.performance_metrics['Nurse']['successful_assists']}")
+st.write(f"Nurse's Failed Assists: {st.session_state.performance_metrics['Nurse']['failed_assists']}")