Update src/streamlit_app.py

src/streamlit_app.py

@@ -113,86 +113,88 @@ def predict_prob(x: np.ndarray) -> float:
     return max(0.0, min(1.0, prob))
 
 # -----------------------------
-# Grad-CAM (robust for nested "resnet50" submodel)
+
+# -----------------------------
+# -----------------------------
+# Grad-CAM (robust for nested ResNet backbone)
 # -----------------------------
 @st.cache_resource
-def build_gradcam_tools():
-    # If your backbone layer name is different, change here:
-    backbone_name = "resnet50"
+def get_backbone_and_last_conv():
+    backbone_name = "resnet50"   # your model has this layer name
     backbone = model.get_layer(backbone_name)
 
-    # pick the last Conv2D inside the backbone
     last_conv = None
     for lyr in reversed(backbone.layers):
         if isinstance(lyr, tf.keras.layers.Conv2D):
             last_conv = lyr.name
             break
+
     if last_conv is None:
-        raise ValueError("Could not find a Conv2D layer inside the ResNet backbone.")
+        raise ValueError("No Conv2D layer found inside resnet50 backbone.")
 
-    # outputs: last conv feature map + probability head
-    conv_out = backbone.get_layer(last_conv).output
-    prob_out = model.outputs[-1] if isinstance(model.outputs, (list, tuple)) else model.output
+    # model that outputs the conv feature map
+    conv_model = keras.Model(
+        inputs=model.inputs,
+        outputs=backbone.get_layer(last_conv).output
+    )
 
-    grad_model = keras.Model(inputs=model.inputs, outputs=[conv_out, prob_out])
-    return grad_model, last_conv
+    return backbone_name, last_conv, conv_model
 
 def make_gradcam_heatmap(img_batch: np.ndarray) -> np.ndarray:
-    grad_model, _ = build_gradcam_tools()
+    _, last_conv, conv_model = get_backbone_and_last_conv()
 
     x = tf.convert_to_tensor(img_batch, dtype=tf.float32)
 
     with tf.GradientTape() as tape:
-        conv_out, preds = grad_model(x, training=False)
-        loss = preds[:, 0]  # binary sigmoid prob
+        conv_out = conv_model(x, training=False)   # (1, h, w, ch)
+
+        preds = model(x, training=False)
+        if isinstance(preds, (list, tuple)):
+            prob = preds[-1]
+        else:
+            prob = preds
+
+        loss = prob[:, 0]  # binary prob
 
     grads = tape.gradient(loss, conv_out)
     if grads is None:
-        raise ValueError("Gradients are None. Grad-CAM cannot be computed for this model setup.")
+        raise ValueError(
+            f"Gradients are None (cannot compute Grad-CAM). Last conv was: {last_conv}"
+        )
 
     pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
-    conv_out = conv_out[0]  # (H,W,channels)
+    conv_out = conv_out[0]
 
     heatmap = tf.reduce_sum(conv_out * pooled_grads, axis=-1)
-    heatmap = tf.maximum(heatmap, 0)
+    heatmap = tf.maximum(heatmap, 0.0)
 
     denom = tf.reduce_max(heatmap) + 1e-8
     heatmap = heatmap / denom
-    return heatmap.numpy()
 
-def overlay_heatmap(img_2d: np.ndarray, heatmap: np.ndarray):
-    # resize heatmap to img_size
-    heat = tf.image.resize(heatmap[..., None], (img_size, img_size)).numpy().squeeze()
-
-    # ensure base image displayed at img_size
-    base = tf.image.resize(img_2d[..., None], (img_size, img_size)).numpy().squeeze()
+    return heatmap.numpy()
 
-    fig = plt.figure(figsize=(5, 5))
-    plt.imshow(base, cmap="gray")
-    plt.imshow(heat, cmap="jet", alpha=0.35)
-    plt.axis("off")
-    plt.tight_layout()
-    return fig
 
 # -----------------------------
 # PDF generation (fix unicode issues)
 # -----------------------------
-def safe_text(s: str, max_len: int = 180) -> str:
-    """
-    Convert to something FPDF core fonts can render.
-    Also trims very long strings to avoid layout failures.
-    """
+# -----------------------------
+# PDF generator (robust wrapping)
+# -----------------------------
+def safe_text(s: str, max_len: int = 220) -> str:
     if s is None:
         return ""
     s = str(s)
 
-    # Replace common unicode dashes/quotes with ascii
+    # replace unicode dashes/quotes
     s = s.replace("–", "-").replace("—", "-").replace("’", "'").replace("“", '"').replace("”", '"')
 
-    # Remove / replace any remaining unsupported chars (latin-1 fallback)
+    # add break opportunities for long tokens (UUIDs, filenames)
+    s = s.replace("-", "- ").replace("_", "_ ").replace("/", "/ ")
+
+    # latin-1 safe
     s = s.encode("latin-1", "replace").decode("latin-1")
 
-    # Avoid extremely long unbroken lines
+    # trim
     if len(s) > max_len:
         s = s[:max_len] + "..."
     return s
@@ -201,8 +203,12 @@ def build_pdf_report(df_ok: pd.DataFrame, threshold: float, model_version: str)
     pdf = FPDF()
     pdf.set_auto_page_break(auto=True, margin=12)
     pdf.add_page()
+
     pdf.set_font("Helvetica", size=12)
 
+    # effective width (prevents “not enough horizontal space”)
+    w = pdf.w - pdf.l_margin - pdf.r_margin
+
     pdf.cell(0, 8, safe_text("Pneumonia Detection Report"), ln=True)
     pdf.set_font("Helvetica", size=10)
     pdf.cell(0, 6, safe_text(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"), ln=True)
@@ -210,24 +216,23 @@ def build_pdf_report(df_ok: pd.DataFrame, threshold: float, model_version: str)
     pdf.cell(0, 6, safe_text(f"Decision Threshold: {threshold:.2f}"), ln=True)
     pdf.ln(4)
 
-    pdf.set_font("Helvetica", size=10)
     for _, row in df_ok.iterrows():
-        line1 = f"File: {row['file_name']}"
-        line2 = f"Probability: {row['probability']*100:.2f}%"
-        line3 = f"Confidence: {row['confidence_level']}"
-        line4 = f"Prediction: {row['prediction']}"
-
-        for line in [line1, line2, line3, line4]:
-            pdf.multi_cell(0, 6, safe_text(line))
-
+        lines = [
+            f"File: {row['file_name']}",
+            f"Probability: {row['probability']*100:.2f}%",
+            f"Confidence: {row['confidence_level']}",
+            f"Prediction: {row['prediction']}",
+        ]
+        for line in lines:
+            pdf.multi_cell(w, 6, safe_text(line))
         pdf.ln(2)
 
     out = pdf.output(dest="S")
-    # fpdf may return str in some versions
     if isinstance(out, str):
         out = out.encode("latin-1", "ignore")
     return out
 
+
 # -----------------------------
 # UI
 # -----------------------------
@@ -353,14 +358,15 @@ if submit:
         if len(df_ok) > 0:
             pdf_bytes = build_pdf_report(df_ok, threshold, MODEL_VERSION)
             st.download_button(
-                "Download PDF Report",
-                data=pdf_bytes,
-                file_name="pneumonia_report.pdf",
-                mime="application/pdf",
-                use_container_width=True
-            )
+            "Download PDF Report",
+            data=pdf_bytes,
+            file_name="pneumonia_report.pdf",
+            mime="application/pdf",
+            use_container_width=True
+        )
         else:
             st.info("PDF report is available only when at least one file is successfully processed.")
+    
 
 st.divider()
 st.caption(