cifar10-tools 0.1.0__tar.gz

cifar10_tools-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 George Perdrizet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cifar10_tools-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: cifar10_tools
+Version: 0.1.0
+Summary: Tools for training neural networks on the CIFAR-10 task with PyTorch and TensorFlow
+License: GPLv3
+License-File: LICENSE
+Keywords: Python,Machine learning,Deep learning,CNNs,Computer vision,Image classification,CIFAR-10
+Author: gperdrizet
+Author-email: george@perdrizet.org
+Requires-Python: >=3.10,<3.13
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Provides-Extra: tensorflow
+Requires-Dist: numpy (>=1.24)
+Requires-Dist: torch (>=2.0)
+Requires-Dist: torchvision (>=0.15)
+Project-URL: Documentation, https://gperdrizet.github.io/CIFAR10/README.md
+Project-URL: Homepage, https://github.com/gperdrizet/CIFAR10
+Project-URL: Issues, https://github.com/gperdrizet/CIFAR10/issues
+Project-URL: PyPI, https://pypi.org/project/cifar10_tools
+Project-URL: Repository, https://github.com/gperdrizet/CIFAR10
+Description-Content-Type: text/markdown
+
+# PyTorch: CIFAR10 demonstration

cifar10_tools-0.1.0/README.md

@@ -0,0 +1 @@
+# PyTorch: CIFAR10 demonstration

cifar10_tools-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["poetry-core>=1.9.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "cifar10_tools"
+version = "0.1.0"
+description = "Tools for training neural networks on the CIFAR-10 task with PyTorch and TensorFlow"
+authors = ["gperdrizet <george@perdrizet.org>"]
+readme = "README.md"
+license = "GPLv3"
+packages = [{include = "cifar10_tools", from = "src"}]
+exclude = ["notebooks", "models", "logs"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+keywords = ["Python", "Machine learning", "Deep learning", "CNNs", "Computer vision", "Image classification", "CIFAR-10"]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+torch = ">=2.0"
+torchvision = ">=0.15"
+numpy = ">=1.24"
+
+[tool.poetry.extras]
+tensorflow = ["tensorflow"]
+
+[tool.poetry.urls]
+Homepage = "https://github.com/gperdrizet/CIFAR10"
+Documentation = "https://gperdrizet.github.io/CIFAR10/README.md"
+Repository = "https://github.com/gperdrizet/CIFAR10"
+Issues = "https://github.com/gperdrizet/CIFAR10/issues"
+PyPI = "https://pypi.org/project/cifar10_tools"

cifar10_tools-0.1.0/src/cifar10_tools/pytorch/data.py

@@ -0,0 +1,27 @@
+'''Data download function for CIFAR-10 dataset. Use to pre-download data
+during devcontainer creation'''
+
+from pathlib import Path
+from torchvision import datasets
+
+def download_cifar10_data(data_dir: str='data/pytorch/CIFAR10'):
+    '''Download CIFAR-10 dataset using torchvision.datasets.'''
+
+    data_dir = Path(data_dir)
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    _ = datasets.CIFAR10(
+        root=data_dir,
+        train=True,
+        download=True
+    )
+
+    _ = datasets.CIFAR10(
+        root=data_dir,
+        train=False,
+        download=True
+    )
+
+if __name__ == '__main__':
+
+    download_cifar10_data()

cifar10_tools-0.1.0/src/cifar10_tools/pytorch/evaluation.py

@@ -0,0 +1,38 @@
+'''Evaluation functions for models.'''
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+
+def evaluate_model(
+    model: nn.Module,
+    test_loader: DataLoader
+) -> tuple[float, np.ndarray, np.ndarray]:
+    '''Evaluate model on test set.
+    
+    Note: Assumes data is already on the correct device.
+    '''
+
+    model.eval()
+    correct = 0
+    total = 0
+    all_predictions = []
+    all_labels = []
+
+    with torch.no_grad():
+
+        for images, labels in test_loader:
+
+            outputs = model(images)
+            _, predicted = torch.max(outputs.data, 1)
+
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+            all_predictions.extend(predicted.cpu().numpy())
+            all_labels.extend(labels.cpu().numpy())
+
+    accuracy = 100 * correct / total
+    return accuracy, np.array(all_predictions), np.array(all_labels)

cifar10_tools-0.1.0/src/cifar10_tools/pytorch/training.py

@@ -0,0 +1,93 @@
+'''Training functions for models.'''
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+def train_model(
+    model: nn.Module,
+    train_loader: DataLoader,
+    val_loader: DataLoader,
+    criterion: nn.Module,
+    optimizer: optim.Optimizer,
+    epochs: int = 10,
+    print_every: int = 1
+) -> dict[str, list[float]]:
+    '''Training loop for PyTorch classification model.
+    
+    Note: Assumes data is already on the correct device.
+    '''
+
+    history = {'train_loss': [], 'val_loss': [], 'train_accuracy': [], 'val_accuracy': []}
+
+    for epoch in range(epochs):
+
+        # Training phase
+        model.train()
+        running_loss = 0.0
+        correct = 0
+        total = 0
+
+        for images, labels in train_loader:
+
+            # Forward pass
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+
+            # Backward pass
+            loss.backward()
+            optimizer.step()
+
+            # Track metrics
+            running_loss += loss.item()
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+        # Calculate training metrics
+        train_loss = running_loss / len(train_loader)
+        train_accuracy = 100 * correct / total
+
+        # Validation phase
+        model.eval()
+        val_running_loss = 0.0
+        val_correct = 0
+        val_total = 0
+
+        with torch.no_grad():
+
+            for images, labels in val_loader:
+
+                outputs = model(images)
+                loss = criterion(outputs, labels)
+
+                val_running_loss += loss.item()
+                _, predicted = torch.max(outputs.data, 1)
+                val_total += labels.size(0)
+                val_correct += (predicted == labels).sum().item()
+
+        val_loss = val_running_loss / len(val_loader)
+        val_accuracy = 100 * val_correct / val_total
+
+        # Record metrics
+        history['train_loss'].append(train_loss)
+        history['val_loss'].append(val_loss)
+        history['train_accuracy'].append(train_accuracy)
+        history['val_accuracy'].append(val_accuracy)
+
+        # Print progress
+        if (epoch + 1) % print_every == 0 or epoch == 0:
+
+            print(
+                f'Epoch {epoch+1}/{epochs} - ' +
+                f'loss: {train_loss:.4f} - ' +
+                f'accuracy: {train_accuracy:.2f}% - ' +
+                f'val_loss: {val_loss:.4f} - ' +
+                f'val_accuracy: {val_accuracy:.2f}%'
+            )
+
+    print('\nTraining complete.')
+
+    return history