Create streamlit_app.py

streamlit_app.py

@@ -0,0 +1,128 @@
+import streamlit as st
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+# Import preprocess_input specifically from the efficientnet application module
+from tensorflow.keras.applications.efficientnet import preprocess_input
+import os
+from PIL import Image # Needed to display image in Streamlit
+
+# --- Configuration ---
+# Ensure this matches the IMG_SIZE used during training
+IMG_SIZE = 260
+# Define the expected model filename
+MODEL_FILENAME = 'skin_lesion_model.keras'
+# Define class names based on the training script output
+CLASS_NAMES = ['Benign', 'Malignant'] # From training: ['benign', 'malignant']
+
+# --- Model Loading (Cached) ---
+@st.cache_resource # Decorator to cache the model loading
+def load_skin_model():
+    """Loads the Keras model. Returns the model or None if not found."""
+    if not os.path.exists(MODEL_FILENAME):
+        st.error(f"Error: Model file '{MODEL_FILENAME}' not found.")
+        st.info(f"Please ensure the model file is in the same directory as the script.")
+        return None
+    try:
+        # Load the model, compile=False speeds up loading for inference only
+        model = load_model(MODEL_FILENAME, compile=False)
+        print("Model loaded successfully.") # Log for server console
+        return model
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        print(f"Error loading model: {e}") # Log for server console
+        return None
+
+# --- Preprocessing Function ---
+def preprocess_image(img_input):
+    """Loads and preprocesses an image for EfficientNetB0."""
+    try:
+        # Load image directly from uploaded file object or path
+        # Use PIL to open the image from the BytesIO object provided by file_uploader
+        img = Image.open(img_input).convert('RGB') # Ensure image is RGB
+        img = img.resize((IMG_SIZE, IMG_SIZE))
+
+        img_array = image.img_to_array(img)
+        img_array = np.expand_dims(img_array, axis=0)
+        # Use the appropriate preprocessing function for EfficientNet
+        processed_img = preprocess_input(img_array)
+        print(f"Image preprocessed successfully. Shape: {processed_img.shape}") # Debug print
+        return processed_img
+    except Exception as e:
+        st.error(f"Error during image preprocessing: {e}")
+        print(f"Error during image preprocessing: {e}") # Log for server console
+        return None # Return None to indicate failure
+
+# --- Prediction Function ---
+def predict_skin_lesion(model, processed_image):
+    """Makes predictions using the loaded model and preprocessed image."""
+    try:
+        # Make prediction
+        print("Making prediction...") # Debug print
+        prediction = model.predict(processed_image)[0]
+        print(f"Raw prediction output: {prediction}") # Debug print
+
+        # Get the class with highest probability
+        class_index = np.argmax(prediction)
+        confidence = float(prediction[class_index])
+
+        # Map class index to label using CLASS_NAMES
+        class_label = CLASS_NAMES[class_index]
+
+        print(f"Predicted class: {class_label}, Confidence: {confidence:.4f}") # Debug print
+        return class_label, confidence
+
+    except Exception as e:
+        st.error(f"An error occurred during prediction: {e}")
+        print(f"An error occurred during prediction: {e}") # Log for server console
+        return None, None # Return None to indicate failure
+
+# --- Streamlit App UI ---
+st.set_page_config(page_title="Skin Lesion Classifier", layout="centered")
+st.title("Skin Lesion Classification (EfficientNetB0)")
+st.markdown(f"Upload an image of a skin lesion to classify it as benign or malignant. Model trained on {IMG_SIZE}x{IMG_SIZE} images.")
+
+# Load the model using the cached function
+model = load_skin_model()
+
+# Only proceed if the model loaded successfully
+if model is not None:
+    # File uploader
+    uploaded_file = st.file_uploader("Choose a skin lesion image...", type=["jpg", "jpeg", "png"])
+
+    if uploaded_file is not None:
+        # Display the uploaded image
+        st.image(uploaded_file, caption='Uploaded Image.', use_column_width=True)
+        st.write("") # Add a little space
+
+        # Classify button
+        if st.button('Classify Lesion'):
+            with st.spinner('Preprocessing image and making prediction...'):
+                # Preprocess the image
+                processed_image = preprocess_image(uploaded_file)
+
+                if processed_image is not None:
+                    # Make prediction
+                    label, confidence = predict_skin_lesion(model, processed_image)
+
+                    if label is not None:
+                        # Display result
+                        st.success(f'Prediction: **{label}**')
+                        st.metric(label="Confidence", value=f"{confidence:.2%}")
+                        # Optional: Display confidence breakdown
+                        # st.write("Confidence Scores:")
+                        # st.write({name: f"{pred:.2%}" for name, pred in zip(CLASS_NAMES, model.predict(processed_image)[0])})
+                    else:
+                        st.error("Prediction failed. Please check the logs or try a different image.")
+                else:
+                    st.error("Image preprocessing failed. Please ensure the image is valid.")
+else:
+    # Message if model loading failed (already handled in load_skin_model, but good practice)
+    st.warning("Model could not be loaded. Please check the setup.")
+
+# --- How to Run ---
+# Save this code as a Python file (e.g., app.py)
+# Ensure 'skin_lesion_model.keras' is in the same directory.
+# Install libraries: pip install streamlit numpy tensorflow Pillow
+# Run from terminal: streamlit run app.py