def __init__(self, nclass, backbone, aux, se_loss, dilated=True, norm_layer=None, base_size=576, crop_size=608, mean=[.485, .456, .406], std=[.229, .224, .225], root='./pretrain_models', multi_grid=False, multi_dilation=None): super(BaseNet, self).__init__() self.nclass = nclass self.aux = aux self.se_loss = se_loss self.mean = mean self.std = std self.base_size = base_size self.crop_size = crop_size # copying modules from pretrained models if backbone == 'resnet50': self.pretrained = resnet.resnet50(pretrained=False, dilated=dilated, norm_layer=norm_layer, root=root, multi_grid=multi_grid, multi_dilation=multi_dilation) elif backbone == 'resnet101': self.pretrained = resnet.resnet101(pretrained=True, dilated=dilated, norm_layer=norm_layer, root=root, multi_grid=multi_grid,multi_dilation=multi_dilation) elif backbone == 'resnet152': self.pretrained = resnet.resnet152(pretrained=True, dilated=dilated, norm_layer=norm_layer, root=root, multi_grid=multi_grid, multi_dilation=multi_dilation) else: raise RuntimeError('unknown backbone: {}'.format(backbone)) # bilinear upsample options self._up_kwargs = up_kwargs
def __init__(self, model_name='resnet', classes_number=20, is_train=False): """ :param model_name: pre-train model name. a str :param classes_number: number of classes. a int """ super(Classifier, self).__init__() self.model_name = model_name self.is_train = is_train if model_name == 'resnet': self.feature_net = resnet101(pretrained=is_train) elif model_name == 'mobilenet': net = MobileNetV2(n_class=1000) if is_train: state_dict = torch.load('./models/mobilenet_v2.pth.tar') # add map_location='cpu' if no gpu net.load_state_dict(state_dict) self.feature_net = net.features else: print('Error: wrong model name.') exit() if model_name == 'mobilenet': self.avgpool = torch.nn.AdaptiveAvgPool2d((1, 1)) self.drop_out = torch.nn.Dropout(0.5) self.fc = torch.nn.Linear(1280, classes_number) else: self.drop_out = torch.nn.Dropout(0.5) self.fc = torch.nn.Linear(2048, classes_number) self.fc.weight.data.normal_(0, 0.1)
def deeplabv3_resnet101(pretrained=False, progress=True, num_classes=21, aux_loss=None, **kwargs): backbone = resnet101(pretrained=True, replace_stride_with_dilation=[False, True, True]) return_layers = {'layer4': 'out'} #if aux_loss: # return_layers['layer3'] = 'aux' backbone = IntermediateLayerGetter(backbone, return_layers=return_layers) aux_classifier = None #if aux_loss: # inplanes = 1024 # aux_classifier = FCNHead(inplanes, num_classes) model_map = { 'deeplabv3': (DeepLabHead, DeepLabV3) } inplanes = 2048 classifier = model_map["deeplabv3"][0](inplanes, num_classes) base_model = model_map["deeplabv3"][1] model = base_model(backbone, classifier, aux_classifier) return model
def __init__(self, nclass, backbone, aux, se_loss, dilated=True, norm_layer=None, base_size=576, crop_size=608, mean=[.485, .456, .406], std=[.229, .224, .225], root='./pretrain_models', multi_grid=False, multi_dilation=None): super(BaseNet, self).__init__() self.nclass = nclass self.aux = aux self.se_loss = se_loss self.mean = mean self.std = std self.base_size = base_size self.crop_size = crop_size # copying modules from pretrained models self.pretrained = resnet101(pretrained=True, dilated=dilated, norm_layer=norm_layer, root=root, multi_grid=multi_grid, multi_dilation=multi_dilation)
def __init__(self, nclass, backbone): super(DeepTen, self).__init__() self.backbone = backbone # copying modules from pretrained models if self.backbone == 'resnet50': self.pretrained = resnet50(pretrained=True, dilated=False) elif self.backbone == 'resnet101': self.pretrained = resnet101(pretrained=True, dilated=False) elif self.backbone == 'resnet152': self.pretrained = resnet152(pretrained=True, dilated=False) else: raise RuntimeError('unknown backbone: {}'.format(self.backbone)) self.scalenum = 4 n_codes = 32 self.fc = nn.Sequential( Normalize(), nn.Linear(64 * 64, 128), ) self.classifier = nn.Sequential(Normalize(), nn.Linear(128 * self.scalenum, nclass)) self.head1 = self.make_layer_head_customize(256, n_codes, 56) self.head2 = self.make_layer_head_customize(512, n_codes, 28) self.head3 = self.make_layer_head_customize(1024, n_codes, 14) self.head4 = self.make_layer_head_customize(2048, n_codes, 7) self.pool1 = self.make_layer_pooling_customize(256, 56) self.pool2 = self.make_layer_pooling_customize(512, 28) self.pool3 = self.make_layer_pooling_customize(1024, 14) self.pool4 = self.make_layer_pooling_customize(2048, 7)
def __init__( self, last_conv_stride=1, last_conv_dilation=1, num_stripes=6, local_conv_out_channels=256, num_classes=0 ): super(PCBModel, self).__init__() self.base = resnet101( pretrained=False, last_conv_stride=last_conv_stride, last_conv_dilation=last_conv_dilation) self.num_stripes = num_stripes print (self.base) self.local_conv_list = nn.ModuleList() for _ in range(num_stripes): self.local_conv_list.append(nn.Sequential( nn.Conv2d(4096, local_conv_out_channels, 1), nn.BatchNorm2d(local_conv_out_channels), #nn.ReLU(inplace=True) )) if num_classes > 0: self.fc_list = nn.ModuleList() for _ in range(num_stripes): fc = nn.Linear(local_conv_out_channels, num_classes) init.normal(fc.weight, std=0.001) init.constant(fc.bias, 0) self.fc_list.append(fc)
def get_model(model_name, pho_size=299, num_classes=110): if model_name == "vgg16": model = VGG(num_classes=num_classes, pho_size=299) elif model_name == "resnet101": model = resnet101(num_classes=num_classes) elif model_name == "densenet": model = DenseNet(growth_rate=12, block_config=[(100 - 4) // 6 for _ in range(3)], num_classes=num_classes, small_inputs=False, efficient=True, pho_size=pho_size) elif model_name == "InceptionResNetV2": model = InceptionResNetV2(num_classes=num_classes) elif model_name == "InceptionV4": model = InceptionV4(num_classes=num_classes) elif model_name == "Inception3": model = Inception3(num_classes=num_classes) elif model_name == "denoise": model = get_denoise() elif model_name == "Mymodel": model = Mymodel() elif model_name == 'Comdefend': model = ComDefend() elif model_name == 'Rectifi': model = Rectifi() return model
def __init__(self, backbone=resnet101(pretrained=True)): super(FPN, self).__init__() self.backbone = backbone self.conv6 = nn.Conv2d(2048, 256, kernel_size=3, stride=2, padding=1) self.conv7 = nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1) self.latlayer1 = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0) self.latlayer2 = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0) self.latlayer3 = nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0) self.toplayer1 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) self.toplayer2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
def __init__(self, n_classes=19): super(DeepLabV3Plus, self).__init__() self.out_channels = 256 self.backbone = resnet101( pretrained=True, replace_stride_with_dilation=[False, False, False]) self.stem = nn.Sequential(*list(self.backbone.children())[:4]) self.block1 = self.backbone.layer1 self.block2 = self.backbone.layer2 self.block3 = self.backbone.layer3 self.block4 = self.backbone.layer4 self.low_level_features_in_channels = 256 self.low_level_features_out_channels = 48 self.low_level_features_conv = ConvBlock( self.low_level_features_in_channels, self.low_level_features_out_channels, kernel_size=1) self.aspp = AtrousSpatialPyramidPooling(2048, self.out_channels) self.decoder = nn.Sequential( ConvBlock(self.low_level_features_out_channels + self.out_channels, self.out_channels, kernel_size=3), nn.Dropout(0.5), ConvBlock(self.out_channels, self.out_channels, kernel_size=3), nn.Dropout(0.1), nn.Conv2d(self.out_channels, n_classes, kernel_size=1), )
def build_net(phase, size=321, num_classes=21): if phase != "test" and phase != "train": print("ERROR: Phase: " + phase + " not recognized") return base_, head_ = multibox(resnet101(), mbox[str(size)], num_classes) extras_ = add_extras(base_, size=size) return ACD(phase, size, base_, extras_, head_, num_classes)
def main(): net_path = 'logs/modelnet/modelnet_int_norm' dump_path = 'output_data/modelnet_errors' dataset_location = 'datasets' # TODO update to dataset path device = torch.device('cpu') dataset = ModelNetSo3.ModelNetSo3(dataset_location) dataset_eval = dataset.get_eval() base = resnet101() model = ResnetHead(base, 10, 32, 512, 9) loggers = logger.Logger(net_path, ModelNetSo3.ModelNetSo3, load=True) loggers.load_network_weights(49, model, device) model.eval() if not os.path.exists(dump_path): os.makedirs(dump_path) idx = np.arange(len(dataset_eval)) sampler = ListSampler(idx) dataloader = torch.utils.data.DataLoader(dataset_eval, sampler=sampler, batch_size=32, drop_last=False) stats = logger.SubsetLogger( None, None, 0, False ) # not intended use, need to look over how to set up logger differently i = 0 for batch in tqdm.tqdm(dataloader): # if i > 1: # break i += 1 image, extrinsic, class_idx_cpu, hard, intrinsic, _ = batch image = image.to(device) R = extrinsic[:, :3, :3].to(device) R = R.clone() class_idx = class_idx_cpu.to(device) out = model(image, class_idx) losses, Rest = loss_func(out, R) loss = torch.mean(losses) stats.add_samples(image, losses, out.view(-1, 3, 3), R, Rest, class_idx_cpu, hard) easy_stats, hard_stats = get_errors(stats.angular_errors, stats.class_indices, stats.hard, ModelNetSo3.ModelNetSo3Classes) per_class = easy_stats[1] for k, v in per_class.items(): savefile = os.path.join(dump_path, '{}.txt'.format(k)) all_errors = v[4] with open(savefile, 'w') as f: for e in all_errors: f.write('{}\n'.format(e)) with open(os.path.join(dump_path, 'all.pkl'), 'wb') as f: pickle.dump(easy_stats, f) errs = per_class['bathtub'][4] plt.hist(errs, 100) plt.show()
def visualize_random_errors(): net_path = 'logs/pascal/pascal_new_norm_full' image_dir_out = 'plots/random_errors' dataset_location = 'datasets' # TODO update with dataset path device = torch.device('cpu') dataset = Pascal3D.Pascal3D(train_all=True) dataset_vis = dataset.get_eval() base = resnet101() model = ResnetHead(base, 13, 32, 512, 9) loggers = logger.Logger(net_path, Pascal3D.PascalClasses, load=True) loggers.load_network_weights(119, model, device) model.eval() if not os.path.exists(image_dir_out): os.makedirs(image_dir_out) np.random.seed(9001) idx = np.arange(len(dataset_vis)) np.random.shuffle(idx) sampler = ListSampler(idx) dataloader = torch.utils.data.DataLoader(dataset_vis, sampler=sampler, batch_size=1, drop_last=False) fig, axs = plt.subplots(3, 4, figsize=(10, 7.5), dpi=100 * 4) for i, batch in enumerate(dataloader): if i == 12: break ax = axs[i // 4][i % 4] image, extrinsic, class_idx_cpu, hard, intrinsic, _ = batch extrinsic_np = extrinsic[0].numpy() intrinsic_np = intrinsic[0].numpy() im_np = image[0].numpy().transpose(1, 2, 0) R_gt = extrinsic[0, :3, :3].numpy() out = model(image, class_idx_cpu).view(-1, 3, 3) R_est = loss.batch_torch_A_to_R(out).detach().cpu().view(3, 3).numpy() err = loss.angle_error_np(R_gt, R_est) extr_est = np.copy(extrinsic_np) extr_est[:3, :3] = R_est points_est = proj_axis(extr_est, intrinsic_np) points_true = proj_axis(extrinsic_np, intrinsic_np) ax.imshow(im_np) for p, c in zip(points_est[:, 1:].transpose(), ['r', 'g', 'b']): x = [points_est[0, 0], p[0]] y = [points_est[1, 0], p[1]] ax.plot(x, y, c, linewidth=5) for p, c in zip(points_true[:, 1:].transpose(), ['m', 'y', 'c']): x = [points_true[0, 0], p[0]] y = [points_true[1, 0], p[1]] ax.plot(x, y, c, linewidth=2) ax.title.set_text("error: {:3.2f}".format(err)) ax.axes.get_xaxis().set_visible(False) ax.axes.get_yaxis().set_visible(False) image_out = os.path.join(image_dir_out, 'im_errors.pdf') plt.savefig(image_out)
def main(): """Sample main function""" model = resnet101(pretrained=True) model.eval() ori_top1, ori_top5 = model_forward(model, batch_size=32, iterations=5) # Quantize configurations args_shape = [(1, 3, 224, 224)] input_data = tuple([torch.randn(arg_shape) for arg_shape in args_shape]) # pylint: disable=E1101 if torch.cuda.is_available(): input_data = tuple([data.to('cuda') for data in input_data]) model.to('cuda') config_json_file = os.path.join(TMP, 'config.json') skip_layers = [] batch_num = 2 amct.create_quant_config(config_json_file, model, input_data, skip_layers, batch_num) # Phase1: do conv+bn fusion, weights calibration and generate # calibration model record_file = os.path.join(TMP, 'record.txt') modified_model = os.path.join(TMP, 'modified_model.onnx') calibration_model = amct.quantize_model(config_json_file, modified_model, record_file, model, input_data, input_names=['input'], output_names=['output'], dynamic_axes={ 'input': { 0: 'batch_size' }, 'output': { 0: 'batch_size' } }) # Phase2: do calibration model_forward(calibration_model, batch_size=32, iterations=batch_num) if torch.cuda.is_available(): torch.cuda.empty_cache() # Phase3: save final model, one for onnx do fake quant test, one # deploy model for ATC result_path = os.path.join(OUTPUTS, 'resnet-101') amct.save_model(modified_model, record_file, result_path) # Phase4: run fake_quant model test quant_top1, quant_top5 = onnx_forward( '%s_%s' % (result_path, 'fake_quant_model.onnx'), batch_size=32, iterations=5) print('[INFO] ResNet101 before quantize top1:{:>10} top5:{:>10}'.format( ori_top1, ori_top5)) print('[INFO] ResNet101 after quantize top1:{:>10} top5:{:>10}'.format( quant_top1, quant_top5))
def init_net(self): net_args = { "pretrained": True, "n_input_channels": len(self.kwargs["static"]["imagery_bands"]) } # https://pytorch.org/docs/stable/torchvision/models.html if self.kwargs["net"] == "resnet18": self.model = resnet.resnet18(**net_args) elif self.kwargs["net"] == "resnet34": self.model = resnet.resnet34(**net_args) elif self.kwargs["net"] == "resnet50": self.model = resnet.resnet50(**net_args) elif self.kwargs["net"] == "resnet101": self.model = resnet.resnet101(**net_args) elif self.kwargs["net"] == "resnet152": self.model = resnet.resnet152(**net_args) elif self.kwargs["net"] == "vgg11": self.model = vgg.vgg11(**net_args) elif self.kwargs["net"] == "vgg11_bn": self.model = vgg.vgg11_bn(**net_args) elif self.kwargs["net"] == "vgg13": self.model = vgg.vgg13(**net_args) elif self.kwargs["net"] == "vgg13_bn": self.model = vgg.vgg13_bn(**net_args) elif self.kwargs["net"] == "vgg16": self.model = vgg.vgg16(**net_args) elif self.kwargs["net"] == "vgg16_bn": self.model = vgg.vgg16_bn(**net_args) elif self.kwargs["net"] == "vgg19": self.model = vgg.vgg19(**net_args) elif self.kwargs["net"] == "vgg19_bn": self.model = vgg.vgg19_bn(**net_args) else: raise ValueError("Invalid network specified: {}".format( self.kwargs["net"])) # run type: 1 = fine tune, 2 = fixed feature extractor # - replace run type option with "# of layers to fine tune" if self.kwargs["run_type"] == 2: layer_count = len(list(self.model.parameters())) for layer, param in enumerate(self.model.parameters()): if layer <= layer_count - 5: param.requires_grad = False # Parameters of newly constructed modules have requires_grad=True by default # get existing number for input features # set new number for output features to number of categories being classified # see: https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html if "resnet" in self.kwargs["net"]: num_ftrs = self.model.fc.in_features self.model.fc = nn.Linear(num_ftrs, self.ncats) elif "vgg" in self.kwargs["net"]: num_ftrs = self.model.classifier[6].in_features self.model.classifier[6] = nn.Linear(num_ftrs, self.ncats)
def __init__(self, num_class = 9, input_channel = 3, output_stride=16, layer=101): super(resnet_backbone, self).__init__() if layer == 101: self.resnet = resnet101(pretrained=True, output_stride=output_stride) elif layer == 152: self.resnet = resnet152(pretrained=True, output_stride=output_stride) self.conv1 = self.resnet.conv1
def build_model(self): print('==> Build model and setup loss and optimizer') #build model self.model = resnet101(pretrained= True, channel=self.channel).cuda() #print self.model #Loss function and optimizer self.criterion = nn.CrossEntropyLoss().cuda() self.optimizer = torch.optim.SGD(self.model.parameters(), self.lr, momentum=0.9) self.scheduler = ReduceLROnPlateau(self.optimizer, 'min', patience=1,verbose=True)
def main_worker(gpu_index, gpu_num, args): """main_worker""" # Phase initialization. # If multi-card distributed training is used, initialize the training # process. if args.distributed: dist.init_process_group(backend='nccl', init_method=args.dist_url, world_size=gpu_num, rank=gpu_index) # Generate training dataset and validation dataset loader. train_loader, train_sampler, val_loader = create_data_loader( args.train_set, args.eval_set, args) # Phase origin model accuracy. # Step 1: Create model. print("=> Create pre-trained model 'resnet101'") # Choose whether to use the model downloaded online or # the model modified locally. # 1. use the resnet101 model downloaded online. model = models.__dict__['resnet101'](pretrained=True) # 2. use the resnet101 model modified locally. model = resnet101(pretrained=True) # Step 2: Calculate origin model's accuracy. ori_top1, ori_top5 = cal_original_model_accuracy(model, gpu_index, val_loader, args) # Phase retrain the model. # Step 3: Generate the retraining model in default graph and create the # quantization factor record_file. print('==> AMCT step2: create_quant_retrain_model..') record_file = os.path.join(TMP, 'record.txt') model = amct.create_compressed_retrain_model( model, get_input_data([(1, 3, SIZE, SIZE)], model), args.config_defination, record_file) # Step 4: Retraining compressed model and inferencing. train_and_val(model, gpu_index, train_loader, train_sampler, val_loader, args) # Step 5: Save the compressed model and infer the accuracy of the # compressed model. if not args.distributed or (args.distributed and gpu_index == 0): quant_top1, quant_top5 = cal_quant_model_accuracy( model, gpu_index, val_loader, args, record_file) print( '[INFO] ResNet-101 before compress retrain top1:{:.2f}% top5:{:.2f}%' .format(ori_top1, ori_top5)) print( '[INFO] ResNet-101 after compress retrain top1:{:.2f}% top5:{:.2f}%' .format(quant_top1, quant_top5))
def __init__(self, *args, **kwargs): super(ContextPath, self).__init__() self.resnet = resnet101(pretrained=False) self.arm16 = AttentionRefinementModule(1024, 128) #256 1024 self.arm32 = AttentionRefinementModule(2048, 128) # 512 2048 self.conv_head32 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1) self.conv_head16 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1) self.conv_avg = ConvBNReLU(2048, 128, ks=1, stride=1, padding=0) #512 2048 self.init_weight()
def Generator(net): if net == 'lenet': return lenet.Feature() if net == 'resnet18': return resnet.resnet18(pretrained=True) if net == 'resnet50': return resnet.resnet50(pretrained=True) if net == 'resnet101': return resnet.resnet101(pretrained=True) if net == 'alexnet': return alexnet.alexnet(pretrained=True)
def build_model(model_name, pretrained=False): if model_name == 'resnet34': model = resnet.resnet34(pretrained=False) elif model_name == 'resnet50': model = resnet.resnet50(pretrained=False) elif model_name == 'resnet101': model = resnet.resnet101(pretrained=False) elif model_name == 'resnet152': model = resnet.resnet152(pretrained=False) if model_name == 'resnet18': model.conv1 = nn.Conv2d(2, 64, kernel_size=7, stride=2, padding=3, bias=False) model.avg_pool = nn.AdaptiveAvgPool2d(1) model.last_linear = nn.Linear(512, 8) elif model_name == 'resnet34': model.conv1 = nn.Conv2d(2, 64, kernel_size=7, stride=2, padding=3, bias=False) model.avgpool = nn.AdaptiveAvgPool2d(1) model.fc = nn.Linear(512, 8) # Nx8 else: model.conv1 = nn.Conv2d(2, 64, kernel_size=7, stride=2, padding=3, bias=False) model.avgpool = nn.AdaptiveAvgPool2d(1) model.fc = nn.Linear(2048, 8) # Nx8 if pretrained == True: exclude_dict = ['conv1.weight', 'fc.weight', 'fc.bias'] pretrained_dict = model_zoo.load_url(model_urls[model_name]) model_dict = model.state_dict() pretrained_dict = { k: v for k, v in pretrained_dict.items() if k not in exclude_dict } model_dict.update(pretrained_dict) model.load_state_dict(model_dict) return model
def visualize_probs(): net_path = 'logs/upna/upna_int_norm' image_dir_out = 'plots/probs' dataset_location = 'datasets' # TODO update to dataset path device = torch.device('cpu') dataset = UPNA.UPNA(dataset_location) dataset_vis = dataset.get_eval() base = resnet101() model = ResnetHead(base, 1, 0, 512, 9) loggers = logger.Logger(net_path, ModelNetSo3.ModelNetSo3Classes, load=True) loggers.load_network_weights(119, model, device) model.eval() if not os.path.exists(image_dir_out): os.makedirs(image_dir_out) np.random.seed(29001) idx = np.arange(len(dataset_vis)) np.random.shuffle(idx) # idx = [2822, 8446, 6171, 3479] sampler = ListSampler(idx) dataloader = torch.utils.data.DataLoader( dataset_vis, sampler=sampler, batch_size=1, drop_last=False) errors = [] load_pkl = False if load_pkl and os.path.exists('UPNA_errors.pkl'): with open('UPNA_errors.pkl', 'rb') as f: errors = pickle.load(f) else: print(len(dataloader)) for i, (idx, batch) in enumerate(zip(idx, dataloader)): print(i) image, extrinsic, class_idx_cpu, hard, intrinsic, _ = batch extrinsic_np = extrinsic[0].numpy() intrinsic_np = intrinsic[0].numpy() im_np = image[0].numpy().transpose(1,2,0) R_gt = extrinsic[0, :3,:3].numpy() out = model(image, class_idx_cpu).view(-1,3,3) R_est = loss.batch_torch_A_to_R(out).detach().cpu().view(3,3).numpy() err = loss.angle_error_np(R_gt, R_est) errors.append(err) print(err) with open('UPNA_errors.pkl', 'wb') as f: pickle.dump(errors, f) print(np.mean(errors)) print(np.median(errors)) plt.hist(errors,100) plt.show()
def __init__(self, num_classes=3): super(pair_cnn, self).__init__() #self.resnet101_union = resnet.resnet101() self.resnet101_a = resnet.resnet101() #self.resnet101_b = self.resnet101_a #self.bboxes = nn.Linear(10, 256) self.fc6 = nn.Linear(2048 + 2048, 4096) self.fc7 = nn.Linear(4096, num_classes) self.ReLU = nn.ReLU(False) self.Dropout = nn.Dropout() self._initialize_weights()
def __init__(self, class_num, bn_momentum=0.01, pretrained=False): super(PSPNet, self).__init__() self.pool_scales = [1, 2, 3, 6] self.fc_dim = 2048 resnet101 = resnet.resnet101(pretrained=pretrained) self.backbone = nn.Sequential(*list(resnet101.children())[:-2]) self.psp_layer = PyramidPooling('psp', out_planes=class_num, fc_dim=self.fc_dim, pool_scales=self.pool_scales, norm_layer=nn.BatchNorm2d) self.cls_head = nn.Sequential( ConvBnRelu(self.fc_dim + len(self.pool_scales) * 512, 512, size=3, stride=1, pad=1, has_bn=True, has_relu=True, has_bias=False, norm_layer=nn.BatchNorm2d), nn.Dropout2d(0.1, inplace=False), nn.Conv2d(512, class_num, kernel_size=1) )
def __init__(self, k=7, classes=None, debug=False, training=False): super(FasterRCNN, self).__init__() if classes is not None: self.classes = classes self.n_classes = len(classes) self.k = k self.training = training self.resnet = resnet101() self.rpn = RPN() self.conv_new_1 = Conv2d(in_channels=2048, out_channels=1024, kernel_size=1, stride=1, relu=True) self.rfcn_cls = nn.Conv2d(in_channels=1024, out_channels=self.n_classes * self.k * self.k, kernel_size=1, stride=1, padding=0, bias=False) self.rfcn_bbox = nn.Conv2d(in_channels=1024, out_channels=8 * self.k * self.k, kernel_size=1, stride=1, padding=0, bias=False) #--class-agnostic self.psroipooling_cls = PSRoIPool(pooled_height=self.k, pooled_width=self.k, spatial_scale=1 / 32.0, group_size=self.k, output_dim=self.n_classes) self.psroipooling_loc = PSRoIPool(pooled_height=self.k, pooled_width=self.k, spatial_scale=1 / 32.0, group_size=self.k, output_dim=2 * 4) #----class-agnostic self.pooling = nn.AvgPool2d(kernel_size=self.k, stride=self.k) # loss self.cross_entropy = None self.loss_box = None # for log self.debug = debug
def main(): # [b, 32, 32, 3] => [b, 1, 1, 512] model = resnet101() model.build(input_shape=(None, 32, 32, 3)) model.summary() optimizer = optimizers.Adam(lr=1e-3) for epoch in range(50): for step, (x,y) in enumerate(train_db): with tf.GradientTape() as tape: # [b, 32, 32, 3] => [b, 100] logits = model(x) # [b] => [b, 100] y_onehot = tf.one_hot(y, depth=100) # compute loss loss = tf.losses.categorical_crossentropy(y_onehot, logits, from_logits=True) loss = tf.reduce_mean(loss) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) if step %50 == 0: print(epoch, step, 'loss:', float(loss)) total_num = 0 total_correct = 0 for x,y in test_db: logits = model(x) prob = tf.nn.softmax(logits, axis=1) pred = tf.argmax(prob, axis=1) pred = tf.cast(pred, dtype=tf.int32) correct = tf.cast(tf.equal(pred, y), dtype=tf.int32) correct = tf.reduce_sum(correct) total_num += x.shape[0] total_correct += int(correct) acc = total_correct / total_num print(epoch, 'acc:', acc)
def __init__(self, num_classes=1000): super(Resnet101_8s, self).__init__() # Load the pretrained weights, remove avg pool # layer and get the output stride of 8 resnet101_8s = resnet.resnet101(fully_conv=True, pretrained=True, output_stride=8, remove_avg_pool_layer=True) # Randomly initialize the 1x1 Conv scoring layer resnet101_8s.fc = nn.Conv2d(resnet101_8s.inplanes, num_classes, 1) self.resnet101_8s = resnet101_8s self._normal_initialization(self.resnet101_8s.fc)
def main(opt): # モデル定義 model = resnet.resnet101(pretrained=True) if torch.cuda.is_available(): # GPUが利用可能か確認 device = 'cuda' else: device = 'cpu' print('device is {0}'.format(device)) # print(model.weight.type) model.to(device) if opt.trained: print('load pretrained model') model.fc = nn.Linear(2048, opt.ftclass) model_data = torch.load(opt.model) model.load_state_dict(model_data) model.eval() # 絶対パスに変換 outpath = os.path.abspath(opt.output) apath = os.path.abspath(opt.input) video_names = sorted(glob.glob(os.path.join(apath, '*'))) if os.path.exists('tmp'): subprocess.call('rm -rf tmp', shell=True) for vpath in video_names: vname = os.path.splitext(os.path.basename(vpath))[0] subprocess.call('mkdir tmp', shell=True) subprocess.call( 'ffmpeg -loglevel warning -i {} -r 5 tmp/image_%05d.jpg'.format( vpath), shell=True) images = sorted(glob.glob('tmp/*.jpg')) print('extract {}\'s DeepFeatrue'.format(vname)) outputs = input_image(images, model) # ファイルに保存 if not os.path.exists(outpath): subprocess.call('mkdir {}'.format(outpath), shell=True) savename = os.path.join(outpath, vname + '.npy') np.save(savename, outputs) subprocess.call('rm -rf tmp', shell=True)
def __init__(self, num_classes, deep_base=True): super(Baseline, self).__init__() resnet = resnet101(pretrained=False, deep_base=deep_base, norm_layer=norm_layer) if deep_base: resnet.load_state_dict(torch.load(res101_csail_path)) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu1, resnet.conv2, resnet.bn2, resnet.relu2, resnet.conv3, resnet.bn3, resnet.relu3, resnet.maxpool) else: resnet.load_state_dict(torch.load(res101_path)) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1 = resnet.layer1 self.layer2 = resnet.layer2 self.layer3 = resnet.layer3 self.layer4 = resnet.layer4 self.m1_3 = Module1(2048, 1024) self.m1_2 = Module1(1024, 512) self.m1_1 = Module1(512, 256) self.m2_4 = Module2(2048, 128, (5, 7, 9)) self.m2_3 = Module2(1024, 128, (10, 14, 18)) self.m2_2 = Module2(512, 128, (20, 28, 36)) self.m2_1 = Module2(256, 128, (40, 56, 72)) self.decoder4 = DecoderBlock(128, 128) self.decoder3 = DecoderBlock(128, 128) self.decoder2 = DecoderBlock(128, 128) self.decoder1 = DecoderBlock(128, 128) self.pred = nn.Sequential( nn.ConvTranspose2d(128, 32, 4, 2, 1), relu, nn.Conv2d(32, 32, kernel_size=3, padding=1), relu, nn.Conv2d(32, num_classes, kernel_size=3, padding=1)) self.aux1 = nn.Conv2d(128, num_classes, kernel_size=1) self.aux2 = nn.Conv2d(128, num_classes, kernel_size=1) self.aux3 = nn.Conv2d(128, num_classes, kernel_size=1) self.aux4 = nn.Conv2d(128, num_classes, kernel_size=1)
def __init__(self, n_class=21, # include background roi_pooling_size=7): super(RCNN, self).__init__() self.n_class = n_class self.feature_stride = 16.0 self.roi_pooling_szie = roi_pooling_size """ self.classifier = nn.Sequential( nn.Linear(1024 * 7 * 7, 1024), nn.ReLU(True), nn.Dropout(), nn.Linear(1024, 2048), nn.ReLU(True), nn.Dropout(), ) for m in self.classifier.modules(): if isinstance(m, (nn.Conv2d, nn.Linear)): nn.init.xavier_uniform_(m.weight) """ def set_bn_fix(m): classname = m.__class__.__name__ if classname.find('BatchNorm') != -1: for p in m.parameters(): p.requires_grad = False resnet = resnet101(pretrained=True) self.rcnn_top = nn.Sequential(resnet.layer4) #self.rcnn_top = nn.Sequential(resnet101().layer4) #self.rcnn_top.apply(set_bn_fix) self.roi_pooling = RoIPooling2D(self.roi_pooling_szie, self.roi_pooling_szie, 1. / self.feature_stride) self.cls_loc = nn.Linear(2048, self.n_class * 4) self.cls_score = nn.Linear(2048, self.n_class) """ normal_init(self.cls_loc, 0, 0.001) normal_init(self.cls_score, 0, 0.01) """ xavier_init(self.cls_loc) xavier_init(self.cls_score)
def __init__( self, last_conv_stride=1, last_conv_dilation=1, num_stripes=6, # number of sub-parts used_levels=[1, 1, 1, 1, 1, 1], num_conv_out_channels=128, global_conv_out_channels=256, num_classes=0 ): super(Pyramid, self).__init__() print("num_stripes:{}".format(num_stripes)) print("num_conv_out_channels:{},".format(num_conv_out_channels)) self.base = resnet101( pretrained=True, last_conv_stride=last_conv_stride, last_conv_dilation=last_conv_dilation) self.dropout_layer = nn.Dropout(p=0.2) # ============================================================================== pyramid self.num_classes = num_classes self.num_stripes = num_stripes self.used_levels = used_levels # ==============================================================================pyramid input_size = 2048 self.pyramid_conv_list0 = nn.ModuleList() self.pyramid_fc_list0 = nn.ModuleList() Pyramid.register_basic_branch(self, num_conv_out_channels, input_size, self.pyramid_conv_list0, self.pyramid_fc_list0) # ==============================================================================pyramid input_size1 = 1024 self.pyramid_conv_list1 = nn.ModuleList() self.pyramid_fc_list1 = nn.ModuleList() Pyramid.register_basic_branch(self, num_conv_out_channels, input_size1, self.pyramid_conv_list1, self.pyramid_fc_list1)