Update app.py

app.py

@@ -1,14 +1,9 @@
-import joblib
+import gradio as gr
 import numpy as np
-import pandas as pd
-import folium
-import streamlit as st
-from streamlit_folium import folium_static
-import warnings
-warnings.filterwarnings("ignore")
+import joblib
 
 # Define model paths
-model_paths = {
+model_paths = { 
     'Path': {
         '3 hours': 'lr_3H_lat_lon.pkl',
         '6 hours': 'lr_6H_lat_lon.pkl',
@@ -22,6 +17,11 @@ model_paths = {
         '30 hours': 'lr_30H_lat_lon.pkl',
         '33 hours': 'lr_33H_lat_lon.pkl',
         '36 hours': 'lr_36H_lat_lon.pkl'
+    },
+    'Speed': {
+        '3 hours': 'lgbm_3H_speed.pkl',
+        '15 hours': 'lgbm_15H_speed.pkl',
+        '27 hours': 'lgbm_27H_speed.pkl'
     }
 }
 
@@ -34,94 +34,131 @@ scaler_paths = {
         '12 hours': 'lr_12H_lat_lon_scaler.pkl',
         '15 hours': 'lr_15H_lat_lon_scaler.pkl',
         '18 hours': 'lr_18H_lat_lon_scaler.pkl',
+        '21 hours': 'lr_21H_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'
+    },
+    'Speed': {
+        '3 hours': 'lgbm_speed_scale_3H.pkl',
+        '15 hours': 'lgbm_speed_scale_15H.pkl',
+        '27 hours': 'lgbm_speed_scaler_27H.pkl'
     }
 }
 
-# Load model and scaler based on time interval
-def load_model(time_interval):
-    model = joblib.load(model_paths['Path'][time_interval])
-    scaler = joblib.load(scaler_paths['Path'][time_interval])
-    return model, scaler
+# Define time intervals for each prediction type
+time_intervals = {
+    'Path': ['3 hours', '6 hours', '9 hours', '12 hours', '15 hours', '18 hours', '21 hours', '24 hours', '27 hours', '30 hours', '33 hours', '36 hours'],
+    'Speed': ['3 hours', '15 hours', '27 hours']
+}
 
-def process_input(input_data, scaler):
+def process_input(input_data, scaler, prediction_type):
     input_data = np.array(input_data).reshape(-1, 7)
-    processed_data = input_data[:2].reshape(1, -1)
+    if prediction_type == 'Speed':
+        # For speed prediction, reshape accordingly
+        input_data = input_data[:2].reshape(1, 2, 7)
+        processed_data = input_data.reshape(-1, 14)
+    else:  # Path
+        processed_data = input_data[:2].reshape(1, -1)
     processed_data = scaler.transform(processed_data)
     return processed_data
 
-def predict_path(time_interval, input_data):
-    model, scaler = load_model(time_interval)
-    processed_data = process_input(input_data, scaler)
-    prediction = model.predict(processed_data)
-    
-    # Create DataFrame for predictions
-    df_predictions = pd.DataFrame(prediction, columns=['LAT', 'LON'])
-    df_predictions['Time'] = [time_interval]
-    return df_predictions
-
-# Function to plot predictions on a folium map and return the HTML representation
-def plot_predictions_on_map(df_predictions):
-    latitudes = df_predictions['LAT'].tolist()
-    longitudes = df_predictions['LON'].tolist()
-
-    m = folium.Map(location=[latitudes[0], longitudes[0]], zoom_start=6)
-    locations = list(zip(latitudes, longitudes))
-
-    for lat, lon in locations:
-        folium.Marker([lat, lon]).add_to(m)
-
-    folium.PolyLine(locations, color='blue', weight=2.5, opacity=0.7).add_to(m)
-    return m
-
-# Streamlit App
-def main():
-    st.title("Cyclone Path Prediction")
-    st.write("Input current and previous cyclone data to predict the path and visualize it on a map.")
-
-    # User inputs
-    time_interval = st.selectbox("Select Prediction Time Interval", [
-        '3 hours', '6 hours', '9 hours', '12 hours', '15 hours', '18 hours', 
-        '21 hours', '24 hours', '27 hours', '30 hours', '33 hours', '36 hours'
-    ])
-
-    previous_lat = st.number_input("Previous Latitude", format="%f")
-    previous_lon = st.number_input("Previous Longitude", format="%f")
-    previous_speed = st.number_input("Previous Speed", format="%f")
-    previous_year = st.number_input("Previous Year", format="%d")
-    previous_month = st.number_input("Previous Month", format="%d")
-    previous_day = st.number_input("Previous Day", format="%d")
-    previous_hour = st.number_input("Previous Hour", format="%d")
-
-    present_lat = st.number_input("Present Latitude", format="%f")
-    present_lon = st.number_input("Present Longitude", format="%f")
-    present_speed = st.number_input("Present Speed", format="%f")
-    present_year = st.number_input("Present Year", format="%d")
-    present_month = st.number_input("Present Month", format="%d")
-    present_day = st.number_input("Present Day", format="%d")
-    present_hour = st.number_input("Present Hour", format="%d")
-
-    if st.button("Predict"):
-        # Process input into array format
-        previous_data = [previous_lat, previous_lon, previous_speed, previous_year, previous_month, previous_day, previous_hour]
-        present_data = [present_lat, present_lon, present_speed, present_year, present_month, present_day, present_hour]
-        input_data = [previous_data, present_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])
         
-        # Predict path
-        df_predictions = predict_path(time_interval, input_data)
-
-        # Display predicted path DataFrame
-        st.write("Predicted Path DataFrame:")
-        st.write(df_predictions)
-
-        # Plot map with predictions
-        st.write("Cyclone Path Map:")
-        map_ = plot_predictions_on_map(df_predictions)
-        folium_static(map_)
-
-if __name__ == "__main__":
-    main()
+        # Process input and predict
+        processed_data = process_input(input_data, scaler, prediction_type)
+        prediction = model.predict(processed_data)
+        
+        if prediction_type == 'Path':
+            return f"Predicted Path after {time_interval}: Latitude: {prediction[0][0]}, Longitude: {prediction[0][1]}"
+        elif prediction_type == 'Speed':
+            return f"Predicted Speed after {time_interval}: {prediction[0]}"
+    except Exception as e:
+        return str(e)
+
+# Gradio interface components
+with gr.Blocks() as cyclone_predictor:
+    gr.Markdown("# Cyclone Path and Speed Prediction App")
+    
+    # Dropdown for Prediction Type
+    prediction_type = gr.Dropdown(
+        choices=['Path', 'Speed'],
+        value='Path',
+        label="Select Prediction Type"
+    )
+    
+    # Dropdown for Time Interval
+    time_interval = gr.Dropdown(
+        choices=time_intervals['Path'],
+        label="Select Time Interval"
+    )
+    
+    # Function to update time intervals based on prediction type
+    def update_time_intervals(prediction_type_value):
+        return gr.update(choices=time_intervals[prediction_type_value])
+    
+    # Update time intervals when prediction type changes
+    prediction_type.change(
+        fn=update_time_intervals,
+        inputs=prediction_type,
+        outputs=time_interval
+    )
+    
+    # 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)"
+    )
+
+    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)"
+    )
+
+    # Output prediction
+    prediction_output = gr.Textbox(label="Prediction Output")
+    
+    # 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")
+    
+    # Linking function to UI elements
+    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],
+        outputs=prediction_output
+    )
+
+cyclone_predictor.launch()