Update app.py

app.py

@@ -7,82 +7,98 @@ import pandas as pd
 from joblib import load
 from tensorflow.keras.models import load_model
 from sklearn.preprocessing import MinMaxScaler
+import matplotlib.pyplot as plt
 import os
-import sklearn  # Import sklearn
-
-# Display library versions
-print(f"Gradio version: {gr.__version__}")
-print(f"NumPy version: {np.__version__}")
-print(f"Scikit-learn version: {sklearn.__version__}")
-print(f"Joblib version: {joblib.__version__}")
-print(f"TensorFlow version: {tf.__version__}")
-print(f"Pandas version: {pd.__version__}")
-
-# Directory paths for the saved models
-script_dir = os.path.dirname(os.path.abspath(__file__))
-scaler_path = os.path.join(script_dir, 'toolkit', 'scaler_X.json')
-rf_model_path = os.path.join(script_dir, 'toolkit', 'rf_model.joblib')
-mlp_model_path = os.path.join(script_dir, 'toolkit', 'mlp_model.keras')
-meta_model_path = os.path.join(script_dir, 'toolkit', 'meta_model.joblib')
-image_path = os.path.join(script_dir, 'toolkit', 'car.png')
-
-# Load the scaler and models
-try:
-    # Load the scaler
-    with open(scaler_path, 'r') as f:
-        scaler_params = json.load(f)
-    scaler_X = MinMaxScaler()
-    scaler_X.scale_ = np.array(scaler_params["scale_"])
-    scaler_X.min_ = np.array(scaler_params["min_"])
-    scaler_X.data_min_ = np.array(scaler_params["data_min_"])
-    scaler_X.data_max_ = np.array(scaler_params["data_max_"])
-    scaler_X.data_range_ = np.array(scaler_params["data_range_"])
-    scaler_X.n_features_in_ = scaler_params["n_features_in_"]
-    scaler_X.feature_names_in_ = np.array(scaler_params["feature_names_in_"])
-
-    # Load the models
-    loaded_rf_model = load(rf_model_path)
-    print("Random Forest model loaded successfully.")
-    loaded_mlp_model = load_model(mlp_model_path)
-    print("MLP model loaded successfully.")
-    loaded_meta_model = load(meta_model_path)
-    print("Meta model loaded successfully.")
-except Exception as e:
-    print(f"Error loading models or scaler: {e}")
-
-def predict_new_values(new_input_data):
+import sklearn
+
+# Assuming the previous setup and imports have been done
+
+def predict_and_plot(velocity, temperature, precipitation, humidity):
     try:
-        # Ensure the new input data is in the correct format
-        print(f"Raw Input Data: {new_input_data}")
-        new_input_data = np.array(new_input_data).reshape(1, -1)
-        
-        # Scale the new input data
-        new_input_scaled = scaler_X.transform(new_input_data)
-        print(f"Scaled Input Data: {new_input_scaled}")
+        # Prepare the example data
+        example_data = pd.DataFrame({
+            'Velocity(mph)': [velocity],
+            'Temperature': [temperature],
+            'Precipitation': [precipitation],
+            'Humidity': [humidity]
+        })
 
-        # Make predictions with the MLP model
-        contamination_predictions, gradients_predictions = loaded_mlp_model.predict(new_input_scaled)
+        # Scale the example data
+        example_data_scaled = scaler_X.transform(example_data)
 
-        return contamination_predictions[0], gradients_predictions[0]
-    except Exception as e:
-        print(f"Error in prediction: {e}")
-        return (["Error"] * 6, ["Error"] * 6)
+        # Function to predict contamination levels
+        def predict_contamination(example_data_scaled):
+            # Predict using MLP model
+            mlp_predictions_contamination, mlp_predictions_gradients = loaded_mlp_model.predict(example_data_scaled)
 
