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

.gitkeep transfer_learning.py basic_nn.py advanced_features_example.py

saved_models/.gitkeep

# Saved Models Directory
# Project: PyTorch Neural Networks
# Author: RSK World
# Website: https://rskworld.in
# Email: help@rskworld.in
# Phone: +91 93305 39277

8 lines•170 B

text

models/transfer_learning.py

Raw Download

"""
Transfer Learning Models - PyTorch Neural Networks
Project: PyTorch Neural Networks
Author: RSK World
Website: https://rskworld.in
Email: help@rskworld.in
Phone: +91 93305 39277
Description: Transfer learning examples using pre-trained models
"""

import torch
import torch.nn as nn
import torchvision.models as models

# Handle compatibility with different torchvision versions
try:
    from torchvision.models import ResNet18_Weights, ResNet50_Weights, VGG16_Weights, DenseNet121_Weights
    TORCHVISION_NEW_API = True
except ImportError:
    TORCHVISION_NEW_API = False


class TransferLearningModel(nn.Module):
    """
    Transfer learning model using pre-trained architectures
    
    Project: PyTorch Neural Networks
    Author: RSK World
    Website: https://rskworld.in
    """
    
    def __init__(self, model_name='resnet18', num_classes=10, pretrained=True, freeze_backbone=False):
        """
        Initialize transfer learning model
        
        Args:
            model_name: Name of pre-trained model ('resnet18', 'resnet50', 'vgg16', etc.)
            num_classes: Number of output classes
            pretrained: Whether to use pre-trained weights
            freeze_backbone: Whether to freeze backbone layers
        """
        super(TransferLearningModel, self).__init__()
        
        # Load pre-trained model
        # Handle compatibility with different torchvision versions
        if TORCHVISION_NEW_API and pretrained:
            # New API (torchvision >= 0.13)
            if model_name == 'resnet18':
                self.backbone = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
                num_features = self.backbone.fc.in_features
                self.backbone.fc = nn.Linear(num_features, num_classes)
            elif model_name == 'resnet50':
                self.backbone = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
                num_features = self.backbone.fc.in_features
                self.backbone.fc = nn.Linear(num_features, num_classes)
            elif model_name == 'vgg16':
                self.backbone = models.vgg16(weights=VGG16_Weights.IMAGENET1K_V1)
                num_features = self.backbone.classifier[6].in_features
                self.backbone.classifier[6] = nn.Linear(num_features, num_classes)
            elif model_name == 'densenet121':
                self.backbone = models.densenet121(weights=DenseNet121_Weights.IMAGENET1K_V1)
                num_features = self.backbone.classifier.in_features
                self.backbone.classifier = nn.Linear(num_features, num_classes)
            else:
                raise ValueError(f"Unsupported model: {model_name}")
        else:
            # Old API (torchvision < 0.13) or pretrained=False
            if model_name == 'resnet18':
                self.backbone = models.resnet18(pretrained=pretrained)
                num_features = self.backbone.fc.in_features
                self.backbone.fc = nn.Linear(num_features, num_classes)
            elif model_name == 'resnet50':
                self.backbone = models.resnet50(pretrained=pretrained)
                num_features = self.backbone.fc.in_features
                self.backbone.fc = nn.Linear(num_features, num_classes)
            elif model_name == 'vgg16':
                self.backbone = models.vgg16(pretrained=pretrained)
                num_features = self.backbone.classifier[6].in_features
                self.backbone.classifier[6] = nn.Linear(num_features, num_classes)
            elif model_name == 'densenet121':
                self.backbone = models.densenet121(pretrained=pretrained)
                num_features = self.backbone.classifier.in_features
                self.backbone.classifier = nn.Linear(num_features, num_classes)
            else:
                raise ValueError(f"Unsupported model: {model_name}")
        
        # Freeze backbone if requested
        if freeze_backbone:
            for param in self.backbone.parameters():
                param.requires_grad = False
            # Unfreeze last layer
            if hasattr(self.backbone, 'fc'):
                for param in self.backbone.fc.parameters():
                    param.requires_grad = True
            elif hasattr(self.backbone, 'classifier'):
                for param in self.backbone.classifier.parameters():
                    param.requires_grad = True
    
    def forward(self, x):
        """Forward pass"""
        return self.backbone(x)
    
    def unfreeze_all(self):
        """Unfreeze all layers for fine-tuning"""
        for param in self.backbone.parameters():
            param.requires_grad = True
    
    def freeze_backbone(self):
        """Freeze backbone layers"""
        for param in self.backbone.parameters():
            param.requires_grad = False
        # Unfreeze classifier
        if hasattr(self.backbone, 'fc'):
            for param in self.backbone.fc.parameters():
                param.requires_grad = True
        elif hasattr(self.backbone, 'classifier'):
            for param in self.backbone.classifier.parameters():
                param.requires_grad = True

