adding files

README.md

@@ -1,12 +1,96 @@
+# Dry Fruit Grade Classification
+
+This project uses a deep learning model to classify images of dry fruits (like almonds and cashews) into different quality grades (e.g., Grade A, Grade B).
+
+The model is built using TensorFlow/Keras and employs transfer learning with the **ResNet50** architecture.
+
+---
+
+## Results
+
+* **Training:** The final fine-tuned model achieved a peak **validation accuracy of ~99.7%** during training.
+* **Inference:** Real-world testing on individual images shows strong performance, with confidence scores often exceeding **99%**. Some images may yield lower confidence (e.g., ~75%) depending on quality and similarity to the training data.
+
 ---
-title: Deployment Model
-emoji: 🐠
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
+
+## Dataset
+
+* **Source:** 850 original 720x720 images of various dry fruits.
+* **Augmentation:** The dataset was expanded "offline" (on-disk) to 42,600 images, including rotations, brightness/contrast changes, and noise.
+* **Classes:** The folder structure `DryFruits_Dataset/Fruit/Grade/` was reorganized into a flat structure (`dataset_flat/Fruit_Grade/`) for training.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Model and Training
+
+The model is a pre-trained ResNet50 base with a new classification head (Global Average Pooling, a 128-node Dense layer, and a final Softmax output).
+
+The training was performed in a Google Colab notebook using a T4 GPU, following a crucial **two-stage process**:
+
+1.  **Stage 1: Feature Extraction**
+    * The ResNet50 base was frozen.
+    * Only the new classification head was trained for 10 epochs. This quickly "warms up" the new layers.
+    * **Result:** ~99.4% validation accuracy.
+
+2.  **Stage 2: Fine-Tuning**
+    * The entire model (including the ResNet50 base) was unfrozen.
+    * The model was re-compiled with a **very low learning rate** (`1e-5`) to prevent destroying the pre-trained weights.
+    * Training continued until `EarlyStopping` (monitoring `val_loss`) stopped the process.
+    * **Final Result:** ~99.7% validation accuracy.
+
+---
+
+## How to Use
+
+### 1. Training the Model
+
+1.  **Setup:**
+    * Upload the project notebook to Google Colab.
+    * Upload your dataset (e.g., `dryfruitsDataset.rar`) to Google Drive.
+
+2.  **Run the Training Cells:**
+    * **Cell 1 (Setup):** Mounts your Google Drive and un-RARs the dataset.
+    * **Cell 2 (Reorganize):** Runs a script to convert the nested folder structure `(Almond/Grade_A)` into the flat structure `(Almond_Grade_A)` required by Keras.
+    * **Cell 3 (Data Generators):** Loads the 42.6k images using `ImageDataGenerator`. It applies the mandatory ResNet50 preprocessing.
+    * **Cell 4 (Stage 1 Training):** Trains the frozen model head.
+    * **Cell 5 (Stage 2 Training):** Unfreezes and fine-tunes the full model, saving the best version as `resnet50_dryfruits_best.keras`.
+
+### 2. Running Inference (Predicting New Images)
+
+1.  **Load Model:** In a new cell (ideally in the same notebook), load the saved model.
+    ```python
+    from tensorflow.keras.models import load_model
+    
+    model = load_model('resnet50_dryfruits_best.keras')
+    
+    # Get the class mapping from the training generator
+    # (This requires 'train_generator' to still be in memory)
+    class_indices = train_generator.class_indices
+    class_names = {v: k for k, v in class_indices.items()}
+    ```
+
+2.  **Upload and Predict:** Use the provided inference code to upload a single image, preprocess it, and see the model's prediction.
+    ```python
+    from google.colab import files
+    from tensorflow.keras.preprocessing import image
+    from tensorflow.keras.applications.resnet50 import preprocess_input
+    import numpy as np
+    
+    # Upload an image
+    uploaded = files.upload()
+    test_image_path = list(uploaded.keys())[0]
+    
+    # Load and preprocess the image
+    img = image.load_img(test_image_path, target_size=(224, 224))
+    img_array = image.img_to_array(img)
+    img_batch = np.expand_dims(img_array, axis=0)
+    img_preprocessed = preprocess_input(img_batch)
+    
+    # Make prediction
+    prediction = model.predict(img_preprocessed)
+    predicted_index = np.argmax(prediction[0])
+    predicted_class_name = class_names[predicted_index]
+    confidence = np.max(prediction[0])
+    
+    print(f"Prediction: {predicted_class_name} | Confidence: {confidence*100:.2f}%")
+    ```

app.py

@@ -0,0 +1,56 @@
+import streamlit as st
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.applications.resnet50 import preprocess_input
+import numpy as np
+from PIL import Image
+
+# --- Load Your Model and Class Names ---
+# Use st.cache_resource to load the model only once
+@st.cache_resource
+def load_my_model():
+    # Make sure this file name matches your model file
+    model = load_model('resnet50_dryfruits.h5') 
+    return model
+
+# --- This is the updated dictionary based on your list ---
+class_names = {
+    0: 'AlmondGrade_A',
+    1: 'CashewGrade_B',
+    2: 'RaisinGrade_A',
+    3: 'CashewGrade_A',
+    4: 'AlmondGrade_B',
+    5: 'PistachioGrade_A',
+    6: 'RaisinGrade_B',
+    7: 'WalnutGrade_A',
+    8: 'CashewGrade_C'
+}
+# --------------------------------------------------------
+
+model = load_my_model()
+
+# --- App Interface ---
+st.title("Dry Fruit Quality Grader")
+st.write("Upload an image of a dry fruit, and the model will predict its grade.")
+
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    # 1. Preprocess the image
+    img = Image.open(uploaded_file).convert('RGB') # Ensure 3 channels
+    img = img.resize((224, 224))
+    img_array = image.img_to_array(img)
+    img_batch = np.expand_dims(img_array, axis=0)
+    img_preprocessed = preprocess_input(img_batch)
+    
+    # 2. Make prediction
+    prediction = model.predict(img_preprocessed)
+    predicted_index = np.argmax(prediction[0])
+    predicted_class_name = class_names[predicted_index]
+    confidence = np.max(prediction[0])
+    
+    # 3. Display results
+    st.image(img, caption="Uploaded Image", use_column_width=True)
+    st.markdown(f"## Prediction: **{predicted_class_name}**")
+    st.markdown(f"### Confidence: **{confidence * 100:.2f}%**")

requirements.txt

@@ -0,0 +1,4 @@
+tensorflow
+streamlit
+Pillow
+numpy

resnet50_dryfruits.h5

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