cifar10-tools 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

cifar10_tools/pytorch/data.py

@@ -1,8 +1,10 @@
-'''Data download function for CIFAR-10 dataset. Use to pre-download data
-during devcontainer creation'''
+'''Data loading and preprocessing functions for CIFAR-10 dataset.'''
 
 from pathlib import Path
-from torchvision import datasets
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
 
 def download_cifar10_data(data_dir: str='data/pytorch/cifar10'):
     '''Download CIFAR-10 dataset using torchvision.datasets.'''
@@ -22,6 +24,112 @@ def download_cifar10_data(data_dir: str='data/pytorch/cifar10'):
         download=True
     )
 
+
+def make_data_loaders(
+    data_dir: Path,
+    batch_size: int,
+    train_transform: transforms.Compose,
+    eval_transform: transforms.Compose,
+    device: torch.device | None = None,
+    download: bool = False,
+):
+    """
+    Loads CIFAR-10, applies preprocessing with separate train/eval transforms,
+    and returns DataLoaders.
+    
+    Args:
+        data_dir: Path to CIFAR-10 data directory
+        batch_size: Batch size for DataLoaders
+        train_transform: Transform to apply to training data
+        eval_transform: Transform to apply to validation and test data
+        device: Device to preload tensors onto. If None, data stays on CPU 
+                and transforms are applied on-the-fly during iteration.
+        download: Whether to download the dataset if not present
+        
+    Returns:
+        Tuple of (train_loader, val_loader, test_loader)
+    """
+
+    # Load datasets with respective transforms
+    train_dataset_full = datasets.CIFAR10(
+        root=data_dir,
+        train=True,
+        download=download,
+        transform=train_transform,
+    )
+    
+    val_test_dataset_full = datasets.CIFAR10(
+        root=data_dir,
+        train=True,
+        download=download,
+        transform=eval_transform,
+    )
+    
+    test_dataset = datasets.CIFAR10(
+        root=data_dir,
+        train=False,
+        download=download,
+        transform=eval_transform,
+    )
+
+    if device is not None:
+        # Preload entire dataset to device for faster training
+        X_train_full = torch.stack([img for img, _ in train_dataset_full]).to(device)
+        y_train_full = torch.tensor([label for _, label in train_dataset_full]).to(device)
+        
+        X_val_test_full = torch.stack([img for img, _ in val_test_dataset_full]).to(device)
+        y_val_test_full = torch.tensor([label for _, label in val_test_dataset_full]).to(device)
+
+        X_test = torch.stack([img for img, _ in test_dataset]).to(device)
+        y_test = torch.tensor([label for _, label in test_dataset]).to(device)
+
+        # Train/val split (80/20)
+        n_train = int(0.8 * len(X_train_full))
+        indices = torch.randperm(len(X_train_full))
+
+        X_train = X_train_full[indices[:n_train]]
+        y_train = y_train_full[indices[:n_train]]
+        X_val = X_val_test_full[indices[n_train:]]
+        y_val = y_val_test_full[indices[n_train:]]
+
+        # TensorDatasets
+        train_tensor_dataset = torch.utils.data.TensorDataset(X_train, y_train)
+        val_tensor_dataset = torch.utils.data.TensorDataset(X_val, y_val)
+        test_tensor_dataset = torch.utils.data.TensorDataset(X_test, y_test)
+        
+    else:
+        # Don't preload - use datasets directly for on-the-fly transforms
+        # Train/val split (80/20) using Subset
+        n_train = int(0.8 * len(train_dataset_full))
+        indices = torch.randperm(len(train_dataset_full)).tolist()
+        
+        train_indices = indices[:n_train]
+        val_indices = indices[n_train:]
+        
+        train_tensor_dataset = torch.utils.data.Subset(train_dataset_full, train_indices)
+        val_tensor_dataset = torch.utils.data.Subset(val_test_dataset_full, val_indices)
+        test_tensor_dataset = test_dataset
+
+    # DataLoaders
+    train_loader = DataLoader(
+        train_tensor_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+    )
+    val_loader = DataLoader(
+        val_tensor_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+    )
+    test_loader = DataLoader(
+        test_tensor_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+    )
+
+    return train_loader, val_loader, test_loader
+
+
 if __name__ == '__main__':
 
     download_cifar10_data()

cifar10_tools/pytorch/hyperparameter_optimization.py

