def __init__(self, config, in_channels, RCNN_top=None): super(ResNet50Conv5ROIFeatureExtractorFlatten, self).__init__() resolution = config.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION scales = config.MODEL.ROI_BOX_HEAD.POOLER_SCALES sampling_ratio = config.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO pooler = Pooler( output_size=(resolution, resolution), scales=scales, sampling_ratio=sampling_ratio, ) stage = resnet.StageSpec(index=4, block_count=3, return_features=False) head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.pooler = pooler self.head = head hidden_channels = head.out_channels use_gn = config.MODEL.ROI_BOX_HEAD.USE_GN self.out_channels = config.MODEL.ROI_BOX_HEAD.MLP_HEAD_DIM self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( make_fc(hidden_channels, self.out_channels, use_gn), nn.ReLU())
def __init__(self, config): super(ResNet50Conv5ROIFeatureExtractor, self).__init__() resolution = config.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION scales = config.MODEL.ROI_BOX_HEAD.POOLER_SCALES sampling_ratio = config.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO pooler = Pooler( output_size=(resolution, resolution), scales=scales, sampling_ratio=sampling_ratio, ) stage = resnet.StageSpec(index=4, block_count=3, return_features=False) head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.pooler = pooler self.head = head
def __init__(self, config, select_num=10, class_num=5, is_cat=True): super(Network, self).__init__() self.detector = build_detection_model(config) self.detector.eval() self.detector.load_state_dict(torch.load(config.MODEL.WEIGHT)['model'], strict=False) # output_dir = config.OUTPUT_DIR # checkpointer = DetectronCheckpointer(config, self.detector, save_dir=output_dir) # ckpt = config.MODEL.WEIGHT # _ = checkpointer.load(ckpt, use_latest=True) for count, child in enumerate(self.detector.children()): count += 1 print(count) print(child) if count < 4: for param in child.parameters(): param.requires_grad = False self.selector = Selector() self.select_num = select_num self.sftmax = nn.Softmax(dim=0) self.is_cat = is_cat # ResNet Head stage = resnet.StageSpec(index=4, block_count=3, return_features=False) self.head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.avgpool_glob = nn.AdaptiveAvgPool2d(output_size=14) # self.conv_glob = nn.Conv2d(1024, 2048, 2, stride=2) # self.relu_glob = nn.PReLU(2048) if self.is_cat: self.conv1 = nn.Conv2d(2048, 512, 1) # self.relu1 = nn.PReLU(512) self.relu1 = nn.ReLU(inplace=True) self.fc1 = nn.Linear(512 * (self.select_num + 1), 512) # select top 5 # self.fc1_relu = nn.PReLU(512) self.fc1_relu = nn.ReLU(inplace=True) self.fc2 = nn.Linear(512, class_num) else: self.conv1 = nn.Conv2d(4096, 512, 1, 1) # self.relu1 = nn.PReLU(512) self.relu1 = nn.ReLU(inplace=True) self.fc1 = nn.Linear(512, 512) # self.fc1_relu = nn.PReLU(512) self.fc1_relu = nn.ReLU(inplace=True) self.fc2 = nn.Linear(512, class_num) self.avgpool = nn.AdaptiveAvgPool2d(output_size=1) self.dropout = nn.Dropout()
def build_resnet_fpn_p3p7_backbone(stem_out_channels=64, in_channels_stage2=256, out_channels=256, use_c5=False, use_gn=False, use_relu=False, num_input_channels=4): stem_module = resnet.StemWithFixedBatchNorm(stem_out_channels, in_channels=num_input_channels) stage_specs = [ # R-50-FPN-RETINANET resnet.StageSpec(index=1, block_count=3, return_features=True), resnet.StageSpec(index=2, block_count=4, return_features=True), resnet.StageSpec(index=3, block_count=6, return_features=True), resnet.StageSpec(index=4, block_count=3, return_features=True) ] transformation_module = resnet.BottleneckWithFixedBatchNorm body = resnet.ResNetLight(stem_module, stage_specs, transformation_module, freeze_conv_body_at=-1) in_channels_p6p7 = in_channels_stage2 * 8 if use_c5 else out_channels fpn = fpn_module.FPN( in_channels_list=[ 0, in_channels_stage2 * 2, in_channels_stage2 * 4, in_channels_stage2 * 8, ], out_channels=out_channels, conv_block=conv_with_kaiming_uniform(use_gn, use_relu), top_blocks=fpn_module.LastLevelP6P7(in_channels_p6p7, out_channels), ) model = nn.Sequential(OrderedDict([("body", body), ("fpn", fpn)])) model.out_channels = out_channels return model
def __init__(self, config, select_num=10, class_num=4, side=False, is_cat=False): super(Predictor, self).__init__() self.selector = Selector() self.select_num = select_num self.sftmax = nn.Softmax(dim=0) self.side = side self.is_cat = is_cat # ResNet Head stage = resnet.StageSpec(index=4, block_count=3, return_features=False) self.head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, dilation=config.MODEL.RESNETS.RES5_DILATION) self.head.load_state_dict( torch.load('/data6/SRIP19_SelfDriving/Outputs/layer4.pth') ) #TODO: how to avoid this? Maybe we can involve the weights into model_final.pth self.avgpool_glob = nn.AdaptiveAvgPool2d(output_size=14) if self.is_cat: self.avg1 = nn.AdaptiveAvgPool3d(output_size=1) self.avg2 = nn.AdaptiveAvgPool2d(output_size=1) self.fc1 = nn.Linear(4096, 100) self.relu1 = nn.ReLU(inplace=True) self.fc2 = nn.Linear(100, class_num) self.drop = nn.Dropout(p=0.25) if self.side: self.fc_side1 = nn.Linear(4096, 100) self.relu_side1 = nn.ReLU(inplace=True) self.fc_side2 = nn.Linear(100, 21) else: self.avg = nn.AdaptiveAvgPool2d(output_size=1) self.fc2 = nn.Linear(2048, class_num) self.drop = nn.Dropout(p=0.25) if self.side: self.fc_side = nn.Linear(2048, 21)
def __init__(self, config, in_channels): super(ResNet50Conv5ROIFeatureExtractor, self).__init__() pooler = Pooler(config.MODEL.ROI_BOX_HEAD) stage = resnet.StageSpec(index=4, block_count=3, return_features=False) head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.pooler = pooler self.head = head self.out_channels = head.out_channels
def __init__(self, config, class_num=4, is_cat=False, is_feature=False): super(baseline, self).__init__() self.class_num = class_num # number of actions self.is_cat = is_cat self.is_feature = is_feature # conv layers stage = resnet.StageSpec(index=4, block_count=3, return_features=False) self.head = ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage,), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) # TODO: specify the arguments here! output: (1, 2048, 14, 14) self.head.load_state_dict(torch.load('/data6/SRIP19_SelfDriving/Outputs/layer4.pth')) self.avgpool1 = nn.AdaptiveAvgPool3d(output_size=1) self.avgpool2 = nn.AdaptiveAvgPool2d(output_size=1) self.action_pred = nn.Linear(2048+1024, 4)
def __init__(self, config, in_channels): super(ResNet50Conv5ROIFeatureExtractor, self).__init__() resolution = config.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION scales = config.MODEL.ROI_BOX_HEAD.POOLER_SCALES sampling_ratio = config.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO pooler = Pooler( output_size=(resolution, resolution), scales=scales, sampling_ratio=sampling_ratio, ) # ResNet50Conv5 input size is 1024, which is the default for backbone # without FPN. For FPN structure, the in_channels will be 256. So we # need to add a transit conv layer to make it compatible. # The corresponding predictor should be FastRCNNPredictor. if in_channels != 1024: self.trans_conv = nn.Conv2d(in_channels, 1024, kernel_size=3, padding=1) torch.nn.init.normal_(self.trans_conv.weight, std=0.01) torch.nn.init.constant_(self.trans_conv.bias, 0) else: self.trans_conv = None stage = resnet.StageSpec(index=4, block_count=3, return_features=False) head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.pooler = pooler self.head = head self.out_channels = head.out_channels
def __init__(self, cfg): super(ResNet50Conv5ROIFeatureExtractor, self).__init__() self.cfg = cfg self.in_channels = 2048 self.out_channels = cfg.REID.OUT_CHANNELS self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = make_fc(self.in_channels, self.out_channels) if self.cfg.REID.USE_DIFF_FEAT: stage = resnet.StageSpec(index=4, block_count=3, return_features=False) head = resnet.ResNetHead( block_module=cfg.MODEL.RESNETS.TRANS_FUNC, stages=(stage,), num_groups=cfg.MODEL.RESNETS.NUM_GROUPS, width_per_group=cfg.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=cfg.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=cfg.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=cfg.MODEL.RESNETS.RES5_DILATION ) self.head = head
def __init__(self, config, class_num=2, is_cat=True, is_feature=False): super(baseline, self).__init__() self.class_num = class_num # number of actions self.is_cat = is_cat self.is_feature = is_feature # conv layers stage = resnet.StageSpec(index=4, block_count=3, return_features=False) self.head = ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION ) # TODO: specify the arguments here! output: (1, 2048, 14, 14) self.head.load_state_dict( torch.load('/data6/SRIP19_SelfDriving/Outputs/layer4.pth')) self.selector = Selector() self.softmax = nn.Softmax(dim=0) # self.avg_glob = nn.AdaptiveAvgPool2d(output_size=7) '''if not self.is_cat: self.avgpool1 = nn.AdaptiveAvgPool3d(output_size=1) self.fc1 = nn.Linear(2048+1024, 256) self.relu1 = nn.PReLU(256) self.avgpool2 = nn.AdaptiveAvgPool2d(output_size=1) else: self.avgpool1 = nn.AdaptiveAvgPool2d(output_size=1) self.fc1 = nn.Linear(2048*6, 256) self.relu1 = nn.PReLU(256) self.drop = nn.Dropout(p=0.5) self.fc2 = nn.Linear(256, self.class_num)''' self.avg = nn.AdaptiveAvgPool2d(output_size=1) self.drop = nn.Dropout(p=0.25) self.fc = nn.Linear(2048, self.class_num)
def __init__(self, config, select_num=5, class_num=5, is_cat=True): super(Predictor, self).__init__() self.selector = Selector() self.select_num = select_num self.sftmax = nn.Softmax(dim=0) self.is_cat = is_cat # ResNet Head stage = resnet.StageSpec(index=4, block_count=3, return_features=False) self.head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.avgpool_glob = nn.AdaptiveAvgPool2d(output_size=14) # self.conv_glob = nn.Conv2d(1024, 2048, 2, stride=2) # self.relu_glob = nn.PReLU(2048) if self.is_cat: self.conv1 = nn.Conv2d(2048, 512, 1) self.relu1 = nn.ReLU(inplace=True) self.fc1 = nn.Linear(512 * (self.select_num + 1), 512) # select top 5 self.fc1_relu = nn.ReLU(inplace=True) self.fc2 = nn.Linear(512, class_num) else: self.conv1 = nn.Conv2d(4096, 512, 1, 1) self.relu1 = nn.ReLU(inplace=True) self.fc1 = nn.Linear(512) self.fc1_relu = nn.ReLU(inplace=True) self.fc2 = nn.Linear(512, class_num) self.avgpool = nn.AdaptiveAvgPool2d(output_size=1) self.dropout = nn.Dropout()
def __init__(self, config): super(MultiLabelCls, self).__init__() stage = resnet.StageSpec(index=4, block_count=3, return_features=False) self.head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) self.pooler = nn.AdaptiveAvgPool2d(7) self.avgpool = nn.AdaptiveAvgPool2d(1) self.num_classes = config.MODEL.ROI_BOX_HEAD.NUM_CLASSES - 1 # 80 # 1024 for both c4 and FPN architecture num_inputs = config.MODEL.RESNETS.BACKBONE_OUT_CHANNELS * 2 self.classifier = nn.Linear(num_inputs, self.num_classes) nn.init.normal_(self.classifier.weight, mean=0, std=0.01) nn.init.constant_(self.classifier.bias, 0) self.softmax = nn.Softmax()
def __init__(self, config, in_channels): super(ResNet50Conv5ROIFeatureExtractor, self).__init__() resolution = config.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION scales = config.MODEL.ROI_BOX_HEAD.POOLER_SCALES sampling_ratio = config.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO pooler = Pooler( output_size=(resolution, resolution), scales=scales, sampling_ratio=sampling_ratio, ) stage = resnet.StageSpec(index=4, block_count=3, return_features=False) head = resnet.ResNetHead( block_module=config.MODEL.RESNETS.TRANS_FUNC, stages=(stage, ), num_groups=config.MODEL.RESNETS.NUM_GROUPS, width_per_group=config.MODEL.RESNETS.WIDTH_PER_GROUP, stride_in_1x1=config.MODEL.RESNETS.STRIDE_IN_1X1, stride_init=None, res2_out_channels=config.MODEL.RESNETS.RES2_OUT_CHANNELS, dilation=config.MODEL.RESNETS.RES5_DILATION) model_parameters = head.state_dict() if '.pkl' in cfg.MODEL.VG.RESNET_PARAMS_FILE: with open(cfg.MODEL.VG.RESNET_PARAMS_FILE, 'rb') as f: if torch._six.PY3: pretrained_paras = pickle.load(f, encoding="latin1")['blobs'] else: pretrained_paras = pickle.load(f)['blobs'] stages = ["1.2", "2.3", "3.5", "4.2"] pretrained_paras = _rename_weights_for_resnet( pretrained_paras, stages) pretrained_dict = {} model_parameters.keys() for k, v in pretrained_paras.items(): if k in list(model_parameters.keys()): print(k) pretrained_dict[k] = v else: pretrained_paras = torch.load( cfg.MODEL.VG.RESNET_PARAMS_FILE)['model'] pretrained_new = {} keys_list = list(pretrained_paras.keys()) for keys in keys_list: pretrained_new[keys] = pretrained_paras[keys].cpu() pretrained_paras = pretrained_new pretrained_dict = {} model_parameters.keys() print('loading pascal pretrained weights') for key in key_words: new_key = "module.roi_heads.box.feature_extractor.head." + key if new_key in list(pretrained_paras.keys()): pretrained_dict[key] = pretrained_paras[new_key] print(key, '------>', new_key) model_parameters.update(pretrained_dict) head.load_state_dict(model_parameters) print('loading bottom up attention feature done') self.pooler = pooler self.head = head self.out_channels = head.out_channels spatial_dim = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION if cfg.MODEL.VG.SPATIAL_FEAT: self.spatial_transform = nn.Sequential( nn.Linear(2 * spatial_dim * spatial_dim, 256), nn.ReLU())