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

.gitkeep transfer_learning.py basic_nn.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

Theme Settings

Color Scheme

Display Options

Font Size