def main(): global cfg, global_all_step global_all_step = 0 cfg = DefaultConfig() args = { 'resnet18': RESNET18_SUNRGBD_CONFIG().args(), } # Setting random seed # if cfg.MANUAL_SEED is None: # cfg.MANUAL_SEED = random.randint(1, 10000) # random.seed(cfg.MANUAL_SEED) # torch.manual_seed(cfg.MANUAL_SEED) # args for different backbones cfg.parse(args['resnet18']) run_id = random.randint(1, 100000) summary_dir = '/home/lzy/summary/generateDepth/' + 'train_depth_1e-3_0909_' + str( run_id) if not os.path.exists(summary_dir): os.mkdir(summary_dir) writer = SummaryWriter(summary_dir) cfg.LR = 0.001 os.environ["CUDA_VISIBLE_DEVICES"] = '0,1,2' device_ids = torch.cuda.device_count() print('device_ids:', device_ids) # project_name = reduce(lambda x, y: str(x) + '/' + str(y), os.path.realpath(__file__).split(os.sep)[:-1]) # util.mkdir('logs') # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) # normalize=transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # data train_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_TRAIN, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.RandomHorizontalFlip(), # dataset.RandomRotate(), # dataset.RandomFlip(), # dataset.PILBrightness(0.4), # dataset.PILContrast(0.4), # dataset.PILColorBalance(0.4), # dataset.PILSharpness(0.4), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) val_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_VAL, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) # train_loader = torch.utils.data.DataLoader( # train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True, # num_workers=4, pin_memory=True, sampler=None) # val_loader = torch.utils.data.DataLoader( # val_dataset,batch_size=16, shuffle=False, # num_workers=4, pin_memory=True) train_loader = DataProvider(cfg, dataset=train_dataset, batch_size=150, shuffle=True) val_loader = DataProvider(cfg, dataset=val_dataset, batch_size=120, shuffle=False) # class weights # num_classes_train = list(Counter([i[1] for i in train_loader.dataset.imgs]).values()) # cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train) # writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard # net_classification_1=resnet50(pretrained=True) # net_classification_2=resnet50(pretrained=True) net_classification_2 = models.__dict__['resnet50'](num_classes=365) # net_classification_2=torchvision.models.resnext101_32x8d(pretrained=True, progress=True) # net_classification_2 = models.__dict__['resnet18'](num_classes=365) # net_classification_2=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') net_classification_2.fc = nn.Linear(2048, 19) # net_classification_2=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') # for param in net_classification_1.parameters(): # param.requires_grad = False # for param in net_classification_2.parameters(): # param.requires_grad = True # net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048, 1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67)) # net_classification_2.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048,1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67)) # net_classification_1.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl"))、 # net_classification_2.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl")) # net_classification_2 load_path = "resnet50_Depth_sunrgbd_best_0909_5e-4_.pth.tar" checkpoint = torch.load(load_path, map_location=lambda storage, loc: storage) state_dict = { str.replace(k, 'module.', ''): v for k, v in checkpoint['state_dict'].items() } best_mean_depth = checkpoint['best_mean_2'] print("load sunrgbd dataset:", best_mean_depth) net_classification_2.load_state_dict(state_dict) # print(net_classification_1) # num_ftrs = net_classification_1.fc.in_features # net_classification_1.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES) # num_ftrs = net_classification_2.fc.in_features # net_classification_2.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES) # net_classification_2.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048,1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67)) net_classification_2.fc = nn.Linear(2048, 67) init_weights(net_classification_2.fc, 'normal') print(net_classification_2) # net_classification_1.cuda() net_classification_2.cuda() cudnn.benchmark = True if cfg.GENERATE_Depth_DATA: print('GENERATE_Depth_DATA model set') cfg_generate = copy.deepcopy(cfg) cfg_generate.CHECKPOINTS_DIR = '/home/lzy/generateDepth/bestmodel/before_best.pth' cfg_generate.GENERATE_Depth_DATA = False cfg_generate.NO_UPSAMPLE = False checkpoint = torch.load(cfg_generate.CHECKPOINTS_DIR) model = define_TrecgNet(cfg_generate, upsample=True, generate=True) load_checkpoint_depth(model, cfg_generate.CHECKPOINTS_DIR, checkpoint, data_para=True) generate_model = torch.nn.DataParallel(model).cuda() generate_model.eval() # net_classification_1 = torch.nn.DataParallel(net_classification_1).cuda() net_classification_2 = torch.nn.DataParallel(net_classification_2).cuda() criterion = nn.CrossEntropyLoss().cuda() # best_mean_1=0 best_mean_2 = 0 # optimizer_2 = torch.optim.Adam(net_classification_2.parameters(), lr=cfg.LR, betas=(0.5, 0.999)) optimizer_2 = torch.optim.SGD(net_classification_2.parameters(), lr=cfg.LR, momentum=cfg.MOMENTUM, weight_decay=cfg.WEIGHT_DECAY) schedulers = get_scheduler(optimizer_2, cfg, cfg.LR_POLICY) for epoch in range(0, 1000): if global_all_step > cfg.NITER_TOTAL: break # meanacc_1,meanacc_2=validate(val_loader, net_classification_1,net_classification_2,generate_model,criterion,epoch) # for param_group in optimizer_2.param_groups: # lr_t = param_group['lr'] # print('/////////learning rate = %.7f' % lr_t) # writer.add_scalar('LR',lr_t,global_step=epoch) printlr(optimizer_2, writer, epoch) train(train_loader, schedulers, net_classification_2, generate_model, criterion, optimizer_2, epoch, writer) meanacc_2 = validate(val_loader, net_classification_2, generate_model, criterion, epoch, writer) # meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer) # train(train_loader,net_classification_2,generate_model,criterion,optimizer_2,epoch,writer) # meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer) # writer.add_image(depth_image[0]) # save best # if meanacc_1>best_mean_1: # best_mean_1=meanacc_1 # print('best_mean_color:',str(best_mean_1)) # save_checkpoint({ # 'epoch': epoch, # 'arch': cfg.ARCH, # 'state_dict': net_classification_1.state_dict(), # 'best_mean_1': best_mean_1, # 'optimizer' : optimizer_1.state_dict(), # },CorD=True) if meanacc_2 > best_mean_2: best_mean_2 = meanacc_2 print('best_mean_depth:', str(best_mean_2)) save_checkpoint( { 'epoch': epoch, 'arch': cfg.ARCH, 'state_dict': net_classification_2.state_dict(), 'best_mean_2': best_mean_2, 'optimizer': optimizer_2.state_dict(), }, CorD=False) # print('best_mean_color:',str(best_mean_1)) # writer.add_scalar('mean_acc_color', meanacc_1, global_step=epoch) writer.add_scalar('mean_acc_depth', meanacc_2, global_step=epoch) # writer.add_scalar('best_meanacc_color', best_mean_1, global_step=epoch) writer.add_scalar('best_meanacc_depth', best_mean_2, global_step=epoch) writer.close()
def main(): global cfg cfg = DefaultConfig() args = { 'resnet18': RESNET18_SUNRGBD_CONFIG().args(), } # Setting random seed # if cfg.MANUAL_SEED is None: # cfg.MANUAL_SEED = random.randint(1, 10000) # random.seed(cfg.MANUAL_SEED) # torch.manual_seed(cfg.MANUAL_SEED) # args for different backbones cfg.parse(args['resnet18']) run_id = random.randint(1, 100000) summary_dir = '/home/lzy/summary/generateDepth/' + 'train_rgb_' + str( run_id) if not os.path.exists(summary_dir): os.mkdir(summary_dir) writer = SummaryWriter(summary_dir) cfg.LR = 0.0001 os.environ["CUDA_VISIBLE_DEVICES"] = '1,2' device_ids = torch.cuda.device_count() print('device_ids:', device_ids) # project_name = reduce(lambda x, y: str(x) + '/' + str(y), os.path.realpath(__file__).split(os.sep)[:-1]) # util.mkdir('logs') # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) # normalize=transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # data train_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_TRAIN, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.RandomHorizontalFlip(), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) val_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_VAL, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) # train_loader = torch.utils.data.DataLoader( # train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True, # num_workers=4, pin_memory=True, sampler=None) # val_loader = torch.utils.data.DataLoader( # val_dataset,batch_size=16, shuffle=False, # num_workers=4, pin_memory=True) train_loader = DataProvider(cfg, dataset=train_dataset, batch_size=40, shuffle=True) val_loader = DataProvider(cfg, dataset=val_dataset, batch_size=10, shuffle=False) # class weights # num_classes_train = list(Counter([i[1] for i in train_loader.dataset.imgs]).values()) # cfg.CLASS_WEIGHTS_TRAIN = torch.FloatTensor(num_classes_train) # writer = SummaryWriter(log_dir=cfg.LOG_PATH) # tensorboard # net_classification_1=resnet50(pretrained=True) # net_classification_2=resnet50(pretrained=True) # net_classification_1 = models.__dict__['resnet18'](num_classes=365) # net_classification_2 = models.__dict__['resnet18'](num_classes=365) net_classification_1 = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') # net_classification_2=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') # for param in net_classification_1.parameters(): # param.requires_grad = False # for param in net_classification_2.parameters(): # param.requires_grad = True net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5), nn.Linear(2048, 1024), nn.LeakyReLU(inplace=True), nn.Linear(1024, 67)) # net_classification_2.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048, 1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67)) net_classification_1.load_state_dict( torch.load( "./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl")) # net_classification_2.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl")) # net_classification_2 # load_path = "/home/dudapeng/workspace/pretrained/place/resnet18_places365.pth" # checkpoint = torch.load(load_path, map_location=lambda storage, loc: storage) # state_dict = {str.replace(k, 'module.', ''): v for k, v in checkpoint['state_dict'].items()} # net_classification_1.load_state_dict(state_dict) # net_classification_2.load_state_dict(state_dict) print(net_classification_1) # num_ftrs = net_classification_1.fc.in_features # net_classification_1.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES) # num_ftrs = net_classification_2.fc.in_features # net_classification_2.fc = nn.Linear(num_ftrs, cfg.NUM_CLASSES) net_classification_1.cuda() # net_classification_2.cuda() cudnn.benchmark = True # if cfg.GENERATE_Depth_DATA: # print('GENERATE_Depth_DATA model set') # cfg_generate = copy.deepcopy(cfg) # cfg_generate.CHECKPOINTS_DIR='/home/lzy/generateDepth/checkpoints/best_AtoB/trecg_AtoB_best.pth' # cfg_generate.GENERATE_Depth_DATA = False # cfg_generate.NO_UPSAMPLE = False # checkpoint = torch.load(cfg_generate.CHECKPOINTS_DIR) # model = define_TrecgNet(cfg_generate, upsample=True,generate=True) # load_checkpoint_depth(model,cfg_generate.CHECKPOINTS_DIR, checkpoint, data_para=True) # generate_model = torch.nn.DataParallel(model).cuda() # generate_model.eval() net_classification_1 = torch.nn.DataParallel(net_classification_1).cuda() # net_classification_2 = torch.nn.DataParallel(net_classification_2).cuda() criterion = nn.CrossEntropyLoss().cuda() best_mean_1 = 0 # best_mean_2=0 # optimizer = optim.SGD(model_ft.parameters(), lr=0.05,momentum=0.9)#,weight_decay=0.00005) optimizer_1 = torch.optim.SGD(net_classification_1.parameters(), lr=cfg.LR, momentum=cfg.MOMENTUM, weight_decay=cfg.WEIGHT_DECAY) # optimizer_2 = torch.optim.SGD(net_classification_2.parameters(),lr=cfg.LR,momentum=cfg.MOMENTUM,weight_decay=cfg.WEIGHT_DECAY) for epoch in range(0, 100): adjust_learning_rate(optimizer_1, epoch) # meanacc_1,meanacc_2=validate(val_loader, net_classification_1,net_classification_2,generate_model,criterion,epoch) # train(train_loader, net_classification_1, criterion, optimizer_1, epoch, writer) meanacc_1 = validate(val_loader, net_classification_1, criterion, epoch, writer) # meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer) # train(train_loader,net_classification_2,generate_model,criterion,optimizer_2,epoch,writer) # meanacc_2=validate(val_loader,net_classification_2,generate_model,criterion,epoch,writer) # writer.add_image(depth_image[0]) # save best if meanacc_1 > best_mean_1: best_mean_1 = meanacc_1 print('best_mean_color:', str(best_mean_1)) save_checkpoint( { 'epoch': epoch, 'arch': cfg.ARCH, 'state_dict': net_classification_1.state_dict(), 'best_mean_1': best_mean_1, 'optimizer': optimizer_1.state_dict(), }, CorD=True) # if meanacc_2>best_mean_2: # best_mean_2=meanacc_2 # print('best_mean_depth:',str(best_mean_2)) # save_checkpoint({ # 'epoch': epoch, # 'arch': cfg.ARCH, # 'state_dict': net_classification_2.state_dict(), # 'best_mean_2': best_mean_2, # 'optimizer' : optimizer_2.state_dict(), # },CorD=False) print('best_mean_color:', str(best_mean_1)) writer.add_scalar('mean_acc_color', meanacc_1, global_step=epoch) # writer.add_scalar('mean_acc_depth', meanacc_2, global_step=epoch) writer.add_scalar('best_meanacc_color', best_mean_1, global_step=epoch) # writer.add_scalar('best_meanacc_depth', best_mean_2, global_step=epoch) writer.close()
def main(): global cfg cfg = DefaultConfig() args = { 'resnet18': RESNET18_SUNRGBD_CONFIG().args(), } # args for different backbones cfg.parse(args['resnet18']) cfg.LR = 1e-4 cfg.EPOCHS = 200 # print('cfg.EPOCHS:',cfg.EPOCHS) os.environ["CUDA_VISIBLE_DEVICES"] = '0,1' # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) # dataset.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # data train_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_TRAIN, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.RandomHorizontalFlip(), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) val_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_VAL, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) # train_loader = torch.utils.data.DataLoader( # train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True, # num_workers=4, pin_memory=True, sampler=None) # val_loader = torch.utils.data.DataLoader( # val_dataset,batch_size=cfg.BATCH_SIZE, shuffle=False, # num_workers=4, pin_memory=True) train_loader = DataProvider(cfg, dataset=train_dataset, batch_size=20, shuffle=True) val_loader = DataProvider(cfg, dataset=val_dataset, batch_size=5, shuffle=False) run_id = random.randint(1, 100000) summary_dir = '/home/lzy/summary/generateDepth/' + 'finetuning_nofix_' + str( run_id) if not os.path.exists(summary_dir): os.mkdir(summary_dir) writer = SummaryWriter(summary_dir) if cfg.GENERATE_Depth_DATA: print('GENERATE_Depth_DATA model set') cfg_generate = copy.deepcopy(cfg) cfg_generate.CHECKPOINTS_DIR = '/home/lzy/generateDepth/checkpoints/best_AtoB/trecg_AtoB_best.pth' cfg_generate.GENERATE_Depth_DATA = False cfg_generate.NO_UPSAMPLE = False checkpoint = torch.load(cfg_generate.CHECKPOINTS_DIR) model = define_TrecgNet(cfg_generate, upsample=True, generate=True) load_checkpoint_depth(model, cfg_generate.CHECKPOINTS_DIR, checkpoint, data_para=True) generate_model = torch.nn.DataParallel(model).cuda() generate_model.eval() model = ReD_Model(cfg) policies = model.get_optim_policies() model = torch.nn.DataParallel(model).cuda() criterion = nn.CrossEntropyLoss().cuda() best_mean = 0 # optimizer= torch.optim.Adam(policies, cfg.LR, # weight_decay=cfg.WEIGHT_DECAY) optimizer = torch.optim.SGD(policies, cfg.LR, momentum=cfg.MOMENTUM, weight_decay=cfg.WEIGHT_DECAY) for epoch in range(cfg.START_EPOCH, cfg.EPOCHS + 1): adjust_learning_rate(optimizer, epoch) # mean_acc=validate(val_loader,model,criterion,generate_model,epoch,writer) train(train_loader, model, criterion, generate_model, optimizer, epoch, writer) mean_acc = validate(val_loader, model, criterion, generate_model, epoch, writer) if mean_acc > best_mean: best_mean = mean_acc print('best mean accuracy:', best_mean) else: print('best mean accuracy:', best_mean) writer.add_scalar('mean_acc_color', mean_acc, global_step=epoch) writer.add_scalar('best_meanacc_color', best_mean, global_step=epoch) writer.close()
def main(): global cfg, global_all_step global_all_step = 0 cfg = DefaultConfig() args = { 'resnet18': RESNET18_SUNRGBD_CONFIG().args(), } # Setting random seed # if cfg.MANUAL_SEED is None: # cfg.MANUAL_SEED = random.randint(1, 10000) # random.seed(cfg.MANUAL_SEED) # torch.manual_seed(cfg.MANUAL_SEED) # args for different backbones cfg.parse(args['resnet18']) run_id = random.randint(1, 100000) summary_dir = '/home/lzy/summary/generateDepth/' + 'resnet152_train_rgb_place365_2e-3_' + str( run_id) if not os.path.exists(summary_dir): os.mkdir(summary_dir) writer = SummaryWriter(summary_dir) cfg.LR = 0.002 os.environ["CUDA_VISIBLE_DEVICES"] = '2' device_ids = torch.cuda.device_count() print('device_ids:', device_ids) # project_name = reduce(lambda x, y: str(x) + '/' + str(y), os.path.realpath(__file__).split(os.sep)[:-1]) # util.mkdir('logs') # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) # normalize=transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # data train_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_TRAIN, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.RandomCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.RandomHorizontalFlip(), # dataset.RandomRotate(), # dataset.RandomFlip(), # dataset.PILBrightness(0.4), # dataset.PILContrast(0.4), # dataset.PILColorBalance(0.4), # dataset.PILSharpness(0.4), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) val_dataset = dataset.SingleDataset( cfg, data_dir=cfg.DATA_DIR_VAL, transform=transforms.Compose([ dataset.Resize((cfg.LOAD_SIZE, cfg.LOAD_SIZE)), dataset.CenterCrop((cfg.FINE_SIZE, cfg.FINE_SIZE)), dataset.ToTensor(), dataset.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])) # train_loader = torch.utils.data.DataLoader( # train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True, # num_workers=4, pin_memory=True, sampler=None) # val_loader = torch.utils.data.DataLoader( # val_dataset,batch_size=16, shuffle=False, # num_workers=4, pin_memory=True) train_loader = DataProvider(cfg, dataset=train_dataset, batch_size=30, shuffle=True) val_loader = DataProvider(cfg, dataset=val_dataset, batch_size=10, shuffle=False) # class weights net_classification_1 = models.__dict__['resnet152'](num_classes=365) load_path = "./bestmodel/resnet152_places365.pth" checkpoint = torch.load(load_path, map_location=lambda storage, loc: storage) weight = [] for k, v in checkpoint.items(): weight.append(v) i = 0 from collections import OrderedDict new_state_dict = OrderedDict() for k in net_classification_1.state_dict(): # print(k) new_state_dict[k] = weight[i] i += 1 # state_dict = {str.replace(k, 'module.', ''): v for k, v in checkpoint['state_dict'].items()} # state_dict = {str.replace(k, 'norm.', 'norm'): v for k, v in state_dict.items()} # state_dict = {str.replace(k, 'conv.', 'conv'): v for k, v in state_dict.items()} # state_dict = {str.replace(k, 'normweight', 'norm.weight'): v for k, v in state_dict.items()} # state_dict = {str.replace(k, 'normbias', 'norm.bias'): v for k, v in state_dict.items()} # state_dict = {str.replace(k, 'normrunning_var', 'norm.running_var'): v for k, v in state_dict.items()} # state_dict = {str.replace(k, 'convweight', 'conv.weight'): v for k, v in state_dict.items()} # state_dict = {str.replace(k, 'normrunning_mean', 'norm.running_mean'): v for k, v in state_dict.items()} # normweight # state_dict = {str.replace(k, 'conv.', 'conv'): v for k, v in state_dict.items()} # best_mean_depth = checkpoint['best_mean_2'] # print("load sunrgbd dataset:",best_mean_depth) net_classification_1.load_state_dict(new_state_dict) # net_classification_1=torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') # net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(2048, 1024),nn.LeakyReLU(inplace=True),nn.Linear(1024,67)) # net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.2), nn.Linear(2048, 1024), nn.LeakyReLU(inplace=True), nn.Dropout(p=0.2),nn.Linear(1024, 67)) # net_classification_1.fc = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(1024, 67)) # net_classification_1.classifier= nn.Linear(2208, 67) net_classification_1.fc = nn.Linear(2048, 67) # init_weights(net_classification_1.classifier, 'normal') init_weights(net_classification_1.fc, 'normal') # net_classification_1.load_state_dict(torch.load("./bestmodel/best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl")) # for param in net_classification_1.parameters(): # param.requires_grad = False # num_ftrs = net_classification_1.fc.in_features print(net_classification_1) net_classification_1.cuda() # net_classification_2.cuda() cudnn.benchmark = True net_classification_1 = torch.nn.DataParallel(net_classification_1).cuda() # net_classification_2 = torch.nn.DataParallel(net_classification_2).cuda() criterion = nn.CrossEntropyLoss().cuda() best_mean_1 = 0 # best_mean_2=0 # optimizer_1 = torch.optim.Adam(net_classification_1.parameters(), lr=cfg.LR, betas=(0.5, 0.999)) optimizer_1 = torch.optim.SGD(net_classification_1.parameters(), lr=cfg.LR, momentum=cfg.MOMENTUM, weight_decay=cfg.WEIGHT_DECAY) schedulers = get_scheduler(optimizer_1, cfg, cfg.LR_POLICY) # optimizer_1 = torch.optim.SGD(net_classification_1.parameters(),lr=cfg.LR,momentum=cfg.MOMENTUM,weight_decay=cfg.WEIGHT_DECAY) # optimizer_2 = torch.optim.SGD(net_classification_2.parameters(),lr=cfg.LR,momentum=cfg.MOMENTUM,weight_decay=cfg.WEIGHT_DECAY) for epoch in range(0, 1000): if global_all_step > cfg.NITER_TOTAL: break # meanacc_1,meanacc_2=validate(val_loader, net_classification_1,net_classification_2,generate_model,criterion,epoch) printlr(optimizer_1, writer, epoch) train(train_loader, schedulers, net_classification_1, criterion, optimizer_1, epoch, writer) meanacc_1 = validate(val_loader, net_classification_1, criterion, epoch, writer) # writer.add_image(depth_image[0]) # save best if meanacc_1 > best_mean_1: best_mean_1 = meanacc_1 print('best_mean_color:', str(best_mean_1)) save_checkpoint( { 'epoch': epoch, 'arch': cfg.ARCH, 'state_dict': net_classification_1.state_dict(), 'best_mean_1': best_mean_1, 'optimizer': optimizer_1.state_dict(), }, CorD=True) print('best_mean_color:', str(best_mean_1)) writer.add_scalar('mean_acc_color', meanacc_1, global_step=epoch) # writer.add_scalar('mean_acc_depth', meanacc_2, global_step=epoch) writer.add_scalar('best_meanacc_color', best_mean_1, global_step=epoch) # writer.add_scalar('best_meanacc_depth', best_mean_2, global_step=epoch) writer.close()