Update app.py

app.py

@@ -1,111 +1,157 @@
-import gradio as gr
-import tensorflow as tf
-from PIL import Image
+import os
+import requests
+import pandas as pd
 import numpy as np
-import tensorflow as tf
-import keras.backend as K
-
-
-# Define focal loss
-def focal_loss(gamma=2., alpha=0.25):
-    def focal_loss_fixed(y_true, y_pred):
-        y_pred = tf.clip_by_value(y_pred, K.epsilon(), 1. - K.epsilon())
-        cross_entropy = -y_true * tf.math.log(y_pred)
-        weight = alpha * y_true * tf.math.pow((1 - y_pred), gamma)
-        loss = weight * cross_entropy
-        return tf.reduce_sum(loss, axis=-1)
-    return focal_loss_fixed
-
-
-# Load models
-vgg16_model = tf.keras.models.load_model(
-    "vgg16_best_model.keras"
-)
-
-xception_model = tf.keras.models.load_model(
-    'xception_best.keras',
-    custom_objects={'focal_loss_fixed': focal_loss()}
+import joblib
+import google.generativeai as genai
+import gradio as gr
+from google.colab import drive, userdata
+from datetime import datetime, timedelta
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image as keras_image
+from tensorflow.keras.applications.vgg16 import preprocess_input as vgg_preprocess
+from tensorflow.keras.applications.xception import preprocess_input as xce_preprocess
+from tensorflow.keras.losses import BinaryFocalCrossentropy
+
+# --- CONFIGURATION ---
+# Coordinates for a representative forest area in Pakistan
+FOREST_COORDS = {'Pakistan Forest': (34.0, 73.0)}
+API_URL = (
+    "https://archive-api.open-meteo.com/v1/archive"
+    "?latitude={lat}&longitude={lon}"
+    "&start_date={start}&end_date={end}"
+    "&daily=temperature_2m_max,temperature_2m_min,"
+    "precipitation_sum,windspeed_10m_max,"
+    "relative_humidity_2m_max,relative_humidity_2m_min"
+    "&timezone=UTC"
 )
 
+# --- GEMINI SETUP ---
+GOOGLE_API_KEY = userdata.get('GOOGLE_API_KEY')
+genai.configure(api_key=GOOGLE_API_KEY)
+flash = genai.GenerativeModel('gemini-1.5-flash')
+
+# --- LOAD MODELS ---
+def load_models():
+    drive.mount('/content/drive', force_remount=False)
+    # Fire detection (VGG16 binary classifier)
+    vgg_model = load_model(
+        '/content/drive/MyDrive/vgg16_focal_unfreeze_more.keras',
+        custom_objects={'BinaryFocalCrossentropy': BinaryFocalCrossentropy}
+    )
+    # Severity classification (Xception + RF/XGB ensemble)
+    def focal_loss_fixed(gamma=2., alpha=.25):
+        import tensorflow.keras.backend as K
+        def loss_fn(y_true, y_pred):
+            eps = K.epsilon(); y_pred = K.clip(y_pred, eps, 1.-eps)
+            ce = -y_true * K.log(y_pred)
+            w = alpha * K.pow(1-y_pred, gamma)
+            return K.mean(w*ce, axis=-1)
+        return loss_fn
+    xce_model = load_model(
+        '/content/drive/My Drive/severity_post_tta.keras',
+        custom_objects={'focal_loss_fixed': focal_loss_fixed()}
+    )
+    rf_model = joblib.load('/content/drive/My Drive/ensemble_rf_model.pkl')
+    xgb_model = joblib.load('/content/drive/My Drive/ensemble_xgb_model.pkl')
+    # Weather trend (Logistic Regression)
+    lr_model = joblib.load('/content/drive/MyDrive/wildfire_logistic_model_synthetic.joblib')
+    return vgg_model, xce_model, rf_model, xgb_model, lr_model
+
+vgg_model, xception_model, rf_model, xgb_model, lr_model = load_models()
+
+# --- LABEL MAPS ---
+target_map = {0: 'mild', 1: 'moderate', 2: 'severe'}
+trend_map = {1: 'increase', 0: 'same', -1: 'decrease'}
+trend_rules = {
+    'mild':    {'decrease':'mild','same':'mild','increase':'moderate'},
+    'moderate':{'decrease':'mild','same':'moderate','increase':'severe'},
+    'severe':  {'decrease':'moderate','same':'severe','increase':'severe'}
+}
+
+# --- PIPELINE FUNCTIONS ---
+def detect_fire(img):
+    x = keras_image.img_to_array(img.resize((128,128)))[None]
+    x = vgg_preprocess(x)
+    prob = float(vgg_model.predict(x)[0][0])
+    return prob >= 0.5, prob
+
+
+def classify_severity(img):
+    x = keras_image.img_to_array(img.resize((224,224)))[None]
+    x = xce_preprocess(x)
+    preds = xception_model.predict(x)
+    rf_p = rf_model.predict(preds)[0]
+    xgb_p = xgb_model.predict(preds)[0]
+    ensemble = int(round((rf_p + xgb_p)/2))
+    return target_map.get(ensemble, 'moderate')
+
+
+def fetch_weather_trend(lat, lon):
+    end = datetime.utcnow()
+    start = end - timedelta(days=1)
+    url = API_URL.format(lat=lat, lon=lon,
+                         start=start.strftime('%Y-%m-%d'),
+                         end=end.strftime('%Y-%m-%d'))
+    data = requests.get(url).json().get('daily', {})
+    df = pd.DataFrame(data)
+    # convert to numeric
+    for c in ['precipitation_sum','temperature_2m_max','temperature_2m_min',
+              'relative_humidity_2m_max','relative_humidity_2m_min','windspeed_10m_max']:
+        df[c] = pd.to_numeric(df.get(c, []), errors='coerce')
+    df['precipitation'] = df['precipitation_sum'].fillna(0)
+    df['temperature'] = (df['temperature_2m_max'] + df['temperature_2m_min'])/2
+    df['humidity']    = (df['relative_humidity_2m_max'] + df['relative_humidity_2m_min'])/2
+    df['wind_speed']  = df['windspeed_10m_max']
+    df['fire_risk_score'] = (
+        0.4*(df['temperature']/55) +
+        0.2*(1-df['humidity']/100) +
+        0.3*(df['wind_speed']/60) +
+        0.1*(1-df['precipitation']/50)
+    )
+    feats = df[['temperature','humidity','wind_speed','precipitation','fire_risk_score']]
+    v = feats.fillna(feats.mean()).iloc[-1].values.reshape(1,-1)
+    trend_cl = lr_model.predict(v)[0]
+    return trend_map.get(trend_cl)
+
+
+def generate_recommendations(wildfire_present, severity, weather_trend):
+    prompt = f"""
+You are a wildfire management expert.
+- Wildfire Present: {wildfire_present}
+- Severity: {severity}
+- Weather Trend: {weather_trend}
+Provide:
+1. Immediate actions
+2. Evacuation guidelines
+3. Short-term containment
+4. Long-term prevention & recovery
+5. Community education
+"""
+    return flash.generate_content(prompt).text
+
+# --- GRADIO INTERFACE ---
+def pipeline(image):
+    img = Image.fromarray(image).convert('RGB')
+    fire, prob = detect_fire(img)
+    if not fire:
+        return f"No wildfire detected (prob={prob:.2f})", "N/A", "No wildfire detected. Stay alert."
+    severity = classify_severity(img)
+    trend = fetch_weather_trend(*FOREST_COORDS['Pakistan Forest'])
+    recs = generate_recommendations(True, severity, trend)
+    return f"Fire Detected (prob={prob:.2f})", severity.title(), recs
 
-def predict_fire(image):
-    img = Image.fromarray(image).convert("RGB")
-
-    # Preprocess for vgg16_model (128x128 input size)
-    vgg16_img = img.resize((128, 128))
-    vgg16_img_array = np.array(vgg16_img) / 255.0
-    vgg16_img_array = np.expand_dims(vgg16_img_array, axis=0)
-
-    # Fire detection using vgg16_model
-    fire_pred = vgg16_model.predict(vgg16_img_array)
-    fire_status = "Fire Detected" if fire_pred[0][0] > 0.5 else "No Fire Detected"
-
-    # If fire is detected, preprocess for xception_model (224x224 input size)
-    if fire_status == "Fire Detected":
-        xception_img = img.resize((224, 224))
-        xception_img_array = np.array(xception_img) / 255.0
-        xception_img_array = np.expand_dims(xception_img_array, axis=0)
-
-        # Severity prediction using xception_model
-        severity_pred = xception_model.predict(xception_img_array)
-        severity_level = np.argmax(severity_pred[0])
-        severity = ["Mild", "Moderate", "Severe"][severity_level]
-        
-        # Static rule-based recommendations with detailed instructions
-        if severity == "Mild":
-            recommendation = (
-                "Fire detected is mild and manageable. "
-                "For the Fire Department: Ensure continuous monitoring of the fire. "
-                "Deploy fire trucks and extinguishing equipment if necessary to prevent escalation. "
-                "For the Public: Stay alert and stay indoors. Evacuate only if advised by authorities. "
-                "Ensure clear access routes for emergency services. "
-                "Keep fire safety equipment such as fire extinguishers readily available."
-            )
-        elif severity == "Moderate":
-            recommendation = (
-                "Fire detected is moderate and poses a significant risk. "
-                "For the Fire Department: Immediate response is needed. "
-                "Deploy sufficient fire trucks, helicopters (if possible), and personnel to contain the fire. "
-                "Establish firebreaks and coordinate with neighboring departments. "
-                "For the Public: Evacuate the area promptly as the fire might spread. "
-                "Follow evacuation routes and do not return to the area until authorities deem it safe. "
-                "Be cautious of smoke inhalation, and wear protective masks if available."
-            )
-        else:  # Severe
-            recommendation = (
-                "Severe fire detected with rapid spread potential. Immediate action is critical. "
-                "For the Fire Department: Prioritize evacuation operations. "
-                "Deploy all available resources, including specialized teams and air support. "
-                "Set up perimeters around the affected area and prevent access. "
-                "Coordinate with national agencies for additional resources and backup. "
-                "For the Public: Evacuate immediately. Leave all belongings behind and proceed to designated safe zones. "
-                "Avoid smoke exposure and keep away from fire zones. Follow all official instructions and do not attempt to return to the area until clearance is given by emergency services. "
-                "Remain in contact with local authorities for further updates."
-            )
-
-    else:
-        severity = "N/A"
-        recommendation = (
-            "No fire detected. However, always be cautious of any unusual smoke or smells in your environment. "
-            "Ensure that fire alarms are functioning, and regularly check fire extinguishers. "
-            "Stay prepared by familiarizing yourself with fire evacuation routes and emergency contact numbers."
-        )
-
-    return fire_status, severity, recommendation
-
-
-# Gradio interface
 interface = gr.Interface(
-    fn=predict_fire,
-    inputs=gr.Image(type="numpy", label="Upload Image"),
+    fn=pipeline,
+    inputs=gr.Image(type='numpy', label='Upload Wildfire Image'),
     outputs=[
-        gr.Textbox(label="Fire Status"),
-        gr.Textbox(label="Severity Level"),
-        gr.Textbox(label="Recommendation")
+        gr.Textbox(label='Fire Status'),
+        gr.Textbox(label='Severity Level'),
+        gr.Markdown(label='Recommendations')
     ],
-    title="Fire Prediction and Severity Classification",
-    description="Upload an image to predict fire and its severity level (Mild, Moderate, Severe), and get recommendations.",
+    title='Wildfire Detection & Management Assistant',
+    description='Upload an image from a forest region in Pakistan to determine wildfire presence, severity, weather-driven trend, and get expert recommendations.'
 )
 
-if __name__ == "__main__":
-    interface.launch()
+if __name__ == '__main__':
+    interface.launch()