diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..2eea525d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.env \ No newline at end of file diff --git a/README.md b/README.md index b58f55ca..4520cccf 100644 --- a/README.md +++ b/README.md @@ -1,194 +1,64 @@ -# FoodSnap AI - Hackathon Project +# 🥗 FoodSnap AI -🎉 **Welcome to the FoodSnap AI Hackathon!** 🎉 +**FoodSnap AI** is a lightweight FastAPI application that enables users to obtain nutritional information about food items by simply uploading an image. It uses a pre-trained machine learning model to classify food images and retrieves detailed macronutrient data from a connected database. -Get ready to combine your coding skills with the fascinating world of artificial intelligence and nutrition! We're excited to see what innovative solutions you come up with. +--- + +## Features + +- **Intelligent Food Classification** + Upload an image, and our integrated ResNet50 model identifies the food item. + +- **Comprehensive Nutritional Data** + Get calories, carbohydrates, protein, and fats for the identified food. -**The Challenge:** -Your mission, should you choose to accept it, is to develop a solution that can estimate the caloric content (and ideally, macronutrient breakdown – protein, carbs, fats) of a food item from an input image. +- **Quantity-Based Calculations** + Receive accurate nutritional values scaled to your specified quantity. -## Table of Contents +- **Efficient Model Management** + The AI model is loaded once at startup for fast subsequent processing. -1. [Project Overview](#project-overview) -2. [Why This Project?](#why-this-project) -3. [Scope & Implementation Freedom](#project-scope--implementation-freedom) -4. [Key Objectives / Potential Features](#key-objectives--potential-features) -5. [Helpful Resources & APIs](#helpful-resources--apis) - * [Food Image Datasets](#food-image-datasets) - * [Nutrition Information Databases & APIs](#nutrition-information-databases--apis) - * [Machine Learning / AI Tools](#machine-learning--ai-tools) -6. [Getting Started: Git & Submission Workflow](#getting-started-git--submission-workflow) - * [1. Fork the Repository](#1-fork-the-repository) - * [2. Clone Your Forked Repository](#2-clone-your-forked-repository) - * [3. Create a New Branch](#3-create-a-new-branch) - * [4. Develop Your Project](#4-develop-your-project) - * [5. Push Your Branch to Your Fork](#5-push-your-branch-to-your-fork) - * [6. Submit Your Project (Create a Pull Request)](#6-submit-your-project-create-a-pull-request) -7. [What to Include in Your Submission](#what-to-include-in-your-submission) -8. [Judging Criteria (General Pointers)](#judging-criteria-general-pointers) +- **Robust API** + Exposes a well-structured `/foodsnap/v1/upload` endpoint for seamless integration. + +- **Data Population (Web Scraping)** + Nutritional data is fetched and updated in the database using web scraping techniques. + + --- -## Project Overview +## Getting Started -**Project Name:** FoodSnap AI +Follow the steps below to set up and run **FoodSnap AI** on your local machine. -**The Challenge:** -Develop a solution that can estimate the caloric content (and ideally, macronutrient breakdown – protein, carbs, fats) of a food item from an input image. +## Tech Stack -## Why This Project? +- FastAPI +- TensorFlow +- ResNet50 (pre-trained model) +- Beautiful Soup +- Selenium +- Pandas +- SQLAlchemy + PostgreSQL -Understanding calorie intake is crucial for health and fitness. Manually logging food can be tedious. FoodSnap AI aims to simplify this process, making nutritional awareness more accessible to everyone. Imagine snapping a photo of your meal and instantly getting its nutritional information! -## Project Scope & Implementation Freedom +## Installation -You have complete freedom in how you bring FoodSnap AI to life! - -* **Platform:** Mobile App (iOS, Android, cross-platform), Web App, Website, or even a Command Line Interface (CLI) tool. -* **Technology Stack:** Use any programming languages, frameworks, libraries, or APIs you prefer. Python, JavaScript, Java, Swift, Kotlin, Ruby, Go – the choice is yours! -* **Approach:** You can use pre-trained machine learning models, train your own, leverage existing food recognition APIs, or come up with a completely novel approach. - -## Key Objectives / Potential Features - -1. **Image Input:** The system must accept an image of food as input. -2. **Food Identification (Implicit or Explicit):** The system needs to identify the food item(s) in the image. This could be a direct output or an internal step. -3. **Calorie Estimation:** Based on the identified food, estimate its total calories. -4. **Macronutrient Breakdown (Bonus):** If possible, also estimate protein, carbohydrates, and fats. -5. **Portion Size Consideration (Advanced Bonus):** Accurately estimating portion size from an image is challenging but would be a significant enhancement. -6. **User Interface (for non-CLI):** If you're building an app or website, make it user-friendly and intuitive. -7. **Multiple Food Items (Advanced Bonus):** Can your solution handle an image with multiple food items on a plate? - -## Helpful Resources & APIs - -To get you started, here are some resources that might be useful. You are **not limited** to these and are encouraged to explore! - -### Food Image Datasets -*(For training/inspiration if you go the custom ML route)* - -* **Food-101:** [https://data.vision.ee.ethz.ch/cvl/datasets_extra/food-101/](https://data.vision.ee.ethz.ch/cvl/datasets_extra/food-101/) (101 food categories, 101,000 images) -* **UECFood-100 / UECFood-256:** [http://foodcam.mobi/dataset.html](http://foodcam.mobi/dataset.html) (Japanese food primarily, good for object detection) -* **Recipe1M+:** [http://pic2recipe.csail.mit.edu/](http://pic2recipe.csail.mit.edu/) (Images and recipes) -* **Google Images / Flickr:** Can be used for scraping specific food images (be mindful of terms of service). - -### Nutrition Information Databases & APIs -*(For calorie/macro lookup)* - -* **USDA FoodData Central API:** [https://fdc.nal.usda.gov/api-guide.html](https://fdc.nal.usda.gov/api-guide.html) (Comprehensive US food composition database) -* **Edamam Food Database API:** [https://developer.edamam.com/food-database-api](https://developer.edamam.com/food-database-api) (Offers free tier for recipe analysis and food database lookup) -* **Spoonacular API:** [https://spoonacular.com/food-api](https://spoonacular.com/food-api) (Nutrition, recipes, food products, free tier available) -* **MyFitnessPal / CalorieKing / FatSecret:** While direct API access might be limited or paid, these websites are excellent sources for manual data collection or understanding how nutritional information is presented. Web scraping *could* be an option, but always respect `robots.txt` and terms of service. -* **Open Food Facts:** [https://world.openfoodfacts.org/](https://world.openfoodfacts.org/) (A collaborative, free, and open database of food products from around the world. They have an API.) - -### Machine Learning / AI Tools - -* **TensorFlow / Keras:** For building and training custom models. -* **PyTorch:** Another popular deep learning framework. -* **OpenCV:** For image processing tasks. -* **Pre-trained Image Recognition Models:** (e.g., MobileNet, ResNet, InceptionV3 available via TensorFlow Hub, PyTorch Hub, etc.) These can often be fine-tuned for food recognition. -* **Cloud AI Services:** Google Cloud Vision AI, AWS Rekognition, Azure Computer Vision (these often have free tiers for experimentation and can perform object/food recognition out-of-the-box). - -## Getting Started: Git & Submission Workflow - -We will be using GitHub for version control and submission. Please follow these steps carefully. - -**This Repository (Main Project):** `https://github.com/WeCode-Community-Dev/foodsnap-ai` - -### 1. Fork the Repository -* Go to the main project repository: `https://github.com/WeCode-Community-Dev/foodsnap-ai` -* In the top-right corner of the page, click the "**Fork**" button. -* This will create a copy of the repository under your own GitHub account (e.g., `https://github.com/YOUR_USERNAME/foodsnap-ai`). This is *your* personal remote copy. - -### 2. Clone Your Forked Repository -* On your GitHub page for *your forked repository* (`https://github.com/YOUR_USERNAME/foodsnap-ai`), click the green "**Code**" button. -* Copy the HTTPS or SSH URL. -* Open your terminal or Git client and run: - ```bash - git clone https://github.com/YOUR_USERNAME/foodsnap-ai.git - cd foodsnap-ai - ``` - (Replace `YOUR_USERNAME` with your actual GitHub username.) - -### 3. Create a New Branch -* It's crucial to work on a new branch rather than directly on `main` or `master`. -* Choose a descriptive branch name, for example, `feature/your-team-name` or `solution-john-doe`. -* In your terminal, inside the `foodsnap-ai` directory, run: - ```bash - git checkout -b feature/your-team-name - ``` - (e.g., `git checkout -b feature/awesome-coders` or `git checkout -b solution-jane-doe`) -* You are now on your new branch. Verify by running `git branch`. - -### 4. Develop Your Project -* Start coding! Add your files, write your logic, and build your FoodSnap AI solution. -* Commit your changes frequently with clear commit messages: - ```bash - # Stage all new and modified files - git add . - # Or stage specific files - # git add path/to/your/file.py path/to/another/file.js - - # Commit your changes - git commit -m "feat: Implement image upload functionality" - # Example commit types: feat, fix, docs, style, refactor, test, chore - ``` - -### 5. Push Your Branch to Your Fork -* When you're ready to save your progress to *your remote fork on GitHub*, push your branch: - ```bash - git push origin feature/your-team-name - ``` - (Replace `feature/your-team-name` with your actual branch name.) -* If it's the first time pushing this branch, Git might suggest a command like `git push --set-upstream origin feature/your-team-name`. Use that command. - -### 6. Submit Your Project (Create a Pull Request) -* Once your project is complete (or at a submittable stage), go to *your* forked repository on GitHub (`https://github.com/YOUR_USERNAME/foodsnap-ai`). -* You should see a prompt saying "`feature/your-team-name` had recent pushes". Click the "**Compare & pull request**" button. -* If you don't see the prompt, go to the "**Pull requests**" tab and click "**New pull request**". -* **Crucially, ensure the settings are:** - * **Base repository:** `WeCode-Community-Dev/foodsnap-ai` - * **Base branch:** `main` (or `master`, whichever is the default for this repository) - * **Head repository:** `YOUR_USERNAME/foodsnap-ai` - * **Compare branch:** `feature/your-team-name` (your development branch) -* Write a clear title and a detailed description for your Pull Request (PR). Include: - * A brief overview of your solution. - * Technologies used. - * How to run/test your project (setup, commands, etc.). - * Any known issues or limitations. - * A link to a live demo if applicable (e.g., Heroku, Netlify, GitHub Pages). - * Screenshots or a short video showcasing your project can be very helpful! -* Click "**Create pull request**". - -## What to Include in Your Submission -*(In your project's directory, pushed to your branch and included in the PR)* - -* **Source Code:** All the code for your project. -* **`README.md` (Your Project's README):** This is very important! Your project's `README.md` (different from this main hackathon `README.md`) should include: - * Project Title & Team Name/Members (if applicable). - * A brief description of your FoodSnap AI solution. - * What features you implemented. - * Tech stack used. - * **Clear instructions on how to set up and run *your specific project* locally.** This includes dependencies, environment variables, build steps, and run commands. - * Any API keys or environment variables needed (explain how to get them, but **DO NOT COMMIT ACTUAL KEYS** to the repository). Use a `.env.example` file to show what's needed. - * Link to a live demo (if any). -* **(Optional but Recommended)** A short demo video or presentation slides (you can link these in your PR description or in your project's README). - -## Judging Criteria (General Pointers) - -While specific criteria might be announced, generally projects are evaluated on: - -* **Functionality:** Does it work as intended? Does it achieve the core goal of calorie estimation from an image? -* **Accuracy:** How close are the calorie/macro estimations? (We understand this is complex!) -* **Innovation & Creativity:** Did you come up with a unique approach or an interesting feature? -* **Technical Implementation:** Quality of code, choice of technology, and complexity handled. -* **User Experience (UX/UI):** If applicable, is the application easy and pleasant to use? -* **Presentation/Demo:** How well you explain and showcase your project. -* **Adherence to Submission Guidelines:** Including a good project `README.md` and following the Git workflow. +```bash +# Clone the repository +git clone https://github.com/your-username/foodsnap-ai.git +cd foodsnap-ai +# Create and activate a virtual environment +python -m venv venv +source venv\Scripts\activate ---- +# Install dependencies +pip install -r requirements.txt -Good luck, innovators! We can't wait to see your FoodSnap AI creations. Remember to have fun, learn, and collaborate! +# Setup .env file -**Happy Hacking!** -The WeCode Community Dev Team +# Run +python main.py diff --git a/__pycache__/config.cpython-311.pyc b/__pycache__/config.cpython-311.pyc new file mode 100644 index 00000000..f5e29805 Binary files /dev/null and b/__pycache__/config.cpython-311.pyc differ diff --git a/__pycache__/database.cpython-311.pyc b/__pycache__/database.cpython-311.pyc new file mode 100644 index 00000000..0bb2ee2a Binary files /dev/null and b/__pycache__/database.cpython-311.pyc differ diff --git a/__pycache__/main.cpython-311.pyc b/__pycache__/main.cpython-311.pyc new file mode 100644 index 00000000..a4c60f23 Binary files /dev/null and b/__pycache__/main.cpython-311.pyc differ diff --git a/__pycache__/models.cpython-311.pyc b/__pycache__/models.cpython-311.pyc new file mode 100644 index 00000000..4b2afa4f Binary files /dev/null and b/__pycache__/models.cpython-311.pyc differ diff --git a/__pycache__/script.cpython-310.pyc b/__pycache__/script.cpython-310.pyc new file mode 100644 index 00000000..b60e6f7e Binary files /dev/null and b/__pycache__/script.cpython-310.pyc differ diff --git a/__pycache__/script.cpython-311.pyc b/__pycache__/script.cpython-311.pyc new file mode 100644 index 00000000..d08e8ab6 Binary files /dev/null and b/__pycache__/script.cpython-311.pyc differ diff --git a/config.py b/config.py new file mode 100644 index 00000000..06f083bc --- /dev/null +++ b/config.py @@ -0,0 +1,22 @@ +import os +from dotenv import load_dotenv + +load_dotenv() + +class Settings: + # database + DATABASE_URL: str = os.getenv("DATABASE_URL") + + # Model + MODEL_PATH: str = os.getenv("MODEL_PATH") + MODEL_NAME: str = "RestNet50" + + # API + HOST: str = os.getenv("HOST") + PORT: int = int(os.getenv("PORT")) + CORS_ORIGINS: str = os.getenv("CORS_ORIGINS") + + +settings = Settings() + + diff --git a/db/__pycache__/database.cpython-311.pyc b/db/__pycache__/database.cpython-311.pyc new file mode 100644 index 00000000..ddcbaf25 Binary files /dev/null and b/db/__pycache__/database.cpython-311.pyc differ diff --git a/db/__pycache__/models.cpython-311.pyc b/db/__pycache__/models.cpython-311.pyc new file mode 100644 index 00000000..8285a6fc Binary files /dev/null and b/db/__pycache__/models.cpython-311.pyc differ diff --git a/db/database.py b/db/database.py new file mode 100644 index 00000000..81e22682 --- /dev/null +++ b/db/database.py @@ -0,0 +1,10 @@ +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from sqlalchemy.ext.declarative import declarative_base +from config import settings + + +engine = create_engine(settings.DATABASE_URL) +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) +Base = declarative_base() + diff --git a/db/models.py b/db/models.py new file mode 100644 index 00000000..68087c12 --- /dev/null +++ b/db/models.py @@ -0,0 +1,21 @@ +from sqlalchemy import Column, Integer, String +from db.database import Base + +class CalorieNutritionData(Base): + __tablename__ = 'nutrition_data_project' + + id = Column(Integer, primary_key=True, index=True) + dish_name = Column(String, index= True) + calories = Column(String) + carbohydrates = Column(String, default=None) + protein = Column(String, default=None) + fats = Column(String, default=None) + free_sugar = Column(String, default=None) + fibre = Column(String, default=None) + sodium = Column(String, default=None) + calcium = Column(String, default=None) + iron = Column(String, default=None) + vitamin_c = Column(String, default=None) + folate = Column(String, default=None) + + diff --git a/main.py b/main.py new file mode 100644 index 00000000..fab191c2 --- /dev/null +++ b/main.py @@ -0,0 +1,51 @@ +from fastapi import FastAPI +from contextlib import asynccontextmanager +import uvicorn +from fastapi.middleware.cors import CORSMiddleware + +from config import settings +from db import models +from db.database import engine +from routes import foodsnap +from ml_model.model import food_ai_model + +# Global model storage +ml_models = {} + +@asynccontextmanager +async def lifespan(app: FastAPI): + """ Calling Model only Single time""" + + print(f'\nLoading {settings.MODEL_NAME} model') + ml_models["food_classifier"] = food_ai_model() # code to execute when app is loading + # expose models on app state for access within routes + app.state.ml_models = ml_models + yield + print('\nShutting down the model...') # code to execute when app is shutting down + +#FastAPI app +app = FastAPI( + title="FoodSnap AI", + description="AI-powered food classification and nutrition analysis", + version="1.0.0", + lifespan=lifespan +) + +# Create database tables +models.Base.metadata.create_all(bind=engine) + +app.add_middleware( + CORSMiddleware, + allow_origins= settings.CORS_ORIGINS, + allow_credentials=True, # Allow cookies and authorization headers + allow_methods=["*"], # Allow all HTTP methods (GET, POST, PUT, DELETE, etc.) + allow_headers=["*"], # Allow all headers in the request +) + +# router +app.include_router(foodsnap.router) + +if __name__ == "__main__": + uvicorn.run(app, host=settings.HOST, port=settings.PORT) + + diff --git a/ml_model/__pycache__/model.cpython-310.pyc b/ml_model/__pycache__/model.cpython-310.pyc new file mode 100644 index 00000000..1c289828 Binary files /dev/null and b/ml_model/__pycache__/model.cpython-310.pyc differ diff --git a/ml_model/__pycache__/model.cpython-311.pyc b/ml_model/__pycache__/model.cpython-311.pyc new file mode 100644 index 00000000..9b95ae46 Binary files /dev/null and b/ml_model/__pycache__/model.cpython-311.pyc differ diff --git a/ml_model/model.py b/ml_model/model.py new file mode 100644 index 00000000..c354fdbd --- /dev/null +++ b/ml_model/model.py @@ -0,0 +1,50 @@ +import tensorflow as tf +import cv2 as cv +import numpy as np +from config import settings + + +def food_ai_model(): + """ + Loads a pre-trained food classification model and returns a prediction function. + + This function initializes a TensorFlow Keras model from a specified path. + It then defines and returns an inner function, `predict_food_name`, which + takes an image (as bytes), preprocesses it, and uses the loaded model to + predict the food item's name from a predefined list of classes. + + Returns: + function: A function `predict_food_name` that takes an image (bytes) + and returns the predicted food name (string). + """ + + model = tf.keras.models.load_model(settings.MODEL_PATH) + + def predict_food_name(image): + # image=cv.imread(image, cv.IMREAD_COLOR_RGB) + img = cv.imdecode(np.frombuffer(image, dtype= np.uint8), cv.IMREAD_COLOR_RGB) + image_resized = cv.resize(img, (180,180)) + image = np.expand_dims(image_resized,axis=0) + + pred = model.predict(image) + + class_names = ['adhirasam', 'aloo matar', 'aloo shimla mirch', 'aloo tikki', 'anarsa', 'apple fruit', 'ariselu', + 'banana fruit', 'bandar laddu', 'basundi', 'bhatura', 'bhindi masala', 'biryani', 'boiled egg', + 'boiled rice', 'boondi raita', 'butter chicken', 'carrot', 'cauliflower', 'cham cham', + 'chana masala', 'chapati', 'cheese pizza', 'chicken stew', 'chicken tikka', 'chicken tikka masala', + 'chikki', 'daal baati churma', 'daal puri', 'dal makhani', 'dal tadka', 'dharwad pedha', 'doodhpak', + 'double ka meetha', 'dum aloo', 'fish curry', 'gajar ka halwa', 'gavvalu', 'ghee rice', 'ghevar', + 'gobi 65', 'gulab jamun with khoya', 'hot tea', 'idli', 'imarti', 'jalebi', 'kachori', + 'kadhi pakoda', 'kajjikaya', 'kakinada khaja', 'kalakand', 'karela bharta', 'kofta', + 'kuzhi paniyaram', 'lassi', 'litti chokha', 'makki ki roti', 'malapua', 'misti doi', 'modak', + 'mysore pak', 'naan', 'navrattan korma', 'orange fruit', 'palak paneer', 'paneer butter masala', + 'pea paneer curry', 'phirni', 'pithe', 'plain dosa', 'poha', 'poornalu', 'pootharekulu', 'rabri', + 'ras malai', 'rasgulla', 'rice puttu', 'sandesh', 'shankarpali', 'sheer korma', 'sheera', 'shrikhand', + 'sohan halwa', 'sohan papdi', 'tandoori chicken', 'tomatoes', 'unni appam'] + + + output_class = class_names[np.argmax(pred)] + return output_class + + return predict_food_name + \ No newline at end of file diff --git a/ml_model/resnet50_finetune.ipynb b/ml_model/resnet50_finetune.ipynb new file mode 100644 index 00000000..5ea61c07 --- /dev/null +++ b/ml_model/resnet50_finetune.ipynb @@ -0,0 +1,344 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jK4dl_zNjmXu" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "import PIL\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "from tensorflow.python.keras.layers import Dense, Input, Flatten\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.optimizers import Adam\n", + "from tensorflow.keras.models import Model\n", + "# from tensorflow.keras.applications import ResNet50\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nTdVTk0kj_Y-" + }, + "source": [ + "# Setuping Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Twh9rwHuj-NQ", + "collapsed": true + }, + "outputs": [], + "source": [ + "import zipfile\n", + "\n", + "extracted_file = \"/content/indian_food_images\"\n", + "\n", + "with zipfile.ZipFile(\"/content/drive/MyDrive/ai-project-dataset/Indian Food Images.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(extracted_file)\n", + "\n", + "# /content/drive/MyDrive/ai-project-dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3GC362e7dR9M", + "outputId": "27a63b0f-f51f-44ad-f8c6-3ae9ea7f9a6b" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "PosixPath('/content/indian_food_images/Indian Food Images')" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ], + "source": [ + "import pathlib\n", + "\n", + "data_dir = pathlib.Path(\"/content/indian_food_images/Indian Food Images\")\n", + "data_dir" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 331 + }, + "id": "4ICRx796btqy", + "outputId": "73e65284-4d06-478c-e6e4-0aa68e205972", + "collapsed": true + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "50\n", + "[PosixPath('/content/indian_food_images/Indian Food Images/bhatura/9bdae15cf5.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/6b7d6a02b0.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/8b37f8729e.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/10e2670c3b.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/3f2be0dce2.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/9ff0e71a7b.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/5e5fcfafab.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/8a31202469.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/6ca43de67f.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/7f4e67b3a2.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/2b9a862167.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/7dfec3ba4c.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/1a1920e559.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/1ed8f97fe2.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/5d49d7fc8c.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/0c336b5378.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/4bf6c18d87.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/0b3ed8d096.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/6b717b959f.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/016dd09bb1.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/23c3ce067e.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/7d511d084f.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/1bb2a0ca01.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/6bfc35793f.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/25f97b0569.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/0e84306e25.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/2ec3c7d2d5.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/9f68d9dfe2.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/3db3e71567.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/9bcde83d8d.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/4e052c4c31.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/8aacc3a978.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/5fa68259c7.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/24e4bcbbd9.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/17afbffe7d.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/8a31746a32.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/5cbcf3fdae.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/5f5c3e7090.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/4a2173df91.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/18e4d65d85.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/005c62055f.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/8d41747def.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/0da0ea24b2.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/8e4b799a9a.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/5ecb6ad613.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/1ce23e9981.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/4fe1f53b08.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/14fcac8706.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/14b6125138.jpg'), PosixPath('/content/indian_food_images/Indian Food Images/bhatura/26af243f03.jpg')]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n", + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEDAMIDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwBkOg6NZf6jTLVf9rywT+ZrQjMMHyJCv/AcCoVi/wBunrCn9+s9C9SyLh/4KIYEmk/epu/ip0Kw/wB+p45oaAJXT+NKgcInyNVlrmL+FKjjie9n2RJ8/wDn1pARxJ/vVs2Hhu7vY0fesUTfe3Z3L/wGtjSNFhsoEmlh3XHO5WwR7fj7itmAXH33/wDHfT+tZ+010HymMngy08v97dzs/wDs4H6c1j6j4ce2kZ0fzUX/AGecV3TLv/jakOxI97fN/wCy0NsSSPLGT+CmlU/j+WvR7jStM1OPzXhX/eTIP447/WmWejafZXaOlp/CfmZiwX6Z9afMg5TzWQbP40/2aaRK/wB6vXora3T5Et4lX/rmKju9K069j/0i0ib/AGtuD+Y5p7geRuH/AN6q4lf76p/wGu01HwdcQz77B1lh/wCebsAy/j0Irm50dJHilTbKvysre3FSwRlTz3Hy7Lfd/e2/w0oD1eVHf7n+81McUFFKT5P4Kgk2f3K0I4JrmTZBC0rf7Kk1Vl2Jv3oyuv3l6FaVgKEwTy6ZoEOmJqUv220WWVl3RM3qOv6fyp0pR6pzHZIjp99WoWgWudLfau/l7LdFiX+6vFc9c3P7z56ZcajF/cZmqi9wn3/KX/gVaKLMri+b/t0VD9t/6ZRf980U7SHdHZrF+83/AD1OE/vVTmeZI98T7n/u02LUYX+/u7L83qanmWw2a0axf3/++an2L/lapB/7tSRu/mVqIsBP9it3RbD94t8/8OVTa2PY0tjoSXNotx9o2v8AxLt/TNbEk8XmJbxJt24+Vf4a5qtRNWRtCLTLrTP5fyp92mC9epEdKyrsPPI+x/u/d2t2rFuxpFJm7FcI8fz/APAafGn3n3/7Kr7e1ZNvL+42VowvvgT+/WidyZRsTrCn9+nxt+82M/z1A837z5Pm/wBlf55qYbPM37F3/wB6qSRDJi/8FOaqV08vl7k+8rfzp1pK7x/M+56alrYXLoStNEn3qjMVvNI7zwxOq/dZ1B9fWofs2x5Xl3Oj/Lt/u1P8jxt977tJNjaRlMLe2RFsreOLzZDI21eeOBUL6XpOpyedcW6q/wB3dH8uTycnHeo5YLiO7/1qqrN97sv4VaLqmyKJ/n3fe/vcHt2Fc8akm9TVxVtCnFp9vZWl1p9r91m+ZmYZfOMZPTArN1Hwb/a06Ja3UaeQvlySMpO49QPw6fjV26OyfzWStTTZdke/7u6nCpeWopR00PObrwPr0P8AzD/N+bbujZT+PXP5isTUPDWrafHvn0+eJWbarbc8/hXtjXyJu+eqh1b/AG93/Aq1dRIlJnzzfRSw79yMr/d+bqtZu9/M+Z6+gr3StEuY2u7jTorqWX5WkkUnp6A/0rxvxJpUWmay8Nun+jsvmR7udvXIz3x/WtadVPQynG2pk7KKXD0VuZGta3bvsRU+dl+ZVkzx7+hq0bNJ5P3Uu7zWCsrLjaQfrz6VlzJcaFJK8X3G+X94vK9+KhgvUuY3uJXl83cNrL/XFcbjYs9Agt/3fzOu/wD2en6mtXTdO+0z7Ff5f4mrBt5ZXgi/5avtHzfWvRdG0xNP01Ufa0rfNJt9fSrlPSyLgi5Bb/YrTyv++qga32fvtn8XzN9amuw6QO+/59p2/wBKqafqP7j7PdI2xl/HiufRPlNle1ywTs/z96q6hHk3r9z/ACKsMIng/dbm25+XvUKH7NHLM33KGNEplhST5v8A0H7tW4in30+ZKis7uynh374l+Y/MzAbfanvd2/mMifK/92tFbe4n2LUZT+4q0yR/+BKv3l7r/kViXQuJ7T91L86t8vpis6zsrieRklf5eGb5vw7e3FS6j2SD2a7nYRv+7+f5qegff8v/AAGq0EqJGu5/T64GB+VTq7vJv/h/h+X8q2Micn+9Vea/hSP97Uudkf8AsVXuIEufkl+5RK/QFbqZtxd29zBv3r975V/l/n3pIURJP3vyv/Cv96k/smFJF2/c3fLu/hp947wb3XdO/wDn9K5+V7s1utkTMlv5f7+qD3yfci+VV+7WZNc3H3Pvf8BpqzIke+V/+A1LncaiWp5bh4HdYmZf4v8AZrNW5h8ttzssv8Ee3Ib6ntVO51S4mnREdliVv4en5VoQWTvtmlRlT734euO1ZfG9DRrlWpYglmSRPtW5Ytvyr7H2q9NoejeINN+zz2i7dx8uTaA6n1DdR9OhrO8r94+z5t1bGnu8Eez5f61rTvFmUtUebyfCrXvNfZfWhTcdpy4yPpiivVdz/wB9qK6/aGHKeJTGK5/c3r+b/ss2f/1VS1Syito0+wJ8/wDGse3PPtiqWmapcJH8s3ybvmZlBP15rZhm1DULuLz0gWyVhu8tfmlx6nsKwbsrsiKbdjoPh9Bffa3lvUZYVX90si/eb1+gr0VZZkkf51X5tu5V7/4VzuimG28reiqm7+FeFH+FatxM6SO6p8n9339R9PSs4zurnd7NR0NKYvNBvf76/wB3+L3HtWXcSw/8Di/PBq9Y3bvJsZ93ynZ8p6dTRJbxPI7/AC1bXMtCNmRWn3PuMv8AFVPU/Oe0lStQ7IP4NyfxbW5X/wCtTGhTy327mXn738Oe2fzolG6sJS1ucGs00PyP/e/lVqHUXSREVNtal7p32mfybW32sud3X5u/fpxS2vh5/k8/av8AwIZ9T1PpXN7Od7I6eeO5pWvz2ivvpqh3k3yvt2/d7cAe1WECJ8n8H3v89iP8Klgt0mk3qm1P9pc8/jXQo30MHKw+1Z/v7F3bdq7a1IYX8tfn/wA96db2iQxp/wDFU922f+zV0xhZanPKVxSKbv2fO9NMu/7m7/eqNS/l7H+Zv/QqbEkTIUf+ClGygH/vmkdN8m/ZVDK81lE8m/Yq1nX+g280fyfK/wDu8Vtg76fs/d1DgmhKTRwU3h2WGT7+5Kms7L94ife/2a6u6RP+Wv3f9r/Co4IUh3bU/wDHea5/ZRT0NvaNoZBpMKRr8nzUj2/kSfKn+FXprnZH/wChVCl/E/8AGv8AvVv7uxnqQFpcn/W0Vb+0Q/36KXKu4czPmmLT7tLt7fYq2+75ZNuNo/rXT6UkVtJv3s26Pav0B5/GpJk/j+6v92oiN9j/AGhEjbIpDCzf3c42n+n41z4jax0Yejrzs6G2vUSNkf221bgvLfy9nnN8zfeZvun/AD/KuQ+3Svt/2flq9aXaJHLDLDudvutuxt/SuJOx2OJ1cd9skREdX/L5e3UfzrYW42bf/Zq4vTH2bpv4v89q6LStRR59lx+9/vb+evbn6VvTn0ZhUh2NV7hE2b38p2+7uU/MR1Ht+NWFn/d/J/u1TuJooZE2ov8As7f4f1p9s1vc/OkLf3fl4P4j0rpT1sc7RLGjv++far/7pP6+lNvNP+2x7Jfm2/Nt3Yqfyov7/wDh+NSx2+yP77S/3W3ZrTl0syXLqNisESNN+7su2tLzYbaP5/lqktx/Hv3bf73r+NJ5yPJs2f71Pb4Sd9zR3p5f+x+tJlP46q5f/PX3pVR3/u/59BV3JsTH/ZpsZ2Sb3f8A+xqLf/sfJSs7vHsTb/tLQOxZSeJ/n31N/wB81zot7v7X99lra37I6UZN7oUopbEwKJ8lPEqVQaV6c9ykEezeu/7tPmsLlbJ50if73zbahnWbyHeBPn/9Cqhc38MEnzyr97+Hr+NRy30zxu6Tf7qr/FUcyZfK0YV7qd2k7Q3G5fmqFdZ2VemsLvVvv7V8r+Lb978a5bUbeWyn8p65Zc0dehsrM3P7cT+//P8Aworlt70VHtGVyGDf3GyPyovvtXdWdk8GkxafLtbzbcLLHwOcZ6nvz+YriNDi/tDxAjt9yLMn/fPT684r0uWWG9tFd4Wb+HcuB9OKps6qulkjzloNl3LE/wB5W2/4Gr0cDv8Ae/76qXxAfs12m3a275d1JDc7IK5JLUvmurl2yu/sU+xEVvlP3lB6/XvVKK/eB3+T5uf4iPp0qexu7eCTZcJ87fN5lWFt9Mnu97PuVv4d2P5U7gl5GlojTXvzv/496V01ukSSfun2/wC0uP6daxIri3so1SD5U/3hj/HPWtBrjfH9/wC9XXRaSOKsrs1HmRPk3tu/i71jXGp6hZTskHzo30NTJN+83/d/3ac48771bSvJaGcdC9A/nwI7/eZfm+tKLh4JPJ8pdv3t38Wf8Kql9kfyJTG+eP5027vxov0FYl/teFJNm/b/AMC/zn8aLoPPGrq7fL/tHPr1rnHtH+1/Pv8A9n0atW2n2R7F/wDHqzU29JGkopao1Iru48tEVPKRcK3zZLetWPNTy3fft/hZmqhDNvk/zmr7pbpshf77fw7s/j0rZPQyaLVoP3a7H3O3zfN6VPNsTZuf+Kqluz+Y38O37rVYYpP/AAf4VotiXuRh98++qOp22+BvKfa1WxDN5n3Kr3Vx5Pyfx1nK1tS43vocbew3ySfP838KtW3oKzP+5dGX+JfrUDXf7xt3/oNb1jcwvH8qbdv96uelFc17mtVvltYo6rPfafH8qfuv7y1zMzvez75/uLXoRZJ49n3kb+Gs270a0SP7n/Ae1bTg3rcxjI4j7Rbf8+K0V0X9nWn/ADyWisfZvuac/kcb4N0NHsZdQd23tmNenTPP403+0biyneGXd8vy/wC96V12nGK20aG0ihZUiULu3Z575+tZN1aJe3a+bt/2qxmr7HR7S8ncxZ0+2xq7pu/u1oaZoHnR+ddPti/hrcWwt0+SJNqKvzfWq16ZvLRF/wCAr2qZLl3BPmGXmgO8f7hFaJV+X5a56+sbu2k+5Xb6LPd+QyTv8n93/PapNR2eWzt/6D+VV7OLXMhKq4uxw1j508mxnaurilSCNd//ANeqe1Pm2J860ze7ybN9XBcpM3zGp5tu8n7p5dn/AE0x1/DtUpn/ANuqUIRI2SX5f96qktynmfJLurRysZctzaWZPLpVl/efJ8/+e9YkL+fJ9/5K0N6JH9+mpticS6IU8x3+Td/F/hUbxI/3arrqNv5H8VNTUIX3/wBz/Pak5xKUJF2G4Ty3T7v8Py/4/wCetVZEh0//AFUzMzf3s1gXOoy20jbP/r1DaajLPOn3v96s3UubqnbU7q1nlSP+Jv8AaWtCK78n5JX/AO+f88/WslHSC0/u/KPu1kvqM3mP87N/utjdW7qcpgocx2cmoW/kI+/73zfhj0Nc5qF5b+eiJL8/O79KxJ3meP7jr/Eq9frVVXd5Pmhb5f4utROrdao0hSs9zSluE/4H/eq7a3aQQbN9YRbf975f4qclwn3P4P4a5lNxdzWUFJWOys7n7tTXWookdcxDfOkH95qz9Qvbh/vpt/utu+9XQ6/unOqXvHQ/bk/v/wCfzoriPtz/AN+isPaM39mjWuJ3Sf8AdblT+7VmB0S0a4b7y/w+/ap7nyfM/wBuszU/3Fo6J7bv6U7ct2QveaRZiuX8j/x7/eoM/wBzfWCl3/ff/d+b9DWpbXtu8bI77v7u3GaxWpu42NuC+2Rq/wD3z6f5xWgn7+D96i/N+Nc5dG3SNHT73+1z+mKdb6m/8D7lX73y/d/pW8KlnZmE4XV0WtQMUEexNq1j7n+/v2vS3c7zSff+T/OappKk8jeQ7bF/v/xGoc7sqMLIlnnmmj2NMzf7Xeo0+So13u9X10u+8velu23+9Qk2GxCk+z7tTR3bp87/ADf7P96qkkMsMn71GX/ep6xP5e/Z8lF2FkVrx5p53miTylb+Fc4q9pgdPnbdUkM6QfeTdVk31ikezYrN/vU0lu2NybVrDL2FLn71R2gt9Pk3/e/u0qy1l37+TJRLTVChrobVzqO+Pfv2/wCFZkN7vnTc9Z1u/wBpk2O+2i4H2aT7/wDhUttmygloddBqMMMGxv8A9r/Cqtxqv308r5Pu/wCHSsRrj7jxJ8n3flblT71Fexaj5f8Ae/4FTcpWsQoq5aNwn9+mvLs2PvXZ/DWCGlhkZH3LUr32+PYr/KvzN/tGpsaHXae/nxtUN9C7wfNSeHp0e0erNy3nRt/drSMU4nNNtSOY8iir2yip5R851UNhM/75/uVV1SFHkdIk/df1I5xWcmrXz3eyKZki3f3uPyq1NN+8/i3/AIVfMnGxNmnc52SxdJH/AIf121YtrS4SN5tjbK0pjKmyaWrMVwjx7NlZKNzZ1HYxy/8AdrW0xEudyb9v97b/AJ6Vn3tlC8/7q4Zn/ij8sjb6fWrEFvNbR71f+hpxVpCm04i6nCnkP5U211/JqzbRXSRYvl/vN9a1z++j+d6eEhgj2Ii/71OUbu5KnZWKUUyQz7/mVq15NZeGB/Km3f3fp7jArlNSvdl3WdNfv/A9TGUlexv7NOxvT63LeT/6ZK0v8KdPlHbinpe3CQPb+d+6b+HaP51kaRA9zJ52yte5hoTe5nNRTsivI7/cquo2Sb6nYO/z7KiZ/wDYoEjSint0nTc7SxfxeVwfpz/OqmrOk8H7r7v+11qrvq1AEeP56q99BWs7nOB5fuI7LurVsrfzo/J+/Ur2CeZ/sVbEKW0Hmr/DRY0lO+w6K2Sy+f8A9CpH1BPnrPn1HfWfNdp/wOk12JSfU1J9X05IPKfTopW/vf3R/n+tYV3eJN/x7xeUrfhULI/3/OX/AL6pq7E+Sn0NbJG9Y3P2a0VP++q1JLz93XNWwfzFrXf9z956cTCa1Js0U37XD/caincguQujyJMjruZv9X1Kir986J++2L93c+3rjt/WshLiXTJ2e1RdzN8zbf8AGrN8JZrT7Q3lb1Ut+764P3h9KI21Q2tUxbnUUufK+T/gVWoX8mP5/wC7XNi7hSNreX+L7jVcs97wff3J/DUK6ZckmizdanCk6fPu/vKuB+tTWeoQz/eRYv8Adzj9c1nzWCPJvq2ttsjT5G2fws3RvSmrg+W1jUhKeZ8if7X3SenJ49MUx3/55fNVAXe/f91lX+Lbxx+FX7K5i+/8uz+KqvfQzcWtTA1m0mn/ANI8pV/vben0rIexTzF8p2b5fm+XG38e9dzdLbz79rp/u1lrYP5lS1bY0jV0LegaW/kf61lT+8vrW1c6dYpH/rWZ/u9u1c+dZmto/s+xfl+Wltrt7n53f5F/z0ojNJWsKUG9WDwp5mz+Dd97oK1tM0rT5/vIzfL97tWdqdxClp8kPzL96Td97pjisIa5cJ8iStFt/u8Gqi0pahyNx0Or1KysYd6JtX/d9fp6VgxI6SNtf/7KsWfU7u9n/e3DN/eZmya24J4njTykZVVfuyNnce5z2pSld3L5GkMupXSOsGa/mSRvnbZW7LLFc/JvrGv7bZ/AtIIaaMzzN/HSgb6s+RafZN6S/vv7tV1/1lM1uMNo71PDbbKsrUgXfRqQ5k9uEg+f+Oo53px+Sq0j1SRg3djvPoqDKUUBodJdwb/+W21f7rNxVa0eWDfDs+Rl+9WnLaReXveXdu/u4+X9av2gsUgeFf8AvplGaQa2PPr1f9v7tW9Lvdkeyk1y08i7fb/wGqdnTNN4nQfa08v5qTz3dH+f5Nv8TfoKzZh+7q4Yf3G//wAdpMlaFVNTuEge0R9qNWvpwfyNny/L/nrVS7vUntLdNis6/KuxQNo/Afzq7bbLaNPN3f7q9ahlyehp2vk+Xs+bd/u8fnVtbvyJN6ov/wAT74qKw+eDe6feq5HDb+X8+2tYp2OeVrmFfQ/aZ/tCJt3f7NLaWDvOvyf/AK66Em08zynTbuqRbREk/wBilyJlc7SM+505HtGR65G9sf7P3ps3f79ekTInkbF+9/WuZ1obNs0vzbf4upb8aqpFJXClN3scvZWVwn+kfd6r8ucrn1qcu6fJ/B/d71Ld6tC8Cwxe/wDnpTrCC4ufnZPvf56Vi1fY6uayuyNoH+R9+1ana0S9gfc+1FrUltHmj2bKw9R064tpESXdElPlaMlNMy2h2SOn3k/haoJkmeT5ErWj06Z/kRGqY6FqHl7/ACW/3e9CTY3JIzIA6R/NVhf9ig2z+XUf3KpGbYs42R1nyPVid/79Z7nfJWiQkPy9FTfYJaKq6NPYyOy01N/8C1XlaZNWeFPlRv6VPodzD5f3/n/irQa2R7tZdn+frWcoXRkpWbMTVod+ybYzbV2s22sBU/efJXcajv8AMeJ9vlcMvr6VyF5aPBO6f3vmWk0ODLtubfzF+1Ptq9O9p/ywf5fu/NWEu94/3vz7alV0/j/8dp2G7EyWbpP53lN5W7723hfxrorZU/j+aseKV3/c+a2zd93tW0o8iP56cURORoMXeNNqVjXyTJJ/s/xN/dqydd2f6J5O7/apzz+d9/5UpySkRG8ShBC6fcm3f3ev9a1reX9wqN/wLbVLz4v4Kerv5e/f96oUUnc0cm9zSE/9zcn61XvrT7bA8OzbVRLub76J93+7UkmrfIqOn/AqfOrWYcjTujOtPD3kT/vfu1sxWyQf6rbtp9tqKPH8/wDu1XmvoU/j+f8Au1S5VqTJyb1NRLuGCPe23ev3dq/e+vrXO6lqM17fN9of/R1+7/n0pLnUXeN0RP8AdauUnvXgkfe+7dUTm3oi6UNbnQDUETdt+Wsy8124TcizNs/2fWsuW43wffqiWqIpo6OVHT6bN51jK8v97+lVJn+9VO3nfy9lSTP+7q4mE1qVpnp9lb/aZ/8AYXDN/hSRWz3Mn39qfr+FaceyCPYnyrVs6KNJvVlz5aKrebRUHYVvDGrp5CPLF8397kdO47GuwF/DP8/zKjY+Vm49K8+vJbeykd9k7XDfKvdUX+6uOOK1tHvEuYPJlfym/hVv61tJO2h4caqqa9TqdQvEedE+X5VrCuG8+T5kqOaX95v+6y/d+lVJtRd4Nmz+L5qjV7myVti3s3x/JSQW6PJ81QQT/wADVOsrpTSJbLuIoJ4tv/Aq0ZLlPLrn3f8Aeb6Xz3ppNCepff8A1m+p0m/dvWcstV7yaby02O23+KkxpXZp43/cqjcXEtt8n3qrpe3Gz90n3fvVXub67uZP3v8Ayyx8yqPw9qzaNoRNK113ZHs/4D97H6f0qc6mlz/s1yzj+P8Ai/pUfnTJScTVWOne78j54n+X/PpUVvd+fPvd/m/9Crnlnd5Pmep/O/2P8ajlsNpHQtO8/wAiVlahB58j7U+f/YpbS7fy6fLcVSRjezMtrZ/46fFaf36nZ3eliOyP560SByYvyQR73/h/irPe78+T5Pu/3qg1W93yLEr/AHfvVTSartZGtKCerN6O5p/2isVZ6V7vZHU2Ou9jZ87/AG6K5b+3aKfs5djL28O5nHVJX+dvv/3u7fX1q7YazMkiJK/y/wALd/zrGUUEV3uKaseLGydzuINWR5Njvt/9mrUDp5e/5a88iuH+T5/nX7tXV1y+ST+D/vmsfZHU2nqjvEomfZ89Yel+IYr3906eVcfo30rXZ9kfz/xf3qhxsZ31Hw3CTf7NSrLWTIjpJViGb9381QjRxVtDRLVWYu8mz/apr3aQxrv+WnEP99HptCTsWX2eXsX5aymd4Y2hV/lb71WGldPvVUkm/vVLiaRbIXL/AMdRM7vQ5/u0zzf79KxdwVHeSr8EWz733qRJ0SNalPz1LQnIVnpjPTHNIz/u/kqbAOD1R1LVEh3xRf63/wBB/wDr1BeXv2KP/pq33V/qaw9+/wCdvv1pGIJXZMHqRXquDUm+qZumT+bWXf32/wDdLTbu7/gX71UBWsIdWc9Wv9lC5op1FanMa8i6Z9yD7Uz/AMLNtxVV0rRWy8imSQ7KLmaiZJXZUqsj/I/3/wC9T5kquRV7gm0yQh0rVsdZuPMWKe4Zov8Aa52ntz6VlJN/A/zJT/K3/PF83+z3qXE1UkzvILv7u9/NRq0kVHjry9Zpk+RHZf8AgVdLo/iL935N6+3b92T+99ajlE0zqmtt/wDrfKZP1oaJPL8paqm4SaPfvVl/2aeJ6liTI5YHT/lqtMeyfy9/3qS5G+TfVdXuEk+R/wDe+lRY0UiCRP3n92oilXr7VbdNqSyou7+/WW2rackmxpVb/dyR+YpOLNIzui0j/wAFWTMiR/fql/bekpHv37m/uqpzWXe+JN/yWtuq/wC0ygn8ulLkYua5qz3P956zJ9b8j5Lf5m/vdv8A69Ys1zcXMm+WVm/l+VRiqVNLcpMsPM80jPK+5mpymoVoedEqrFXsWt+yqNxd/wAC1WluHm/3ajBq407bmU619EOFPHSmbqXzaswJN9FRefRRZhdHcPF+8qtOlXy1VZfn/wCA1ki7GXJElUZ4q1pP9qqVxWqZDRnEUgOyppEqIitjIlE+/wD1qbv9road5SP/AKp/+AtwagIpKXKmWqjRaWe7tvuTSrt+7sYitGPxPqCff8pv+A4P5islJpk/jp/m/wB6Jf5VHIVzxe5ot4lvn++kW3+6q4/XNZ09/d3P+tuHZf7u7imnyf8AbWmN9n/57f8AfVTyspOJGTRQZrdP+Xj/AMdNNNzaf89m/wC+TRysfNHuOoqFr23/ALjN+VRNf/3Yl/4FzRyMHUii6BSltn3qynu5X/i/754qAmr9n3Idfsar3P8AceqzOn9+qitUgNPlSI52ybzaYXpuaaTTsK44u9NzS0lMhhmijNFAz0X/AJaVGP4qKK5jpWxVl6VRkoorREyK8lQ0UVqjAGoFFFUQIaozTSeZ980UUhspyyyHq5paKKYhKbRRQgCkNFFIBDRRRQAlOFFFDGh9LRRSKEooooEwooooA//Z\n" + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "food_images = list(data_dir.glob('bhatura/*'))\n", + "print(len(food_images))\n", + "print(food_images)\n", + "PIL.Image.open(str(food_images[0]))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_yzHPVqYcqJL", + "outputId": "4d44531a-cf64-494b-8141-a4aac98334ed" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 4427 files belonging to 87 classes.\n", + "Using 3542 files for training.\n" + ] + } + ], + "source": [ + "img_height,img_width=180,180\n", + "batch_size=32\n", + "\n", + "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " data_dir,\n", + " validation_split=0.2,\n", + " subset=\"training\",\n", + " seed=123, #randomness\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size) #chunk of data passed into model at a time" + ] + }, + { + "cell_type": "code", + "source": [ + "val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " data_dir,\n", + " validation_split=0.2,\n", + " subset=\"validation\",\n", + " seed=123,\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cckvvzwlwZsu", + "outputId": "e4ae8e95-7137-472b-fa2f-24e837410ac5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 4427 files belonging to 87 classes.\n", + "Using 885 files for validation.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "class_names = len(train_ds.class_names)\n", + "cls_nm = train_ds.class_names\n", + "print(cls_nm)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GbhCLL6_wfM4", + "outputId": "1928ad23-91f6-4f1d-a09e-361e083a448e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['adhirasam', 'aloo matar', 'aloo shimla mirch', 'aloo tikki', 'anarsa', 'apple fruit', 'ariselu', 'banana fruit', 'bandar laddu', 'basundi', 'bhatura', 'bhindi masala', 'biryani', 'boiled egg', 'boiled rice', 'boondi raita', 'butter chicken', 'carrot', 'cauliflower', 'cham cham', 'chana masala', 'chapati', 'cheese pizza', 'chicken stew', 'chicken tikka', 'chicken tikka masala', 'chikki', 'daal baati churma', 'daal puri', 'dal makhani', 'dal tadka', 'dharwad pedha', 'doodhpak', 'double ka meetha', 'dum aloo', 'fish curry', 'gajar ka halwa', 'gavvalu', 'ghee rice', 'ghevar', 'gobi 65', 'gulab jamun with khoya', 'hot tea', 'idli', 'imarti', 'jalebi', 'kachori', 'kadhi pakoda', 'kajjikaya', 'kakinada khaja', 'kalakand', 'karela bharta', 'kofta', 'kuzhi paniyaram', 'lassi', 'litti chokha', 'makki ki roti', 'malapua', 'misti doi', 'modak', 'mysore pak', 'naan', 'navrattan korma', 'orange fruit', 'palak paneer', 'paneer butter masala', 'pea paneer curry', 'phirni', 'pithe', 'plain dosa', 'poha', 'poornalu', 'pootharekulu', 'rabri', 'ras malai', 'rasgulla', 'rice puttu', 'sandesh', 'shankarpali', 'sheer korma', 'sheera', 'shrikhand', 'sohan halwa', 'sohan papdi', 'tandoori chicken', 'tomatoes', 'unni appam']\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Training Model" + ], + "metadata": { + "id": "1l0hF31Dxk47" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "input_tensor = tf.keras.Input(shape=(180, 180, 3))\n", + "\n", + "base_model = tf.keras.applications.ResNet50(\n", + " include_top=False,\n", + " weights='imagenet',\n", + " input_tensor=input_tensor, # Must be tf.keras.Input\n", + " pooling='avg'\n", + ")\n", + "\n", + "base_model.trainable = False\n", + "\n", + "x = base_model.output\n", + "x = tf.keras.layers.Flatten()(x)\n", + "x = tf.keras.layers.Dense(512, activation='relu')(x)\n", + "output_tensor = tf.keras.layers.Dense(87, activation='softmax')(x)\n", + "\n", + "model = tf.keras.Model(inputs=input_tensor, outputs=output_tensor)\n", + "\n", + "model.summary()" + ], + "metadata": { + "id": "L639e5wUv53r", + "collapsed": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model.compile(\n", + " optimizer=Adam(learning_rate=0.001), #small value = slower, stable learning\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy']\n", + ")\n" + ], + "metadata": { + "id": "DKgJ8aM4Xn-J" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#one full pass through the entire training dataset(1 epoch)\n", + "#validation_data = Dataset used to evaluate performance after each epoch\n", + "\n", + "epochs=10\n", + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=epochs\n", + ")" + ], + "metadata": { + "id": "ZNCN41Nb0Jgl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3309ed34-486d-4c6f-8007-14e78a053827" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m573s\u001b[0m 5s/step - accuracy: 0.1479 - loss: 4.0349 - val_accuracy: 0.3525 - val_loss: 2.5790\n", + "Epoch 2/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m556s\u001b[0m 5s/step - accuracy: 0.5381 - loss: 1.7626 - val_accuracy: 0.4316 - val_loss: 2.2191\n", + "Epoch 3/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m527s\u001b[0m 5s/step - accuracy: 0.7218 - loss: 1.0611 - val_accuracy: 0.4610 - val_loss: 2.1351\n", + "Epoch 4/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m603s\u001b[0m 5s/step - accuracy: 0.8296 - loss: 0.6809 - val_accuracy: 0.4768 - val_loss: 2.0970\n", + "Epoch 5/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m571s\u001b[0m 5s/step - accuracy: 0.9008 - loss: 0.4201 - val_accuracy: 0.5017 - val_loss: 2.1226\n", + "Epoch 6/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m604s\u001b[0m 5s/step - accuracy: 0.9374 - loss: 0.2896 - val_accuracy: 0.4994 - val_loss: 2.1443\n", + "Epoch 7/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m559s\u001b[0m 5s/step - accuracy: 0.9706 - loss: 0.1753 - val_accuracy: 0.5232 - val_loss: 2.0536\n", + "Epoch 8/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m567s\u001b[0m 5s/step - accuracy: 0.9834 - loss: 0.1197 - val_accuracy: 0.5209 - val_loss: 2.1182\n", + "Epoch 9/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m562s\u001b[0m 5s/step - accuracy: 0.9919 - loss: 0.0901 - val_accuracy: 0.5401 - val_loss: 2.1051\n", + "Epoch 10/10\n", + "\u001b[1m111/111\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m566s\u001b[0m 5s/step - accuracy: 0.9936 - loss: 0.0631 - val_accuracy: 0.5209 - val_loss: 2.1849\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "model.save('food_model.keras')" + ], + "metadata": { + "id": "ST1LVkfZTV-L" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..8afe7205 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +fastapi==0.115.13 +uvicorn==0.34.3 +tensorflow==2.19.0 +opencv-python==4.11.0.86 +beautifulsoup4==4.13.4 +SQLAlchemy==2.0.41 +psycopg2==2.9.10 +python-dotenv==1.1.1 \ No newline at end of file diff --git a/routes/__pycache__/foodsnap.cpython-311.pyc b/routes/__pycache__/foodsnap.cpython-311.pyc new file mode 100644 index 00000000..161893a0 Binary files /dev/null and b/routes/__pycache__/foodsnap.cpython-311.pyc differ diff --git a/routes/foodsnap.py b/routes/foodsnap.py new file mode 100644 index 00000000..6b7f266a --- /dev/null +++ b/routes/foodsnap.py @@ -0,0 +1,83 @@ +from fastapi import APIRouter, UploadFile, HTTPException, Depends, Form, Request +from starlette import status +from typing import Annotated +from sqlalchemy.orm import Session + +from db.database import SessionLocal +from services.nutrition_service import NutritionService + + +router = APIRouter(prefix="/foodsnap/v1", tags=["foodsnap"]) + +def get_db(): + db = SessionLocal() + try: + yield db + finally: + db.close() + +db_dependency = Annotated[Session, Depends(get_db)] + +def get_ml_models(request: Request) -> dict: + return request.app.state.ml_models + + +@router.get('/', status_code= status.HTTP_200_OK) +async def project(): + return ({"message": "Foodsnap Project"}) + +@router.post('/upload', status_code=status.HTTP_200_OK) +async def upload_food_image(db: db_dependency, image: UploadFile, + quantity: int = Form(1, gt=0), + ml_models: dict = Depends(get_ml_models)): + """Upload and classify food image, return nutritional information""" + + uploaded_image = await image.read() + + try: + food_name = ml_models["food_classifier"](uploaded_image) + if not food_name: + raise ValueError('Food classification failed or returned empty result.') + + except Exception as e: + print(f"An unexpected error occurred: {e}") + raise HTTPException( + status_code=500, + detail='Could not classify the food item. Please try again or with a clearer image' + ) + + food_data = NutritionService.get_food_nutrition_data(db, food_name) + print(f"Food name --> {food_name}") + if not food_data: + raise HTTPException( + status_code=404, + detail=f"Nutritional data for '{food_name}' could not be found." + ) + + # Calculate nutritional values + calories = await NutritionService.calculate_nutritional_values( + quantity, float(food_data.calories) + ) + carbohydrates = await NutritionService.calculate_nutritional_values( + quantity, float(food_data.carbohydrates) + ) + protein = await NutritionService.calculate_nutritional_values( + quantity, float(food_data.protein) + ) + fats = await NutritionService.calculate_nutritional_values( + quantity, float(food_data.fats) + ) + + nutrition_response = { + "Dish_Name": food_name, + "Quantity": quantity, + "Calories": f'{calories}', + "Carbohydrates": f'{carbohydrates}(g)', + "Protein": f'{protein}(g)', + "Fats": f'{fats}(g)' + } + + print(f"Response: {nutrition_response}") + return nutrition_response + + diff --git a/scripts/populate_database.py b/scripts/populate_database.py new file mode 100644 index 00000000..5fdc6a2d --- /dev/null +++ b/scripts/populate_database.py @@ -0,0 +1,55 @@ +import pandas as pd +from db.database import engine +import csv +from io import StringIO + + +def psql_insert_copy(table, conn, keys, data_iter): + """ + Execute SQL statement inserting data + + Parameters + ---------- + table : name of SQL table. + conn : sqlalchemy connection engine. + keys : list of str + Column names + data_iter : Iterable that iterates the values to be inserted + """ + # gets a DBAPI connection that can provide a cursor + dbapi_conn = conn.connection + with dbapi_conn.cursor() as cur: + s_buf = StringIO() + writer = csv.writer(s_buf) + writer.writerows(data_iter) + s_buf.seek(0) + + columns = ', '.join(['"{}"'.format(k) for k in keys]) + if table.schema: + table_name = '{}.{}'.format(table.schema, table.name) + else: + table_name = table.name + + sql = 'COPY {} ({}) FROM STDIN WITH CSV'.format( + table_name, columns) + cur.copy_expert(sql=sql, file=s_buf) + + +def populate_database(csv_path): + """Populate database with nutrition data""" + df = pd.read_csv(csv_path) + + df.to_sql( + name= 'nutrition_data_project', + con= engine, + if_exists= 'append', + index= False, + method= psql_insert_copy + ) + + print("DATA SAVED INTO TABLE SUCCESSFULLY !!!") + +# FASTEST METHOD TO STORE LARGE DATASETS INTO DB. +if __name__ == "__main__": + populate_database(r'C:\Users\GAFAR\Desktop\ai-project\web_scrap\cal_data.csv') + diff --git a/services/__pycache__/nutrition_service.cpython-311.pyc b/services/__pycache__/nutrition_service.cpython-311.pyc new file mode 100644 index 00000000..30a0772f Binary files /dev/null and b/services/__pycache__/nutrition_service.cpython-311.pyc differ diff --git a/services/nutrition_service.py b/services/nutrition_service.py new file mode 100644 index 00000000..53e98629 --- /dev/null +++ b/services/nutrition_service.py @@ -0,0 +1,21 @@ +from db import models +from sqlalchemy.orm import Session +# from typing import Dict, Any + + +class NutritionService: + @staticmethod + async def calculate_nutritional_values(quantity: int, macronutrients: float) -> float: + """Calculates the nutritional value based on quantity and macronutrients""" + value = ((macronutrients * 100) * quantity)/100 + return value + + @staticmethod + def get_food_nutrition_data(db: Session, food_name: str): + """Retrieve nutrition data for a food item""" + + nutri_values = db.query(models.CalorieNutritionData).filter(models.CalorieNutritionData.dish_name == food_name).first() + return nutri_values + + +