Update app.py

app.py

@@ -1,144 +1,125 @@
 import gradio as gr
 import numpy as np
-import joblib
+import pandas as pd
 import folium
+import joblib
 from io import BytesIO
 import base64
 
-# Define model paths
-model_paths = {
-    'Path': {
-        '3 hours': 'lr_3H_lat_lon.pkl',
-        '6 hours': 'lr_6H_lat_lon.pkl',
-        '9 hours': 'lr_9H_lat_lon.pkl',
-        '12 hours': 'lr_12H_lat_lon.pkl',
-        '15 hours': 'lr_15H_lat_lon.pkl',
-        '18 hours': 'lr_18H_lat_lon.pkl',
-        '21 hours': 'lr_21H_lat_lon.pkl',
-        '24 hours': 'lr_24H_lat_lon.pkl',
-        '27 hours': 'lr_27H_lat_lon.pkl',
-        '30 hours': 'lr_30H_lat_lon.pkl',
-        '33 hours': 'lr_33H_lat_lon.pkl',
-        '36 hours': 'lr_36H_lat_lon.pkl'
-    }
-}
-
-# Define scaler paths
-scaler_paths = {
-    'Path': {
-        '3 hours': 'lr_3H_lat_lon_scaler.pkl',
-        '6 hours': 'lr_6H_lat_lon_scaler.pkl',
-        '9 hours': 'lr_9H_lat_lon_scaler.pkl',
-        '12 hours': 'lr_12H_lat_lon_scaler.pkl',
-        '15 hours': 'lr_15H_lat_lon_scaler.pkl',
-        '18 hours': 'lr_18H_lat_lon_scaler.pkl',
-        '24 hours': 'lr_24H_lat_lon_scaler.pkl',
-        '27 hours': 'lr_27H_lat_lon_scaler.pkl',
-        '30 hours': 'lr_30H_lat_lon_scaler.pkl',
-        '33 hours': 'lr_33H_lat_lon_scaler.pkl',
-        '36 hours': 'lr_36H_lat_lon_scaler.pkl'
-    }
-}
-
-def process_input(input_data, scaler):
-    input_data = np.array(input_data).reshape(-1, 7)
-    processed_data = input_data[:2].reshape(1, -1)
-    processed_data = scaler.transform(processed_data)
-    return processed_data
-
-def load_model_and_predict(prediction_type, time_interval, input_data):
-    try:
-        # Load the model and scaler based on user selection
-        model = joblib.load(model_paths[prediction_type][time_interval])
-        scaler = joblib.load(scaler_paths[prediction_type][time_interval])
-        
-        # Process input and predict
-        processed_data = process_input(input_data, scaler)
-        prediction = model.predict(processed_data)
-        
-        lat, lon = prediction[0][0], prediction[0][1]
-        
-        # Create Folium map for predicted location
-        map_ = folium.Map(location=[lat, lon], zoom_start=6)
-        folium.Marker([lat, lon], popup=f"Predicted Location ({lat:.2f}, {lon:.2f})").add_to(map_)
-        
-        # Save map as HTML and convert to base64
-        map_html = BytesIO()
-        map_.save(map_html)  # removed 'format' argument
-        map_html.seek(0)
-        map_base64 = base64.b64encode(map_html.getvalue()).decode("utf-8")
-        
-        return f"Predicted Path after {time_interval}: Latitude: {lat}, Longitude: {lon}", f'<iframe src="data:text/html;base64,{map_base64}" width="100%" height="400"></iframe>'
-    except Exception as e:
-        return str(e), None
-
-# Gradio interface components
-with gr.Blocks() as cyclone_predictor:
-    gr.Markdown("# Cyclone Path Prediction App")
+# Load the saved model
+def load_model():
+    return joblib.load('cyclone_model.pkl')
+
+# Predict the next 6 rows based on input
+def predict_next_6_rows(lat_present, lon_present, dist2land_present, storm_speed_present,
+                        year_present, month_present, day_present, hour_present,
+                        lat_prev, lon_prev, dist2land_prev, storm_speed_prev):
     
