Update app.py

app.py

@@ -1,125 +1,127 @@
-import gradio as gr
+import joblib
 import numpy as np
 import pandas as pd
 import folium
-import joblib
-from io import BytesIO
-import base64
-
-# 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):
-    
-    # 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)
+import streamlit as st
+from streamlit_folium import folium_static
+import warnings
+warnings.filterwarnings("ignore")
+
+# 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'
+    }
+}
+
+# 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
+
+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 predict_path(time_interval, input_data):
+    model, scaler = load_model(time_interval)
+    processed_data = process_input(input_data, scaler)
+    prediction = model.predict(processed_data)
     
-    # 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
-
+    # Create DataFrame for predictions
+    df_predictions = pd.DataFrame(prediction, columns=['LAT', 'LON'])
+    df_predictions['Time'] = [time_interval]
     return df_predictions
 
-# Plot predictions on a folium map and return an HTML iframe
+# Function to plot predictions on a folium map and return the HTML representation
 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')
-    
-    return f'<iframe src="data:text/html;base64,{map_base64}" width="100%" height="400"></iframe>'
-
-# 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
-
-# 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")
-    
-    # Prediction and map output
-    prediction_output = gr.Dataframe(label="Predicted DataFrame")
-    map_output = gr.HTML(label="Predicted Path Map")
-    
-    # Button to trigger prediction
-    predict_button = gr.Button("Predict")
-    predict_button.click(
-        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()
+    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]
+        
+        # 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()