Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/ismailtekin05/caloriedetectingai

🍎🔍 Smart AI system that identifies food items in photos and calculates their calorie content automatically. Built with TensorFlow, YOLOv8, CUDA and computer vision for accurate nutrition tracking.
https://github.com/ismailtekin05/caloriedetectingai

ai aimodel calorie-calculator computer-vision cuda data-analysis data-science data-segmentation data-visualization dataset dataset-generation image-processing image-recognition python segmentation-models tensorflow ultralytics yaml yolo yolov8

Last synced: about 1 month ago
JSON representation

🍎🔍 Smart AI system that identifies food items in photos and calculates their calorie content automatically. Built with TensorFlow, YOLOv8, CUDA and computer vision for accurate nutrition tracking.

Awesome Lists containing this project

README 

          
# CalorieDetectingAI 🍎🔍



An intelligent AI-powered system that automatically detects and estimates calories in food items from images using deep learning and computer vision techniques.



![License](https://img.shields.io/github/license/IsmailTekin05/CalorieDetectingAI)

![Python](https://img.shields.io/badge/Python-3.8+-blue.svg)

![TensorFlow](https://img.shields.io/badge/TensorFlow-2.x-orange.svg)

![OpenCV](https://img.shields.io/badge/OpenCV-4.x-green.svg)



## 📋 Table of Contents



- [Overview](#overview)

- [Features](#features)

- [Installation](#installation)

- [Usage](#usage)

- [Model Architecture](#model-architecture)

- [Dataset](#dataset)

- [Training](#training)

- [API Reference](#api-reference)

- [Contributing](#contributing)

- [License](#license)

- [Acknowledgments](#acknowledgments)



## 🎯 Overview



CalorieDetectingAI is a cutting-edge machine learning application that leverages computer vision and deep learning to automatically identify food items in images and provide accurate calorie estimations. The system is designed to help users track their dietary intake effortlessly by simply taking a photo of their meal.



### Key Capabilities



- **Food Recognition**: Identifies multiple food items in a single image

- **Portion Estimation**: Estimates serving sizes using visual cues

- **Calorie Calculation**: Provides accurate calorie counts based on food type and portion

- **Nutritional Analysis**: Offers detailed macro and micronutrient breakdowns

- **Real-time Processing**: Fast inference for mobile and web applications



## ✨ Features



- 🔍 **Multi-Food Detection**: Recognizes and analyzes multiple food items simultaneously

- 📏 **Portion Size Estimation**: Advanced algorithms for accurate serving size determination

- 🧮 **Calorie Calculation**: Precise calorie estimation based on food type and quantity

- 📊 **Nutritional Breakdown**: Complete macro and micronutrient analysis

- 🚀 **Real-time Inference**: Optimized for fast processing and mobile deployment

- 🌐 **REST API**: Easy integration with web and mobile applications

- 📱 **Mobile Friendly**: Lightweight models suitable for mobile deployment

- 🎨 **User Interface**: Clean and intuitive web interface for testing



## 🛠 Installation



### Prerequisites



- Python 3.8 or higher

- CUDA-compatible GPU (optional, for faster training)

- 4GB+ RAM recommended



### Quick Start



1. **Clone the repository**

   ```bash

   git clone https://github.com/IsmailTekin05/CalorieDetectingAI.git

   cd CalorieDetectingAI

   ```



2. **Create virtual environment**

   ```bash

   python -m venv venv

   source venv/bin/activate  # On Windows: venv\Scripts\activate

   ```



3. **Install dependencies**

   ```bash

   pip install -r requirements.txt

   ```



4. **Download pre-trained models**

   ```bash

   python scripts/download_models.py

   ```



### Docker Installation



```bash

docker build -t calorie-detecting-ai .

docker run -p 8000:8000 calorie-detecting-ai

```



## 💻 Usage



### Command Line Interface



```bash

# Analyze a single image

python detect_calories.py --image path/to/food_image.jpg



# Batch processing

python detect_calories.py --batch path/to/images/



# With detailed output

python detect_calories.py --image food.jpg --verbose --save-results

```



### Python API



```python

from calorie_detector import CalorieDetector



# Initialize the detector

detector = CalorieDetector(model_path='models/food_detection.h5')



# Analyze an image

results = detector.predict('path/to/food_image.jpg')



print(f"Total Calories: {results['total_calories']}")

for food_item in results['detected_foods']:

    print(f"{food_item['name']}: {food_item['calories']} cal")

```



### Web Interface



Start the web server:

```bash

python app.py

```



Visit `http://localhost:8000` to use the web interface.



### REST API



Start the API server:

```bash

uvicorn api:app --host 0.0.0.0 --port 8000

```



Example API call:

```bash

curl -X POST "http://localhost:8000/analyze" \

     -H "Content-Type: multipart/form-data" \

     -F "file=@food_image.jpg"

```



## 🏗 Model Architecture



The CalorieDetectingAI system uses a multi-stage deep learning pipeline:



### 1. Food Detection Model

- **Base Architecture**: YOLOv8 / EfficientDet / CUDA

- **Purpose**: Locates and identifies food items in images

- **Output**: Bounding boxes with food class predictions



### 2. Portion Estimation Model

- **Architecture**: Custom CNN with attention mechanisms

- **Purpose**: Estimates portion sizes using visual references

- **Features**: Volume estimation, density consideration



### 3. Calorie Calculation Engine

- **Method**: Rule-based system with ML corrections

- **Database**: USDA Food Database integration

- **Accuracy**: ±15% for most common foods



```

Input Image → Food Detection → Portion Estimation → Calorie Calculation → Results

     ↓              ↓               ↓                    ↓

  Preprocessing → Bounding Boxes → Volume/Weight → Nutritional Data

```



## 📊 Dataset



The model is trained on a comprehensive dataset combining:



- **Food-101**: 101 food categories with 101,000 images

- **USDA Food Database**: Nutritional information for 8,000+ foods

- **Custom Dataset**: 10,000+ portion-annotated images

- **Augmented Data**: Synthetic variations for improved robustness



### Dataset Statistics

- Total Images: 150,000+

- Food Categories: 500+

- Portion Annotations: 50,000+

- Nutritional Entries: 15,000+



## 🎯 Training



### Data Preparation



```bash

# Download and prepare datasets

python scripts/prepare_data.py --download-food101 --download-usda



# Create training splits

python scripts/split_data.py --train-ratio 0.8 --val-ratio 0.1

```



### Model Training



```bash

# Train food detection model

python train_detection.py --epochs 100 --batch-size 32 --gpu



# Train portion estimation model

python train_portion.py --epochs 50 --learning-rate 0.001



# Fine-tune combined model

python train_combined.py --pretrained-detection models/detection.h5

```



### Training Configuration



Key hyperparameters:

- Learning Rate: 0.001 (with cosine annealing)

- Batch Size: 32

- Optimizer: AdamW

- Loss Function: Combined IoU + Classification + Regression

- Augmentation: Random rotation, scaling, color jitter



## 📚 API Reference



### CalorieDetector Class



#### Methods



**`__init__(model_path, confidence_threshold=0.5)`**

- Initialize the detector with a pre-trained model

- `model_path`: Path to the trained model file

- `confidence_threshold`: Minimum confidence for detections



**`predict(image_path, return_image=False)`**

- Analyze an image for food items and calories

- Returns: Dictionary with detection results



**`predict_batch(image_paths, batch_size=8)`**

- Process multiple images efficiently

- Returns: List of result dictionaries



### API Endpoints



#### POST `/analyze`

Analyze a food image for calorie content.



**Request:**

- Method: POST

- Content-Type: multipart/form-data

- Body: Image file



**Response:**

```json

{

  "total_calories": 450,

  "detected_foods": [

    {

      "name": "pizza",

      "confidence": 0.95,

      "calories": 285,

      "portion_size": "1 slice",

      "nutrients": {

        "protein": 12.2,

        "carbs": 36.0,

        "fat": 10.4

      },

      "bounding_box": [100, 150, 300, 400]

    }

  ],

  "processing_time": 1.2

}

```



## 🔧 Configuration



Configuration options can be set in `config.yaml`:



```yaml

model:

  detection_model: "models/yolo_food.pt"

  portion_model: "models/portion_estimator.h5"

  confidence_threshold: 0.5

  

processing:

  max_image_size: 1024

  batch_size: 8

  gpu_memory_limit: 4096

  

database:

  nutrition_db: "data/usda_nutrition.db"

  custom_foods: "data/custom_foods.json"

```



## 🧪 Testing



Run the test suite:

```bash

# Unit tests

pytest tests/unit/



# Integration tests

pytest tests/integration/



# Performance tests

pytest tests/performance/



# All tests

pytest

```



### Model Evaluation



```bash

# Evaluate on test set

python evaluate.py --test-data data/test/ --model models/best_model.h5



# Generate performance report

python scripts/generate_report.py --results evaluation_results.json

```



## 📈 Performance



### Accuracy Metrics

- **Food Classification**: 94.2% top-1 accuracy

- **Calorie Estimation**: 87% within ±20% of actual values

- **Processing Speed**: 0.8 seconds per image (GPU)

- **Model Size**: 45MB (optimized for mobile)



### Benchmark Results

| Food Category | Accuracy | Avg Error |

|---------------|----------|-----------|

| Fruits        | 96.1%    | ±12%      |

| Vegetables    | 93.8%    | ±15%      |

| Fast Food     | 91.2%    | ±18%      |

| Desserts      | 89.5%    | ±22%      |



## 🤝 Contributing



We welcome contributions from the community! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details.



### Development Setup



1. Fork the repository

2. Create a feature branch: `git checkout -b feature/your-feature`

3. Install development dependencies: `pip install -r requirements-dev.txt`

4. Make your changes and add tests

5. Run tests: `pytest`

6. Submit a pull request



### Code Style



We use:

- **Black** for code formatting

- **isort** for import sorting

- **flake8** for linting

- **mypy** for type checking



Run quality checks:

```bash

pre-commit run --all-files

```



## 🐛 Issues and Support



- 📋 [Issue Tracker](https://github.com/IsmailTekin05/CalorieDetectingAI/issues)

- 💬 [Discussions](https://github.com/IsmailTekin05/CalorieDetectingAI/discussions)

- 📧 Contact: [your.email@example.com](mailto:your.email@example.com)



## 📄 License



This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.



## 🙏 Acknowledgments



- **Food-101 Dataset** by ETH Zurich for the comprehensive food image dataset

- **USDA** for providing nutritional database

- **TensorFlow/Keras** for the deep learning framework

- **OpenCV** for computer vision utilities

- **FastAPI** for the REST API framework



## 📚 Citation



If you use this project in your research, please cite:



```bibtex

@misc{calorie_detecting_ai,

  author = {Ismail Tekin},

  title = {CalorieDetectingAI: AI-Powered Calorie Detection from Food Images},

  year = {2024},

  publisher = {GitHub},

  howpublished = {\url{https://github.com/IsmailTekin05/CalorieDetectingAI}}

}

```



---





  
Made with ❤️ by Ismail Tekin


  
⭐ Star this project if you found it helpful!