120 lines•5.1 KB

python

models/basic_nn.py

Raw Download

"""
Basic Neural Network Model
Project: PyTorch Neural Networks
Author: RSK World
Website: https://rskworld.in
Email: help@rskworld.in
Phone: +91 93305 39277
Description: Basic feedforward neural network implementation
"""

import torch
import torch.nn as nn
import torch.nn.functional as F


class BasicNeuralNetwork(nn.Module):
    """
    Basic Feedforward Neural Network
    
    A simple multi-layer perceptron with configurable hidden layers.
    Demonstrates PyTorch's dynamic computation graph and automatic differentiation.
    """
    
    def __init__(self, input_size, hidden_size=64, output_size=10, num_layers=2, dropout=0.2):
        """
        Initialize the neural network
        
        Args:
            input_size: Number of input features
            hidden_size: Number of neurons in hidden layers
            output_size: Number of output classes
            num_layers: Number of hidden layers
            dropout: Dropout probability for regularization
        """
        super(BasicNeuralNetwork, self).__init__()
        
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        # Create layers dynamically
        layers = []
        
        # Input layer
        layers.append(nn.Linear(input_size, hidden_size))
        layers.append(nn.ReLU())
        layers.append(nn.Dropout(dropout))
        
        # Hidden layers
        for _ in range(num_layers - 1):
            layers.append(nn.Linear(hidden_size, hidden_size))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(dropout))
        
        # Output layer
        layers.append(nn.Linear(hidden_size, output_size))
        
        self.network = nn.Sequential(*layers)
    
    def forward(self, x):
        """
        Forward pass through the network
        
        Args:
            x: Input tensor of shape (batch_size, input_size)
            
        Returns:
            Output tensor of shape (batch_size, output_size)
        """
        # Flatten input if needed
        if x.dim() > 2:
            x = x.view(x.size(0), -1)
        
        return self.network(x)
    
    def predict(self, x):
        """
        Make predictions on input data
        
        Args:
            x: Input tensor
            
        Returns:
            Predicted class indices
        """
        self.eval()
        with torch.no_grad():
            outputs = self.forward(x)
            _, predicted = torch.max(outputs.data, 1)
        return predicted

92 lines•2.6 KB

python

examples/advanced_features_example.py

Raw Download

"""
Advanced Features Example - PyTorch Neural Networks
Project: PyTorch Neural Networks
Author: RSK World
Website: https://rskworld.in
Email: help@rskworld.in
Phone: +91 93305 39277
Description: Example demonstrating advanced training features
"""

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import sys
import os

# Add parent directory to path
sys.path.append('..')

from models.basic_nn import BasicNeuralNetwork
from training.advanced_trainer import AdvancedTrainer
from training.callbacks import EarlyStopping, ModelCheckpoint, LearningRateScheduler
from training.metrics import evaluate_model, plot_confusion_matrix, classification_report_metrics
from training.utils import generate_sample_data
from utils.tensorboard_logger import TensorBoardLogger


