# 🍎 AI Fruit Identification System

A modern web application that uses deep learning to identify fruits from uploaded images. Built with Flask, PyTorch, and a beautiful responsive UI.

![Python](https://img.shields.io/badge/Python-3.8+-blue.svg)
![Flask](https://img.shields.io/badge/Flask-2.0+-green.svg)
![PyTorch](https://img.shields.io/badge/PyTorch-1.9+-red.svg)
![License](https://img.shields.io/badge/License-MIT-yellow.svg)

## 🌟 Features

- **🚀 Real-time Fruit Recognition** - Upload images and get instant AI-powered fruit identification
- **📱 Modern Responsive UI** - Beautiful interface that works on desktop, tablet, and mobile
- **🎯 High Accuracy** - Deep learning model trained on fruit image datasets
- **⚡ Fast Processing** - Optimized inference for quick results
- **🖱️ Drag & Drop Upload** - Intuitive file upload with drag-and-drop support
- **📊 Confidence Scoring** - Shows prediction confidence levels
- **🔄 Easy to Use** - Simple, clean interface for effortless fruit identification

## 🖥️ Demo

![App Screenshot](static/demo/app_screenshot.png)

### Live Features:
- Upload fruit images via click or drag-and-drop
- Real-time image preview
- AI-powered fruit classification
- Modern glassmorphism design
- Mobile-responsive interface

## 🛠️ Technology Stack

- **Backend**: Flask (Python Web Framework)
- **Deep Learning**: PyTorch, torchvision
- **Model Architecture**: ResNet-18 (Transfer Learning)
- **Frontend**: HTML5, CSS3, JavaScript
- **Image Processing**: PIL (Python Imaging Library)
- **Styling**: Modern CSS with glassmorphism effects

## 📋 Prerequisites

Before running this application, make sure you have:

- Python 3.8 or higher
- pip (Python package installer)
- At least 4GB RAM for model loading
- Modern web browser (Chrome, Firefox, Safari, Edge)

## ⚡ Quick Start

### 1. Clone the Repository
```bash
git clone https://github.com/yourusername/ai-fruit-identification.git
cd ai-fruit-identification
```

### 2. Create Virtual Environment
```bash
# Windows
python -m venv venv
venv\Scripts\activate

# macOS/Linux
python3 -m venv venv
source venv/bin/activate
```

### 3. Install Dependencies
```bash
pip install -r requirements.txt
```

### 4. Download Pre-trained Model
```bash
# If you have a pre-trained model, place it in the root directory
# Otherwise, run the training script (see Training section)
```

### 5. Run the Application
```bash
python app.py
```

### 6. Open Your Browser
Navigate to `http://localhost:5000`

## 📁 Project Structure

```
ai-fruit-identification/
│
├── app.py                 # Flask web application
├── predict.py            # Prediction logic and model loading
├── train.py              # Model training script
├── model.py              # CNN model architecture
├── requirements.txt      # Python dependencies
├── class_names.json      # Fruit class labels
├── plant_model.pth       # Trained model weights
│
├── templates/
│   ├── index.html        # Upload page template
│   └── result.html       # Results page template
│
├── static/
│   ├── css/
│   │   └── style.css     # Styling and animations
│   ├── uploads/          # Uploaded images storage
│   └── demo/             # Demo images and screenshots
│
└── README.md             # Project documentation
```

## 🎯 Model Architecture

The system uses a **ResNet-18** architecture with transfer learning:

- **Base Model**: Pre-trained ResNet-18 on ImageNet
- **Custom Classifier**: Fully connected layer for fruit classification
- **Input Size**: 224x224 RGB images
- **Normalization**: Mean=[0.5, 0.5, 0.5], Std=[0.5, 0.5, 0.5]
- **Training Strategy**: Freeze base layers, train only the classifier

## 🏋️ Training Your Own Model

### 1. Prepare Dataset
Organize your fruit dataset in the following structure:
```
dataset/
├── Train_Set_Folder/
│   ├── apple/
│   ├── banana/
│   ├── orange/
│   └── ...
└── Validation_Set_Folder/
    ├── apple/
    ├── banana/
    ├── orange/
    └── ...
```

### 2. Update Dataset Path
Edit the `dataset_dir` path in `train.py`:
```python
dataset_dir = 'path/to/your/dataset'
```

### 3. Start Training
```bash
python train.py
```

### 4. Monitor Training
The script will show:
- Training progress with progress bars
- Loss values per epoch
- Model saving confirmation

## 🔧 Configuration

### Environment Variables
Create a `.env` file for configuration:
```env
FLASK_ENV=development
UPLOAD_FOLDER=static/uploads
MAX_CONTENT_LENGTH=16777216  # 16MB max file size
```

### Model Parameters
Adjust in `train.py`:
```python
num_epochs = 10        # Training epochs
batch_size = 32        # Batch size
learning_rate = 0.001  # Learning rate
```

## 📱 API Usage

### Upload and Predict Endpoint
```python
POST /predict
Content-Type: multipart/form-data

Parameters:
- file: Image file (jpg, png, webp)

Response:
- Redirects to results page with prediction
```

### Programmatic Usage
```python
from predict import predict_fruit

# Predict fruit from image path
result = predict_fruit('path/to/fruit/image.jpg')
print(f"Predicted fruit: {result}")
```

## 🎨 UI Customization

### Color Scheme
Edit CSS variables in `style.css`:
```css
:root {
    --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    --accent-color: #4ecdc4;
    --text-color: #333;
}
```

### Responsive Breakpoints
```css
@media (max-width: 768px) { /* Tablet */ }
@media (max-width: 480px) { /* Mobile */ }
```

## 🚀 Deployment

### Local Development
```bash
python app.py
# App runs on http://localhost:5000
```

### Production Deployment

#### Using Gunicorn
```bash
pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:8000 app:app
```

#### Using Docker
```dockerfile
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]
```

#### Deploy to Heroku
```bash
# Install Heroku CLI
heroku create your-app-name
git push heroku main
```

## 🧪 Testing

### Test Predictions
```bash
python predict.py
```

### Test Web Interface
1. Start the application
2. Navigate to `http://localhost:5000`
3. Upload test fruit images
4. Verify predictions and UI responsiveness

## 📊 Performance Metrics

Current model performance:
- **Accuracy**: ~85-90% on validation set
- **Inference Time**: <500ms per image
- **Model Size**: ~45MB
- **Supported Formats**: JPG, PNG, WebP

## 🔍 Troubleshooting

### Common Issues

**Model Loading Error**
```bash
# Ensure model file exists
ls plant_model.pth class_names.json
```

**Import Errors**
```bash
# Reinstall dependencies
pip install -r requirements.txt --force-reinstall
```

**Memory Issues**
```bash
# Reduce batch size in train.py
batch_size = 16  # Instead of 32
```

**File Upload Issues**
```bash
# Check upload folder permissions
mkdir -p static/uploads
chmod 755 static/uploads
```

## 🤝 Contributing

We welcome contributions! Here's how to get started:

1. **Fork the Repository**
2. **Create Feature Branch**
   ```bash
   git checkout -b feature/amazing-feature
   ```
3. **Make Changes**
4. **Commit Changes**
   ```bash
   git commit -m "Add amazing feature"
   ```
5. **Push to Branch**
   ```bash
   git push origin feature/amazing-feature
   ```
6. **Open Pull Request**

### Development Guidelines
- Follow PEP 8 for Python code
- Add comments for complex logic
- Update documentation for new features
- Test thoroughly before submitting

## 📝 Requirements

```txt
Flask==2.3.3
torch==2.0.1
torchvision==0.15.2
Pillow==10.0.0
Werkzeug==2.3.7
tqdm==4.66.1
```

## 📄 License

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

```
MIT License

Copyright (c) 2024 AI Fruit Identification

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
```

## 👥 Authors

- **Your Name** - *Initial work* - [YourGitHub](https://github.com/yourusername)

## 🙏 Acknowledgments

- PyTorch team for the excellent deep learning framework
- Flask community for the lightweight web framework
- ResNet authors for the groundbreaking architecture
- All contributors who helped improve this project

## 📞 Support

- 📧 Email: [email protected]
- 🐛 Issues: [GitHub Issues](https://github.com/yourusername/ai-fruit-identification/issues)
- 💬 Discussions: [GitHub Discussions](https://github.com/yourusername/ai-fruit-identification/discussions)

## 🚀 Future Enhancements

- [ ] Add more fruit categories
- [ ] Implement confidence thresholds
- [ ] Add batch prediction support
- [ ] Create mobile app version
- [ ] Add nutritional information display
- [ ] Implement user feedback system
- [ ] Add multi-language support
- [ ] Create REST API documentation

---

⭐ **Star this repository if you found it helpful!** ⭐