PyTorch-GoogLeNet-Implementation/Pytorch-InceptionNet.py at main · Dikashmashree/PyTorch-GoogLeNet-Implementation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#Imports
import torch
import torch.nn as nn # All neural network modules, nn.Linear , nn.Conv2d , BatchNorm , Loss functions

class GoogLeNet(nn.Module):
    def __init__(self, in_channels=3 , num_clasess=1000):
        super(GoogLeNet, self).__init__()

        self.conv1 = conv_block(in_channels=in_channels, out_channels=64, kernel_size=(7,7),stride=(2,2), padding=(3,3))
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride =2 ,padding = 1)

        self.conv2 = conv_block(64,192,  kernel_size=3, stride=1 , padding=1)
        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2 , padding=1)

        #In this order:  in_channels , out_1x1 , red_3x3 , out_3x3 , red_5x5 , out_5x5 ,  out_1x1pool
        self.inception3a = Inception_block(192,64, 96,128, 16, 32,32)
        self.inception3b = Inception_block(256,128,128,192, 32,96,64)
        self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2 , padding=1)

        self.inception4a = Inception_block(480,192,96,208,16 ,48,64)
        self.inception4b = Inception_block(512,160,112,224,24,64,64)
        self.inception4c = Inception_block(512,128,128,256,24,64,64)
        self.inception4d = Inception_block(512,112,144,288,32,64,64)
        self.inception4e = Inception_block(528,256,160,320,32,128,128)
        self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2 , padding=1)

        self.inception5a = Inception_block(832,256,160,320,32,128,128)
        self.inception5b = Inception_block(832,384,192,384,48,128,128)

        self.avgpool=nn.AvgPool2d(kernel_size=7, stride=1)
        self.dropout =nn.Dropout2d(p=0.4)
        self.fc1 = nn.Linear(1024,1000)

    def forward(self,x):
        x = self.conv1(x)
        x = self.maxpool1(x)

        x = self.conv2(x)
        x = self.maxpool2(x)

        x = self.inception3a(x)
        x = self.inception3b(x)
        x = self.maxpool3(x)

        x = self.inception4a(x)
        x = self.inception4b(x)
        x = self.inception4c(x)
        x = self.inception4d(x)
        x = self.inception4e(x)
        x = self.maxpool4(x)

        x =self.inception5a(x)
        x =self.inception5b(x)

        x = self.avgpool(x)
        x = x.reshape(x.shape[0], -1) #so that it can perform the fully connected
        x = self.dropout(x)
        x = self.fc1(x)

        return x


# why Inception_block before conv_block ? ----Because it uses multiple conv_blocks with different kernels
class Inception_block(nn.Module):
    def __init__(self , in_channels , out_1x1 , red_3x3 , out_3x3 , red_5x5 , out_5x5 ,  out_1x1pool): #filters
        super (Inception_block , self).__init__()

        self.branch1 = conv_block(in_channels , out_1x1 , kernel_size=1 ) #kernel_size=(1,1)
        self.branch2 = nn.Sequential(
            conv_block(in_channels,red_3x3,kernel_size=1),
            conv_block(red_3x3,out_3x3,kernel_size=3,padding=1) #stride=1
        )
        self.branch3 = nn.Sequential(
            conv_block(in_channels,red_5x5,kernel_size=1),#stride=1,padding=0---default
            conv_block(red_5x5,out_5x5,kernel_size=5,padding=2)#stride=1----default
        )
        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3 , stride=1 ,padding=1),
            conv_block(in_channels,out_1x1pool,kernel_size=1)
        )

    def forward(self , x):
        # N(i.e.no. of images) x filters x 28 x 28
        return torch.cat([self.branch1(x),self.branch2(x),self.branch3(x),self.branch4(x)] , 1) #N->dim(0), *filters->dim(1)*

class conv_block(nn.Module):
    def __init__(self , in_channels , out_channels , **kwarks):
        super(conv_block , self).__init__()
        self.relu = nn.ReLU()
        self.conv = nn.Conv2d(in_channels , out_channels , **kwarks) # kernel_size = (1,1) ,(3,3), (5,5)
        self.batchnorm = nn.BatchNorm2d(out_channels)

    def forward(self , x):
        return self.relu(self.batchnorm(self.conv(x)))


if __name__ =='__main__':
    x = torch.randn(3,3,224,224)
    model =  GoogLeNet()
    print(model(x).shape)

###output
###torch.Size([3,1000])------three images and all of them have 1000