model

.gitignore

@@ -0,0 +1,10 @@
+# Training data
+data
+# Results (this is where the model stats are saved)
+results
+# Model weights
+model_weights.pth
+# Python metadata
+venv
+__pycache__
+symmetric_test.egg-info

README.md

@@ -1,3 +1,30 @@
 ---
+tags:
+- image-classification
+- mnist
+- pytorch
 license: mit
 ---
+
+# MNIST Digit Classifier
+
+A convolutional neural network trained on MNIST to classify digits 0-9.
+
+## Usage
+
+```python
+from src.model import DigitClassifier
+import torch
+
+model = DigitClassifier()
+model.load_state_dict(torch.load("model_weights.pth"))
+model.eval()
+
+# Preprocessing (same as training):
+transform = transforms.Compose([
+    transforms.Resize((28, 28)),
+    transforms.Grayscale(),
+    transforms.ToTensor(),
+    transforms.Normalize((0.1307,), (0.3081,))
+])
+```

pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "symmetric_test"
+version = "0.1.0"
+description = "Classifies images of numbers from 0-9"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "SupremoUGH" }
+]
+license = { text = "MIT License" }
+dependencies = []  # Add dependencies here if needed
+
+[project.urls]
+Homepage = "https://huggingface.co/SupremoUGH/symmetric_test"
+
+[tool.setuptools.packages.find]
+include = ["symmetric_test"]  # Ensure it finds the correct package

requirements.txt

@@ -0,0 +1,3 @@
+torch>=2.0.1
+torchvision>=0.15.2
+huggingface_hub>=0.16.4

scripts/evaluate.py

@@ -0,0 +1,9 @@
+from symmetric_test.evaluate import evaluate_model, upload_results
+
+if __name__ == "__main__":
+    # Evaluate
+    metrics = evaluate_model()
+    print(f"Test Accuracy: {metrics['accuracy']:.2%}")
+    
+    # Upload results to Hub
+    upload_results()

scripts/train.py

@@ -0,0 +1,4 @@
+from symmetric_test.train import train
+
+if __name__ == "__main__":
+    train()

symmetric_test/evaluate.py

@@ -0,0 +1,80 @@
+import torch
+import numpy as np
+from torchvision import datasets, transforms
+from sklearn.metrics import classification_report, confusion_matrix
+import matplotlib.pyplot as plt
+import json
+from pathlib import Path
+from huggingface_hub import HfApi
+from .model import DigitClassifier
+
+def evaluate_model(model_path="model_weights.pth", output_dir="results"):
+    # Setup
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    Path(output_dir).mkdir(exist_ok=True)
+    
+    # Load model
+    model = DigitClassifier()
+    model.load_state_dict(torch.load(model_path))
+    model.to(device)
+    model.eval()
+    
+    # Data (MNIST Test Set)
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.1307,), (0.3081,))
+    ])
+    test_set = datasets.MNIST(
+        root='./data', 
+        train=False,
+        download=True, 
+        transform=transform
+    )
+    test_loader = torch.utils.data.DataLoader(test_set, batch_size=64, shuffle=False)
+    
+    # Evaluation
+    all_preds = []
+    all_targets = []
+    
+    with torch.no_grad():
+        for images, labels in test_loader:
+            images = images.to(device)
+            outputs = model(images)
+            _, preds = torch.max(outputs, 1)
+            all_preds.extend(preds.cpu().numpy())
+            all_targets.extend(labels.cpu().numpy())
+    
+    # Metrics
+    metrics = {
+        "accuracy": np.mean(np.array(all_preds) == np.array(all_targets)),
+        "classification_report": classification_report(all_targets, all_preds, output_dict=True),
+        "confusion_matrix": confusion_matrix(all_targets, all_preds).tolist()
+    }
+    
+    # Save metrics
+    with open(Path(output_dir)/"metrics.json", "w") as f:
+        json.dump(metrics, f, indent=2)
+    
+    # Plot confusion matrix
+    plt.figure(figsize=(10, 8))
+    plt.imshow(metrics["confusion_matrix"], cmap='Blues')
+    plt.colorbar()
+    plt.title("Confusion Matrix")
+    plt.xlabel("Predicted")
+    plt.ylabel("True")
+    plt.xticks(range(10))
+    plt.yticks(range(10))
+    plt.savefig(Path(output_dir)/"confusion_matrix.png")
+    plt.close()
+    
+    return metrics
+
+def upload_results(repo_id="SupremoUGH/symmetric_test"):
+    api = HfApi()
+    api.upload_folder(
+        folder_path="results",
+        path_in_repo="evaluation",
+        repo_id=repo_id,
+        repo_type="model"
+    )
+

symmetric_test/model.py

@@ -0,0 +1,23 @@
+import torch.nn as nn
+
+class DigitClassifier(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv_block = nn.Sequential(
+            nn.Conv2d(1, 32, 3),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(64*5*5, 128),
+            nn.ReLU(),
+            nn.Linear(128, 10)
+        )
+    
+    def forward(self, x):
+        x = self.conv_block(x)
+        x = x.view(x.size(0), -1)
+        return self.classifier(x)

symmetric_test/train.py

@@ -0,0 +1,52 @@
+import torch
+import torch.nn as nn
+from torch import optim
+from torchvision import datasets, transforms
+from huggingface_hub import HfApi, Repository
+from .model import DigitClassifier
+
+# Config (better to put in separate config.yaml)
+BATCH_SIZE = 64
+EPOCHS = 5
+LR = 0.001
+
+def train():
+    # Initialize
+    model = DigitClassifier()
+    optimizer = optim.Adam(model.parameters(), lr=LR)
+    criterion = nn.CrossEntropyLoss()
+    
+    # Data
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.1307,), (0.3081,))
+    ])
+    
+    train_loader = torch.utils.data.DataLoader(
+        datasets.MNIST('./data', train=True, download=True, transform=transform),
+        batch_size=BATCH_SIZE,
+        shuffle=True
+    )
+    
+    # Training loop
+    for epoch in range(EPOCHS):
+        model.train()
+        for batch_idx, (data, target) in enumerate(train_loader):
+            optimizer.zero_grad()
+            output = model(data)
+            loss = criterion(output, target)
+            loss.backward()
+            optimizer.step()
+    
+    # Save artifacts
+    torch.save(model.state_dict(), "model_weights.pth")
+    
+    # Upload to Hub
+api = HfApi()
+api.upload_file(
+    path_or_fileobj="model_weights.pth",
+    path_in_repo="model_weights.pth",
+    repo_id="SupremoUGH/symmetric_test",
+    repo_type="model",
+    token=True  # Explicitly use your credentials
+)