def _load_pretrained_weight(self): ## trick: get 4 channels weights from pretrained resnet _net = se_resnet50(pretrained='imagenet', input_channel=3) state_dict = _net.state_dict().copy() layer0_weights = state_dict['layer0.conv1.weight'] print('raw_weight size: ', layer0_weights.size()) layer0_weights_new = torch.nn.Parameter( torch.cat((layer0_weights, layer0_weights[:, :1, :, :]), dim=1)) print('new_weight size: ', layer0_weights_new.size()) new_state_dict = OrderedDict(('layer0.conv1.weight', layer0_weights_new) if key == 'layer0.conv1.weight' \ else (key, value) for key, value in state_dict.items()) ## net = se_resnet50(pretrained=None, input_channel=4) net.load_state_dict(new_state_dict) return net
def __init__( self, model_path='./models/seresnet50/seresnet50_final.pth', img_size=224, ): self.model_path = model_path self.img_size = img_size self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') print('devices=', self.device) self.net = se_resnet.se_resnet50(num_classes=4).to(self.device) self.net.load_state_dict(torch.load(self.model_path)) self.net.eval() to_bgr_transform = transforms.Lambda(lambda x: x[[2, 1, 0]]) self.transform = transforms.Compose([ transforms.ToPILImage(), PadImage(), transforms.Resize([self.img_size, self.img_size], interpolation=3), transforms.ToTensor(), # to_bgr_transform, transforms.Normalize((0.5, ), (0.5, )) ]) #for one image crop to a batch self.transform_crop = transforms.Compose([ transforms.ToPILImage(), CropPadImage(), transforms.Resize([self.img_size, self.img_size], interpolation=3), transforms.ToTensor(), to_bgr_transform, transforms.Normalize((0.5, ), (0.5, )) ])
def main(batch_size, data_root): transform_train = transforms.Compose([ transforms.RandomSizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform_test = transforms.Compose([ transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) traindir = os.path.join(data_root, 'train') valdir = os.path.join(data_root, 'val') train = datasets.ImageFolder(traindir, transform_train) val = datasets.ImageFolder(valdir, transform_test) train_loader = torch.utils.data.DataLoader(train, batch_size=batch_size, shuffle=True, num_workers=8) test_loader = torch.utils.data.DataLoader(val, batch_size=batch_size, shuffle=True, num_workers=8) se_resnet = se_resnet50(num_classes=1000) optimizer = optim.SGD(params=se_resnet.parameters(), lr=0.6, momentum=0.9, weight_decay=1e-4) scheduler = StepLR(optimizer, 30, gamma=0.1) trainer = Trainer(se_resnet, optimizer, F.cross_entropy, save_dir=".") trainer.loop(100, train_loader, test_loader, scheduler)
def main(batch_size, root, lrate): ##################################################################### "The implementation of tensorboardX and topK accuracy is in utils.py" ##################################################################### # get checkpoint information checkpoint_newest = get_checkPoint("./lr" + str(lrate) + "/checkpoint/") #TIMESTAMP = "{0:%Y-%m-%dT%H-%M-%S/}".format(datetime.now()) # write log and visualize the losses of batches of training and testing TIMESTAMP = "" writer1 = SummaryWriter('./lr' + str(lrate) + '/tensorboard_log/batch/' + TIMESTAMP) # write log and visualize the accuracy of batches of training and testing writer2 = SummaryWriter('./lr' + str(lrate) + '/tensorboard_log/epoch/' + TIMESTAMP) train_loader, test_loader = get_dataloader(batch_size, root) gpus = list(range(torch.cuda.device_count())) # initialize your net/optimizer seresnet50 = nn.DataParallel(se_resnet50(num_classes=340), device_ids=gpus) optimizer = optim.SGD(params=seresnet50.parameters(), lr=lrate / 1024 * batch_size, momentum=0.9, weight_decay=1e-4) # No existed checkpoint if checkpoint_newest == 0: scheduler = optim.lr_scheduler.StepLR(optimizer, 30, gamma=0.1) trainer = Trainer(seresnet50, optimizer, F.cross_entropy, save_dir="./lr" + str(lrate) + "/checkpoint/", writer1=writer1, writer2=writer2, save_freq=1) trainer.loop(50, train_loader, test_loader, 1, scheduler) # load existed checkpoint else: print("The path of the pretrained model %s" % checkpoint_newest) print("load pretrained model......") checkpoint = torch.load(checkpoint_newest) seresnet50.load_state_dict(checkpoint['weight']) optimizer.load_state_dict(checkpoint['optimizer']) scheduler = optim.lr_scheduler.StepLR(optimizer, 30, gamma=0.1, last_epoch=checkpoint['epoch']) print("The current epoch is %d" % checkpoint['epoch']) trainer = Trainer(seresnet50, optimizer, F.cross_entropy, save_dir="./lr" + str(lrate) + "/checkpoint/", writer1=writer1, writer2=writer2, save_freq=1) trainer.loop(100, train_loader, test_loader, checkpoint['epoch'] + 1, scheduler)
def main(batch_size, root): train_loader, test_loader = get_dataloader(batch_size, root) _se_resnet = se_resnet50(num_classes=1000) se_resnet = nn.DataParallel(_se_resnet, device_ids=[0, 1]) optimizer = optim.SGD(params=se_resnet.parameters(), lr=0.6, momentum=0.9, weight_decay=1e-4) scheduler = StepLR(optimizer, 30, gamma=0.1) trainer = Trainer(se_resnet, optimizer, F.cross_entropy, save_dir=".") trainer.loop(100, train_loader, test_loader, scheduler)
def main(batch_size, root): train_loader, test_loader = get_dataloader(batch_size, root) gpus = list(range(torch.cuda.device_count())) se_resnet = nn.DataParallel(se_resnet50(num_classes=345), device_ids=gpus) optimizer = optim.SGD(params=se_resnet.parameters(), lr=0.6 / 1024 * batch_size, momentum=0.9, weight_decay=1e-4) scheduler = optim.lr_scheduler.StepLR(optimizer, 30, gamma=0.1) trainer = Trainer(se_resnet, optimizer, F.cross_entropy, save_dir=".") trainer.loop(100, train_loader, test_loader, scheduler)
def train_cnn_ivr(): lowAccLabel_fp = '../data/list_tc/label/accLeccThan20Label_filter.txt' loaders, cnnidx2label = load_data_for_training_cnn( batch_size=16 * 1, lowAccLabel_fp=lowAccLabel_fp) # model = InceptionResNetV2(num_classes=365, num_feature=1024, drop_rate=0.2) model = se_resnet50(num_classes=365) criterion_cent = CenterLoss(num_classes=365, feat_dim=1024, use_gpu=False) DEVICE = torch.device('cuda:0') train_cnn(model, criterion_cent, loaders['train_cnn'], loaders['val_cnn'], cnnidx2label, DEVICE, multi_gpu=None, repick=True)
def feature_extract(): # model = InceptionResNetV2(num_classes=365, num_feature=2048) model = se_resnet50(num_classes=365) DEVICE_ID = 0 device = torch.device(f'cuda:{DEVICE_ID}') model.load_state_dict( torch.load('../data/classficaData/B3_IVR2_1/pth/irv2_9_0.678389.pth')) model = model.to(device) loaders, cnnidx2label = load_data_for_feature_extract() print("load data is ok") ''' extract_features(model, loaders['train_A'], device, '../data/train_A_feat.npy') extract_features(model, loaders['train_B'], device, '../data/train_B_feat.npy') extract_features(model, loaders['test_A'], device, '../data/test_A_feat.npy') extract_features(model, loaders['test_B'], device, '../data/test_B_feat.npy') ''' extract_features(model, loaders['train_C'], device, '../data/train_C_feat.npy') extract_features(model, loaders['test_C'], device, '../data/test_C_feat.npy')
train_dl = DataLoader(label_lists.train, num_workers=8, batch_sampler=BatchSampler( RandomSamplerWithEpochSize(label_lists.train, epoch_size), bs, True)) valid_dl = DataLoader(label_lists.valid, bs, False, num_workers=8) test_dl = DataLoader(label_lists.test, bs, False, num_workers=8) data_bunch = ImageDataBunch(train_dl, valid_dl, test_dl) classes = data_bunch.classes pd.to_pickle(classes, PATH / "classes.pkl") from fastai.callbacks import SaveModelCallback, EarlyStoppingCallback import sys sys.path.append("./senet.pytorch/") from se_resnet import se_resnet50 model = se_resnet50(340) learn = Learner( data_bunch, model, metrics=[accuracy, map3], callback_fns=[partial(SaveModelCallback, every="epoch", name="senet-v2")]) ckpt = "final-senet-stage-1" print(f"Loading ckpt : {ckpt}") learn.load(ckpt) learn.fit_one_cycle(72, max_lr=5e-4) name = 'final-senet-stage-1' learn.save(f'{name}')
def run_on_opencv_imgbatch(img): images = [transform_crop(img) for i in range(3)] images = torch.cat([t.unsqueeze(0) for t in images], 0) images = images.to(device) net.eval() outputs = net(images) preds = torch.softmax(outputs, 1) mea = torch.mean(preds, 0) ind = mea.argmax() label = ind.item() return label if __name__ == '__main__': device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') net = se_resnet.se_resnet50(num_classes=args.class_num).to(device) # input = torch.randn(8, 3, 214, 214).to(device) # outputs = net(input) # print(outputs.size()) net.load_state_dict(torch.load(args.model_path)) dic_img = img_label_dic(args.eval_list) total = 0 correct = 0 for k, v in dic_img.items(): print(k) imgpath = args.eval_imgpath + k if not os.path.exists(imgpath): print('not exist image {}'.format(k)) continue pred = run_on_opencv_imgbatch(cv2.imread(imgpath)) labels = v
transforms.Resize(224), transforms.ToTensor(), normalize, ])) val_loader = torch.utils.data.DataLoader( val_dataset, batch_size=test_batch, shuffle=False, num_workers=num_workers['val'], pin_memory=True) dataset_sizes = {'train': len(train_dataset), 'val': len(val_dataset)} dataloaders = {'train': train_loader, 'val': val_loader} model_ft = se_resnet50(num_classes=1000) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model_ft = model_ft.to(device) print(sum(p.numel() for p in model_ft.parameters() if p.requires_grad)) #Loss Function criterion = nn.CrossEntropyLoss() # Observe that all parameters are being optimized Init_lr = 0.005 optimizer_ft = optim.SGD(model_ft.parameters(), lr=Init_lr, momentum=0.9) def adjust_learning_rate(optimizer, epoch, Init_lr): """Sets the learning rate to the initial LR decayed by 10 every 30 epochs""" lr = Init_lr * (0.1 ** (epoch // 30)) for param_group in optimizer.param_groups:
def __init__(self, classCount, isTrained): super(SE_ResNet50, self).__init__() self.se_resnet50 = se_resnet.se_resnet50(num_classes = classCount,pretrained=isTrained)
def create_seresnet50(): return se_resnet50(n_classes)
class test_model(nn.Module): def __init__(self, opts, device, model_path): super(test_model, self).__init__() self.opts = opts self.device = device self.model_path = model_path # model self.network = self.model_choice(self.opts.case) # loss function self.loss_func = torch.nn.CrossEntropyLoss().to(device) def model_choice(self, case): case = case.lower() # resnet if case == 'resnet50': self.model = resnet50(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to(self.device) if case == 'resnet101': self.model = resnet101(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to(self.device) if case == 'resnet152': self.model = resnet152(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to(self.device) # aa_resnet if case == 'aa_resnet50': self.model = aa_resnet50(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to( self.device) if case == 'aa_resnet101': self.model = aa_resnet101(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to( self.device) if case == 'aa_resnet152': self.model = aa_resnet152(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to( self.device) # se_resnet if case == 'se_resnet50': self.model = se_resnet50(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to( self.device) if case == 'se_resnet101': self.model = se_resnet101(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to( self.device) if case == 'se_resnet152': self.model = se_resnet152(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.model_path).to( self.device) return self.model
class train_model(nn.Module): def __init__(self, opts, device): super(train_model, self).__init__() self.opts = opts self.device = device # model self.network = self.model_choice(self.opts.case) # optimizer self.optimizer = torch.optim.Adam(self.network.parameters(), lr=self.opts.lr) # loss function self.loss_func = torch.nn.CrossEntropyLoss().to(device) def model_choice(self, case): case = case.lower() # resnet if case == 'resnet50': self.model = resnet50(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) if case == 'resnet101': self.model = resnet101(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) if case == 'resnet152': self.model = resnet152(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) # aa_resnet if case == 'aa_resnet50': self.model = aa_resnet50(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) if case == 'aa_resnet101': self.model = aa_resnet101(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) if case == 'aa_resnet152': self.model = aa_resnet152(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) # se_resnet if case == 'se_resnet50': self.model = se_resnet50(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) if case == 'se_resnet101': self.model = se_resnet101(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) if case == 'se_resnet152': self.model = se_resnet152(pretrained=self.opts.pretrained, num_classes=self.opts.num_classes, model_path=self.opts.checkpoint).to( self.device) return self.model