Update README.md

README.md

@@ -1,3 +1,565 @@
----
-license: mit
----
+---
+license: mit
+task_categories:
+- object-detection
+language:
+- en
+tags:
+- food
+- ingrident
+- recipe
+- object-detection
+size_categories:
+- 1K<n<10K
+---
+
+"Eyes on Eats," aims to address the challenge many individuals face when they are unsure of what to cook with the ingredients available. This uncertainty often leads to wasted time contemplating meal options or even unnecessary spending on ordering food. "Eyes on Eats" offers a solution by employing advanced deep learning techniques in object detection and text generation. By analyzing images of ingredients, the system generates personalized recipes tailored to the user's available ingredients. This innovative approach not only streamlines the cooking process but also
+encourages culinary creativity. With "Eyes on Eats," users can confidently embark on their culinary journey without the stress of meal planning, ultimately saving time and potentially reducing unnecessary expenses.
+
+### **Objectives:**
+
+- Develop a robust object detection model capable of accurately identifying various ingredients depicted in images.
+- Implement an efficient text generation model to seamlessly translate detected ingredients into personalized recipe recommendations.
+- Ensure the scalability and adaptability of the system to accommodate a wide range of ingredients and recipes.
+
+# Datasets
+
+We need two types of data, for this project one going to be the image data of the ingredients to train the model on the object detection and we need textual data second we need the to train the other model to generate the recipe according to the depicted ingredients.
+
+## Object Detection Data
+
+We explored various ingredients datasets around the internet and they lack the requirements we need, and very short for training the complex model, so we manually do the web scraping using the Bing image downloader, but we noticed there’s inconsistency in the image formats and the bounded by the limitation of which we can only download one class at a time. So we modified it for our requirements and scrape 100 classes of images utilizing this. 
+
+<aside>
+🔗 Access the tool [here!](https://github.com/REDDITARUN/Snap_Swift)
+
+</aside>
+
+Here's the list of ingredients we are going to using the  tool:
+
+| all_purpose_flour | almonds | apple | apricot | asparagus |
+| --- | --- | --- | --- | --- |
+| avocado | bacon | banana | barley | basil |
+| basmati_rice | beans | beef | beets | bell_pepper |
+| berries | biscuits | blackberries | black_pepper | blueberries |
+| bread | bread_crumbs | bread_flour | broccoli | brownie_mix |
+| brown_rice | butter | cabbage | cake | cardamom |
+| carrot | cashews | cauliflower | celery | cereal |
+| cheese | cherries | chicken | chickpeas | chocolate |
+| chocolate_chips | chocolate_syrup | cilantro | cinnamon | clove |
+| cocoa_powder | coconut | cookies | corn | cucumber |
+| dates | eggplant | eggs | fish | garlic |
+| ginger | grapes | honey | jalapeno | kidney_beans |
+| lemon | mango | marshmallows | milk | mint |
+| muffins | mushroom | noodles | nuts | oats |
+| okra | olive | onion | orange | oreo_cookies |
+| pasta | pear | pepper | pineapple | pistachios |
+| pork | potato | pumpkin | radishes | raisins |
+| red_chilies | rice | rosemary | salmon | salt |
+| shrimp | spinach | strawberries | sugar | sweet_potato |
+| tomato | vanilla_ice_cream | walnuts | watermelon | yogurt |
+
+After the scraping the data is stored in a directory in a structured format, where everything is every category is  subdivided into separate directories and each containing the images of the respective category. For now we collected the image classification data. But we need the object detection data. Before that we need to clean and verify the collected data.
+
+## Correcting the initial data
+
+The class name in the above table has underscore but we cant use such names to scrape the data form the web, as that can lead to less accurate results, so we to scrape the keywords are provided in such a way that it wont effect the data search. As you can see form the given example.
+
+```python
+queries = [ "baking powder", "basil", "cereal", "cheese", "chicken"]
+
+for query in queries:
+    if len(sys.argv) == 3:
+        filter = sys.argv[2]
+    else:
+        filter = ""
+        
+    downloader.download(
+        query,
+        limit=50,
+        output_dir="dataset_dem",
+        adult_filter_off=True,
+        force_replace=False,
+        timeout=120,
+        filter=filter,
+        verbose=True,
+    )
+```
+
+The above process in the scraping lead to creating the directory names to “baking powder” which can lead to various inconsistences in the further processes. So  we created these steps to ensure consistency:
+
+- **Convert Spaces in Directory Names to Underscores**: Rename directories to replace spaces with underscores to avoid inconsistencies. For example, rename "all purpose flour" to "all_purpose_flour".
+
+```python
+Renamed 'all purpose flour' to 'all_purpose_flour'
+Renamed 'basmati rice' to 'basmati_rice'
+Renamed 'bell pepper' to 'bell_pepper'
+Renamed 'black pepper' to 'black_pepper'
+```
+
+- **Verify Folder Names Against Class List**: Ensure all folder names match exactly with the classes listed in a "Final_classes.txt" file. This step checks for both missing directories and extra directories not listed in the class list.
+
+```python
+All classes in 'Final_classes.txt' have corresponding directories in the dataset.
+No extra directories in the dataset that are not listed in 'Final_classes.txt'.
+```
+
+- **Remove Non-JPG Files**: Execute a script to traverse the dataset directories and remove any files that are not in .jpg format. This is crucial for maintaining consistency in the file format across the dataset.
+
+```python
+
+def remove_non_jpg_images(dataset_dir):
+    removed_files = []
+    for root, dirs, files in os.walk(dataset_dir):
+        for file in files:
+            # Check if the file extension is not .jpg
+            if not file.lower().endswith('.jpg'):
+                file_path = os.path.join(root, file)
+                os.remove(file_path)  # Remove the non-JPG file
+                removed_files.append(file_path)
+    return removed_files
+
+dataset_dir = r'C:\Users\Kiyo\Desktop\DL\Project\image_data\initial_data'
+removed_files = remove_non_jpg_images(dataset_dir)
+
+if removed_files:
+    print(f"Removed {len(removed_files)} non-JPG files:")
+    for file in removed_files:
+        print(file)
+else:
+    print("No non-JPG files found in the dataset.")
+
+```
+
+- **Check for Class Image Count**: Ensure that each class directory contains exactly 50 images. If a class has more than 50 images, randomly remove the excess images to limit each class to 50.
+
+```python
+all_purpose_flour: 50 images
+almonds: 50 images
+apple: 50 images
+apricot: 50 images
+asparagus: 50 images
+avocado: 50 images
+bacon: 50 images
+..
+..
+```
+
+- **Augment Images for Underrepresented Classes**: For classes with fewer than 50 images, perform image augmentation to increase the total to 50 images per class. This ensures uniformity in the number of images across all classes.
+
+```python
+Completed augmentation for class 'all_purpose_flour'.
+Completed augmentation for class 'almonds'.
+Completed augmentation for class 'apple'.
+Completed augmentation for class 'apricot'.
+Completed augmentation for class 'asparagus'.
+Completed augmentation for class 'avocado'.
+Completed augmentation for class 'bacon'.
+```
+
+---
+
+## Annotating the object detection data
+
+The dataset is ready, it consists of 100 classes present in the dataset, and each class contains 50 samples. But this is in the image classification format, which means to satisfy the stated objective of the project, The model is to be provided with pictures of one ingredient at a time and, after all the ingredients are collected by the user, with the help of the encoded vectors, it generates recipes through text generation. Which was very inconvenient, but also annotating the image data is very inconvenient. Then we discovered Grounding Dino. A zero-shot object detection model. 
+
+### Step 1: Check GPU Availability
+
+Use `!nvidia-smi` to check if a GPU is available for faster processing.
+
+### Step 2: Set Home Directory
+
+Define a `HOME` constant to manage datasets, images, and models easily:
+
+```python
+import os
+HOME = os.getcwd()
+print(HOME)
+
+```
+
+### Step 3: Install Grounding DINO
+
+Clone the Grounding DINO repository, switch to a specific feature branch (if necessary), and install the dependencies:
+
+```python
+%cd {HOME}
+!git clone https://github.com/IDEA-Research/GroundingDINO.git
+%cd {HOME}/GroundingDINO
+
+# we use latest Grounding DINO model API that is not official yet
+!git checkout feature/more_compact_inference_api
+
+!pip install -q -e .
+!pip install -q roboflow dataclasses-json onemetric
+```
+
+### Step 4: Additional Dependencies & Verify CUDA and PyTorch
+
+Ensure CUDA and PyTorch are correctly installed and compatible:
+
+```python
+import torch
+!nvcc --version
+TORCH_VERSION = ".".join(torch.__version__.split(".")[:2])
+CUDA_VERSION = torch.__version__.split("+")[-1]
+print("torch: ", TORCH_VERSION, "; cuda: ", CUDA_VERSION)
+
+import roboflow
+import supervision
+
+print(
+    "roboflow:", roboflow.__version__,
+    "; supervision:", supervision.__version__
+)
+```
+
+```python
+# confirm that configuration file exist
+
+import os
+
+CONFIG_PATH = os.path.join(HOME, "GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py")
+print(CONFIG_PATH, "; exist:", os.path.isfile(CONFIG_PATH))
+```
+
+### Step 5: Download Configuration and Weights
+
+Ensure the configuration file exists within the cloned repository and download the model weights:
+
+```python
+# download weights file
+
+%cd {HOME}
+!mkdir {HOME}/weights
+%cd {HOME}/weights
+
+!wget -q https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth
+
+# confirm that weights file exist
+
+import os
+
+WEIGHTS_PATH = os.path.join(HOME, "weights", "groundingdino_swint_ogc.pth")
+print(WEIGHTS_PATH, "; exist:", os.path.isfile(WEIGHTS_PATH))
+```
+
+### Step 6: Download and Prepare Your Dataset
+
+If your dataset is zipped in your drive, unzip it to a local directory:
+
+```python
+import zipfile
+
+# Path to the zip file
+zip_file_path = "/content/drive/MyDrive/....[your file path]"
+
+# Directory to extract the contents of the zip file
+extract_dir = "/content/data"
+
+# Unzip the file
+with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+    zip_ref.extractall(extract_dir)
+
+print("Extraction complete.")
+
+```
+
+### Step 7: Load the Grounding DINO Model
+
+Load the model using the configuration and weights path:
+
+```python
+%cd {HOME}/GroundingDINO
+
+from groundingdino.util.inference import Model
+
+model = Model(model_config_path=CONFIG_PATH, model_checkpoint_path=WEIGHTS_PATH)
+```
+
+### Step 8: Annotate Dataset and Save to PASCAL voc
+
+Use the model to annotate images. You can run inference in different modes like `caption`, `classes`, or `enhanced classes` depending on your needs. After inference, use the detections and labels to annotate images using your preferred method or the provided utility functions.
+
+Automate the annotation process for your entire dataset by iterating over your images, running the model to detect objects, and saving both the annotated images and their PASCAL VOC XML files.
+
+```python
+import os
+import cv2
+import xml.etree.ElementTree as ET
+from groundingdino.util.inference import Model
+from tqdm import tqdm
+
+# Define the home directory and the path to the dataset
+HOME = "/content"
+DATASET_DIR = os.path.join(HOME, "data", "ingredients_images_dataset")
+
+# Load the Grounding DINO model
+MODEL_CONFIG_PATH = os.path.join(HOME, "GroundingDINO", "groundingdino", "config", "GroundingDINO_SwinT_OGC.py")
+WEIGHTS_PATH = os.path.join(HOME, "weights", "groundingdino_swint_ogc.pth")
+model = Model(model_config_path=MODEL_CONFIG_PATH, model_checkpoint_path=WEIGHTS_PATH)
+
+# Load class labels from the file
+LABELS_FILE_PATH = "[ txt file path containing your images labels one per line]"
+with open(LABELS_FILE_PATH, "r") as f:
+    CLASSES = [line.strip() for line in f.readlines()]
+
+# Define annotation thresholds
+BOX_THRESHOLD = 0.35
+TEXT_THRESHOLD = 0.25
+
+# Function to enhance class names
+def enhance_class_name(class_names):
+    return [f"all {class_name}s" for class_name in class_names]
+
+# Function to create Pascal VOC format XML annotation
+def create_pascal_voc_xml(image_filename, image_shape, boxes, labels):
+    annotation = ET.Element("annotation")
+
+    folder = ET.SubElement(annotation, "folder")
+    folder.text = "ingredient_annotations"  # Folder name for annotations
+
+    filename = ET.SubElement(annotation, "filename")
+    filename.text = image_filename
+
+    source = ET.SubElement(annotation, "source")
+    database = ET.SubElement(source, "database")
+    database.text = "Unknown"
+
+    size = ET.SubElement(annotation, "size")
+    width = ET.SubElement(size, "width")
+    height = ET.SubElement(size, "height")
+    depth = ET.SubElement(size, "depth")
+
+    width.text = str(image_shape[1])
+    height.text = str(image_shape[0])
+    depth.text = str(image_shape[2])
+
+    segmented = ET.SubElement(annotation, "segmented")
+    segmented.text = "0"
+
+    for box, label in zip(boxes, labels):
+        object = ET.SubElement(annotation, "object")
+        name = ET.SubElement(object, "name")
+        pose = ET.SubElement(object, "pose")
+        truncated = ET.SubElement(object, "truncated")
+        difficult = ET.SubElement(object, "difficult")
+        bndbox = ET.SubElement(object, "bndbox")
+        xmin = ET.SubElement(bndbox, "xmin")
+        ymin = ET.SubElement(bndbox, "ymin")
+        xmax = ET.SubElement(bndbox, "xmax")
+        ymax = ET.SubElement(bndbox, "ymax")
+
+        name.text = label
+        pose.text = "Unspecified"
+        truncated.text = "0"
+        difficult.text = "0"
+        xmin.text = str(int(box[0]))
+        ymin.text = str(int(box[1]))
+        xmax.text = str(int(box[2]))
+        ymax.text = str(int(box[3]))
+
+    # Format the XML for better readability
+    xml_string = ET.tostring(annotation, encoding="unicode")
+
+    return xml_string
+
+# Function to annotate images in a directory and save annotated images in Pascal VOC format
+def annotate_images_in_directory(directory):
+    for class_name in CLASSES:
+        class_dir = os.path.join(directory, class_name)
+        annotated_dir = os.path.join(directory, f"{class_name}_annotated")
+        os.makedirs(annotated_dir, exist_ok=True)
+
+        print("Processing images in directory:", class_dir)
+        if os.path.isdir(class_dir):
+            for image_name in tqdm(os.listdir(class_dir)):
+                image_path = os.path.join(class_dir, image_name)
+                image = cv2.imread(image_path)
+                if image is None:
+                    print("Failed to load image:", image_path)
+                    continue
+
+                detections = model.predict_with_classes(
+                    image=image,
+                    classes=enhance_class_name([class_name]),
+                    box_threshold=BOX_THRESHOLD,
+                    text_threshold=TEXT_THRESHOLD
+                )
+                # Drop potential detections with phrase not part of CLASSES set
+                detections = detections[detections.class_id != None]
+                # Drop potential detections with area close to area of the whole image
+                detections = detections[(detections.area / (image.shape[0] * image.shape[1])) < 0.9]
+                # Drop potential double detections
+                detections = detections.with_nms()
+
+                # Create the Pascal VOC XML annotation for this image
+                xml_annotation = create_pascal_voc_xml(image_filename=image_name, image_shape=image.shape, boxes=detections.xyxy, labels=[class_name])
+
+                # Save the Pascal VOC XML annotation to a file
+                xml_filename = os.path.join(annotated_dir, f"{os.path.splitext(image_name)[0]}.xml")
+                with open(xml_filename, "w") as xml_file:
+                    xml_file.write(xml_annotation)
+
+                # Save the annotated image
+                annotated_image_path = os.path.join(annotated_dir, image_name)
+                cv2.imwrite(annotated_image_path, image)
+
+# Annotate images in the dataset directory
+annotate_images_in_directory(DATASET_DIR)
+
+```
+
+Now, wr’re use it to automate the process of annotating the dataset in Pascal VOC format. Which will be in the following format, An image that belong to some class and xml file for that respective image. 
+
+![Untitled](https://prod-files-secure.s3.us-west-2.amazonaws.com/a801b46f-690f-4f46-89cd-53a07ae8b478/70398d3d-e736-40ce-9012-23ba04edf471/Untitled.jpeg)
+
+```python
+<annotation>
+<folder>ingredient_annotations</folder>
+<filename>Image_1.jpg</filename>
+<source>
+<database>Unknown</database>
+</source>
+<size>
+<width>1920</width>
+<height>1280</height>
+<depth>3</depth>
+</size>
+<segmented>0</segmented>
+<object>
+<name>almonds</name>
+<pose>Unspecified</pose>
+<truncated>0</truncated>
+<difficult>0</difficult>
+<bndbox>
+<xmin>252</xmin>
+<ymin>650</ymin>
+<xmax>803</xmax>
+<ymax>920</ymax>
+</bndbox>
+</object>
+</annotation>
+```
+
+## Verifying the Annotated Data
+
+- Check if all the images are annotated by checking if the image file has the respective xml file, if not we remove and manually create a new annotated sample.
+
+```python
+
+def check_dataset_integrity(dataset_directory):
+    for class_name in os.listdir(dataset_directory):
+        class_path = os.path.join(dataset_directory, class_name)
+        if os.path.isdir(class_path):
+            jpg_files = set()
+            xml_files = set()
+            other_files = set()
+
+            # Collect file names for each extension
+            for file_name in os.listdir(class_path):
+                if file_name.endswith('.jpg'):
+                    jpg_files.add(os.path.splitext(file_name)[0])
+                elif file_name.endswith('.xml'):
+                    xml_files.add(os.path.splitext(file_name)[0])
+                else:
+                    other_files.add(file_name)
+
+            # Check for discrepancies
+            missing_xmls = jpg_files - xml_files
+            missing_jpgs = xml_files - jpg_files
+            is_perfect = len(missing_xmls) == 0 and len(missing_jpgs) == 0 and len(other_files) == 0
+
+            # Report
+            print(f"Class '{class_name}':", "Perfect" if is_perfect else "Discrepancies Found")
+            if missing_xmls:
+                print(f"  Missing XML files for: {', '.join(sorted(missing_xmls))}")
+            if missing_jpgs:
+                print(f"  Missing JPG files for: {', '.join(sorted(missing_jpgs))}")
+            if other_files:
+                print(f"  Non-JPG/XML files: {', '.join(sorted(other_files))}")
+        else:
+            print(f"'{class_name}' is not a directory. Skipping.")
+
+# Specify the path to the dataset directory
+dataset_directory = r'C:\Users\Kiyo\Desktop\DL\Project\image_data\initial_data_annotated'
+check_dataset_integrity(dataset_directory)
+```
+
+```python
+# Output Sample
+Class 'all_purpose_flour_annotated': Perfect
+Class 'almonds_annotated': Perfect
+Class 'apple_annotated': Perfect
+Class 'apricot_annotated': Perfect
+Class 'asparagus_annotated': Perfect
+```
+
+- Renamed all the directories containing samples, as you can see the dir names changed after annoateion, they are named as <some class name>_annotated. Now we remove that so that ensuring that the class name in the text file matches with the dir names.
+- Again after these changes we checked if all the images have the respective annotations and dir names matches with the class list text file.
+
+This completes our dataset preparation which is the major part in our project and took lot of time to reach the consistency through various trail and error approaches we created and perfected the dataset for the object detection training.
+
+## Text Generation Data
+
+The RecipeNLG dataset, available in RecipeNLG_dataset.csv, encompasses 2,231,142 cooking recipes sourced from RecipeNLG. This extensive dataset, totaling 2.14 GB, contains crucial recipe details such as titles, ingredients, directions, links, sources, and Named Entity Recognition (NER) labels. With label distribution categorized into various ranges and a vast array of unique values, the dataset showcases a diverse and comprehensive collection of cooking recipes. This dataset serves as a valuable resource for training and evaluating models in a multitude of natural language processing tasks, particularly in the context of generating cooking-related text.
+
+<aside>
+🔗
+
+[Access Here!](https://recipenlg.cs.put.poznan.pl/)
+
+</aside>
+
+**Sample** 
+
+| Title | Ingredients | Link | Directions | NER |
+| --- | --- | --- | --- | --- |
+| No-Bake Nut Cookies | ["1 c. firmly packed brown sugar", "1/2 c. evaporated milk", "1/2 tsp. vanilla", "1/2 c. broken nuts... | www.cookbooks.com/Recipe-Details.aspx?id=44874 | ["In a heavy 2-quart saucepan, mix brown sugar, nuts, evaporated milk and butter or margarine.", "St... | ["brown sugar", "milk", "vanilla", "nuts", "butter", "bite size shredded rice biscuits"] |
+
+For training the BART transformer model, we need to prepare the tokenized data. First, the dataset is extracted using the unzip command to access the recipe data. Next, we imported libraries such as pandas, transformers, tqdm, numpy, and TensorFlow are imported. 
+
+```python
+!unzip '/user/bhanucha/recipe_data.zip' -d '/user/bhanucha/data'
+import pandas as pd
+from transformers import BartTokenizer
+from tqdm import tqdm
+import numpy as np
+import tensorflow as tf
+from transformers import TFBartForConditionalGeneration
+import numpy as np
+```
+
+The BART tokenizer is initialized from the pretrained BART model, and if the tokenizer lacks a padding token, it is added. The dataset is then loaded into a pandas DataFrame.
+
+```python
+
+model_checkpoint = "facebook/bart-base"
+tokenizer = BartTokenizer.from_pretrained(model_checkpoint)
+if tokenizer.pad_token is None:
+    tokenizer.add_special_tokens({'pad_token': tokenizer.eos_token})
+
+data = pd.read_csv('/user/bhanucha/data/dataset/full_dataset.csv')
+
+```
+
+Subsequently, the ingredients and directions from each recipe are concatenated into text strings and tokenized using the BART tokenizer. The tokenized data is then processed to ensure consistency in length and format, with the tokenized inputs saved for training.
+
+```python
+texts = ["Ingredients: " + row['ingredients'] + " Directions: " + row['directions'] for _, row in data.iterrows()]
+
+tokenized_inputs = []
+for texts_text in tqdm(texts, desc="Tokenizing Data"):
+    tokenized_input = tokenizer(
+        texts_text,
+        padding="max_length",
+        truncation=True,
+        max_length=512,
+        return_tensors="np"
+    )
+    tokenized_inputs.append(tokenized_input['input_ids'])
+
+train_data = np.concatenate(tokenized_inputs, axis=0)
+np.save('/user/bhanucha/train_data.npy', train_data)
+
+```