def advanced_training_example():
    """
    Demonstrate advanced training features
    """
    print("=" * 60)
    print("Advanced Training Features Example")
    print("Author: RSK World (https://rskworld.in)")
    print("=" * 60)
    
    # Set device
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print(f"\nUsing device: {device}\n")
    
    # Generate data
    print("Generating sample data...")
    X_train, y_train, X_val, y_val = generate_sample_data(
        n_samples=1000, n_features=20, n_classes=3
    )
    X_test, y_test, _, _ = generate_sample_data(
        n_samples=200, n_features=20, n_classes=3
    )
    
    # Create data loaders
    train_loader = DataLoader(TensorDataset(X_train, y_train), batch_size=32, shuffle=True)
    val_loader = DataLoader(TensorDataset(X_val, y_val), batch_size=32, shuffle=False)
    test_loader = DataLoader(TensorDataset(X_test, y_test), batch_size=32, shuffle=False)
    
    # Create model
    model = BasicNeuralNetwork(input_size=20, hidden_size=64, output_size=3).to(device)
    
    # Define loss and optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # Create learning rate scheduler
    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3)
    lr_scheduler = LearningRateScheduler(scheduler)
    
    # Create callbacks
    early_stopping = EarlyStopping(patience=5, verbose=True)
    checkpoint = ModelCheckpoint(
        filepath='../saved_models/best_model.pth',
        monitor='val_loss',
        save_best_only=True
    )
    
    # Create TensorBoard logger
    logger = TensorBoardLogger(log_dir='../runs/advanced_example')
    
    # Create advanced trainer with gradient clipping
    trainer = AdvancedTrainer(
        model, criterion, optimizer, device,
        gradient_clip=1.0,  # Clip gradients to norm 1.0
        use_mixed_precision=False  # Set to True if using CUDA
    )
    
    # Training loop with callbacks
    num_epochs = 20
    best_val_loss = float('inf')
    
    print("\nStarting training with advanced features...")
    print("-" * 60)
    
    for epoch in range(num_epochs):
        # Train
        train_loss, train_acc = trainer.train_epoch(train_loader)
        
        # Validate
        val_results = evaluate_model(model, val_loader, device, criterion)
        val_loss = val_results['loss']
        val_acc = val_results['accuracy']
        
        # Update learning rate
        lr_scheduler.step(val_loss)
        
        # Log metrics
        logger.log_training_metrics({'loss': train_loss, 'accuracy': train_acc}, epoch)
        logger.log_validation_metrics({'loss': val_loss, 'accuracy': val_acc}, epoch)
        logger.log_learning_rate(optimizer, epoch)
        logger.increment_step()
        
        print(f"Epoch {epoch+1}/{num_epochs}")
        print(f"Train - Loss: {train_loss:.4f}, Acc: {train_acc:.2f}%")
        print(f"Val   - Loss: {val_loss:.4f}, Acc: {val_acc:.2f}%")
        
        # Checkpoint
        checkpoint(val_loss, model, optimizer, epoch)
        
        # Early stopping
        if early_stopping(val_loss, model):
            print("Early stopping triggered!")
            break
        
        print("-" * 60)
    
    logger.close()
    
    # Final evaluation on test set
    print("\nEvaluating on test set...")
    test_results = evaluate_model(model, test_loader, device, criterion)
    print(f"Test Accuracy: {test_results['accuracy']:.2f}%")
    
    # Confusion matrix
    plot_confusion_matrix(
        test_results['labels'],
        test_results['predictions'],
        class_names=['Class 0', 'Class 1', 'Class 2'],
        save_path='../confusion_matrix.png'
    )
    
    # Classification report
    print("\nClassification Report:")
    classification_report_metrics(
        test_results['labels'],
        test_results['predictions'],
        class_names=['Class 0', 'Class 1', 'Class 2']
    )
    
    print("\n" + "=" * 60)
    print("Example completed!")
    print("Check TensorBoard: tensorboard --logdir=runs")
    print("=" * 60)


if __name__ == '__main__':
    advanced_training_example()

156 lines•5.1 KB

python

Theme Settings

Color Scheme

Display Options

Font Size