Update app.py

app.py

@@ -1,3 +1,5 @@
+improve the text in the rcommendation, display each point on next line and improve the UI a little bit
+
 import os
 import requests
 import pandas as pd
@@ -26,45 +28,39 @@ API_URL = (
 
 # --- LOAD MODELS ---
 def load_models():
-    try:
-        vgg_model = load_model(
-            'vgg16_focal_unfreeze_more.keras',
-            custom_objects={'BinaryFocalCrossentropy': BinaryFocalCrossentropy}
-        )
-        
-        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(
-            'severity_post_tta.keras',
-            custom_objects={'focal_loss_fixed': focal_loss_fixed()}
-        )
-        rf_model = joblib.load('ensemble_rf_model.pkl')
-        xgb_model = joblib.load('ensemble_xgb_model.pkl')
-        lr_model = joblib.load('wildfire_logistic_model_synthetic.joblib')
-        return vgg_model, xce_model, rf_model, xgb_model, lr_model
-    except Exception as e:
-        raise gr.Error(f"Model loading failed: {str(e)}")
+    # Fire detector (VGG16)
+    vgg_model = load_model(
+        'vgg16_focal_unfreeze_more.keras',
+        custom_objects={'BinaryFocalCrossentropy': BinaryFocalCrossentropy}
+    )
+    # Severity classifier (Xception)
+    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(
+        'severity_post_tta.keras',
+        custom_objects={'focal_loss_fixed': focal_loss_fixed()}
+    )
+    # Ensemble and trend models
+    rf_model = joblib.load('ensemble_rf_model.pkl')
+    xgb_model = joblib.load('ensemble_xgb_model.pkl')
+    lr_model = joblib.load('wildfire_logistic_model_synthetic.joblib')
+    return vgg_model, xce_model, rf_model, xgb_model, lr_model
 
-try:
-    vgg_model, xception_model, rf_model, xgb_model, lr_model = load_models()
-except Exception as e:
-    print(f"Initial model loading failed: {str(e)}")
+vgg_model, xception_model, rf_model, xgb_model, lr_model = load_models()
 
 # --- RULES & TEMPLATES ---
 target_map = {0: 'mild', 1: 'moderate', 2: 'severe'}
 trend_map = {1: 'increase', 0: 'same', -1: 'decrease'}
 task_rules = {
-    'mild':    {'decrease': 'mild', 'same': 'mild', 'increase': 'moderate'},
-    'moderate': {'decrease': 'mild', 'same': 'moderate', 'increase': 'severe'},
-    'severe':  {'decrease': 'moderate', 'same': 'severe', 'increase': 'severe'}
+    'mild':    {'decrease':'mild','same':'mild','increase':'moderate'},
+    'moderate':{'decrease':'mild','same':'moderate','increase':'severe'},
+    'severe':  {'decrease':'moderate','same':'severe','increase':'severe'}
 }
 templates = {
     'mild': (
@@ -90,138 +86,83 @@ templates = {
     )
 }
 
-# --- FUNCTIONS ---
+# --- PIPELINE FUNCTIONS ---
 def detect_fire(img):
-    img_resized = img.resize((224, 224))
-    arr = keras_image.img_to_array(img_resized)
-    arr = np.expand_dims(arr, axis=0)
-    arr = vgg_preprocess(arr)
-    pred = vgg_model.predict(arr)[0][0]
-    is_fire = pred >= 0.5
-    return is_fire, pred
-
-def classify_severity(img):
-    img_resized = img.resize((224, 224))
-    arr = keras_image.img_to_array(img_resized)
-    arr = np.expand_dims(arr, axis=0)
-    arr = xce_preprocess(arr)
-    feat = np.squeeze(arr)
-    feat_flat = feat.flatten().reshape(1, -1)
-    
-    rf_pred = rf_model.predict_proba(feat_flat)
-    xgb_pred = xgb_model.predict_proba(feat_flat)
-    avg_pred = (rf_pred + xgb_pred) / 2
-    final_class = np.argmax(avg_pred)
-    return target_map[final_class]
+    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 fetch_weather_trend(lat, lon):
-    today = datetime.utcnow().date()
-    start_date = today - timedelta(days=2)
-    end_date = today - timedelta(days=1)
-
-    url = API_URL.format(lat=lat, lon=lon, start=start_date, end=end_date)
-    response = requests.get(url)
-    if response.status_code != 200:
-        return 'same'  # fallback if API fails
-
-    data = response.json()
-    temp_max = data['daily']['temperature_2m_max']
-    wind_max = data['daily']['windspeed_10m_max']
-    humidity_min = data['daily']['relative_humidity_2m_min']
 
-    # crude trend logic: hotter, windier = worse
-    temp_trend = np.sign(temp_max[-1] - temp_max[0])
-    wind_trend = np.sign(wind_max[-1] - wind_max[0])
-    humidity_trend = -np.sign(humidity_min[-1] - humidity_min[0])
+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')
 
-    overall_trend = temp_trend + wind_trend + humidity_trend
-    if overall_trend > 0:
-        return 'increase'
-    elif overall_trend < 0:
-        return 'decrease'
-    else:
-        return 'same'
 
-def generate_recommendations(original, trend):
-    projected = task_rules[original][trend]
-    header = (
-        f"## 🔥 Wildfire Situation Update\n"
-        f"- **Original Severity:** {original.title()}\n"
-        f"- **Weather Trend:** {trend.title()}\n"
-        f"- **Projected Severity:** {projected.title()}\n\n"
+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'))
+    df = pd.DataFrame(requests.get(url).json().get('daily', {}))
+    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)
     )
-    paras = templates[projected].split("\n\n")
-    formatted = "\n\n".join(paras)
-    return header + formatted
-
+    feats = df[['temperature','humidity','wind_speed','precipitation','fire_risk_score']]
+    feat = feats.fillna(feats.mean()).iloc[-1].values.reshape(1,-1)
+    trend_cl = lr_model.predict(feat)[0]
+    return trend_map.get(trend_cl, 'same')
+
+
+def generate_recommendations(original_severity, weather_trend):
+    # determine projected severity
+    proj = task_rules[original_severity][weather_trend]
+    rec = templates[proj]
+    # proper multi-line header
+    header = f"""**Original:** {original_severity.title()}  
+**Trend:** {weather_trend.title()}  
+**Projected:** {proj.title()}\n\n"""
+    return header + rec
+
+# --- GRADIO INTERFACE ---
 def pipeline(image):
     img = Image.fromarray(image).convert('RGB')
     fire, prob = detect_fire(img)
     if not fire:
-        return (
-            f"**No wildfire detected** (probability={prob:.2f})",
-            "N/A",
-            "N/A",
-            "There is currently no sign of wildfire in the image. Continue normal monitoring."
-        )
+        return f"No wildfire detected (prob={prob:.2f})", "N/A", "N/A", "**No wildfire detected. Stay alert.**"
     sev = classify_severity(img)
     trend = fetch_weather_trend(*FOREST_COORDS['Pakistan Forest'])
     recs = generate_recommendations(sev, trend)
-    return (
-        f"**🔥 Fire Detected** (probability={prob:.2f})",
-        sev.title(),
-        trend.title(),
-        recs
-    )
-
-# --- GRADIO APP ---
-custom_css = """
-#component-0 { max-width: 800px; margin: 0 auto; }
-.gradio-container { background: #f0f4f7; }
-#upload-wildfire-image { min-height: 300px; }
-.panel {
-    background: white !important;
-    border-radius: 12px !important;
-    padding: 20px !important;
-    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-}
-.status-box { 
-    background: #fff3e6 !important; 
-    border: 1px solid #ffd8b3 !important;
-}
-.dark-red { color: #cc0000 !important; }
-.green { color: #008000 !important; }
-"""
-
-with gr.Blocks(css=custom_css) as demo:
-    gr.Markdown("# 🔥 Wildfire Detection & Management Assistant")
-    
-    with gr.Row(variant="panel"):
-        with gr.Column(scale=2):
-            inp = gr.Image(type="numpy", label="Satellite Image", elem_id="upload-wildfire-image")
-        with gr.Column(scale=1):
-            status = gr.Textbox(label="Fire Status", interactive=False, elem_classes="status-box")
-            severity = gr.Textbox(label="Severity Level", interactive=False)
-            trend = gr.Textbox(label="Weather Trend", interactive=False)
-    
-    with gr.Accordion("📋 Detailed Recommendations", open=False):
-        rec_box = gr.Markdown()
-    
-    btn = gr.Button("Analyze", variant="primary")
-    btn.click(
-        fn=pipeline,
-        inputs=inp,
-        outputs=[status, severity, trend, rec_box],
-        api_name="analyze"
-    )
-    
-    gr.Markdown("---")
-    gr.HTML("<div style='text-align: center; color: #666;'>© 2025 ForestAI Labs</div>")
-
-def handle_errors(inputs, outputs):
-    for output in outputs:
-        if isinstance(output, Exception):
-            raise gr.Error("Analysis failed. Please check the input and try again.")
+    return f"Fire Detected (prob={prob:.2f})", sev.title(), trend, recs
+
+interface = gr.Interface(
+    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='Weather Trend'),
+        gr.Markdown(label='Recommendations')
+    ],
+    title='Wildfire Detection & Management Assistant',
+    description='Upload an image from a forest region in Pakistan to determine wildfire presence, severity, weather-driven trend, projection, and get expert recommendations.'
+)
 
-if __name__ == "__main__":
-    demo.launch()  # Fixed the space typo in launch()
+if __name__ == '__main__':
+    interface.launch()