thomasdeboer/garbage_classifier_A1

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

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

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.