Update app.py

app.py

@@ -1,49 +1,30 @@
 import streamlit as st
 import numpy as np
 import random
-import time  # For animation delays
-
-# Initialize agents (doctors, nurses, clinicians, patients)
-agents = {
-    "Doctors": 5,
-    "Nurses": 10,
-    "Clinicians": 8,
-    "Patients": 200
-}
-
-# Define states for patients (health conditions)
-patient_conditions = ["Healthy", "Mild Illness", "Chronic Illness", "Emergency"]
-
-# Define emotions for healthcare agents (stress, focus, etc.)
-doctor_emotions = ["Calm", "Stressed", "Overwhelmed"]
-nurse_emotions = ["Focused", "Fatigued", "Panicked"]
-
-# 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"]
+# Initialize constants
+DOCTOR_ACTIONS = ["Prescribe Medication", "Recommend Tests", "Consult Clinician", "Schedule Surgery"]
+NURSE_ACTIONS = ["Monitor Vitals", "Administer Medication", "Report to Doctor", "Assist Surgery"]
+PATIENT_CONDITIONS = ["Healthy", "Mild Illness", "Chronic Illness", "Emergency"]
+DOCTOR_EMOTIONS = ["Calm", "Stressed", "Overwhelmed"]
+NURSE_EMOTIONS = ["Focused", "Fatigued", "Panicked"]
 
