Fine-tuning Pretrained Convolutional Neural Networks with PyTorch

Are you looking to leverage state-of-the-art Convolutional Neural Networks (CNNs) for your image classification tasks but want to adapt them to your specific needs? With the pytorch-cnn-finetune package, you can easily fine-tune pretrained CNNs using PyTorch. In this article, we will explore the features, supported architectures, and models available in the package, as well as demonstrate how to install, configure, and utilize them effectively.

Features

The pytorch-cnn-finetune package offers several key features that make it a powerful tool for fine-tuning pretrained CNNs. These features include:

1. Access to popular CNN architectures pretrained on ImageNet: The package provides access to a wide range of popular architectures such as ResNet, DenseNet, Inception v3, VGG, SqueezeNet, MobileNet V2, ShuffleNet v2, AlexNet, GoogLeNet, and more.

2. Automatic classifier replacement: You can easily replace the classifier on top of the network, allowing you to train the network with a dataset that has a different number of classes.

3. Resolution flexibility: Unlike many other libraries, pytorch-cnn-finetune allows you to use images with any resolution, not just the resolution used for training the original model on ImageNet.

4. Custom layer addition: You can add a Dropout layer or a custom pooling layer to the model, offering more control over the network’s behavior.

Supported Architectures and Models

The package supports various architectures from the torchvision and pretrained-models packages. From torchvision, you can fine-tune models like ResNet, ResNeXt, DenseNet, Inception v3, VGG, SqueezeNet, MobileNet V2, ShuffleNet v2, AlexNet, and GoogLeNet. From pretrained-models, you have access to models like NASNet-A, Dual Path Networks, Inception-ResNet v2, Xception, Squeeze-and-Excitation Networks, PNASNet-5-Large, and PolyNet.

Installation and Setup

To get started, make sure you have Python 3.5+ and PyTorch 1.1+ installed on your machine. Once the prerequisites are met, install the pytorch-cnn-finetune package using the following pip command:

pip install cnn_finetune

With the package installed, you are now ready to create and fine-tune your models.

Example Usage

Let’s walk through a few examples to showcase the capabilities of pytorch-cnn-finetune.

1. Make a model with ImageNet weights for a specific number of classes

“`python
from cnn_finetune import make_model

model = make_model(‘resnet18’, num_classes=10, pretrained=True)
“`

Here, we create a ResNet18 model and set the number of classes to 10. The classifier is automatically replaced and the model is initialized with ImageNet weights.

2. Make a model with Dropout

python
model = make_model('nasnetalarge', num_classes=10, pretrained=True, dropout_p=0.5)

In this example, we create a nasnetalarge model with a dropout probability of 0.5, enabling regularization during training.

3. Make a model with Global Max Pooling instead of Global Average Pooling

“`python
import torch.nn as nn

model = make_model(‘inceptionresnetv2’, num_classes=10, pretrained=True, pool=nn.AdaptiveMaxPool2d(1))
“`

Here, we use the inceptionresnetv2 architecture and replace the global average pooling with global max pooling.

4. Make a VGG16 model with customized input size and classifier

“`python
import torch.nn as nn

def make_classifier(in_features, num_classes):
return nn.Sequential(
nn.Linear(in_features, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, num_classes),
)

model = make_model(‘vgg16’, num_classes=10, pretrained=True, input_size=(256, 256), classifier_factory=make_classifier)
“`

In this example, we create a VGG16 model with an input size of 256×256 pixels and a custom classifier. We define the make_classifier function to create a sequential classifier with two linear layers and ReLU activation.

5. Preprocessing information of a model

python
model = make_model('resnext101_64x4d', num_classes=10, pretrained=True)
print(model.original_model_info)
print(model.original_model_info.mean)

If you want to know the preprocessing information used to train the original model on ImageNet, you can access it using the original_model_info attribute of the model. In this example, we display the input space, input size, input range, mean, and standard deviation of the model.

Conclusion

Fine-tuning pretrained Convolutional Neural Networks is made easy with the pytorch-cnn-finetune package. By leveraging popular architectures and models pretrained on ImageNet, you can adapt them to your specific needs. Whether you want to replace the classifier, adjust the input size, add custom layers, or access preprocessing information, this package provides the necessary tools. Install pytorch-cnn-finetune, explore the example usages, and start building powerful image classification models today.

Feel free to ask any questions or share your experiences with fine-tuning CNNs in the comments section below!

References

Contributors: creafz (Repository Owner)

Licensing information: MIT License

GitHub Repository

PyPI Package