File models/decide_net.py added (mode: 100644) (index 0000000..1040c6b) |
|
1 |
|
import torch.nn as nn |
|
2 |
|
import torch |
|
3 |
|
from torchvision import models |
|
4 |
|
from torchvision.models.detection import FasterRCNN |
|
5 |
|
import torchvision |
|
6 |
|
from torchvision.models.detection.rpn import AnchorGenerator |
|
7 |
|
|
|
8 |
|
def very_simple_param_count(model): |
|
9 |
|
result = sum([p.numel() for p in model.parameters()]) |
|
10 |
|
return result |
|
11 |
|
|
|
12 |
|
class DecideNet(nn.Module): |
|
13 |
|
""" |
|
14 |
|
Purpose this model is to count number of parameters in DecideNet |
|
15 |
|
(https://arxiv.org/pdf/1712.06679.pdf) |
|
16 |
|
It does not implement decide net correctly |
|
17 |
|
Just 'nearly' correct to estimate number of parameters |
|
18 |
|
""" |
|
19 |
|
def __init__(self, load_weights=False): |
|
20 |
|
super(DecideNet, self).__init__() |
|
21 |
|
self.seen = 0 |
|
22 |
|
self.reg_net_feat = [(7, 20, 1), (5, 40, 1), (5, 20, 1), (5, 10, 1), (1, 1, 1)] |
|
23 |
|
self.reg_net = make_layers(self.reg_net_feat, 3) |
|
24 |
|
self.quality_net_feat = [(7, 20, 1), (5, 40, 1), (5, 20, 1), (1, 1, 1)] |
|
25 |
|
self.quality_net = make_layers(self.quality_net_feat, 3) |
|
26 |
|
# backbone = torchvision.models.mobilenet_v2(pretrained=False).features |
|
27 |
|
backbone = torchvision.models.detection.backbone_utils.resnet_fpn_backbone('resnet101','False') |
|
28 |
|
# model = torchvision.models.detection.fasterrcnn_resnet50_fpn() |
|
29 |
|
# backbone.out_channels = 1280 |
|
30 |
|
anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),), |
|
31 |
|
aspect_ratios=((0.5, 1.0, 2.0),)) |
|
32 |
|
roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0], |
|
33 |
|
output_size=7, |
|
34 |
|
sampling_ratio=2) |
|
35 |
|
self.fastercnn = FasterRCNN(backbone, |
|
36 |
|
num_classes=2, |
|
37 |
|
rpn_anchor_generator=anchor_generator, |
|
38 |
|
box_roi_pool=roi_pooler) |
|
39 |
|
|
|
40 |
|
|
|
41 |
|
|
|
42 |
|
def forward(self, x): |
|
43 |
|
x = self.frontend(x) |
|
44 |
|
x = self.backend(x) |
|
45 |
|
x = self.output_layer(x) |
|
46 |
|
|
|
47 |
|
# remove channel dimension |
|
48 |
|
# (N, C_{out}, H_{out}, W_{out}) => (N, H_{out}, W_{out}) |
|
49 |
|
x = torch.squeeze(x, dim=1) |
|
50 |
|
return x |
|
51 |
|
|
|
52 |
|
# def _initialize_weights(self): |
|
53 |
|
# for m in self.modules(): |
|
54 |
|
# if isinstance(m, nn.Conv2d): |
|
55 |
|
# nn.init.normal_(m.weight, std=0.01) |
|
56 |
|
# if m.bias is not None: |
|
57 |
|
# nn.init.constant_(m.bias, 0) |
|
58 |
|
# elif isinstance(m, nn.BatchNorm2d): |
|
59 |
|
# nn.init.constant_(m.weight, 1) |
|
60 |
|
# nn.init.constant_(m.bias, 0) |
|
61 |
|
|
|
62 |
|
|
|
63 |
|
def make_layers(cfg, in_channels=3, batch_norm=False): |
|
64 |
|
layers = [] |
|
65 |
|
for v in cfg: |
|
66 |
|
if v is 'M': |
|
67 |
|
layers += [nn.MaxPool2d(kernel_size=2, stride=2)] |
|
68 |
|
else: |
|
69 |
|
kernel_size = v[0] |
|
70 |
|
n_filter = v[1] |
|
71 |
|
dilated_rate = v[2] |
|
72 |
|
conv2d = nn.Conv2d(in_channels, n_filter, kernel_size=kernel_size, padding=dilated_rate, dilation=dilated_rate) |
|
73 |
|
if batch_norm: |
|
74 |
|
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=False)] |
|
75 |
|
else: |
|
76 |
|
layers += [conv2d, nn.ReLU(inplace=False)] |
|
77 |
|
in_channels = n_filter |
|
78 |
|
return nn.Sequential(*layers) |
|
79 |
|
|
|
80 |
|
if __name__ == "__main__": |
|
81 |
|
net = DecideNet() |
|
82 |
|
n_param = very_simple_param_count(net) |
|
83 |
|
print(n_param) |
|
84 |
|
resnet101 = torchvision.models.detection.backbone_utils.resnet_fpn_backbone('resnet101','False') |
|
85 |
|
print(very_simple_param_count(resnet101)) |