---
license: mit
tags:
- image-classification
- food-recognition
- raw-food
- multilabel-classification
- pytorch
- resnet
- se-resnet
- computer-vision
- model-comparison
datasets:
- ibrahimdaud/raw-food-recognition
- ibrahimdaud/multi-label-food-recognition
metrics:
- accuracy
- mean-average-precision
- f1-score
---

# Raw Food Recognition Models: Single-Class and Multi-Label

This repository contains both single-class and multi-label classification models trained for raw food ingredient recognition.

## Single-Class Classification Models


| Model        | Parameters | Validation Accuracy | Architecture                |
| ------------ | ---------- | ------------------- | --------------------------- |
| ResNet-50    | ~25.6M    | 97.84%              | Standard residual network   |
| SE-ResNet-50 | ~26.0M    | 95.72%              | ResNet-50 with SE attention |


Both models were trained on the [ibrahimdaud/raw-food-recognition](https://huggingface.co/datasets/ibrahimdaud/raw-food-recognition) dataset, which contains 90+ raw food categories.


## Multi-Label Classification Models

| Model | Training Mode | Parameters | Best mAP | Architecture |
|-------|--------------|------------|----------|--------------|
| Multi-Label ResNet-50 | Freeze Encoder | ~24,656,463 | 0.3747 | ResNet-50 encoder (frozen) + classifier |


Multi-label models were trained on the [ibrahimdaud/multi-label-food-recognition](https://huggingface.co/datasets/ibrahimdaud/multi-label-food-recognition) dataset for recognizing multiple ingredients in a single image.

## Usage

### Download Single-Class Models

```python
from huggingface_hub import hf_hub_download
import torch
from models.resnet50 import create_resnet50
from models.se_resnet50 import create_se_resnet50

# Download ResNet-50 checkpoint
resnet_path = hf_hub_download(
    repo_id="ibrahimdaud/raw-food-recognition-models",
    filename="resnet50_pytorch_model.bin"
)
resnet_checkpoint = torch.load(resnet_path, map_location='cpu')

# Download SE-ResNet-50 checkpoint
se_resnet_path = hf_hub_download(
    repo_id="ibrahimdaud/raw-food-recognition-models",
    filename="se_resnet50_pytorch_model.bin"
)
se_resnet_checkpoint = torch.load(se_resnet_path, map_location='cpu')
```

### Load Single-Class Models

```python
# Create ResNet-50 model
resnet_model = create_resnet50(
    num_classes=90,
    pretrained=False
)
resnet_model.load_state_dict(resnet_checkpoint['model_state_dict'])
resnet_model.eval()

# Create SE-ResNet-50 model
se_resnet_model = create_se_resnet50(
    num_classes=90,
    pretrained=False,
    reduction=16
)
se_resnet_model.load_state_dict(se_resnet_checkpoint['model_state_dict'])
se_resnet_model.eval()
```

### Download Multi-Label Models

```python
from huggingface_hub import hf_hub_download
import torch
from models.multilabel_resnet50 import create_multilabel_resnet50

# Download Freeze Encoder model
freeze_path = hf_hub_download(
    repo_id="ibrahimdaud/raw-food-recognition-models",
    filename="multilabel_freeze_pytorch_model.bin"
)
freeze_checkpoint = torch.load(freeze_path, map_location='cpu')

# Download Full Training model
full_path = hf_hub_download(
    repo_id="ibrahimdaud/raw-food-recognition-models",
    filename="multilabel_full_pytorch_model.bin"
)
full_checkpoint = torch.load(full_path, map_location='cpu')

# Download Fine-Tuning model
finetune_path = hf_hub_download(
    repo_id="ibrahimdaud/raw-food-recognition-models",
    filename="multilabel_finetune_pytorch_model.bin"
)
finetune_checkpoint = torch.load(finetune_path, map_location='cpu')
```


### Load Multi-Label Models

```python
# Load Freeze Encoder model
freeze_model = create_multilabel_resnet50(
    num_classes=freeze_checkpoint['num_classes'],
    pretrained=False
)
freeze_model.load_state_dict(freeze_checkpoint['model_state_dict'])
freeze_model.eval()

# Load Full Training model
full_model = create_multilabel_resnet50(
    num_classes=full_checkpoint['num_classes'],
    pretrained=False
)
full_model.load_state_dict(full_checkpoint['model_state_dict'])
full_model.eval()

# Load Fine-Tuning model
finetune_model = create_multilabel_resnet50(
    num_classes=finetune_checkpoint['num_classes'],
    pretrained=False
)
finetune_model.load_state_dict(finetune_checkpoint['model_state_dict'])
finetune_model.eval()
```

### Multi-Label Inference

```python
import torch
from PIL import Image
import torchvision.transforms as transforms

# Preprocess image
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                        std=[0.229, 0.224, 0.225])
])

image = Image.open('path/to/image.jpg').convert('RGB')
image_tensor = transform(image).unsqueeze(0)

# Get multi-label predictions
with torch.no_grad():
    logits = freeze_model(image_tensor)  # or full_model, finetune_model
    probs = torch.sigmoid(logits)  # Multi-label probabilities
    
    # Get top-k predictions
    top_k = 5
    top_probs, top_indices = torch.topk(probs[0], top_k)
    
    # Assuming you have class names
    for prob, idx in zip(top_probs, top_indices):
        print(f"Class {{idx.item()}}: {{prob.item():.4f}}")
```


### Compare Single-Class Predictions

```python
import torch
from PIL import Image
import torchvision.transforms as transforms

# Preprocess image
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                        std=[0.229, 0.224, 0.225])
])

image = Image.open('path/to/image.jpg').convert('RGB')
image_tensor = transform(image).unsqueeze(0)

# ResNet-50 prediction
with torch.no_grad():
    resnet_outputs = resnet_model(image_tensor)
    resnet_probs = torch.nn.functional.softmax(resnet_outputs[0], dim=0)
    resnet_pred_id = torch.argmax(resnet_probs).item()
    resnet_pred_class = resnet_checkpoint['class_names'][resnet_pred_id]
    resnet_confidence = resnet_probs[resnet_pred_id].item()

# SE-ResNet-50 prediction
with torch.no_grad():
    se_resnet_outputs = se_resnet_model(image_tensor)
    se_resnet_probs = torch.nn.functional.softmax(se_resnet_outputs[0], dim=0)
    se_resnet_pred_id = torch.argmax(se_resnet_probs).item()
    se_resnet_pred_class = se_resnet_checkpoint['class_names'][se_resnet_pred_id]
    se_resnet_confidence = se_resnet_probs[se_resnet_pred_id].item()

# Compare results
print("ResNet-50 Prediction:")
print(f"  Class: {resnet_pred_class}")
print(f"  Confidence: {resnet_confidence*100:.2f}%")

print("\nSE-ResNet-50 Prediction:")
print(f"  Class: {se_resnet_pred_class}")
print(f"  Confidence: {se_resnet_confidence*100:.2f}%")
```

## Model Details

### Single-Class Models

#### ResNet-50
- **Architecture**: Standard residual network with bottleneck blocks
- **Parameters**: ~25.6M
- **Pretrained**: ImageNet weights
- **Best Validation Accuracy**: 97.84%

#### SE-ResNet-50
- **Architecture**: ResNet-50 with Squeeze-and-Excitation attention blocks
- **Parameters**: ~26.0M
- **Pretrained**: ImageNet weights (excluding SE blocks)
- **SE Reduction Ratio**: 16
- **Best Validation Accuracy**: 95.72%

### Multi-Label Models

#### Freeze Encoder Mode
- **Training Strategy**: Encoder frozen, only classifier trained
- **Use Case**: Fast training, preserves encoder features
- **Best for**: When you have limited data or want quick results

#### Full Training Mode
- **Training Strategy**: Both encoder and classifier trained from scratch
- **Use Case**: Maximum flexibility, learns task-specific features
- **Best for**: When you have sufficient data and compute

#### Fine-Tuning Mode
- **Training Strategy**: Encoder trained with lower learning rate, classifier with higher rate
- **Use Case**: Balanced approach, preserves some encoder knowledge while adapting
- **Best for**: General-purpose multi-label classification

## Training Details

### Single-Class Models
- **Dataset**: ibrahimdaud/raw-food-recognition
- **Number of Classes**: 90
- **Image Size**: 224x224
- **Optimizer**: Adam
- **Learning Rate**: 0.001
- **Batch Size**: 32

### Multi-Label Models
- **Dataset**: ibrahimdaud/multi-label-food-recognition
- **Image Size**: 224x224
- **Optimizer**: Adam
- **Loss Function**: BCEWithLogitsLoss
- **Evaluation Metrics**: Mean Average Precision (mAP), F1-Score, Hamming Loss

## Files in Repository

### Single-Class Models
- `resnet50_pytorch_model.bin` - ResNet-50 model weights
- `se_resnet50_pytorch_model.bin` - SE-ResNet-50 model weights
- `resnet50_metadata.json` - ResNet-50 metadata
- `se_resnet50_metadata.json` - SE-ResNet-50 metadata

### Multi-Label Models
- `multilabel_freeze_pytorch_model.bin` - Multi-label ResNet-50 (Freeze Encoder)
- `multilabel_freeze_metadata.json` - Freeze Encoder metadata

- `README.md` - This file

## Citation

If you use these models, please cite:

```bibtex
@model{raw_food_recognition_models_2024,
  title={Raw Food Recognition Models: Single-Class and Multi-Label Classification},
  author={Ibrahim Daud},
  year={2024},
  publisher={HuggingFace},
  url={https://huggingface.co/ibrahimdaud/raw-food-recognition-models}
}
```

## License

MIT License