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.

thomasdeboer/garbage_classifier_A1

Garbage Classification Model (LargeNet)

Model Description

Model Architecture