-    # Dropdown for Prediction Type
-    prediction_type = gr.Dropdown(
-        choices=['Path'],
-        value='Path',
-        label="Select Prediction Type"
-    )
+    # Construct the current and previous data as feature arrays
+    current_data = [lat_present, lon_present, dist2land_present, storm_speed_present, year_present, month_present, day_present, hour_present]
+    previous_data = [lat_prev, lon_prev, dist2land_prev, storm_speed_prev, year_present, month_present, day_present, hour_present - 3]
+
+    # Adjust for negative hours
+    if previous_data[-1] < 0:
+        previous_data[-1] += 24
+        previous_data[6] -= 1  # Adjust day
+
+    # Preprocess the input into the required shape (2 rows, 8 columns)
+    input_data = [previous_data, current_data]
+    input_data = np.array(input_data).reshape(1, 2, 8)
     
-    # Dropdown for Time Interval
-    time_interval = gr.Dropdown(
-        choices=['3 hours', '6 hours', '9 hours', '12 hours', '15 hours', '18 hours', '21 hours', '24 hours', '27 hours', '30 hours', '33 hours', '36 hours'],
-        label="Select Time Interval"
-    )
+    # Flatten the input to match the model's input shape
+    input_data_flat = input_data.reshape(1, -1)
+
+    # Load the model and make predictions
+    loaded_model = load_model()
+    predictions = loaded_model.predict(input_data_flat)
+
+    # Reshape the predictions back to (6, 4) format
+    predictions_reshaped = predictions.reshape(6, 4)
+
+    # Create a DataFrame for the predictions
+    columns = ['LAT', 'LON', 'DIST2LAND', 'STORM_SPEED']
+    df_predictions = pd.DataFrame(predictions_reshaped, columns=columns)
+
+    # Add the 'Hour' column, incrementing by 3 hours from the present time
+    df_predictions['Hour'] = [(hour_present + (i + 1) * 3) % 24 for i in range(6)]  # Ensure the hour wraps around 24
+
+    return df_predictions
+
+# Plot predictions on a folium map and return an HTML iframe
+def plot_predictions_on_map(df_predictions):
+    # Extract LAT and LON from the predictions
+    latitudes = df_predictions['LAT'].tolist()
+    longitudes = df_predictions['LON'].tolist()
+
+    # Create a folium map centered at the first predicted point
+    m = folium.Map(location=[latitudes[0], longitudes[0]], zoom_start=6)
+
+    # Add the predicted points to the map and connect them with a polyline
+    locations = list(zip(latitudes, longitudes))
+
+    # Add the points to the map
+    for lat, lon in locations:
+        folium.Marker([lat, lon]).add_to(m)
+
+    # Add a polyline to connect the points
+    folium.PolyLine(locations, color='blue', weight=2.5, opacity=0.7).add_to(m)
+
+    # Save map as HTML in a BytesIO object
+    map_html = BytesIO()
+    m.save(map_html)
+    map_html.seek(0)
+    map_base64 = base64.b64encode(map_html.getvalue()).decode('utf-8')
     
-    # Input fields for user data
-    previous_lat_lon = gr.Textbox(
-        placeholder="Enter previous 3-hour lat/lon (e.g., 15.54,90.64)",
-        label="Previous 3-hour Latitude/Longitude"
-    )
-    previous_speed = gr.Number(label="Previous 3-hour Speed")
-    previous_timestamp = gr.Textbox(
-        placeholder="Enter previous 3-hour timestamp (e.g., 2024,10,23,0)",
-        label="Previous 3-hour Timestamp (year, month, day, hour)"
-    )
+    return f'<iframe src="data:text/html;base64,{map_base64}" width="100%" height="400"></iframe>'
 
