top of page
Search

PyTorch Assignment Help | Implementing MobileNet Model Using Python

Setup Code

Before getting started we need to run some boilerplate code to set up our environment. You'll need to rerun this setup code each time you start the notebook.

First, run this cell load the autoreload (https://ipython.readthedocs.io/en/stable/config/extensions/autoreload.html?highlight=autoreload) extension. This allows us to edit .py source files, and re-import them into the notebook for a seamless editing and debugging experience.

```%load_ext autoreload

Next we need to run a few commands to set up our environment on Google Colab. If you are running this notebook on a local machine you can skip this section.

```from google.colab import drive
drive.mount('/content/drive/'```

Mounted at /content/drive

Now recall the path in your Google Drive where you uploaded this notebook, fill it in below. If everything is working correctly then running the folowing cell should print the filenames in the assignment directory

```import os
import sys
# TODO: Fill in the Google Drive path where you uploaded the assignment, it s
import time, os
os.environ["TZ"] = "US/Eastern"
time.tzset()```

output:

['images', '__pycache__', 'mobilenet_solutions.ipynb', 'mobilenet.ipynb']

Let us start

Efficient revolutionary neural networks for mobile vision applications to experience Depthwise convolution and Pointwise convolution. (https://arxiv.org/pdf/1704.04861.pdf)

The MobileNet model is based on depthwise separable convolutions which is a form of factorized convolutions which factorize a standard convolution into a depthwise convolution and a 1Ã—1 convolution called a pointwise convolution. For MobileNets the depthwise convolution applies a single filter to each input channel.

The pointwise convolution then applies a 1Ã—1 convolution to combine the outputs the depthwise convolution. A standard convolution both filters and combines inputs into a new set of outputs in one step. The depthwise separable convolution splits this into two layers, a separate layer for filtering and a separate layer for combining. This factorization has the effect of drastically reducing computation and model size. Figure below shows how a standard convolution (a) is factorized into a depthwise convolution (b) and a 1 Ã— 1 pointwise convolution (c). Figure 1. shows standard, depthwise and pointwise convolutional filters.

```#check torch version
import torch
print(torch.__version__) ```

#MobileNet separable convolution

In this cell, you are asked to implement both Mobilenet and Standerd block. showed in the image below.

```import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optim
class MobileNetBlock(nn.Module):
def __init__(self, in_depth, out_depth, stride=1):
super(MobileNetBlock, self).__init__()
# hint: For Depthwise convolution, use the Conv2d with groups equal t

def forward(self, x):

class StandardBlock(nn.Module):
def __init__(self, in_depth, out_depth, stride=1):
super(StandardBlock, self).__init__()

def forward(self, x):
return out
```

Now, you are asked to implement dataloaders that will be used during the training and testing to load the data. To implement the dataloaders you need to implement the following:

• We will work on CIFAR dataset. I am providing few lines to start from.

• transform_train and transform_test: Used to transoform and normalize your data. remember that you need to normalize the data. Do you need to use transformation in the test set ? Justify your answer.

```trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=

output:

Extracting ./data/cifar-10-python.tar.gz to ./data

Data mean [0.49139968 0.48215841 0.44653091]

Data std [0.24703223 0.24348513 0.26158784]

#Create MobileNetV1 network

Now it is the time to create MobileNet network that will classify CIFAR dataset. You will be asked to implement the following architecture. All the convolutions should use the MobileNetBlock except the first convolutional layer which should be standard one (We are trying to follow same steps in the MobileNet paper by starting with standard convolution).

32Ã—32Ã—3 ==> (Standerd convoltion)

32Ã—32Ã—32 ==> (MobileNet convoltion)

32Ã—32Ã—64 ==> (MobileNet convoltion)

16Ã—16Ã—128 ==> (MobileNet convoltion)

16Ã—16Ã—128 ==>(MobileNet convoltion)

8Ã—8Ã—256 ==>(MobileNet convoltion)

8Ã—8Ã—256 ==>(MobileNet convoltion)

4Ã—4Ã—512 ==>(MobileNet convoltion)

4Ã—4Ã—512 ==>(MobileNet convoltion)

2Ã—2Ã—1024 ==>(MobileNet convoltion)

2Ã—2Ã—1024

Mean pooling ==> 1 Ã— 1 Ã— 1024

Finally, it is fully connected to 10 output nodes

```class MobileNetV1(nn.Module):

def __init__(self, num_classes=10):
super(MobileNetV1, self).__init__()

def forward(self, x):
return out```

Now, Implement the StandardNet that replace all MobileNet blocks with StanderdBlocks.

```class StandardNet(nn.Module):

def __init__(self, num_classes=10):
super(StandardNet, self).__init__()
def forward(self, x):
return out```

• Use GPU for faster training.

• Define two networks, MobileNet and stNet.

• Move these networks to the GPU.

• use an appropriate loss functions.

• use an appropriate optimization functions.

```# To use GPU, you can set it in the menu "Runtime" - > "change runtime type"
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Put the network on the GPU
stNet = # add your code here for StandardNet, remeber to move the network for
criterion = # add your code here to define the loss function

#model training

Now put everthing togather and train/test the two networks in the cells below. Train only for 10 epochs for each model.

```# train MobileNet here.
for epoch in range(10): # Repeat multiple rounds
for i, (inputs, labels) in enumerate(trainloader):
inputs = inputs.to(device)
labels = labels.to(device)

# Output statistics
if i % 100 == 0:
print('Epoch: %d Minibatch: %5d loss: %.3f' %(epoch + 1, i + 1, l
print('Finished Training')```

Output:

Epoch: 1 Minibatch: 1 loss: 2.344

Epoch: 1 Minibatch: 101 loss: 1.870

Epoch: 1 Minibatch: 201 loss: 1.661

Epoch: 1 Minibatch: 301 loss: 1.362

Epoch: 2 Minibatch: 1 loss: 1.329

Epoch: 2 Minibatch: 101 loss: 1.426

Epoch: 2 Minibatch: 201 loss: 1.151

Epoch: 2 Minibatch: 301 loss: 1.229

Epoch: 3 Minibatch: 1 loss: 1.206

...

...

#Model test

```# Test MobileNet here ...
correct = 0
total = 0
print('Accuracy of the network on the 10000 test images: %.2f %%' % (
100 * correct / total))```

Accuracy of the network on the 10000 test images: 82.35 %

Model Parameters

```Print the summary for each net here

from torchsummary import summary
summary(stNet, (3,32,32), device = 'cuda')
summary(MobileNet, (3,32,32), device = 'cuda') ```

output:

----------------------------------------------------------------

Layer (type) Output Shape Param # ================================================================

Conv2d-1 [-1, 32, 32, 32] 864

BatchNorm2d-2 [-1, 32, 32, 32] 64

Conv2d-3 [-1, 64, 32, 32] 18,432

BatchNorm2d-4 [-1, 64, 32, 32] 128 StandardBlock-5 [-1, 64, 32, 32] 0

Conv2d-6 [-1, 128, 16, 16] 73,728

...

...

Total params: 18,838,058

Trainable params: 18,838,058

Non-trainable params: 0

----------------------------------------------------------------

Input size (MB): 0.01

Forward/backward pass size (MB): 4.81

Params size (MB): 71.86

Estimated Total Size (MB): 76.69

----------------------------------------------------------------

----------------------------------------------------------------

Layer (type) Output Shape Param # ================================================================

Conv2d-1 [-1, 32, 32, 32] 864

BatchNorm2d-2 [-1, 32, 32, 32] 64

Conv2d-3 [-1, 32, 32, 32] 288 BatchNorm2d-4 [-1, 32, 32, 32] 64

Conv2d-5 [-1, 64, 32, 32] 2,048

...

...

...

• Comment on the performance vs number of paramters vs number of calculations (speed) for each network here.

• What are the Pros and Cons for each Net?

We are providing all deep learning related help, our expert have a good knowledge in all deep learning libraries related work like Pytourch, Tensorflow, keras and more others.

Hire realcode4you expert and get instant help with an affordable price. If you have any other related task then share with us at:

realcode4you@gmail.com