Upload folder using huggingface_hub

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 model/Model2_Transfer.keras filter=lfs diff=lfs merge=lfs -text
+best_model.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,10 +1,10 @@
-# Use a minimal base image with Python
+# Use a minimal Python base image
 FROM python:3.9-slim
 
 # Set working directory
 WORKDIR /app
 
-# Copy only requirements first for caching
+# Copy requirements first for caching
 COPY requirements.txt .
 
 # Install dependencies
@@ -14,8 +14,11 @@ RUN pip install --upgrade pip && \
 # Copy all files (including model folder) into container
 COPY . .
 
-# Expose port (Streamlit default)
+# Expose Streamlit port
 EXPOSE 8501
 
 # Run the Streamlit app
-CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]
+CMD ["streamlit", "run", "app.py", \
+     "--server.port=8501", \
+     "--server.address=0.0.0.0", \
+     "--server.enableXsrfProtection=false"]

app.py

@@ -5,7 +5,6 @@ from PIL import Image
 import numpy as np
 import json
 import os
-import io
 import pandas as pd
 
 st.set_page_config(page_title="Food Image Classification", layout="centered")
@@ -13,33 +12,43 @@ st.set_page_config(page_title="Food Image Classification", layout="centered")
 @st.cache_resource
 def load_model_and_metadata():
     """
-    Load the saved Keras model and metadata (class names, input size) from the local 'model/' folder.
+    Load the saved Keras model (best_model.keras) and metadata.json
+    from the current directory.
     """
-    model_path = os.path.join(os.getcwd(), "model")
-    # Load model: if SavedModel format is present:
+    cwd = os.getcwd()
+    # 1. Load model file
+    model_file = os.path.join(cwd, "best_model.keras")
+    if not os.path.exists(model_file):
+        st.error(f"Model file not found at '{model_file}'. Ensure best_model.keras is present.")
+        return None, None, None, None
     try:
-        model = tf.keras.models.load_model(model_path)
+        model = tf.keras.models.load_model(model_file)
     except Exception as e:
-        st.error(f"Failed to load model from {model_path}: {e}")
+        st.error(f"Failed to load model from {model_file}: {e}")
         return None, None, None, None
-    
-    # Load metadata.json
-    meta_path = os.path.join(model_path, "metadata.json")
+
+    # 2. Load metadata.json at root
+    meta_path = os.path.join(cwd, "metadata.json")
     if not os.path.exists(meta_path):
-        st.error(f"metadata.json not found in {model_path}")
+        st.error(f"metadata.json not found at '{meta_path}'.")
+        return model, None, None, None
+    try:
+        with open(meta_path, "r") as f:
+            metadata = json.load(f)
+    except Exception as e:
+        st.error(f"Failed to read metadata.json: {e}")
         return model, None, None, None
-    
-    with open(meta_path, "r") as f:
-        metadata = json.load(f)
-    class_names = metadata.get("class_names", None)
-    IMG_HEIGHT = metadata.get("IMG_HEIGHT", None)
-    IMG_WIDTH = metadata.get("IMG_WIDTH", None)
-    
+
+    class_names = metadata.get("class_names")
+    IMG_HEIGHT = metadata.get("IMG_HEIGHT")
+    IMG_WIDTH = metadata.get("IMG_WIDTH")
     if class_names is None or IMG_HEIGHT is None or IMG_WIDTH is None:
         st.error("metadata.json must contain 'class_names', 'IMG_HEIGHT', and 'IMG_WIDTH'")
         return model, None, None, None
+
     return model, class_names, IMG_HEIGHT, IMG_WIDTH
 
+
 model, class_names, IMG_HEIGHT, IMG_WIDTH = load_model_and_metadata()
 if model is None or class_names is None:
     st.stop()
@@ -47,112 +56,63 @@ if model is None or class_names is None:
 
 
 st.title("Food Image Classification")
-st.write("Upload one or more food images (Bread / Soup / Vegetables-Fruits) to classify.")
+st.write("Upload a food image (Bread / Soup / Vegetable-Fruit) to classify.")
 
