Update app.py

app.py

@@ -146,45 +146,54 @@ def optimize_signal_rl(congestion_level):
         model.learn(total_timesteps=1000)
 
         # Reset the environment and get the initial observation
-        obs = env.reset()  # `obs` should be a 2D array (vectorized environment)
-        if not isinstance(obs, np.ndarray) or obs.ndim != 2:  # Validate obs shape
-            raise ValueError(f"Unexpected observation shape: {obs}, type: {type(obs)}")
-
+        obs = env.reset()
         logging.info(f"Initial observation: {obs}")
 
+        # Ensure `obs` is valid
+        if not isinstance(obs, np.ndarray) or obs.ndim != 2:
+            raise ValueError(f"Invalid observation after reset: {obs} (type: {type(obs)}, ndim: {obs.ndim if isinstance(obs, np.ndarray) else 'N/A'})")
+
         # RL Optimization loop
-        for _ in range(10):
-            # Predict action and perform step
+        for step_count in range(10):
+            # Predict action
             action, _ = model.predict(obs, deterministic=True)
+
+            # Perform environment step
             obs, rewards, dones, infos = env.step(action)
-            
-            if not isinstance(obs, np.ndarray) or obs.ndim != 2:  # Validate obs shape again
-                raise ValueError(f"Unexpected observation after step: {obs}, type: {type(obs)}")
-            
-            # Flatten the observation for easier handling
-            obs = obs.flatten()
 
-            logging.debug(f"Step results - Obs: {obs}, Reward: {rewards}, Done: {dones}, Info: {infos}")
+            # Check and log the observation
+            logging.debug(f"Step {step_count}: Obs: {obs}, Rewards: {rewards}, Done: {dones}, Infos: {infos}")
+
+            # Validate `obs` after each step
+            if not isinstance(obs, np.ndarray):
+                raise ValueError(f"Observation is not an array after step {step_count}: {obs}")
+            if obs.ndim == 0:  # Handle 0-dimensional observation
+                obs = np.array([obs])  # Convert to at least 1D
+                logging.warning(f"Converted 0D obs to array: {obs}")
+            elif obs.ndim == 1:  # Ensure it's 2D for consistency
+                obs = obs.reshape(1, -1)
 
-            if dones[0]:  # Stop if the environment signals it's done
+            # Stop if the environment signals it's done
+            if dones[0]:
                 break
 
-        # Get optimal signal duration
-        if len(obs) > 1:  # Ensure the array has enough elements
-            optimal_duration = int(obs[1])
-        else:
-            raise ValueError(f"Observation array too short: {obs}")
+        # Extract the optimal signal duration from the last valid observation
+        obs = obs.flatten()  # Ensure it's a 1D array for indexing
+        if len(obs) < 2:
+            raise ValueError(f"Observation does not contain enough elements: {obs}")
+        optimal_duration = int(obs[1])
 
         return f"Green for {optimal_duration}s, Red for {60 - optimal_duration}s"
 
     except ValueError as ve:
-        logging.error(f"Value error: {ve}")
+        logging.error(f"Value error during RL optimization: {ve}")
         return "Error: Unexpected values encountered during optimization."
     except Exception as e:
         logging.error(f"Error optimizing signal with RL: {e}")
         return "Error in RL Optimization"
 
 
+
 def process_traffic_image(image):
     """
     Orchestrates the traffic analysis workflow.