Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip 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

Dockerfile

@@ -1,21 +1,21 @@
+# Use a minimal base image with Python
 FROM python:3.9-slim
 
+# Set working directory
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Copy only requirements first for caching
+COPY requirements.txt .
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Install dependencies
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+# Copy all files (including model folder) into container
+COPY . .
 
+# Expose port (Streamlit default)
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run the Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]

app.py

@@ -0,0 +1,158 @@
+
+import streamlit as st
+import tensorflow as tf
+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")
+
+@st.cache_resource
+def load_model_and_metadata():
+    """
+    Load the saved Keras model and metadata (class names, input size) from the local 'model/' folder.
+    """
+    model_path = os.path.join(os.getcwd(), "model")
+    # Load model: if SavedModel format is present:
+    try:
+        model = tf.keras.models.load_model(model_path)
+    except Exception as e:
+        st.error(f"Failed to load model from {model_path}: {e}")
+        return None, None, None, None
+    
+    # Load metadata.json
+    meta_path = os.path.join(model_path, "metadata.json")
+    if not os.path.exists(meta_path):
+        st.error(f"metadata.json not found in {model_path}")
+        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)
+    
+    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()
+
+
+
+st.title("Food Image Classification")
+st.write("Upload one or more food images (Bread / Soup / Vegetables-Fruits) to classify.")
+
+# Sidebar info
+with st.sidebar:
+    st.header("Instructions")
+    st.write(
+        """
+        - 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")
+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
+        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.
+        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])
+        pred_class = class_names[pred_idx]
+        confidence = 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
+        result_df = pd.DataFrame([{
+            "filename": uploaded_file.name,
+            "predicted_class": pred_class,
+            "confidence": float(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.")

model/Model2_Transfer.keras

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

model/metadata.json

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

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+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