def _init_modules(self):
if self.num_layers == 18:
resnet = resnet18()
elif self.num_layers == 34:
resnet = resnet34()
elif self.num_layers == 50:
resnet = resnet50()
elif self.num_layers == 101:
resnet = resnet101()
elif self.num_layers == 152:
resnet = resnet152()
else:
assert 0, "network not defined"
if self.pretrained == True:
print("Loading pretrained weights from %s" % (self.model_path))
state_dict = torch.load(self.model_path)
resnet.load_state_dict({
k: v
for k, v in state_dict.items() if k in resnet.state_dict()
})
# Build resnet.
if self._fs == 16:
self.base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3)
elif self._fs == 32:
self.base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3,
resnet.layer4)
def _init_modules(self):
if self.num_layers == 18:
resnet = resnet18()
elif self.num_layers == 34:
resnet = resnet34()
elif self.num_layers == 50:
resnet = resnet50()
elif self.num_layers == 101:
resnet = resnet101()
elif self.num_layers == 152:
resnet = resnet152()
else:
assert 0, "network not defined"
if self.pretrained == True:
print("Loading pretrained weights from %s" % (self.model_path))
state_dict = torch.load(self.model_path)
resnet.load_state_dict({
k: v
for k, v in state_dict.items() if k in resnet.state_dict()
})
# Build resnet.
if self._fs == 16:
self.base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3)
self.ROIGN_top = nn.Sequential(
Bottleneck(256 * self.expansions, 64 * self.expansions),
Bottleneck(256 * self.expansions, 64 * self.expansions),
Bottleneck(256 * self.expansions, 64 * self.expansions))
# initialize grasp top
def kaiming_init(m):
def xavier(param):
init.kaiming_normal(param, nonlinearity='relu')
if isinstance(m, nn.Conv2d):
xavier(m.weight.data)
self.ROIGN_top.apply(kaiming_init)
else:
assert 0, "only support stride 16."
def set_bn_fix(m):
classname = m.__class__.__name__
if classname.find('BatchNorm') != -1:
for p in m.parameters():
p.requires_grad = False
# fix batch normalization
self.base.apply(set_bn_fix)
def _init_modules(self):
if self.num_layers == 50:
resnet = resnet50()
elif self.num_layers == 101:
resnet = resnet101()
else:
assert 0, "network not defined"
if self.pretrained == True:
print("Loading pretrained weights from %s" % (self.model_path))
state_dict = torch.load(self.model_path)
resnet.load_state_dict({k: v for k, v in state_dict.items() if k in resnet.state_dict()})
# Build resnet.
self.VMRN_base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3)
self.VMRN_obj_top = nn.Sequential(resnet.layer4)
# VMRN layers
if cfg.VMRN.SHARE_WEIGHTS:
self.VMRN_rel_top = copy.deepcopy(nn.Sequential(resnet.layer4))
else:
self.VMRN_rel_top_o1 = copy.deepcopy(nn.Sequential(resnet.layer4))
self.VMRN_rel_top_o2 = copy.deepcopy(nn.Sequential(resnet.layer4))
self.VMRN_rel_top_union = copy.deepcopy(nn.Sequential(resnet.layer4))
self.VMRN_obj_cls_score = nn.Linear(2048, self.n_classes)
if self.class_agnostic:
self.VMRN_obj_bbox_pred = nn.Linear(2048, 4)
else:
self.VMRN_obj_bbox_pred = nn.Linear(2048, 4 * self.n_classes)
self.VMRN_rel_cls_score = vmrn_rel_classifier(2048 * 3)
# Fix blocks
for p in self.VMRN_base[0].parameters(): p.requires_grad = False
for p in self.VMRN_base[1].parameters(): p.requires_grad = False
assert (0 <= cfg.RESNET.FIXED_BLOCKS < 4)
if cfg.RESNET.FIXED_BLOCKS >= 3:
for p in self.VMRN_base[6].parameters(): p.requires_grad = False
if cfg.RESNET.FIXED_BLOCKS >= 2:
for p in self.VMRN_base[5].parameters(): p.requires_grad = False
if cfg.RESNET.FIXED_BLOCKS >= 1:
for p in self.VMRN_base[4].parameters(): p.requires_grad = False
def set_bn_fix(m):
classname = m.__class__.__name__
if classname.find('BatchNorm') != -1:
for p in m.parameters(): p.requires_grad = False
self.VMRN_base.apply(set_bn_fix)
self.VMRN_obj_top.apply(set_bn_fix)
def _init_modules(self):
resnet = resnet101()
if self.pretrained == True:
print("Loading pretrained weights from %s" % (self.model_path))
state_dict = torch.load(self.model_path)
resnet.load_state_dict({
k: v
for k, v in state_dict.items() if k in resnet.state_dict()
})
# Build resnet.
self.RCNN_base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3)
self.RCNN_top = nn.Sequential(resnet.layer4)
self.RCNN_cls_score = nn.Linear(2048, self.n_classes)
if self.class_agnostic:
self.RCNN_bbox_pred = nn.Linear(2048, 4)
else:
self.RCNN_bbox_pred = nn.Linear(2048, 4 * self.n_classes)
# Fix blocks
for p in self.RCNN_base[0].parameters():
p.requires_grad = False
for p in self.RCNN_base[1].parameters():
p.requires_grad = False
assert (0 <= cfg.RESNET.FIXED_BLOCKS < 4)
if cfg.RESNET.FIXED_BLOCKS >= 3:
for p in self.RCNN_base[6].parameters():
p.requires_grad = False
if cfg.RESNET.FIXED_BLOCKS >= 2:
for p in self.RCNN_base[5].parameters():
p.requires_grad = False
if cfg.RESNET.FIXED_BLOCKS >= 1:
for p in self.RCNN_base[4].parameters():
p.requires_grad = False
def set_bn_fix(m):
classname = m.__class__.__name__
if classname.find('BatchNorm') != -1:
for p in m.parameters():
p.requires_grad = False
self.RCNN_base.apply(set_bn_fix)
self.RCNN_top.apply(set_bn_fix)
def _init_modules(self):
if self.num_layers == 18:
resnet = resnet18()
elif self.num_layers == 34:
resnet = resnet34()
elif self.num_layers == 50:
resnet = resnet50()
elif self.num_layers == 101:
resnet = resnet101()
elif self.num_layers == 152:
resnet = resnet152()
else:
assert 0, "network not defined"
if self.pretrained == True:
print("Loading pretrained weights from %s" %(self.model_path))
state_dict = torch.load(self.model_path)
resnet.load_state_dict({k:v for k,v in state_dict.items() if k in resnet.state_dict()})
# Build resnet.
self.RCNN_base = nn.Sequential(resnet.conv1, resnet.bn1,resnet.relu,
resnet.maxpool)
self.RCNN_feat_layers = nn.ModuleList()
self.RCNN_feat_layers.append(resnet.layer1)
self.RCNN_feat_layers.append(resnet.layer2)
self.RCNN_feat_layers.append(resnet.layer3)
self.RCNN_feat_layers.append(resnet.layer4)
self.RCNN_feat_layers.append(nn.MaxPool2d(kernel_size=3, stride=2))
# FPN channel reducing layers
self.RCNN_newconvs = nn.ModuleList()
self.RCNN_newconvs.append(nn.Conv2d(64 * self.expansions, 256, 1, stride=1))
self.RCNN_newconvs.append(nn.Conv2d(128 * self.expansions, 256, 1, stride=1))
self.RCNN_newconvs.append(nn.Conv2d(256 * self.expansions, 256, 1, stride=1))
self.RCNN_newconvs.append(nn.Conv2d(512 * self.expansions, 256, 1, stride=1))
self.RCNN_newconvs.append(nn.Conv2d(512 * self.expansions, 256, 1, stride=1))
# FPN mix conv layers
self.RCNN_mixconvs = nn.ModuleList()
self.RCNN_mixconvs.append(nn.Conv2d(256, 256, 3, stride=1, padding=1))
self.RCNN_mixconvs.append(nn.Conv2d(256, 256, 3, stride=1, padding=1))
self.RCNN_mixconvs.append(nn.Conv2d(256, 256, 3, stride=1, padding=1))
self.RCNN_mixconvs.append(nn.Conv2d(256, 256, 3, stride=1, padding=1))
self.RCNN_mixconvs.append(nn.Conv2d(256, 256, 3, stride=1, padding=1))
# FPN deconvoutional layers (totally 3)
self.RCNN_deconvs = nn.ModuleList()
for i in range(3):
self.RCNN_deconvs.append(
nn.Conv2d(256, 256, 1, stride=1)
)
hidden_num = 1024
# fully connected classifier and regressor
self.RCNN_top = nn.Sequential(
nn.Linear(self.expansions * 64 * 7 * 7, hidden_num),
nn.ReLU(),
nn.Linear(hidden_num, hidden_num),
nn.ReLU())
self.RCNN_cls_score = nn.Linear(hidden_num, self.n_classes)
if self.class_agnostic:
self.RCNN_bbox_pred = nn.Linear(hidden_num, 4)
else:
self.RCNN_bbox_pred = nn.Linear(1024, 4 * self.n_classes)
# Fix blocks
for p in self.RCNN_base[0].parameters(): p.requires_grad=False
for p in self.RCNN_base[1].parameters(): p.requires_grad=False
assert (0 <= cfg.RESNET.FIXED_BLOCKS < 4)
if cfg.RESNET.FIXED_BLOCKS >= 3:
for p in self.RCNN_feat_layers[2].parameters(): p.requires_grad=False
if cfg.RESNET.FIXED_BLOCKS >= 2:
for p in self.RCNN_feat_layers[1].parameters(): p.requires_grad=False
if cfg.RESNET.FIXED_BLOCKS >= 1:
for p in self.RCNN_feat_layers[0].parameters(): p.requires_grad=False
def set_bn_fix(m):
classname = m.__class__.__name__
if classname.find('BatchNorm') != -1:
for p in m.parameters(): p.requires_grad=False
self.RCNN_base.apply(set_bn_fix)
self.RCNN_feat_layers.apply(set_bn_fix)
def _init_modules(self):
resnet = resnet101()
if self.pretrained == True:
print("Loading pretrained weights from %s" % (self.model_path))
state_dict = torch.load(self.model_path)
resnet.load_state_dict({k: v for k, v in state_dict.items() if k in resnet.state_dict()})
# Build resnet.
self.VMRN_base = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3)
self.VMRN_obj_top = nn.Sequential(resnet.layer4)
# VMRN layers
if cfg.VMRN.SHARE_WEIGHTS:
self.VMRN_rel_top = copy.deepcopy(nn.Sequential(resnet.layer4))
else:
self.VMRN_rel_top_o1 = copy.deepcopy(nn.Sequential(resnet.layer4))
self.VMRN_rel_top_o2 = copy.deepcopy(nn.Sequential(resnet.layer4))
self.VMRN_rel_top_union = copy.deepcopy(nn.Sequential(resnet.layer4))
self.VMRN_obj_cls_score = nn.Linear(2048, self.n_classes)
if self.class_agnostic:
self.VMRN_obj_bbox_pred = nn.Linear(2048, 4)
else:
self.VMRN_obj_bbox_pred = nn.Linear(2048, 4 * self.n_classes)
self.VMRN_rel_cls_score = vmrn_rel_classifier(2048 * 3)
# Fix blocks
for p in self.VMRN_base[0].parameters(): p.requires_grad = False
for p in self.VMRN_base[1].parameters(): p.requires_grad = False
assert (0 <= cfg.RESNET.FIXED_BLOCKS < 4)
if cfg.RESNET.FIXED_BLOCKS >= 3:
for p in self.VMRN_base[6].parameters(): p.requires_grad = False
if cfg.RESNET.FIXED_BLOCKS >= 2:
for p in self.VMRN_base[5].parameters(): p.requires_grad = False
if cfg.RESNET.FIXED_BLOCKS >= 1:
for p in self.VMRN_base[4].parameters(): p.requires_grad = False
def set_bn_fix(m):
classname = m.__class__.__name__
if classname.find('BatchNorm') != -1:
for p in m.parameters(): p.requires_grad = False
self.VMRN_base.apply(set_bn_fix)
self.VMRN_obj_top.apply(set_bn_fix)
self.MGN_top = nn.Sequential(
Bottleneck(256 * self.expansions, 64 * self.expansions),
Bottleneck(256 * self.expansions, 64 * self.expansions),
Bottleneck(256 * self.expansions, 64 * self.expansions)
)
# initialize grasp top
def kaiming_init(m):
def xavier(param):
init.kaiming_normal(param, nonlinearity='relu')
if isinstance(m, nn.Conv2d):
xavier(m.weight.data)
self.MGN_top.apply(kaiming_init)