Update app.py

app.py

@@ -1,72 +1,96 @@
-import streamlit as st
 import numpy as np
-from keras.models import load_model
-from keras.losses import MeanSquaredError
-import joblib
+import pandas as pd
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from keras.models import Sequential, load_model
+from keras.layers import Dense, LSTM
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+# Set the random seed
+np.random.seed(42)
+
+# Load the data
+data = pd.read_csv('/content/Solar_Irradiance.csv')
+data['Latitude'] = data['Latitude'].str.rstrip('°').astype(float)
+data['Longitude'] = data['Longitude'].str.rstrip('°').astype(float)
+
+# Extract features and target
+features = data[['Month', 'Hour', 'Latitude', 'Longitude', 'Panel_Capacity(W)', 'Panel_Efficiency', 'Wind_Speed(km/h)', 'Cloud_Cover(%)', 'temperature (°f)']]
+target = data['Irradiance(W/m^2)']
+from sklearn.preprocessing import OneHotEncoder
+
+# Initialize the OneHotEncoder with the correct parameter
+encoder = OneHotEncoder(sparse_output=False, categories='auto')
 
-# Define MSE function explicitly to be used as a custom object
-def mse(y_true, y_pred):
-    return MeanSquaredError()(y_true, y_pred)
+# Example usage
+categorical_features = features[['Month', 'Hour']]
+encoded_categorical_features = encoder.fit_transform(categorical_features)
 
-# Load the trained model with the custom 'mse' loss function
-try:
-    model = load_model("solar_irradiance_model.h5", custom_objects={"mse": mse})
-    st.sidebar.success("Model loaded successfully!")
-except Exception as e:
-    st.sidebar.error(f"Error loading model: {e}")
-    st.stop()
 
-# Load the encoder and scaler (ensure they are saved as .pkl files during training)
-encoder = joblib.load("encoder.pkl")  # Path to your encoder file
-scaler = joblib.load("scaler.pkl")  # Path to your scaler file
+# Get the feature names after encoding
+encoded_feature_names = encoder.get_feature_names_out(['Month', 'Hour'])
 
+# Create a DataFrame with the encoded categorical features
+encoded_categorical_features_df = pd.DataFrame(encoded_categorical_features, columns=encoded_feature_names)
+
+# Scale the numerical features
+scaler = StandardScaler()
+scaled_numerical_features = scaler.fit_transform(features[['Latitude', 'Longitude', 'Panel_Capacity(W)', 'Panel_Efficiency', 'Wind_Speed(km/h)', 'Cloud_Cover(%)', 'temperature (°f)']])
+
+# Combine encoded categorical and scaled numerical features
+processed_features = np.concatenate((encoded_categorical_features_df, scaled_numerical_features), axis=1)
+
+# Reshape the features to match the LSTM input shape
+reshaped_features = np.reshape(processed_features, (processed_features.shape[0], 1, processed_features.shape[1]))
+# Load the saved model
+# ipython-input-10-d7dffa1aa475
+# Load the saved model
+from keras.models import load_model
+from keras.losses import mean_squared_error # Import the MSE loss function
+
+# Load the model with custom_objects
+loaded_model = load_model('solar_irradiance_model.h5', custom_objects={'mse': mean_squared_error})
+
+# ... (rest of the code remains the same)
+
+# Function to predict the irradiance for a given month, hour, and other features
 def predict_irradiance(month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature):
-    # Encode the categorical features (Month and Hour)
+    # Encode the month and hour
     encoded_month_hour = encoder.transform([[month, hour]])
-    
     # Scale the numerical features
     scaled_features = scaler.transform([[latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature]])
-    
-    # Concatenate encoded categorical and scaled numerical features
+    # Combine encoded categorical and scaled numerical features
     processed_features = np.concatenate((encoded_month_hour, scaled_features), axis=1)
-    
-    # Reshape the features to match the model input shape (1, 1, num_features)
+    # Reshape the features to match the LSTM input shape
     reshaped_features = np.reshape(processed_features, (1, 1, processed_features.shape[1]))
-    
-    # Predict solar irradiance using the trained model
-    predicted_irradiance = model.predict(reshaped_features)
-    
-    # Return the predicted irradiance (ensuring it's non-negative)
+    # Predict the irradiance
+    predicted_irradiance = loaded_model.predict(reshaped_features)
     return max(predicted_irradiance[0][0], 0.0)
 
-# Set up the Streamlit frontend
-st.title("Solar Irradiance Prediction")
-
-# Example Input Data (adjust for your actual inputs)
-st.header("Enter Input Features")
-num_features = 9  # Since you have 9 features in total
-
-example_input = []
-for i in range(num_features):
-    value = st.number_input(f"Feature {i+1}", value=0.0, format="%.2f")
-    example_input.append(value)
-
-# Convert the input into the required format for prediction
-month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature = example_input
-
-# Predict button
-if st.button("Predict"):
-    try:
-        prediction = predict_irradiance(month=month, hour=hour, latitude=latitude, longitude=longitude,
-                                        panel_capacity=panel_capacity, panel_efficiency=panel_efficiency,
-                                        wind_speed=wind_speed, cloud_cover=cloud_cover, temperature=temperature)
-        st.success(f"Predicted Solar Irradiance: {prediction:.2f} W/m²")
-    except Exception as e:
-        st.error(f"Error during prediction: {e}")
-
-# Sidebar information
-st.sidebar.title("About the Model")
-st.sidebar.markdown("""
-This model predicts solar irradiance based on the input features.
-Ensure all required features are filled in before clicking **Predict**.
-""")
+# Function to get the actual irradiance for a given month
+def get_actual_irradiance(month):
+    return data[data['Month'] == month]['Irradiance(W/m^2)'].values
+
+    # Example usage: Predict the irradiance for July, hour 12 with additional features
+month = 'January'
+hour = 12
+predicted_irradiance = predict_irradiance(month, hour, 28.570633, 77.327215, 500, 0.15, 6.43988, 17.7, 55)
+print(f'Predicted irradiance for {month}, hour {hour}: {predicted_irradiance}')
+
+# Plot Actual vs. Predicted Irradiance for a specific month
+month = 'January'
+actual_irradiance = get_actual_irradiance(month)
+predicted_irradiances = []
+
+for hour in range(24):
+    irradiance = predict_irradiance(month, hour, 28.570633, 77.327215, 500, 0.15, 6.43988, 17.7, 55)
+    predicted_irradiances.append(irradiance)
+
+plt.figure(figsize=(12, 6))
+plt.plot(range(24), actual_irradiance, label='Actual Irradiance')
+plt.plot(range(24), predicted_irradiances, label='Predicted Irradiance')
+plt.xlabel('Hour')
+plt.ylabel('Irradiance (W/m^2)')
+plt.title(f'Actual vs. Predicted Irradiance for {month}')
+plt.legend()
+plt.show()