-# Reward and penalty system
-rewards = {
+# Rewards and Penalties
+REWARDS = {
     "Prescribe Medication": 12,
     "Recommend Tests": 7,
     "Consult Clinician": 9,
     "Schedule Surgery": 17,
     "Monitor Vitals": 4,
     "Administer Medication": 12,
-    "Review Diagnostic Test": 7,
-    "Recommend Additional Tests": 6
 }
-
-penalties = {
+PENALTIES = {
     "Wrong Medication": -5,
     "Missed Diagnosis": -10,
-    "Incorrect Test Recommendation": -3,
-    "Stress-Induced Mistake": -7
+    "Stress-Induced Mistake": -7,
 }
 
-# Initialize the session state for counting treatments
+# Initialize session state for metrics and satisfaction
 if "performance_metrics" not in st.session_state:
     st.session_state.performance_metrics = {
         "Doctor": {"successful_treatments": 0, "failed_treatments": 0},
@@ -52,119 +33,121 @@ if "performance_metrics" not in st.session_state:
 if "patient_satisfaction" not in st.session_state:
     st.session_state.patient_satisfaction = 100
 
-# Define Reinforcement Learning algorithm (basic Q-learning approach)
+
+# Define the Agent class for Q-learning
 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)
+        self.actions = DOCTOR_ACTIONS if agent_type == "Doctor" else NURSE_ACTIONS
+        self.q_table = np.zeros((len(PATIENT_CONDITIONS), len(self.actions)))
     
-    def choose_action(self, exploration_rate=0.03):
-        if random.uniform(0, 1) < exploration_rate:
-            return random.randint(0, len(doctor_actions)-1 if self.agent_type == "Doctor" else len(nurse_actions)-1)
-        else:
-            return np.argmax(self.q_table)
-    
-    def update_q_value(self, state, action, reward, learning_rate=0.25, discount_factor=0.95):
+    def choose_action(self, state, exploration_rate=0.05):
+        if random.uniform(0, 1) < exploration_rate:  # Explore
+            return random.randint(0, len(self.actions)-1)
+        else:  # Exploit (choose best action)
+            return np.argmax(self.q_table[state])
+
+    def update_q_value(self, state, action, reward, learning_rate=0.1, discount_factor=0.9):
         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 for smoother transitions
-def animate_text(text, delay=0.1):
-    for char in text:
-        st.write(char, end="")
-        time.sleep(delay)
-    st.write("\n")
 
-# Button to run the simulation
-if st.button("Run Simulation"):
-    st.subheader("Simulation Running...")
-
-    # Simulate special event (disease outbreak or resource shortage)
-    special_event = random.choice([None, "Disease Outbreak", "Resource Shortage"])
-    if special_event:
-        animate_text(f"Special Event: {special_event}")
-        if special_event == "Disease Outbreak":
-            animate_text("A sudden disease outbreak has flooded the hospital with new patients. Resources are limited!")
-        elif special_event == "Resource Shortage":
-            animate_text("A medical supply shortage is impacting the hospital. Staff must prioritize high-risk patients.")
-
-    # Patient Condition Simulation
-    patient_state = random.choice(patient_conditions)
-    animate_text(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)
-    animate_text(f"Doctor's Emotional State: {doctor_emotion}")
-    animate_text(f"Nurse's Emotional State: {nurse_emotion}")
-
-    # Doctor Action Simulation
-    doctor_action = doctor_agent.choose_action()
-    animate_text(f"Doctor's Chosen Action: {doctor_actions[doctor_action]}")
-
-    # Nurse Action Simulation
-    nurse_action = nurse_agent.choose_action()
-    animate_text(f"Nurse's Chosen Action: {nurse_actions[nurse_action]}")
-
-    # Complications that can arise during treatment
+# Function to simulate a special event
+def simulate_special_event():
+    event = random.choice([None, "Disease Outbreak", "Resource Shortage"])
+    if event == "Disease Outbreak":
+        st.subheader("Special Event: Disease Outbreak")
+        st.write("A sudden disease outbreak has flooded the hospital with new patients. Resources are limited!")
+    elif event == "Resource Shortage":
+        st.subheader("Special Event: Resource Shortage")
+        st.write("A medical supply shortage is impacting the hospital. Staff must prioritize high-risk patients.")
+    return event
+
+
+# Function to handle complications during treatment
+def handle_complications():
     complication = random.choices(
         [None, "Allergic Reaction", "Unexpected Complication"],
         weights=[0.6, 0.2, 0.2]
     )[0]
     
+    penalty = 0
     if complication:
-        animate_text(f"Complication: {complication}")
+        st.subheader(f"Complication: {complication}")
         if complication == "Allergic Reaction":
-            animate_text("The patient has developed an allergic reaction to the prescribed medication!")
-            penalty = penalties.get("Wrong Medication", 0)
+            st.write("The patient has developed an allergic reaction to the prescribed medication!")
+            penalty = PENALTIES["Wrong Medication"]
             st.session_state.patient_satisfaction -= 10
         elif complication == "Unexpected Complication":
-            animate_text("An unexpected complication occurred during surgery!")
-            penalty = penalties.get("Stress-Induced Mistake", 0)
+            st.write("An unexpected complication occurred during surgery!")
+            penalty = PENALTIES["Stress-Induced Mistake"]
             st.session_state.patient_satisfaction -= 15
-    else:
-        penalty = 0
+    return penalty
 
-    # Ensure action constraints for healthy patients
-    if patient_state == "Healthy" and doctor_action == 0:
-        penalty = penalties.get("Wrong Medication", 0)
-        animate_text("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)
+# Main simulation button logic
+if st.button("Run Simulation"):
+    # Simulate a special event
+    special_event = simulate_special_event()
+    
+    # Patient condition simulation
+    patient_state = random.choice(PATIENT_CONDITIONS)
+    st.write(f"Simulated Patient Condition: {patient_state}")
+    patient_index = PATIENT_CONDITIONS.index(patient_state)
+    
+    # Doctor and nurse emotions
+    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
+    doctor_action_index = doctor_agent.choose_action(patient_index)
+    doctor_action = DOCTOR_ACTIONS[doctor_action_index]
+    st.write(f"Doctor's Chosen Action: {doctor_action}")
+    
+    # Nurse Action
+    nurse_action_index = nurse_agent.choose_action(patient_index)
+    nurse_action = NURSE_ACTIONS[nurse_action_index]
+    st.write(f"Nurse's Chosen Action: {nurse_action}")
+    
+    # Handle potential complications
+    penalty = handle_complications()
+    
+    # Reward or penalty
+    reward = REWARDS.get(doctor_action, 0) if penalty == 0 else penalty
     if doctor_emotion in ["Stressed", "Overwhelmed"]:
-        penalty += penalties.get("Stress-Induced Mistake", 0)
-
+        penalty += PENALTIES["Stress-Induced Mistake"]
+    
     # Update Q-values
-    doctor_agent.update_q_value(patient_conditions.index(patient_state), doctor_action, reward if penalty == 0 else penalty)
-
-    animate_text(f"Doctor's Reward: {reward if penalty == 0 else penalty}")
-    animate_text(f"Patient Satisfaction: {st.session_state.patient_satisfaction}")
-
-    # Simulated patient feedback and next steps
-    next_step = random.choices(
+    doctor_agent.update_q_value(patient_index, doctor_action_index, reward)
+    
+    st.write(f"Doctor's Reward/Penalty: {reward}")
+    st.write(f"Patient Satisfaction: {st.session_state.patient_satisfaction}")
+    
+    # Outcome and Performance Metrics Update
+    outcome = random.choices(
         ["Recovery", "Further Treatment Needed", "Complication"],
         weights=[0.6, 0.3, 0.1]
     )[0]
-    animate_text(f"Patient Status after treatment: {next_step}")
-
-    # Increment performance based on outcome
-    if next_step == "Recovery":
+    
+    st.write(f"Patient Status after Treatment: {outcome}")
+    
+    if outcome == "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
 
-    st.write("Simulation completed! Click 'Run Simulation' again to simulate different actions and outcomes.")
+    st.write("Simulation completed! Run again for different outcomes.")
 
 # Display performance metrics
 st.subheader("Performance Metrics:")