Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,183 @@
-import altair as alt
+import os
 import numpy as np
-import pandas as pd
+import tensorflow as tf
+from PIL import Image
+import logging
+from pathlib import Path
+from tensorflow.keras.applications import ConvNeXtLarge
 import streamlit as st
+import io
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+
+def create_convnext_model(input_shape=(512, 512, 3)):
+    base_model = ConvNeXtLarge(
+        include_top=False,
+        weights='imagenet',
+        input_shape=input_shape
+    )
+    base_model.trainable = False
+    model = tf.keras.Sequential([
+        base_model,
+        tf.keras.layers.GlobalAveragePooling2D(),
+        tf.keras.layers.Dropout(0.3),
+        tf.keras.layers.Dense(512, activation='relu'),
+        tf.keras.layers.Dropout(0.3),
+        tf.keras.layers.Dense(256, activation='relu'),
+        tf.keras.layers.Dropout(0.3),
+        tf.keras.layers.Dense(1, activation='sigmoid')
+    ])
+    return model
+
+@st.cache_resource
+def load_model(model_path):
+    try:
+        # First create the model architecture
+        model = create_convnext_model()
+        
+        # Then load the weights
+        model.load_weights(model_path)
+        logging.info(f"Model loaded successfully from {model_path}")
+        return model
+    except Exception as e:
+        logging.error(f"Error loading model: {str(e)}")
+        raise
+
+def preprocess_image(image, target_size=(512, 512)):
+    try:
+        # Resize image
+        img = image.resize(target_size, Image.BILINEAR)
+        
+        # Convert to numpy array and normalize
+        img_array = np.array(img)
+        img_array = img_array.astype(float) / 255.
+        img_array = np.clip(img_array, 0., 1.)
+        
+        # Apply the same normalization as in training
+        img_array -= np.array([0.44101639, 0.45513914, 0.40195001])
+        img_array /= np.array([0.28792392, 0.29775171, 0.29840153])
+        
+        # Add batch dimension
+        img_array = np.expand_dims(img_array, axis=0)
+        
+        return img_array
+    except Exception as e:
+        logging.error(f"Error preprocessing image: {str(e)}")
+        raise
+
+def predict_volcano(model, image):
+    try:
+        # Preprocess the image
+        processed_image = preprocess_image(image)
+        
+        # Make prediction
+        prediction = model.predict(processed_image)
+        probability = prediction[0][0]
+        
+        # Determine result
+        result = "Volcanic Eruption" if probability > 0.5 else "No Volcanic Eruption"
+        confidence = probability if probability > 0.5 else 1 - probability
+        
+        return {
+            "result": result,
+            "confidence": float(confidence),
+            "probability": float(probability)
+        }
+    except Exception as e:
+        logging.error(f"Error making prediction: {str(e)}")
+        raise
+
+def get_sample_images():
+    # Create sample images directory if it doesn't exist
+    sample_dir = Path(__file__).parent / 'sample_images'
+    sample_dir.mkdir(exist_ok=True)
+    
+    # Return a dictionary of sample images
+    return {
+        "Select an image": None,
+        "Upload new image": "upload",
+        "Sample Volcano 1": str(sample_dir / "volcano1.jpg"),
+        "Sample Volcano 2": str(sample_dir / "volcano2.jpg"),
+        "Sample No Volcano 1": str(sample_dir / "no_volcano1.jpg"),
+        "Sample No Volcano 2": str(sample_dir / "no_volcano2.jpg")
+    }
+
+def main():
+    st.set_page_config(
+        page_title="Volcano Detection",
+        page_icon="🌋",
+        layout="centered"
+    )
+    
+    st.title("🌋 Volcano Detection")
+    st.write("Select or upload an image to detect if it contains a volcanic eruption.")
+    
+    # Get the base directory
+    base_dir = Path(__file__).parent.absolute()
+    model_path = base_dir / 'model.h5'
+    
+    # Check if model exists
+    if not model_path.exists():
+        st.error(f"Model not found at {model_path}")
+        return
+    
+    # Load the model
+    try:
+        model = load_model(str(model_path))
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
+        return
+    
+    # Get sample images
+    sample_images = get_sample_images()
+    
+    # Create the image selection interface
+    selected_option = st.selectbox("Choose an image", list(sample_images.keys()))
+    
+    # Handle image selection
+    image = None
+    if selected_option == "Upload new image":
+        uploaded_file = st.file_uploader("Upload your image", type=["jpg", "jpeg", "png"])
+        if uploaded_file is not None:
+            image = Image.open(uploaded_file)
+    elif selected_option != "Select an image":
+        try:
+            image = Image.open(sample_images[selected_option])
+        except Exception as e:
+            st.error(f"Error loading sample image: {str(e)}")
+    
+    if image is not None:
+        # Display the image
+        st.image(image, caption="Selected Image", use_column_width=True)
+        
+        # Add a predict button
+        if st.button("Detect Volcano"):
+            with st.spinner("Analyzing image..."):
+                try:
+                    result = predict_volcano(model, image)
+                    
+                    # Display results in a nice format
+                    st.markdown("### Results")
+                    
+                    # Create columns for the results
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.metric("Prediction", result["result"])
+                    
+                    with col2:
+                        st.metric("Confidence", f"{result['confidence']:.2%}")
+                    
+                    # Add a progress bar for the probability
+                    st.progress(result["probability"])
+                    st.write(f"Raw Probability: {result['probability']:.4f}")
+                    
+                except Exception as e:
+                    st.error(f"Error during prediction: {str(e)}")
+
+if __name__ == "__main__":
+    main()