Update app.py

app.py

@@ -1,6 +1,7 @@
 import streamlit as st
 import numpy as np
 import random
+import time  # For animation delays
 
 # Initialize agents (doctors, nurses, clinicians, patients)
 agents = {
@@ -25,8 +26,8 @@ nurse_actions = ["Monitor Vitals", "Administer Medication", "Report to Doctor",
 
 # Reward and penalty system
 rewards = {
-    "Prescribe Medication": 12,  # Slightly increased reward
-    "Recommend Tests": 7,  # Slightly increased reward
+    "Prescribe Medication": 12,
+    "Recommend Tests": 7,
     "Consult Clinician": 9,
     "Schedule Surgery": 17,
     "Monitor Vitals": 4,
@@ -36,7 +37,7 @@ rewards = {
 }
 
 penalties = {
-    "Wrong Medication": -5,  # Reduced penalty
+    "Wrong Medication": -5,
     "Missed Diagnosis": -10,
     "Incorrect Test Recommendation": -3,
     "Stress-Induced Mistake": -7
@@ -58,13 +59,13 @@ class Agent:
         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
+    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:  # Exploit (choose the best action based on Q-values)
+        else:
             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
+    def update_q_value(self, state, action, reward, learning_rate=0.25, discount_factor=0.95):
         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)
@@ -74,60 +75,68 @@ class Agent:
 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:
-        st.subheader(f"Special Event: {special_event}")
+        animate_text(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!")
+            animate_text("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.")
+            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)
-    st.write(f"Simulated Patient Condition: {patient_state}")
+    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)
-    st.write(f"Doctor's Emotional State: {doctor_emotion}")
-    st.write(f"Nurse's Emotional State: {nurse_emotion}")
+    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()
-    st.write(f"Doctor's Chosen Action: {doctor_actions[doctor_action]}")
+    animate_text(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]}")
+    animate_text(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]  # 60% chance no complications, 20% for each complication
+        weights=[0.6, 0.2, 0.2]
     )[0]
     
     if complication:
-        st.subheader(f"Complication: {complication}")
+        animate_text(f"Complication: {complication}")
         if complication == "Allergic Reaction":
-            st.write("The patient has developed an allergic reaction to the prescribed medication!")
+            animate_text("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!")
+            animate_text("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"
+    if patient_state == "Healthy" and doctor_action == 0:
         penalty = penalties.get("Wrong Medication", 0)
-        st.write("Prescribing medication to a healthy patient is unnecessary! Immediate penalty applied.")
+        animate_text("Prescribing medication to a healthy patient is unnecessary! Immediate penalty applied.")
         st.session_state.patient_satisfaction -= 20
-        next_step = "Complication"  # Force a complication due to unnecessary treatment
 
     # Reward or penalty based on action and emotional state
     reward = rewards.get(doctor_actions[doctor_action], 0)
@@ -137,15 +146,15 @@ if st.button("Run Simulation"):
     # Update Q-values
     doctor_agent.update_q_value(patient_conditions.index(patient_state), doctor_action, reward if penalty == 0 else penalty)
 
-    st.write(f"Doctor's Reward: {reward if penalty == 0 else penalty}")
-    st.write(f"Patient Satisfaction: {st.session_state.patient_satisfaction}")
+    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(
         ["Recovery", "Further Treatment Needed", "Complication"],
-        weights=[0.6, 0.3, 0.1]  # Biased toward successful recovery
+        weights=[0.6, 0.3, 0.1]
     )[0]
-    st.write(f"Patient Status after treatment: {next_step}")
+    animate_text(f"Patient Status after treatment: {next_step}")
 
     # Increment performance based on outcome
     if next_step == "Recovery":