Update app.py

app.py

@@ -1,68 +1,57 @@
-import streamlit as st
-import cv2
-import numpy as np
+# Import necessary libraries
+import tensorflow as tf
 from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import numpy as np
+from google.colab import files
+import cv2
+from google.colab.patches import cv2_imshow
 import pickle
-from PIL import Image
-import os
 
-# Load the model and label encoder
-@st.cache_resource
-def load_resources():
-    # Custom loading to handle compatibility
-    try:
-        model = load_model('captains_cv2_model.keras', compile=False)  # Load without compiling first
-    except Exception as e:
-        st.error(f"Model loading failed: {str(e)}")
-        raise
-    with open('label_encoder.pkl', 'rb') as file:
-        le = pickle.load(file)
-    return model, le
+# Upload your model and label encoder files to Colab
+print("Please upload your captains_cv2_model.keras file")
+uploaded_model = files.upload()
+model_filename = list(uploaded_model.keys())[0]
 
-# Preprocess the image
-def preprocess_image(image_path):
-    img1 = cv2.imread(image_path)
-    img1 = cv2.resize(img1, (64, 64, 3))  # Resize to 64x64
-    # img1 = np.asarray(img1)  # Shape: (64, 64, 3)
-    img1 = img1[np.newaxis, :, :, :]  # Shape: (1, 64, 64, 3)
-    return img1
+print("Please upload your label_encoder.pkl file")
+uploaded_encoder = files.upload()
+encoder_filename = list(uploaded_encoder.keys())[0]
 
-# Main app
-def main():
-    model, le = load_resources()
-    
-    st.title("Image Classification App")
-    st.write("Upload an image to get a prediction")
-    
-    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+# Load the pretrained model
+model = load_model(model_filename)
+
+# Load the label encoder
+with open(encoder_filename, 'rb') as file:
+    label_encoder = pickle.load(file)
+
+# Function to preprocess the image (adjust based on your model's requirements)
+def preprocess_image(img_path, target_size=(64, 64)):  # Adjust target_size as per your model
     
-    if uploaded_file is not None:
-        image = Image.open(uploaded_file)
-        st.image(image, caption='Uploaded Image', use_column_width=True)
-        
-        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
-        temp_filename = f"temp_image{file_extension}"
-        
-        with open(temp_filename, "wb") as f:
-            f.write(uploaded_file.getvalue())
-        
-        try:
-            processed_img = preprocess_image(temp_filename)
-            st.write(f"Processed image shape: {processed_img.shape}")
-            
-            prediction = model.predict(processed_img)
-            predicted_class = le.inverse_transform([np.argmax(prediction)])
-            
-            st.write("Prediction:", predicted_class[0])
-            st.write("Prediction Probabilities:")
-            for class_name, prob in zip(le.classes_, prediction[0]):
-                st.write(f"{class_name}: {prob:.4f}")
-                
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-        
-        if os.path.exists(temp_filename):
-            os.remove(temp_filename)
+    img = cv2.imread(img_path)
+    img_array = np.asarray(img)
+    img_array = img_array[np.newaxis, :, :, :]
+    return img_array
+
+# Upload an image to predict
+print("Please upload an image to classify")
+uploaded_image = files.upload()
+
+# Get the uploaded image filename
+img_filename = list(uploaded_image.keys())[0]
+
+# Preprocess the image
+processed_image = preprocess_image(img_filename)
+
+# Make prediction
+prediction = model.predict(processed_image)
+
+# Get the predicted class index
+predicted_class_index = np.argmax(prediction, axis=1)[0]
+
+# Decode the prediction using the label encoder
+predicted_class = label_encoder.inverse_transform([predicted_class_index])[0]
 
-if __name__ == '__main__':
-    main()
+# Output the prediction
+print("Prediction probabilities:", prediction)
+print("Predicted class index:", predicted_class_index)
+print("Predicted class:", predicted_class)