@@ -12,13 +12,17 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
+from cifar10_tools.pytorch.data import make_data_loaders
+
 
 def create_cnn(
     n_conv_blocks: int,
     initial_filters: int,
-    fc_units_1: int,
-    fc_units_2: int,
-    dropout_rate: float,
+    n_fc_layers: int,
+    base_kernel_size: int,
+    conv_dropout_rate: float,
+    fc_dropout_rate: float,
+    pooling_strategy: str,
     use_batch_norm: bool,
     num_classes: int = 10,
     in_channels: int = 3,
@@ -29,9 +33,11 @@ def create_cnn(
     Args:
         n_conv_blocks: Number of convolutional blocks (1-5)
         initial_filters: Number of filters in first conv layer (doubles each block)
-        fc_units_1: Number of units in first fully connected layer
-        fc_units_2: Number of units in second fully connected layer
-        dropout_rate: Dropout probability
+        n_fc_layers: Number of fully connected layers (1-8)
+        base_kernel_size: Base kernel size (decreases by 2 per block, min 3)
+        conv_dropout_rate: Dropout probability after convolutional blocks
+        fc_dropout_rate: Dropout probability in fully connected layers
+        pooling_strategy: Pooling type ('max' or 'avg')
         use_batch_norm: Whether to use batch normalization
         num_classes: Number of output classes (default: 10 for CIFAR-10)
         in_channels: Number of input channels (default: 3 for RGB)
@@ -40,15 +46,21 @@ def create_cnn(
     Returns:
         nn.Sequential model
     '''
+
     layers = []
     current_channels = in_channels
     current_size = input_size
     
+    # Convolutional blocks
     for block_idx in range(n_conv_blocks):
         out_channels = initial_filters * (2 ** block_idx)
+        kernel_size = max(3, base_kernel_size - 2 * block_idx)
+        padding = kernel_size // 2
         
         # First conv in block
-        layers.append(nn.Conv2d(current_channels, out_channels, kernel_size=3, padding=1))
+        layers.append(nn.Conv2d(current_channels, out_channels, kernel_size=kernel_size, padding=padding))
+        # Update size after conv: output_size = (input_size + 2*padding - kernel_size) + 1
+        current_size = (current_size + 2 * padding - kernel_size) + 1
 
         if use_batch_norm:
             layers.append(nn.BatchNorm2d(out_channels))
@@ -56,33 +68,48 @@ def create_cnn(
         layers.append(nn.ReLU())
         
         # Second conv in block
-        layers.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1))
+        layers.append(nn.Conv2d(out_channels, out_channels, kernel_size=kernel_size, padding=padding))
+        current_size = (current_size + 2 * padding - kernel_size) + 1
 
         if use_batch_norm:
             layers.append(nn.BatchNorm2d(out_channels))
 
         layers.append(nn.ReLU())
         
-        # Pooling and dropout
-        layers.append(nn.MaxPool2d(2, 2))
-        layers.append(nn.Dropout(dropout_rate))
+        # Pooling
+        if pooling_strategy == 'max':
+            layers.append(nn.MaxPool2d(2, 2))
+        else:  # avg
+            layers.append(nn.AvgPool2d(2, 2))
+        
+        layers.append(nn.Dropout(conv_dropout_rate))
         
         current_channels = out_channels
-        current_size //= 2
+        current_size //= 2  # Pooling halves the size
     
-    # Calculate flattened size
-    final_channels = initial_filters * (2 ** (n_conv_blocks - 1))
-    flattened_size = final_channels * current_size * current_size
+    # Calculate flattened size using actual current_size
+    flattened_size = current_channels * current_size * current_size
     
-    # Classifier (3 fully connected layers)
+    # Classifier - dynamic FC layers with halving pattern
     layers.append(nn.Flatten())
-    layers.append(nn.Linear(flattened_size, fc_units_1))
-    layers.append(nn.ReLU())
-    layers.append(nn.Dropout(dropout_rate))
-    layers.append(nn.Linear(fc_units_1, fc_units_2))
-    layers.append(nn.ReLU())
-    layers.append(nn.Dropout(dropout_rate))
-    layers.append(nn.Linear(fc_units_2, num_classes))
+    
+    # Generate FC layer sizes by halving from flattened_size
+    fc_sizes = []
+    current_fc_size = flattened_size // 2
+    for _ in range(n_fc_layers):
+        fc_sizes.append(max(10, current_fc_size))  # Minimum 10 units
+        current_fc_size //= 2
+    
+    # Add FC layers
+    in_features = flattened_size
+    for fc_size in fc_sizes:
+        layers.append(nn.Linear(in_features, fc_size))
+        layers.append(nn.ReLU())
+        layers.append(nn.Dropout(fc_dropout_rate))
+        in_features = fc_size
+    
+    # Output layer
+    layers.append(nn.Linear(in_features, num_classes))
     
     return nn.Sequential(*layers)
 
@@ -113,6 +140,7 @@ def train_trial(
     best_val_accuracy = 0.0
     
     for epoch in range(n_epochs):
+
         # Training phase
         model.train()
 
@@ -149,55 +177,96 @@ def train_trial(
 
 
 def create_objective(
-    train_loader: DataLoader,
-    val_loader: DataLoader,
+    data_dir,
+    train_transform,
+    eval_transform,
     n_epochs: int,
     device: torch.device,
     num_classes: int = 10,
-    in_channels: int = 3
+    in_channels: int = 3,
+    search_space: dict = None
 ) -> Callable[[optuna.Trial], float]:
     '''Create an Optuna objective function for CNN hyperparameter optimization.
     
-    This factory function creates a closure that captures the data loaders and
-    training configuration, returning an objective function suitable for Optuna.
+    This factory function creates a closure that captures the data loading parameters
+    and training configuration, returning an objective function suitable for Optuna.
     
     Args:
-        train_loader: DataLoader for training data
-        val_loader: DataLoader for validation data
+        data_dir: Directory containing CIFAR-10 data
+        train_transform: Transform to apply to training data
+        eval_transform: Transform to apply to validation data
         n_epochs: Number of epochs per trial
         device: Device to train on (cuda or cpu)
         num_classes: Number of output classes (default: 10)
         in_channels: Number of input channels (default: 3 for RGB)
+        search_space: Dictionary defining hyperparameter search space (default: None)
     
     Returns:
         Objective function for optuna.Study.optimize()
     
     Example:
-        >>> objective = create_objective(train_loader, val_loader, n_epochs=50, device=device)
+        >>> objective = create_objective(data_dir, transform, transform, n_epochs=50, device=device)
         >>> study = optuna.create_study(direction='maximize')
         >>> study.optimize(objective, n_trials=100)
     '''
     
+    # Default search space if none provided
+    if search_space is None:
+        search_space = {
+            'batch_size': [64, 128, 256, 512, 1024],
+            'n_conv_blocks': (1, 5),
+            'initial_filters': [8, 16, 32, 64, 128],
+            'n_fc_layers': (1, 8),
+            'base_kernel_size': (3, 7),
+            'conv_dropout_rate': (0.0, 0.5),
+            'fc_dropout_rate': (0.2, 0.75),
+            'pooling_strategy': ['max', 'avg'],
+            'use_batch_norm': [True, False],
+            'learning_rate': (1e-5, 1e-1, 'log'),
+            'optimizer': ['Adam', 'SGD', 'RMSprop'],
+            'sgd_momentum': (0.8, 0.99)
+        }
+    
     def objective(trial: optuna.Trial) -> float:
         '''Optuna objective function for CNN hyperparameter optimization.'''
         
-        # Suggest hyperparameters
-        n_conv_blocks = trial.suggest_int('n_conv_blocks', 1, 5)
-        initial_filters = trial.suggest_categorical('initial_filters', [8, 16, 32, 64, 128])
-        fc_units_1 = trial.suggest_categorical('fc_units_1', [128, 256, 512, 1024, 2048])
-        fc_units_2 = trial.suggest_categorical('fc_units_2', [32, 64, 128, 256, 512])
-        dropout_rate = trial.suggest_float('dropout_rate', 0.2, 0.75)
-        use_batch_norm = trial.suggest_categorical('use_batch_norm', [True, False])
-        learning_rate = trial.suggest_float('learning_rate', 1e-5, 1e-1, log=True)
-        optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD', 'RMSprop'])
+        # Suggest hyperparameters from search space
+        batch_size = trial.suggest_categorical('batch_size', search_space['batch_size'])
+        n_conv_blocks = trial.suggest_int('n_conv_blocks', *search_space['n_conv_blocks'])
+        initial_filters = trial.suggest_categorical('initial_filters', search_space['initial_filters'])
+        n_fc_layers = trial.suggest_int('n_fc_layers', *search_space['n_fc_layers'])
+        base_kernel_size = trial.suggest_int('base_kernel_size', *search_space['base_kernel_size'])
+        conv_dropout_rate = trial.suggest_float('conv_dropout_rate', *search_space['conv_dropout_rate'])
+        fc_dropout_rate = trial.suggest_float('fc_dropout_rate', *search_space['fc_dropout_rate'])
+        pooling_strategy = trial.suggest_categorical('pooling_strategy', search_space['pooling_strategy'])
+        use_batch_norm = trial.suggest_categorical('use_batch_norm', search_space['use_batch_norm'])
+        
+        # Handle learning rate with optional log scale
+        lr_params = search_space['learning_rate']
+        learning_rate = trial.suggest_float('learning_rate', lr_params[0], lr_params[1], 
+                                           log=(lr_params[2] == 'log' if len(lr_params) > 2 else False))
+        
+        optimizer_name = trial.suggest_categorical('optimizer', search_space['optimizer'])
+        
+        # Create data loaders with suggested batch size
+        train_loader, val_loader, _ = make_data_loaders(
+            data_dir=data_dir,
+            batch_size=batch_size,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            device=device,
+            download=False
+        )
         
         # Create model
         model = create_cnn(
             n_conv_blocks=n_conv_blocks,
             initial_filters=initial_filters,
-            fc_units_1=fc_units_1,
-            fc_units_2=fc_units_2,
-            dropout_rate=dropout_rate,
+            n_fc_layers=n_fc_layers,
+            base_kernel_size=base_kernel_size,
+            conv_dropout_rate=conv_dropout_rate,
+            fc_dropout_rate=fc_dropout_rate,
+            pooling_strategy=pooling_strategy,
             use_batch_norm=use_batch_norm,
             num_classes=num_classes,
             in_channels=in_channels
@@ -208,7 +277,7 @@ def create_objective(
             optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
         elif optimizer_name == 'SGD':
-            momentum = trial.suggest_float('sgd_momentum', 0.8, 0.99)
+            momentum = trial.suggest_float('sgd_momentum', *search_space['sgd_momentum'])
             optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)
         
         else:  # RMSprop
@@ -228,6 +297,10 @@ def create_objective(
                 trial=trial
             )
 
+        except RuntimeError as e:
+            # Catch architecture errors (e.g., dimension mismatches)
+            raise optuna.TrialPruned(f'RuntimeError with params: {trial.params} - {str(e)}')
+        
         except torch.cuda.OutOfMemoryError:
             # Clear CUDA cache and skip this trial
             torch.cuda.empty_cache()

cifar10_tools/pytorch/plotting.py

@@ -222,7 +222,7 @@ def plot_evaluation_curves(
         roc_auc = auc(fpr, tpr)
         ax1.plot(fpr, tpr, label=class_name)
 
-    ax1.plot([0, 1], [0, 1], 'k--', label='Random classifier')
+    ax1.plot([0, 1], [0, 1], 'k--', label='random classifier')
     ax1.set_xlabel('False positive rate')
     ax1.set_ylabel('True positive rate')
     ax1.legend(loc='lower right', fontsize=12)

cifar10_tools/pytorch/training.py

@@ -115,6 +115,4 @@ def train_model(
                 f'val_accuracy: {val_accuracy:.2f}%'
             )
 
-    print('\nTraining complete.')
-
     return history

cifar10_tools-0.5.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: cifar10_tools
+Version: 0.5.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: CIFAR-10 Demonstration
+
+A progressive deep learning tutorial for image classification on the CIFAR-10 dataset using PyTorch. This project demonstrates the evolution from basic deep neural networks to optimized convolutional neural networks with data augmentation. It also provides a set of utility functions as a PyPI package for use in other projects.
+
+[View on PyPI](https://pypi.org/project/cifar10_tools) | [Documentation](https://gperdrizet.github.io/CIFAR10/)
+
+## Installation
+
+Install the helper tools package locally in editable mode to use in this repository:
+
+```bash
+pip install -e .
+```
+
+Or install from PyPI to use in other projects:
+
+```bash
+pip install cifar10_tools
+```
+
+## Project overview
+
+This repository contains a series of Jupyter notebooks that progressively build more sophisticated neural network architectures for the CIFAR-10 image classification task. Each notebook builds upon concepts from the previous one, demonstrating key deep learning techniques.
+
+## Notebooks
+
+| Notebook | Description |
+|----------|-------------|
+| [01-DNN.ipynb](notebooks/01-DNN.ipynb) | **Deep Neural Network** - Baseline fully-connected DNN classifier using `nn.Sequential`. Establishes a performance baseline with a simple architecture. |
+| [02-CNN.ipynb](notebooks/02-CNN.ipynb) | **Convolutional Neural Network** - Introduction to CNNs with convolutional and pooling layers using `nn.Sequential`. Demonstrates the advantage of CNNs over DNNs for image tasks. |
+| [03-RGB-CNN.ipynb](notebooks/03-RGB-CNN.ipynb) | **RGB CNN** - CNN classifier that utilizes full RGB color information instead of grayscale, improving feature extraction from color images. |
+| [04-optimized-CNN.ipynb](notebooks/04-optimized-CNN.ipynb) | **Hyperparameter Optimization** - Uses Optuna for automated hyperparameter tuning to find optimal network architecture and training parameters. |
+| [05-augmented-CNN.ipynb](notebooks/05-augmented-CNN.ipynb) | **Data Augmentation** - Trains the optimized CNN architecture with image augmentation techniques for improved generalization and robustness. |
+
+## Requirements
+
+- Python >=3.10, <3.13
+- PyTorch >=2.0
+- torchvision >=0.15
+- numpy >=1.24
+
+## License
+
+This project is licensed under the GPLv3 License - see the [LICENSE](LICENSE) file for details.

cifar10_tools-0.5.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cifar10_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cifar10_tools/pytorch/__init__.py,sha256=4er-aMGK-MZTlkH3Owz3x-Pz_Gl_NjplKwOBYdBA1p0,909
+cifar10_tools/pytorch/data.py,sha256=ZJb_EYxHPh6wsnAtzRcDFVVZaa3ChAbnC5IHaWaf0Ls,4272
+cifar10_tools/pytorch/evaluation.py,sha256=i4tRYOqWATVqQVkWT_fATWRbzo9ziX2DDkXKPaiQlFE,923
+cifar10_tools/pytorch/hyperparameter_optimization.py,sha256=VVZbeDRis_pviMSQFTQTgcFLp0-jtjz8hRrzDsuYA3g,11317
+cifar10_tools/pytorch/plotting.py,sha256=SB50bwY4qhvYu_cVNT7EAE2vwOI8-0pxwu7jwGTJRas,9550
+cifar10_tools/pytorch/training.py,sha256=spam_Q1G1ZAoheMMKY26RHl6YhIam8pW6A7Df7oS1to,3824
+cifar10_tools/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cifar10_tools-0.5.0.dist-info/METADATA,sha256=bOqXkMS7dQihCQ2rBwbf9mwwIJN-kofROEeg5bO2cQw,3840
+cifar10_tools-0.5.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+cifar10_tools-0.5.0.dist-info/licenses/LICENSE,sha256=wtHfRwmCF5-_XUmYwrBKwJkGipvHVmh7GXJOKKeOe2U,1073
+cifar10_tools-0.5.0.dist-info/RECORD,,

cifar10_tools-0.3.0.dist-info/METADATA

@@ -1,35 +0,0 @@
-Metadata-Version: 2.4
-Name: cifar10_tools
-Version: 0.3.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.3.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-cifar10_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cifar10_tools/pytorch/__init__.py,sha256=4er-aMGK-MZTlkH3Owz3x-Pz_Gl_NjplKwOBYdBA1p0,909
-cifar10_tools/pytorch/data.py,sha256=09zodpjto0xLq95tDAyq57CFh6MSYRuUBPcMmQcyKZM,626
-cifar10_tools/pytorch/evaluation.py,sha256=i4tRYOqWATVqQVkWT_fATWRbzo9ziX2DDkXKPaiQlFE,923
-cifar10_tools/pytorch/hyperparameter_optimization.py,sha256=92MwDp6CarFp6O-tkJqeVqDyn0Az15gu3pluAvnO2mw,8056
-cifar10_tools/pytorch/plotting.py,sha256=9kRDt9ZEX0uOUlt-9wzJHrx4WELuFYMeeQiJrmwyXNs,9550
-cifar10_tools/pytorch/training.py,sha256=KNaH-Q9u61o3DIcTfBhjnOvOD7yExZeXwBm6qvMGL9I,3859
-cifar10_tools/tensorflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cifar10_tools-0.3.0.dist-info/METADATA,sha256=Ll6YMa77t9ubJLaiFF8BsMmDuj_pzTLejL6Wlje2Qwo,1580
-cifar10_tools-0.3.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
-cifar10_tools-0.3.0.dist-info/licenses/LICENSE,sha256=wtHfRwmCF5-_XUmYwrBKwJkGipvHVmh7GXJOKKeOe2U,1073
-cifar10_tools-0.3.0.dist-info/RECORD,,