RSK World - PyTorch Neural Networks - Project Files | RSK World - Free Programming Resources & Source Code

data/augmentation.py

"""
Data Augmentation Utilities - PyTorch Neural Networks
Project: PyTorch Neural Networks
Author: RSK World
Website: https://rskworld.in
Email: help@rskworld.in
Phone: +91 93305 39277
Description: Data augmentation utilities for images and sequences
"""

import torch
import torchvision.transforms as transforms
import numpy as np


def get_image_augmentation(train=True):
    """
    Get image augmentation transforms
    
    Args:
        train: Whether to apply training augmentations
        
    Returns:
        Transform composition
    """
    if train:
        return transforms.Compose([
            transforms.RandomHorizontalFlip(p=0.5),
            transforms.RandomRotation(degrees=15),
            transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
            transforms.RandomAffine(degrees=0, translate=(0.1, 0.1), scale=(0.9, 1.1)),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        ])
    else:
        return transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        ])


def add_noise(tensor, noise_factor=0.1):
    """
    Add Gaussian noise to tensor
    
    Args:
        tensor: Input tensor
        noise_factor: Noise intensity
        
    Returns:
        Tensor with added noise
    """
    noise = torch.randn_like(tensor) * noise_factor
    return tensor + noise


def random_crop(tensor, crop_size):
    """
    Random crop for tensor
    
    Args:
        tensor: Input tensor (C, H, W)
        crop_size: Size of crop (height, width)
        
    Returns:
        Cropped tensor
    """
    _, h, w = tensor.shape
    th, tw = crop_size
    
    if h < th or w < tw:
        return tensor
    
    i = torch.randint(0, h - th + 1, (1,)).item()
    j = torch.randint(0, w - tw + 1, (1,)).item()
    
    return tensor[:, i:i+th, j:j+tw]


def sequence_augmentation(sequence, noise_factor=0.05, dropout_prob=0.1):
    """
    Augment sequence data
    
    Args:
        sequence: Input sequence tensor (seq_len, features)
        noise_factor: Noise intensity
        dropout_prob: Probability of dropping features
        
    Returns:
        Augmented sequence
    """
    # Add noise
    if noise_factor > 0:
        noise = torch.randn_like(sequence) * noise_factor
        sequence = sequence + noise
    
    # Random feature dropout
    if dropout_prob > 0:
        mask = torch.rand(sequence.shape) > dropout_prob
        sequence = sequence * mask.float()
    
    return sequence


class MixUp:
    """
    MixUp data augmentation
    
    Project: PyTorch Neural Networks
    Author: RSK World
    Website: https://rskworld.in
    """
    
    def __init__(self, alpha=0.2):
        """
        Initialize MixUp
        
        Args:
            alpha: Beta distribution parameter
        """
        self.alpha = alpha
    
    def __call__(self, x1, y1, x2, y2):
        """
        Apply MixUp
        
        Args:
            x1, y1: First sample and label
            x2, y2: Second sample and label
            
        Returns:
            Mixed sample and labels
        """
        lam = np.random.beta(self.alpha, self.alpha)
        mixed_x = lam * x1 + (1 - lam) * x2
        y_a, y_b = y1, y2
        return mixed_x, y_a, y_b, lam

139 lines•3.5 KB

python

main.py

Raw Download

"""
PyTorch Neural Networks - Main Entry Point
Project: PyTorch Neural Networks
Author: RSK World
Website: https://rskworld.in
Email: help@rskworld.in
Phone: +91 93305 39277
Description: Main script to run different neural network models
"""

import argparse
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import numpy as np
import matplotlib.pyplot as plt

from models.basic_nn import BasicNeuralNetwork
from models.cnn import SimpleCNN
from models.rnn import SimpleRNN
from training.trainer import Trainer
from training.utils import generate_sample_data, plot_training_history


def main():
    parser = argparse.ArgumentParser(description='PyTorch Neural Networks - RSK World')
    parser.add_argument('--model', type=str, default='basic', 
                       choices=['basic', 'cnn', 'rnn'],
                       help='Model type to train')
    parser.add_argument('--epochs', type=int, default=10,
                       help='Number of training epochs')
    parser.add_argument('--batch_size', type=int, default=32,
                       help='Batch size for training')
    parser.add_argument('--lr', type=float, default=0.001,
                       help='Learning rate')
    parser.add_argument('--device', type=str, default='auto',
                       choices=['auto', 'cpu', 'cuda'],
                       help='Device to use for training')
    
    args = parser.parse_args()
    
    # Set device
    if args.device == 'auto':
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    else:
        device = torch.device(args.device)
    
    print(f"Using device: {device}")
    print(f"Training {args.model} model for {args.epochs} epochs")
    
    # Generate sample data based on model type
    if args.model == 'basic':
        X_train, y_train, X_test, y_test = generate_sample_data(
            n_samples=1000, n_features=20, n_classes=3
        )
        model = BasicNeuralNetwork(input_size=20, hidden_size=64, output_size=3)
        
    elif args.model == 'cnn':
        # Generate image-like data (batch, channels, height, width)
        X_train = torch.randn(200, 1, 28, 28)
        y_train = torch.randint(0, 10, (200,))
        X_test = torch.randn(50, 1, 28, 28)
        y_test = torch.randint(0, 10, (50,))
        model = SimpleCNN(num_classes=10)
        
    elif args.model == 'rnn':
        # Generate sequence data (batch, seq_len, features)
        X_train = torch.randn(200, 10, 5)
        y_train = torch.randint(0, 3, (200,))
        X_test = torch.randn(50, 10, 5)
        y_test = torch.randint(0, 3, (50,))
        model = SimpleRNN(input_size=5, hidden_size=64, num_layers=2, num_classes=3)
    
    model = model.to(device)
    
    # Create data loaders
    train_dataset = TensorDataset(X_train, y_train)
    test_dataset = TensorDataset(X_test, y_test)
    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False)
    
    # Define loss and optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=args.lr)
    
    # Train model
    trainer = Trainer(model, criterion, optimizer, device)
    history = trainer.train(train_loader, test_loader, epochs=args.epochs)
    
    # Plot training history
    plot_training_history(history)
    
    print("\nTraining completed!")
    print(f"Final Training Loss: {history['train_loss'][-1]:.4f}")
    print(f"Final Test Loss: {history['test_loss'][-1]:.4f}")
    print(f"Final Test Accuracy: {history['test_accuracy'][-1]:.2f}%")


if __name__ == '__main__':
    main()

103 lines•3.7 KB

python

Theme Settings

Color Scheme

Display Options

Font Size

Theme Settings

Color Scheme

Display Options

Font Size

🚀 Support RSK World