Upload folder using huggingface_hub

README.md

@@ -1,3 +1,161 @@
 ---
-license: cc-by-4.0
+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.

config.json

@@ -0,0 +1,37 @@
+{
+  "architecture": "LargeNet",
+  "num_classes": 7,
+  "input_size": [
+    128,
+    128
+  ],
+  "input_channels": 3,
+  "class_names": [
+    "battery",
+    "biological",
+    "cardboard",
+    "glass",
+    "metal",
+    "paper",
+    "plastic"
+  ],
+  "normalization": {
+    "mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "std": [
+      0.5,
+      0.5,
+      0.5
+    ]
+  },
+  "training_params": {
+    "batch_size": 64,
+    "learning_rate": 0.01,
+    "best_epoch": 61,
+    "optimizer": "SGD",
+    "loss_function": "CrossEntropyLoss"
+  }
+}

inference.py

@@ -0,0 +1,74 @@
+import torch
+from PIL import Image
+from torchvision import transforms
+from model import load_model
+import json
+import os
+
+class GarbageClassifier:
+    def __init__(self, model_dir="."):
+        """Initialize the garbage classifier"""
+        # Load config
+        with open(os.path.join(model_dir, "config.json"), "r") as f:
+            self.config = json.load(f)
+
+        # Setup device
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        # Load model
+        model_path = os.path.join(model_dir, "pytorch_model.bin")
+        self.model = load_model(model_path, self.device)
+
+        # Setup transforms
+        mean = self.config["normalization"]["mean"]
+        std = self.config["normalization"]["std"]
+        size = tuple(self.config["input_size"])
+
+        self.transform = transforms.Compose([
+            transforms.Resize(size),
+            transforms.ToTensor(),
+            transforms.Normalize(mean, std)
+        ])
+
+        self.class_names = self.config["class_names"]
+
+    def predict(self, image_path):
+        """
+        Predict the class of a garbage image
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            dict: Contains 'class', 'confidence', and 'all_probabilities'
+        """
+        # Load and preprocess image
+        image = Image.open(image_path).convert('RGB')
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+
+        # Make prediction
+        with torch.no_grad():
+            outputs = self.model(image_tensor)
+            probabilities = torch.nn.functional.softmax(outputs, dim=1)
+            confidence, predicted = torch.max(probabilities, 1)
+
+        # Format results
+        predicted_class = self.class_names[predicted.item()]
+        confidence_score = confidence.item()
+        all_probs = {
+            self.class_names[i]: probabilities[0][i].item() 
+            for i in range(len(self.class_names))
+        }
+
+        return {
+            "class": predicted_class,
+            "confidence": confidence_score,
+            "all_probabilities": all_probs
+        }
+
+# Example usage:
+if __name__ == "__main__":
+    classifier = GarbageClassifier(".")
+    result = classifier.predict("path/to/image.jpg")
+    print(f"Predicted class: {result['class']}")
+    print(f"Confidence: {result['confidence']:.2%}")

model.py

@@ -0,0 +1,31 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class LargeNet(nn.Module):
+    def __init__(self):
+        super(LargeNet, self).__init__()
+        self.name = "large"
+        self.conv1 = nn.Conv2d(3, 5, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(5, 10, 5)
+        self.fc1 = nn.Linear(10 * 29 * 29, 32)
+        self.fc2 = nn.Linear(32, 7)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = x.view(-1, 10 * 29 * 29)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        x = x.squeeze(1)  # Flatten to [batch_size]
+        return x
+
+def load_model(model_path, device='cpu'):
+    """Load the trained model from saved weights"""
+    model = LargeNet()
+    state_dict = torch.load(model_path, map_location=device)
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+    return model

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3500f580debe699b96badecdad7705fb4a9118e8db109fdd87535a8d1b768c0
+size 1087304

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+numpy>=1.21.0