-    present_lat_lon = gr.Textbox(
-        placeholder="Enter present 3-hour lat/lon (e.g., 15.71,90.29)",
-        label="Present 3-hour Latitude/Longitude"
-    )
-    present_speed = gr.Number(label="Present 3-hour Speed")
-    present_timestamp = gr.Textbox(
-        placeholder="Enter present 3-hour timestamp (e.g., 2024,10,23,3)",
-        label="Present 3-hour Timestamp (year, month, day, hour)"
-    )
+# Gradio interface setup
+def main_interface(lat_present, lon_present, dist2land_present, storm_speed_present,
+                   year_present, month_present, day_present, hour_present,
+                   lat_prev, lon_prev, dist2land_prev, storm_speed_prev):
+    
+    # Get the DataFrame prediction
+    df_predictions = predict_next_6_rows(lat_present, lon_present, dist2land_present, storm_speed_present,
+                                         year_present, month_present, day_present, hour_present,
+                                         lat_prev, lon_prev, dist2land_prev, storm_speed_prev)
+    
+    # Generate map
+    map_html = plot_predictions_on_map(df_predictions)
+    
+    return df_predictions, map_html
 
-    # Output prediction
-    prediction_output = gr.Textbox(label="Prediction Output")
-    map_output = gr.HTML(label="Predicted Location Map")
+# Gradio app
+with gr.Blocks() as cyclone_predictor:
+    gr.Markdown("# Cyclone Path Prediction")
+    
+    # Input fields
+    lat_present = gr.Number(label="Current Latitude")
+    lon_present = gr.Number(label="Current Longitude")
+    dist2land_present = gr.Number(label="Current DIST2LAND")
+    storm_speed_present = gr.Number(label="Current STORM_SPEED")
+    year_present = gr.Number(label="Current Year")
+    month_present = gr.Number(label="Current Month")
+    day_present = gr.Number(label="Current Day")
+    hour_present = gr.Number(label="Current Hour")
+    
+    lat_prev = gr.Number(label="Previous Latitude")
+    lon_prev = gr.Number(label="Previous Longitude")
+    dist2land_prev = gr.Number(label="Previous DIST2LAND")
+    storm_speed_prev = gr.Number(label="Previous STORM_SPEED")
     
-    # Predict button
-    def get_input_data(previous_lat_lon, previous_speed, previous_timestamp, present_lat_lon, present_speed, present_timestamp):
-        try:
-            # Parse inputs into required format
-            prev_lat, prev_lon = map(float, previous_lat_lon.split(','))
-            prev_time = list(map(int, previous_timestamp.split(',')))
-            previous_data = [prev_lat, prev_lon, previous_speed] + prev_time
-
-            present_lat, present_lon = map(float, present_lat_lon.split(','))
-            present_time = list(map(int, present_timestamp.split(',')))
-            present_data = [present_lat, present_lon, present_speed] + present_time
-
-            return [previous_data, present_data]
-        except Exception as e:
-            return str(e)
-
-    predict_button = gr.Button("Predict Path")
+    # Prediction and map output
+    prediction_output = gr.Dataframe(label="Predicted DataFrame")
+    map_output = gr.HTML(label="Predicted Path Map")
     
-    # Linking function to UI elements
+    # Button to trigger prediction
+    predict_button = gr.Button("Predict")
     predict_button.click(
-        fn=lambda pt, ti, p_lat_lon, p_speed, p_time, c_lat_lon, c_speed, c_time: load_model_and_predict(
-            pt, ti, get_input_data(p_lat_lon, p_speed, p_time, c_lat_lon, c_speed, c_time)
-        ),
-        inputs=[prediction_type, time_interval, previous_lat_lon, previous_speed, previous_timestamp, present_lat_lon, present_speed, present_timestamp],
+        main_interface,
+        inputs=[lat_present, lon_present, dist2land_present, storm_speed_present,
+                year_present, month_present, day_present, hour_present,
+                lat_prev, lon_prev, dist2land_prev, storm_speed_prev],
         outputs=[prediction_output, map_output]
     )
 
-cyclone_predictor.launch()
+cyclone_predictor.launch()