---
language: en
license: mit
tags:
- image-classification
- pytorch
- garbage-classification
- waste-management
- environmental
datasets:
- garbage-classification-dataset
metrics:
- accuracy
- cross-entropy-loss
library_name: pytorch
pipeline_tag: image-classification
---

# Garbage Classification Model (LargeNet)

## Model Description

This is a PyTorch-based convolutional neural network trained to classify images of garbage into 7 categories:
- **Battery**: Used batteries and battery waste
- **Biological**: Organic and biodegradable waste
- **Cardboard**: Cardboard boxes and packaging
- **Glass**: Glass bottles, jars, and containers
- **Metal**: Metal cans, foil, and containers
- **Paper**: Paper waste, documents, and newspaper
- **Plastic**: Plastic bottles, bags, and containers

The model uses a custom CNN architecture called "LargeNet" that processes 128x128 RGB images.

## Model Architecture

```
LargeNet(
  (conv1): Conv2d(3, 5, kernel_size=5)
  (pool): MaxPool2d(kernel_size=2, stride=2)
  (conv2): Conv2d(5, 10, kernel_size=5)
  (fc1): Linear(in_features=8410, out_features=32)
  (fc2): Linear(in_features=32, out_features=7)
)
```

**Architecture Details:**
- Input: 128x128 RGB images
- 2 Convolutional layers with ReLU activation
- MaxPooling after each convolution
- 2 Fully connected layers
- Output: 7 classes with softmax probabilities

## Training Details

**Training Hyperparameters:**
- Batch size: 64
- Learning rate: 0.01
- Optimizer: SGD
- Loss function: CrossEntropyLoss
- Best epoch: 61
- Training dataset: Garbage Classification Dataset (2100 images)

**Data Preprocessing:**
- Images resized to 128x128 pixels
- Normalized with mean=[0.5, 0.5, 0.5] and std=[0.5, 0.5, 0.5]
- Data split: 72% train, 18% validation, 10% test

## Usage

### Quick Start

```python
from inference import GarbageClassifier

# Initialize the classifier
classifier = GarbageClassifier(".")

# Classify an image
result = classifier.predict("path/to/garbage_image.jpg")

print(f"Predicted class: {result['class']}")
print(f"Confidence: {result['confidence']:.2%}")
print(f"All probabilities: {result['all_probabilities']}")
```

### Manual Usage

```python
import torch
from PIL import Image
from torchvision import transforms
from model import load_model

# Load model
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = load_model("pytorch_model.bin", device)

# Prepare image
transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])

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

# Predict
with torch.no_grad():
    outputs = model(image_tensor)
    probabilities = torch.nn.functional.softmax(outputs, dim=1)
    _, predicted = torch.max(probabilities, 1)

class_names = ["battery", "biological", "cardboard", "glass", "metal", "paper", "plastic"]
print(f"Predicted class: {class_names[predicted.item()]}")
```

## Model Performance

The model achieved competitive performance on the garbage classification task. For detailed metrics and performance analysis, please refer to the training logs and evaluation results.

## Limitations and Bias

- The model is trained on a specific garbage dataset and may not generalize well to all types of waste
- Performance may vary with different lighting conditions, image quality, and garbage appearances
- The dataset may have regional or cultural biases in garbage representation
- Works best with clear, well-lit images of individual garbage items

## Intended Use

This model is intended for:
- Educational purposes in waste management and environmental studies
- Prototype development for waste sorting applications
- Research in automated recycling systems
- Environmental awareness applications

**Not recommended for:**
- Production waste sorting systems without additional validation
- Critical infrastructure without human oversight
- Scenarios requiring 100% accuracy

## Citation

If you use this model, please cite:
```
@misc{garbage-classifier-largenet,
  author = {Your Name},
  title = {Garbage Classification Model},
  year = {2026},
  publisher = {HuggingFace},
  url = {https://huggingface.co/your-username/garbage-classifier-largenet}
}
```

## License

MIT License

## Contact

For questions or feedback, please open an issue on the model repository.