-# Sidebar info
 with st.sidebar:
     st.header("Instructions")
     st.write(
+        f"""
+        - Upload a JPG/PNG image of food.
+        - The model expects images resized to {IMG_HEIGHT}×{IMG_WIDTH}.
+        - The model classes: {', '.join(class_names)}.
+        - For best results, upload a clear image of a single food item.
         """
-        - Upload JPG/PNG images of food.
-        - The model expects images resized to {}×{}.
-        - The model was trained to classify into: {}
-        - For best results, upload clear images of individual food item.
-        """.format(IMG_HEIGHT, IMG_WIDTH, ", ".join(class_names))
     )
 
-# Single image upload
-st.subheader("Single Image Prediction")
+
+st.subheader("Image Prediction")
 uploaded_file = st.file_uploader("Choose an image...", type=["jpg","jpeg","png"], key="single")
+
 if uploaded_file is not None:
-    # Read image
     try:
         image = Image.open(uploaded_file).convert("RGB")
     except Exception as e:
         st.error(f"Cannot open image: {e}")
         image = None
     if image:
-        # Display the uploaded image
         st.image(image, caption="Uploaded Image", use_column_width=True)
-        # Preprocess: resize and scale
+
+        # Preprocess: resize and scale to [0,1]
         img_resized = image.resize((IMG_WIDTH, IMG_HEIGHT))
-        img_array = np.array(img_resized).astype("float32") / 255.0  # scale to [0,1]
-        
-        # If your model expects other preprocessing (e.g., vgg preprocess), ensure metadata / model includes that.
+        img_array = np.array(img_resized).astype("float32") / 255.0
         input_tensor = np.expand_dims(img_array, axis=0)  # shape (1, H, W, 3)
-        
+
         # Predict
-        preds = model.predict(input_tensor)
-        pred_idx = np.argmax(preds[0])
+        preds = model.predict(input_tensor, verbose=0)
+        pred_idx = int(np.argmax(preds[0]))
         pred_class = class_names[pred_idx]
-        confidence = preds[0][pred_idx]
+        confidence = float(preds[0][pred_idx])
         st.write(f"**Prediction:** {pred_class}  \n**Confidence:** {confidence:.3f}")
-        
+
         # Show full probability distribution
         prob_df = pd.DataFrame({
             "class": class_names,
             "probability": preds[0]
         })
         st.bar_chart(data=prob_df.set_index("class"))
-        
-        # Optionally: download result
-        # E.g., prepare a small DataFrame
+
+        # Download result as CSV
         result_df = pd.DataFrame([{
             "filename": uploaded_file.name,
             "predicted_class": pred_class,
-            "confidence": float(confidence)
+            "confidence": confidence
         }])
+
         csv = result_df.to_csv(index=False).encode('utf-8')
+
         st.download_button(
             label="Download prediction as CSV",
             data=csv,
             file_name="prediction.csv",
             mime="text/csv"
         )
-
-# Batch image upload
-st.subheader("Batch Image Prediction")
-uploaded_files = st.file_uploader(
-    "Choose multiple images...", type=["jpg","jpeg","png"], accept_multiple_files=True, key="batch"
-)
-if uploaded_files:
-    if st.button("Run Batch Prediction"):
-        results = []
-        cols = st.columns(3)
-        # Loop through each uploaded image
-        for idx, up_file in enumerate(uploaded_files):
-            try:
-                img = Image.open(up_file).convert("RGB")
-            except Exception as e:
-                st.warning(f"Skipping file {up_file.name}: cannot open as image.")
-                continue
-            # Display thumbnails in grid
-            col = cols[idx % 3]
-            col.image(img.resize((150,150)), caption=up_file.name)
-            # Preprocess
-            img_resized = img.resize((IMG_WIDTH, IMG_HEIGHT))
-            img_array = np.array(img_resized).astype("float32") / 255.0
-            input_tensor = np.expand_dims(img_array, axis=0)
-            preds = model.predict(input_tensor)
-            pred_idx = np.argmax(preds[0])
-            pred_class = class_names[pred_idx]
-            confidence = preds[0][pred_idx]
-            results.append({
-                "filename": up_file.name,
-                "predicted_class": pred_class,
-                "confidence": float(confidence)
-            })
-        if results:
-            results_df = pd.DataFrame(results)
-            st.write("Batch Prediction Results:")
-            st.dataframe(results_df)
-            # Download button
-            csv = results_df.to_csv(index=False).encode('utf-8')
-            st.download_button(
-                label="Download all predictions as CSV",
-                data=csv,
-                file_name="batch_predictions.csv",
-                mime="text/csv"
-            )
-        else:
-            st.info("No valid images to predict.")

best_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f6218c4bdc3c242d7e1dc198a1fa58b466b325c5e6429518dd3ff5a84c14e24
+size 62118073

metadata.json

@@ -0,0 +1,5 @@
+{
+  "class_names": ["Bread", "Soup", "Vegetable-Fruit"],
+  "IMG_HEIGHT": 150,
+  "IMG_WIDTH": 150
+}

requirements.txt

@@ -1,5 +1,5 @@
-streamlit==1.43.2
-Pillow==10.3.0
-tensorflow==2.16.1 # Use the TensorFlow version your model was trained with
-numpy==1.26.4
-scikit-learn==1.4.2 # Needed for LabelBinarizer
+streamlit==1.24.1
+tensorflow>=2.12.0
+Pillow>=9.0.0
+numpy>=1.24.0
+pandas>=2.0.0