-def gradio_interface(velocity, temperature, precipitation, humidity):
-    try:
-        input_data = [velocity, temperature, precipitation, humidity]
-        print(f"Input Data: {input_data}")
-        contamination_predictions, gradients_predictions = predict_new_values(input_data)
-        print(f"Contamination Predictions: {contamination_predictions}")
-        print(f"Gradients Predictions: {gradients_predictions}")
+            # Predict using RF model
+            rf_predictions = loaded_rf_model.predict(example_data_scaled)
+
+            # Combine predictions for meta model
+            combined_features = np.concatenate([np.concatenate([mlp_predictions_contamination, mlp_predictions_gradients], axis=1), rf_predictions], axis=1)
+
+            # Predict using meta model
+            meta_predictions = loaded_meta_model.predict(combined_features)
+
+            return meta_predictions[:, :6]  # Assuming the first 6 columns are contamination predictions
+
+        # Predict contamination levels for the single example
+        contamination_levels = predict_contamination(example_data_scaled)
+
+        # Simulate contamination levels at multiple time intervals
+        time_intervals = np.arange(0, 601, 60)  # Simulating time intervals from 0 to 600 seconds
+
+        # Generate simulated contamination levels (linear interpolation between predicted values)
+        simulated_contamination_levels = np.array([
+            np.linspace(contamination_levels[0][i], contamination_levels[0][i] * 2, len(time_intervals))
+            for i in range(contamination_levels.shape[1])
+        ]).T
+
+        # Function to calculate cleaning time using linear interpolation
+        def calculate_cleaning_time(time_intervals, contamination_levels, threshold=0.4):
+            cleaning_times = []
+            for i in range(contamination_levels.shape[1]):
+                levels = contamination_levels[:, i]
+                for j in range(1, len(levels)):
+                    if levels[j-1] <= threshold <= levels[j]:
+                        # Linear interpolation
+                        t1, t2 = time_intervals[j-1], time_intervals[j]
+                        c1, c2 = levels[j-1], levels[j]
+                        cleaning_time = t1 + (threshold - c1) * (t2 - t1) / (c2 - c1)
+                        cleaning_times.append(cleaning_time)
+                        break
+            return cleaning_times
+
+        # Calculate cleaning times for all 6 lidars
+        cleaning_times = calculate_cleaning_time(time_intervals, simulated_contamination_levels)
+
+        # Lidar names
+        lidar_names = ['F/L', 'F/R', 'Left', 'Right', 'Roof', 'Rear']
+
+        # Plot the graph
+        plt.figure(figsize=(12, 8))
+
+        for i in range(simulated_contamination_levels.shape[1]):
+            plt.plot(time_intervals, simulated_contamination_levels[:, i], label=f'{lidar_names[i]}')
+            plt.axhline(y=0.4, color='r', linestyle='--', label='Contamination Threshold' if i == 0 else "")
+            if i < len(cleaning_times):
+                plt.scatter(cleaning_times[i], 0.4, color='k')  # Mark the cleaning time point
+
+        plt.title('Contamination Levels Over Time for Each Lidar')
+        plt.xlabel('Time (seconds)')
+        plt.ylabel('Contamination Level')
+        plt.legend()
+        plt.grid(True)
         
-        # Flatten the results into a single list of 12 outputs
-        combined_outputs = [f"{val * 100:.2f}%" if val != "Error" else "Error" for val in contamination_predictions] + \
-                           [f"{val:.2f}" if val != "Error" else "Error" for val in gradients_predictions]
-        return combined_outputs
+        # Save the plot to a file
+        plt.savefig('plot.png')
+        
+        # Return the plot and predictions
+        return plt, [f"{val * 100:.2f}%" for val in contamination_levels[0]], [f"{val:.2f}" for val in cleaning_times]
+
     except Exception as e:
         print(f"Error in Gradio interface: {e}")
-        return ["Error"] * 12
+        return plt.figure(), ["Error"] * 6, ["Error"] * 6
 
 inputs = [
     gr.Slider(minimum=0, maximum=100, value=50, step=0.05, label="Velocity (mph)"),
@@ -100,18 +116,18 @@ contamination_outputs = [
     gr.Textbox(label="Rear Contamination")
 ]
 
-gradients_outputs = [
-    gr.Textbox(label="Front Left Gradient"),
-    gr.Textbox(label="Front Right Gradient"),
-    gr.Textbox(label="Left Gradient"),
-    gr.Textbox(label="Right Gradient"),
-    gr.Textbox(label="Roof Gradient"),
-    gr.Textbox(label="Rear Gradient")
+cleaning_time_outputs = [
+    gr.Textbox(label="Front Left Cleaning Time"),
+    gr.Textbox(label="Front Right Cleaning Time"),
+    gr.Textbox(label="Left Cleaning Time"),
+    gr.Textbox(label="Right Cleaning Time"),
+    gr.Textbox(label="Roof Cleaning Time"),
+    gr.Textbox(label="Rear Cleaning Time")
 ]
 
 with gr.Blocks() as demo:
-    gr.Markdown("<h1 style='text-align: center;'>Environmental Factor-Based Contamination & Gradient Prediction</h1>")
-    gr.Markdown("This application predicts the contamination levels and corresponding gradients for different parts of a car's LiDAR system based on environmental factors such as velocity, temperature, precipitation, and humidity.")
+    gr.Markdown("<h1 style='text-align: center;'>Environmental Factor-Based Contamination & Cleaning Time Prediction</h1>")
+    gr.Markdown("This application predicts the contamination levels, corresponding gradients, and cleaning times for different parts of a car's LiDAR system based on environmental factors such as velocity, temperature, precipitation, and humidity.")
     
     with gr.Row():
         with gr.Column():
@@ -124,7 +140,11 @@ with gr.Blocks() as demo:
                 with gr.Column(scale=1, min_width=0):
                     gr.Image(image_path)  # Ensure the image is centered
             
-            gr.Button(value="Submit", variant="primary").click(fn=gradio_interface, inputs=inputs, outputs=contamination_outputs + gradients_outputs)
+            gr.Button(value="Submit", variant="primary").click(
+                fn=predict_and_plot, 
+                inputs=inputs, 
+                outputs=[gr.Plot(label="Contamination Levels Over Time")] + contamination_outputs + cleaning_time_outputs
+            )
             gr.Button(value="Clear").click(fn=lambda: None)
             
         with gr.Column():
@@ -133,8 +153,8 @@ with gr.Blocks() as demo:
                 out.render()
                 
         with gr.Column():
-            gr.Markdown("### Gradients Predictions")
-            for out in gradients_outputs:
+            gr.Markdown("### Cleaning Time Predictions")
+            for out in cleaning_time_outputs:
                 out.render()
 
 demo.launch()