Update app.py

app.py

@@ -1,143 +1,53 @@
-import cv2
-import numpy as np
-import pandas as pd
-import gradio as gr
-from tensorflow.keras.models import load_model
-from sklearn.preprocessing import OneHotEncoder, StandardScaler
+# 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
 
-# If your model uses custom objects, define them here
-# For example, if you used a custom loss or metric during training:
-from keras.losses import MeanSquaredError
+# Load the model with custom_objects
+loaded_model = load_model('solar_irradiance_model.h5', custom_objects={'mse': mean_squared_error}) 
 
-custom_objects = {
-    'custom_loss_name': MeanSquaredError(),  # Replace 'custom_loss_name' if needed
-}
+# ... (rest of the code remains the same)
 
-# Load the pre-trained model with custom objects if applicable
-try:
-    loaded_model = load_model('solar_irradiance_model.h5', custom_objects=custom_objects)
-except Exception as e:
-    print("Error loading model:", e)
-    raise
-
-# Load the dataset for encoder and scaler setup
-data = pd.read_csv('Solar_Irradiance.csv')
-data['Latitude'] = data['Latitude'].str.rstrip('°').astype(float)
-data['Longitude'] = data['Longitude'].str.rstrip('°').astype(float)
-
-# Features and encoder/scaler setup
-features = data[['Month', 'Hour', 'Latitude', 'Longitude', 'Panel_Capacity(W)', 'Panel_Efficiency', 'Wind_Speed(km/h)', 'Cloud_Cover(%)', 'temperature (°f)']]
-encoder = OneHotEncoder(sparse_output=False, categories='auto')
-categorical_features = features[['Month', 'Hour']]
-encoder.fit(categorical_features)
-scaler = StandardScaler()
-numerical_features = features[['Latitude', 'Longitude', 'Panel_Capacity(W)', 'Panel_Efficiency', 'Wind_Speed(km/h)', 'Cloud_Cover(%)', 'temperature (°f)']]
-scaler.fit(numerical_features)
-
-# Shadow Removal Function
-def remove_shadows(image):
-    """Removes shadows using illumination normalization."""
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    blurred = cv2.GaussianBlur(gray, (21, 21), 0)
-    normalized = cv2.divide(gray, blurred, scale=255)
-    result = cv2.cvtColor(normalized, cv2.COLOR_GRAY2BGR)
-    return result
-
-# Preprocess Image with Watershed Algorithm
-def apply_watershed(image):
-    shadow_free_image = remove_shadows(image)
-    denoised = cv2.fastNlMeansDenoisingColored(shadow_free_image, None, 10, 10, 7, 21)
-    gray = cv2.cvtColor(denoised, cv2.COLOR_BGR2GRAY)
-    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
-    sure_bg = cv2.dilate(binary, kernel, iterations=3)
-    sure_fg = cv2.erode(binary, kernel, iterations=3)
-    unknown = cv2.subtract(sure_bg, sure_fg)
-    _, markers = cv2.connectedComponents(sure_fg)
-    markers = markers + 1
-    markers[unknown == 255] = 0
-    markers = cv2.watershed(image, markers)
-    segmented = np.zeros_like(image)
-    segmented[markers > 1] = image[markers > 1]
-    return segmented, markers
-
-# Calculate Usable Roof Area
-def find_usable_area(image, min_area, panel_area):
-    segmented_image, markers = apply_watershed(image)
-    gray = cv2.cvtColor(segmented_image, cv2.COLOR_BGR2GRAY)
-    contours, _ = cv2.findContours(gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    usable_area = 0
-    output_image = image.copy()
-
-    for contour in contours:
-        area = cv2.contourArea(contour)
-        if area >= min_area:
-            usable_area += area
-            cv2.drawContours(output_image, [contour], -1, (0, 255, 0), 3)
-        else:
-            cv2.drawContours(output_image, [contour], -1, (0, 0, 255), 3)
-
-    num_panels = usable_area // panel_area
-    return usable_area, int(num_panels), output_image
-
-# Predict Irradiance
+# 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 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]])
+    # Combine encoded categorical and scaled numerical features
     processed_features = np.concatenate((encoded_month_hour, scaled_features), axis=1)
-    predicted_irradiance = loaded_model.predict(processed_features)
-    return max(predicted_irradiance[0], 0.0)
-
-# Main Function
-def calculate_solar_energy(image, month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature):
-    panel_area = 2  # m² per panel
-    min_area = 1000  # Minimum contour area to consider for valid roof
-
-    usable_area, num_panels, segmented_image = find_usable_area(image, min_area, panel_area)
-    if usable_area == 0:
-        return "No valid roof detected.", segmented_image
-
-    irradiance = predict_irradiance(month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature)
-    potential_energy = num_panels * panel_area * irradiance * panel_efficiency  # in Watts
-    potential_energy_kwh = potential_energy / 1000
-    cost_per_panel = 1000
-    total_cost = num_panels * cost_per_panel
-
-    results = (f"Usable Roof Area: {usable_area:.2f} m²\n"
-               f"Number of Panels: {num_panels}\n"
-               f"Predicted Irradiance: {irradiance:.2f} W/m²\n"
-               f"Potential Solar Energy: {potential_energy_kwh:.2f} kWh\n"
-               f"Total Cost of Panels: Rs. {total_cost}")
-
-    return results, segmented_image
-
-# Gradio Interface function
-def interface_fn(image, month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature):
-    results, segmented_image = calculate_solar_energy(image, month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature)
-    return results, segmented_image
-
-# Gradio interface setup
-interface = gr.Interface(
-    fn=interface_fn,
-    inputs=[
-        gr.Image(type="numpy", label="Upload Rooftop Image"),
-        gr.Dropdown(['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'], label="Month"),
-        gr.Slider(0, 23, step=1, label="Hour"),
-        gr.Number(label="Latitude"),
-        gr.Number(label="Longitude"),
-        gr.Number(label="Panel Capacity (W)"),
-        gr.Number(label="Panel Efficiency (0-1)"),
-        gr.Number(label="Wind Speed (km/h)"),
-        gr.Number(label="Cloud Cover (%)"),
-        gr.Number(label="Temperature (°F)")
-    ],
-    outputs=[
-        gr.Textbox(label="Results"),
-        gr.Image(type="numpy", label="Segmented Rooftop Area")
-    ],
-    title="Solar Energy Potential and Cost Estimator",
-    description="Upload an image of the rooftop and enter environmental details to calculate potential solar energy, number of panels, and cost."
-)
-
-interface.launch()
+    # Reshape the features to match the LSTM input shape
+    reshaped_features = np.reshape(processed_features, (1, 1, processed_features.shape[1]))
+    # Predict the irradiance
+    predicted_irradiance = loaded_model.predict(reshaped_features)
+    return max(predicted_irradiance[0][0], 0.0)
+
+# 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()