def set_model(input_dims_, model_type_, classes_): input_shape = input_dims_ + (3, ) if model_type_ == 'ResNet50': model_ = ResNet50(input_shape=input_shape, classes=classes_, name='ResNet50') elif model_type_ == 'ResNet50_seq': model_ = ResNet50_seq(input_shape=input_shape, classes=classes_, name='ResNet50_seq') elif model_type_ == 'ResNet34': model_ = ResNet34(input_shape=input_shape, classes=classes_, name='ResNet34') elif model_type_ == 'ResNetXX': model_ = ResNetXX(input_shape=input_shape, classes=classes_, name='ResNetXX') elif model_type_ == 'DG': model_ = DG(input_shape=input_shape, classes=classes_, name='DG') model_name_ = '_'.join([ model_.name, 'x'.join(map(str, input_dims_)), '_'.join(Faker().name().split(' ')) ]) return model_, model_name_
def train_resnet50_cifar(self, epochs=200, device="cuda:1", n_models=8): # Based off: https://github.com/kuangliu/pytorch-cifar PATH = Path('/media/rene/data/') save_path = PATH / 'cifar-10-batches-py/models' save_path.mkdir(parents=True, exist_ok=True) epochs = int(epochs) num_workers = 4 batch_size = 256 for i in range(n_models): dataloaders, dataset_sizes = make_batch_gen_cifar( str(PATH), batch_size, num_workers, valid_name='valid') model_name = 'ResNet50_' + str(i) model = ResNet50() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=.05, momentum=0.9, weight_decay=5e-4) scheduler = lr_scheduler.StepLR(optimizer, step_size=int(epochs / 3), gamma=0.1) best_acc, model = train_model(model, criterion, optimizer, scheduler, epochs, dataloaders, dataset_sizes, device) torch.save(model.state_dict(), str(save_path / model_name))
def get_model(name: str): name = name.lower() if name == 'vgg11': return VGG('VGG11') elif name == 'resnet18': return ResNet18() elif name == 'resnet34': return ResNet34() elif name == 'resnet50': return ResNet50()
def _choose_model(dict_config): support_list = ('vgg16', 'resnet50') if dict_config['model_name'] not in support_list: print(f'Not supported {dict_config["model_name"]}') print(f'Only support {support_list}') exit() if dict_config['model_name'] == 'vgg16': dict_config['model'] = VGG16(len(dict_config['class_list']), pretrain=dict_config['pretrain']) elif dict_config['model_name'] == 'resnet50': dict_config['model'] = ResNet50(len(dict_config['class_list']), pretrain=dict_config['pretrain']) return dict_config
def load_model(model_name): if model_name == 'deepyeast': from models import DeepYeast model = DeepYeast() elif model_name == 'resnet': from models import ResNet50 model = ResNet50() elif model_name == 'mobilenet': from models import MobileNet model = MobileNet() elif model_name == 'densenet': from models import DenseNet40_BC model = DenseNet40_BC() return model
def get_backbone(args, pretrained=True): from models import VGG16, VGG19, ResNet50, SEResNet50 if args.backbone == 'resnet': output_shape = 2048 backbone = ResNet50(pretrained=pretrained, kp=args.kp) elif args.backbone == 'vgg16': output_shape = 4096 backbone = VGG16(pretrained=pretrained) elif args.backbone == 'vgg19': output_shape = 4096 backbone = VGG19(pretrained=pretrained) elif args.backbone == 'seresnet': output_shape = 2048 backbone = SEResNet50(pretrained=pretrained) return output_shape, backbone
def __init__(self, desc='resnet50'): super(VGGFace, self).__init__() self.desc = desc # init descriptor, by default - ResNet50, which produces 8631-dim embedding vector if desc == "resnet50": self.descriptor = ResNet50() self.desc_out_shape = 2048 # TODO: replace this path somewhere, possibly as class attribute, or some config # weights_path = "weights/resnet50_ft_dag.pth" weights_path = "weights/resnet50_scratch_dag.pth" # load weights, pretrained on VGGFace2 dataset state_dict = torch.load(weights_path) self.descriptor.load_state_dict(state_dict) # freeze pretrained descriptor, as it should not be updated during further training for param in self.descriptor.parameters(): param.requires_grad = False # change last layer of the model, so it will return not 8631d embiddings, but 512d # num_ftrs = self.descriptor.classifier.in_channels # self.descriptor.classifier = nn.Linear(num_ftrs, 512) elif desc == "resnet_vggface": self.descriptor = ResNet50VGGFace() self.desc_out_shape = 2622 weights_path = "weights/vgg_face_dag.pth" # load weights, pretrained on VGGFace2 dataset state_dict = torch.load(weights_path) self.descriptor.load_state_dict(state_dict) # freeze pretrained descriptor, as it should not be updated during further training for param in self.descriptor.parameters(): param.requires_grad = False # create two FC layers and dropout # TODO: incapsulate number of combinations (3) into variable self.fc1 = nn.Linear(self.desc_out_shape * 3, 256) self.fc2 = nn.Linear(256, 128) self.fc3 = nn.Linear(128, 1) self.relu = nn.ReLU() self.dropout = nn.Dropout(0.5)
def test_voting(args): with fluid.dygraph.guard(place): model1 = ResNet50() model2 = ano_model() model_dict1, _ = fluid.load_dygraph('ResNet50' + '_best') model_dict2, _ = fluid.load_dygraph('ano_model' + '_best') model1.load_dict(model_dict1) model2.load_dict(model_dict2) model1.eval() model2.eval() test_loader = load_data('eval') data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True) data_loader.set_batch_generator(test_loader, places=place) acc_set = [] avg_loss_set = [] for batch_id, data in enumerate(data_loader): x_data, y_data = data img = fluid.dygraph.to_variable(x_data) label = fluid.dygraph.to_variable(y_data) out1 = model1(img) # [b, 10] out2 = model2(img) out = out1 + out2 out = fluid.layers.softmax(input=out) acc = fluid.layers.accuracy(input=out, label=label) loss = fluid.layers.cross_entropy(input=out, label=label) avg_loss = fluid.layers.mean(loss) acc_set.append(float(acc.numpy())) avg_loss_set.append(float(avg_loss.numpy())) #计算多个batch的平均损失和准确率 acc_val_mean = np.array(acc_set).mean() avg_loss_val_mean = np.array(avg_loss_set).mean() print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))
batch_size=batch_size, # mini batch 덩어리 크기 설정 shuffle=True, # 데이터 순서를 뒤섞어라 num_workers=4, # Broken Pipe 에러 뜨면 지우기 ) test_dataset = datasets.CIFAR10(root='dataset/', train=False, transform=transform_test, download=True) test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False, num_workers=4) # ================================================================= # # 5. Initialize the network # # ================================================================= # # %% 05. 모델 초기화 model = ResNet50(img_channel=3, num_classes=10).to(device) print(model) model = torch.nn.DataParallel(model)# 데이터 병렬처리 # (ref) https://tutorials.pytorch.kr/beginner/blitz/data_parallel_tutorial.html # 속도가 더 빨라지진 않음 # (ref) https://tutorials.pytorch.kr/beginner/former_torchies/parallelism_tutorial.html # 오히려 느려질 수 있음 # (ref) https://medium.com/daangn/pytorch-multi-gpu-%ED%95%99%EC%8A%B5-%EC%A0%9C%EB%8C%80%EB%A1%9C-%ED%95%98%EA%B8%B0-27270617936b cudnn.benchmark = True # %% # ================================================================= # # 6. Loss and optimizer # # ================================================================= # # %% 06. 손실 함수와 최적화 알고리즘 정의 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) # 네트워크의 모든 파라미터를 전달한다
'data_dir':'wriitng dataset directory', 'nClass':'writing class number', 'nEpochs':'writing epoch number', 'patchsize':'writing patchsize', 'lr':'writing learning rate', 'wd':'writing weight decay' } print(args) device = torch.device('cuda') print('===Loading Datasets===') train_dataloader = make_dataloader(os.path.join(args['data_dir'], 'train'), args['batchsize'], args['patchsize']) val_dataloader = make_dataloader(os.path.join(args['data_dir'], 'val'), args['batchsize'], args['patchsize'], val=True) print('===Building Model===') model = ResNet50(args['patchsize'], args['nClass']).to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=args['lr'], momentum=0.9, weight_decay=args['wd']) print('======Networks Initialized======') print(model) print('================================') # train def train(epoch): model.train() train_loss = 0 correct = 0 for iteration, batch in tqdm(enumerate(train_dataloader, 1)): # forward
def evaluation(eval_dataset, pretrained_model_path, batch_size=16, num_of_workers=0, num_of_classes=1200): r"""Evaluation a Model Args: :param eval_dataset: (RGBD_Dataset) :param pretrained_model_path: (str) The path :param batch_size: (int) The size of each step. Large batch_size might cause segmentation fault :param num_of_workers: (int) Number of subprocesses to use for data loading. :param num_of_classes: (int) how many subprocesses to use for data loading. ``0`` means that the data will be loaded in the main process. :return: the model of the best accuracy on validation dataset """ # If you get such a RuntimeError, change the `num_workers=0` instead. # RuntimeError: DataLoader worker (pid 83641) is killed by signal: Unknown signal: 0 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") eval_dataloader = DataLoader(eval_dataset, batch_size=batch_size, shuffle=False, num_workers=num_of_workers, drop_last=True) model = ResNet50(eval_dataset.input_channels, num_of_classes, pretrained=False) # if os.path.exists(pretrained_model_path): if (pretrained_model_path is not None) and os.path.exists(pretrained_model_path): model.load_state_dict( torch.load(pretrained_model_path, map_location=device)) print( "Model parameters is loaded from {}".format(pretrained_model_path)) model = model.to(device) criterion = torch.nn.CrossEntropyLoss() since = time.time() model.eval() running_loss, running_corrects, total = 0, 0, 0 p_bar = tqdm(total=len(eval_dataloader)) for step, (inputs, labels) in enumerate(eval_dataloader): inputs, labels = inputs.to(device), labels.to(device) with torch.set_grad_enabled(False): outputs = model(inputs) loss = criterion(outputs, labels) # statistics _, preds = torch.max(outputs, 1) total += inputs.size(0) running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) loss = float(running_loss) / total accu = float(running_corrects) / total * 100 p_bar.set_description('[Evaluation Loss: {:.4f} Acc: {:.2f}%]'.format( loss, accu)) p_bar.update(1) p_bar.close() acc = float(running_corrects) / total * 100 loss = float(running_loss) / total time_elapsed = time.time() - since # in seconds print('Evaluation complete in {:.0f}m {:.0f}s'.format( time_elapsed // 60, time_elapsed % 60)) print('Inference Speed: {:2f} fps'.format(total / time_elapsed)) print('Val Acc: {:4f}, Val loss: {:4f}'.format(acc, loss)) return acc, loss
'/lab/vislab/DATA/{}/classification/test.csv'.format(PARAMS['dataset']), get_transforms(data_transforms['validation'])) train_loader = DataLoader(trainset, batch_size=PARAMS['batch_size'], shuffle=True, num_workers=4, drop_last=True) val_loader = DataLoader(validset, batch_size=PARAMS['batch_size'], num_workers=4, drop_last=True) device = torch.device("cuda") model = ResNet50(pretrained=True, num_classes=len(set(trainset.targets)), max_epochs=PARAMS['epochs'], dropout=0.0).to(device) if PARAMS['parallel']: model = nn.DataParallel(model, [0, 1, 2]) optimizer = torch.optim.SGD(model.parameters(), lr=PARAMS['learning_rate'], momentum=PARAMS['momentum']) criterion = torch.nn.CrossEntropyLoss() scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=PARAMS['step_size'], gamma=0.5) def train(model, epoch, pooling='outlier'):
transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = torchvision.datasets.CIFAR10(root='/media/mu/NewVolume/Programs/waterquality/pytorch-cifar', train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root='/media/mu/NewVolume/Programs/waterquality/pytorch-cifar', train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # Model print('==> Building model..') # net = VGG('VGG19') net = ResNet50(10) # net = PreActResNet18() # net = GoogLeNet() # net = DenseNet121() # net = ResNeXt29_2x64d() # net = MobileNet() # net = MobileNetV2() # net = DPN92() # net = ShuffleNetG2() # net = SENet18() # net = ShuffleNetV2(1) # net = EfficientNetB0() print(net) net = net.to(device) images, labels = next(iter(trainloader))
def train_fusion_IDC_morefc(self, epochs1=2, epochs2=3, device="cuda:0"): epochs1, epochs2 = int(epochs1), int(epochs2) num_workers = 4 device = "cuda:0" PATH = Path('/home/rene/data/') save_path = PATH / models save_path.mkdir(parents=True, exist_ok=True) model_name_list = [ 'ResNet50_2', 'ResNet50_7', 'ResNet50_1', 'ResNet50_0' ] batch_size = 128 dataloaders, dataset_sizes = make_batch_gen_cifar(str(PATH), batch_size, num_workers, valid_name='valid') # get all the models pretrained_model_list = [] for i, model_name in enumerate(model_name_list): model = ResNet50() model = model.to(device) model.load_state_dict( torch.load(os.path.join(save_path, model_name))) pretrained_model_list.append(model) model = TriFusionMoreFC(pretrained_model_list, num_input=40, num_output=10) ###################### TRAIN LAST FEW LAYERS print('training last few layers') model_name = 'Fusion2_2s1' for p in model.parameters(): p.requires_grad = True for p in model.model1.parameters(): p.requires_grad = False for p in model.model2.parameters(): p.requires_grad = False for p in model.model3.parameters(): p.requires_grad = False for p in model.model4.parameters(): p.requires_grad = False criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=.05, momentum=0.9, weight_decay=5e-4) scheduler = lr_scheduler.StepLR(optimizer, step_size=int(epochs1 / 3), gamma=0.1) best_acc, model = train_model(model, criterion, optimizer, scheduler, epochs1, dataloaders, dataset_sizes, device=device) torch.save(model.state_dict(), str(save_path / model_name + '_morefc')) ######################## TRAIN ALL LAYERS model_name = 'Fusion2_2s2' batch_size = 6 dataloaders, dataset_sizes = make_batch_gen_cifar(str(PATH), batch_size, num_workers, valid_name='valid') for p in model.parameters(): p.requires_grad = True criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=.005, momentum=0.9, weight_decay=5e-4) scheduler = lr_scheduler.StepLR(optimizer, step_size=int(epochs2 / 3), gamma=0.1) best_acc, model = train_model(model, criterion, optimizer, scheduler, epochs1, dataloaders, dataset_sizes, device=device) torch.save(model.state_dict(), str(save_path / model_name + '_morefc'))
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform) trainloader = torch.utils.data.DataLoader(testset, batch_size=16, shuffle=True, num_workers=0) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') config = {"mb": 0, "mbr": 2} # config = {"mb":0,"mbr":0} net = ResNet50(config) net = net.to(device) print(torch.cuda.is_available()) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) step_per_epoch = len(trainloader) total_epoch = 1000 loss_list = [] for epoch in range(total_epoch): # loop over the dataset multiple times net.train() running_loss = 0.0
return prediction if __name__ == "__main__": height = 224 width = 224 file_list, X_test, X_angle_test, _ = read_data('data/test.json', height=height, width=width) print X_test.shape file_path = "./model_weights_1.hdf5" prediction_1 = predict_test( file_path, ResNet50.get_model(input_shape1=[height, width, 3], input_shape2=[1]), X_test) # file_path = "./model_weights_2.hdf5" # prediction_2 = predict_test(file_path, # model.get_model(input_shape1=[height, width, 3], # input_shape2=[1]), # X_test) # prediction = (prediction_1 + prediction_2) / 2 prediction = prediction_1 submission = pd.DataFrame({ 'id': file_list, 'is_iceberg': prediction.reshape((prediction.shape[0])) })
def main(): # create the experiments dirs create_dirs([Config.summary_dir, Config.checkpoint_dir, "logs"]) handlers = [ logging.FileHandler( datetime.now().strftime(f"./logs/%Y-%m-%d_%H-%M-%S-Log.log")), logging.StreamHandler() ] logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO, handlers=handlers) logging.info("Started Logging") logging.info( f"Number of cores: {pprint.pformat(Config.num_parallel_cores)}") logging.info( f"Address of GPU used for training: {pprint.pformat(Config.gpu_address)}" ) logging.info( f"Type of DataLoader: {pprint.pformat(Config.dataloader_type)}") logging.info(f"Type of Model: {pprint.pformat(Config.model_type)}") logging.info(f"Number of Epochs: {pprint.pformat(Config.num_epochs)}") logging.info(f"Optimizer Type: {pprint.pformat(Config.optimizer_type)}") logging.info( f"Optimizer parameters: {pprint.pformat(Config.optim_params)}") logging.info( f"Train/Validation split ratio: {pprint.pformat(Config.train_val_split)}" ) logging.info(f"Batch size: {pprint.pformat(Config.batch_size)}") logging.info( f"Training on Subset of the data: {pprint.pformat(Config.train_on_subset)}" ) logging.info( f"Training on Subset of size: {pprint.pformat(Config.subset_size)}") logging.info( f"Generating Patches: {pprint.pformat(Config.train_on_patches)}") logging.info(f"Patch size (square): {pprint.pformat(Config.patch_size)}") # create your data generator with tf.device("/cpu:0"): if (Config.dataloader_type.lower() == 'onlinedatasetloader'): data_loader = OnlineDatasetLoader.OnlineDatasetLoader(Config) if (Config.dataloader_type.lower() == 'datasetfileloader'): data_loader = DatasetFileLoader.DatasetFileLoader(Config) else: data_loader = DatasetLoader.DatasetLoader(Config) # create tensorflow session with tf.Session() as sess: # create instance of the model you want if (Config.model_type.lower() == 'lenet'): model = LeNet.LeNet(data_loader, Config) elif (Config.model_type.lower() == 'resnet50'): model = ResNet50.ResNet50(data_loader, Config) elif (Config.model_type.lower() == 'alexnet'): model = AlexNet.AlexNet(data_loader, Config) elif (Config.model_type.lower() == 'inception'): model = Inception.Inception(data_loader, Config) else: model = LeNet.LeNet(data_loader, Config) # create tensorboard logger logger = DefinedSummarizer(sess, summary_dir=Config.summary_dir, scalar_tags=[ 'train/loss_per_epoch', 'train/acc_per_epoch', 'test/loss_per_epoch', 'test/acc_per_epoch' ]) # create trainer and path all previous components to it trainer = MTrainer(sess, model, Config, logger, data_loader) # here you train your model trainer.train()
def train(**kwargs): opt.parse(kwargs) # log file ps = PlotSaver("FrozenCNN_ResNet50_RGB_"+time.strftime("%m_%d_%H:%M:%S")+".log.txt") # step1: Model compression_model = getattr(models, opt.model)(use_imp = opt.use_imp, model_name="CWCNN_limu_ImageNet_imp_r={r}_γ={w}_for_resnet50".format( r=opt.rate_loss_threshold, w=opt.rate_loss_weight) if opt.use_imp else None) compression_model.load(None, opt.compression_model_ckpt) compression_model.eval() if use_original_RGB: resnet_50 = resnet50() # Official ResNet else: resnet_50 = ResNet50() # My ResNet if opt.use_gpu: # compression_model.cuda() # resnet_50.cuda() compression_model = multiple_gpu_process(compression_model) resnet_50 = multiple_gpu_process(resnet_50) # freeze the compression network for param in compression_model.parameters(): # print (param.requires_grad) param.requires_grad = False cudnn.benchmark = True # pdb.set_trace() # step2: Data normalize = transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ) train_data_transforms = transforms.Compose( [ transforms.Resize(256), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize ] ) val_data_transforms = transforms.Compose( [ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize ] ) train_data = datasets.ImageFolder( opt.train_data_root, train_data_transforms ) val_data = datasets.ImageFolder( opt.val_data_root, val_data_transforms ) train_dataloader = DataLoader(train_data, opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True) val_dataloader = DataLoader(val_data, opt.batch_size, shuffle=False, num_workers=opt.num_workers, pin_memory=True) # step3: criterion and optimizer class_loss = t.nn.CrossEntropyLoss() lr = opt.lr # optimizer = t.optim.Adam(resnet_50.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=opt.weight_decay) optimizer = t.optim.SGD(resnet_50.parameters(), lr=lr, momentum=opt.momentum, weight_decay=opt.weight_decay) start_epoch = 0 if opt.resume: start_epoch = resnet_50.module.load(None if opt.finetune else optimizer, opt.resume, opt.finetune) if opt.finetune: print ('Finetune from model checkpoint file', opt.resume) else: print ('Resume training from checkpoint file', opt.resume) print ('Continue training at epoch %d.' % start_epoch) # step4: meters class_loss_meter = AverageValueMeter() class_acc_top5_meter = AverageValueMeter() class_acc_top1_meter = AverageValueMeter() # class_loss_meter = AverageMeter() # class_acc_top5_meter = AverageMeter() # class_acc_top1_meter = AverageMeter() # ps init ps.new_plot('train class loss', opt.print_freq, xlabel="iteration", ylabel="train_CE_loss") ps.new_plot('val class loss', 1, xlabel="epoch", ylabel="val_CE_loss") ps.new_plot('train top_5 acc', opt.print_freq, xlabel="iteration", ylabel="train_top5_acc") ps.new_plot('train top_1 acc', opt.print_freq, xlabel="iteration", ylabel="train_top1_acc") ps.new_plot('val top_5 acc', 1, xlabel="iteration", ylabel="val_top_5_acc") ps.new_plot('val top_1 acc', 1, xlabel="iteration", ylabel="val_top_1_acc") for epoch in range(start_epoch+1, opt.max_epoch+1): # per epoch avg loss meter class_loss_meter.reset() class_acc_top1_meter.reset() class_acc_top5_meter.reset() # cur_epoch_loss refresh every epoch ps.new_plot("cur epoch train class loss", opt.print_freq, xlabel="iteration in cur epoch", ylabel="cur_train_CE_loss") resnet_50.train() for idx, (data, label) in enumerate(train_dataloader): ipt = Variable(data) label = Variable(label) if opt.use_gpu: ipt = ipt.cuda() label = label.cuda() optimizer.zero_grad() if not use_original_RGB: compressed_RGB = compression_model(ipt) else: compressed_RGB = ipt # print ('RGB', compressed_RGB.requires_grad) predicted = resnet_50(compressed_RGB) class_loss_ = class_loss(predicted, label) class_loss_.backward() optimizer.step() class_loss_meter.add(class_loss_.data[0]) # class_loss_meter.update(class_loss_.data[0], ipt.size(0)) acc1, acc5 = accuracy(predicted.data, label.data, topk=(1, 5)) # pdb.set_trace() class_acc_top1_meter.add(acc1[0]) class_acc_top5_meter.add(acc5[0]) # class_acc_top1_meter.update(acc1[0], ipt.size(0)) # class_acc_top5_meter.update(acc5[0], ipt.size(0)) if idx % opt.print_freq == opt.print_freq - 1: ps.add_point('train class loss', class_loss_meter.value()[0] if opt.print_smooth else class_loss_.data[0]) ps.add_point('cur epoch train class loss', class_loss_meter.value()[0] if opt.print_smooth else class_loss_.data[0]) ps.add_point('train top_5 acc', class_acc_top5_meter.value()[0] if opt.print_smooth else acc5[0]) ps.add_point('train top_1 acc', class_acc_top1_meter.value()[0] if opt.print_smooth else acc1[0]) ps.log('Epoch %d/%d, Iter %d/%d, class loss = %.4f, top 5 acc = %.2f %%, top 1 acc = %.2f %%, lr = %.8f' % (epoch, opt.max_epoch, idx, len(train_dataloader), class_loss_meter.value()[0], class_acc_top5_meter.value()[0], class_acc_top1_meter.value()[0], lr)) # 进入debug模式 if os.path.exists(opt.debug_file): pdb.set_trace() if use_data_parallel: resnet_50.module.save(optimizer, epoch) # plot before val can ease me ps.make_plot('train class loss') # all epoch share a same img, so give ""(default) to epoch ps.make_plot('cur epoch train class loss',epoch) ps.make_plot("train top_5 acc") ps.make_plot("train top_1 acc") val_class_loss, val_top5_acc, val_top1_acc = val(compression_model, resnet_50, val_dataloader, class_loss, None, ps) ps.add_point('val class loss', val_class_loss) ps.add_point('val top_5 acc', val_top5_acc) ps.add_point('val top_1 acc', val_top1_acc) ps.make_plot('val class loss') ps.make_plot('val top_5 acc') ps.make_plot('val top_1 acc') ps.log('Epoch:{epoch}, lr:{lr}, train_class_loss: {train_class_loss}, train_top5_acc: {train_top5_acc} %, train_top1_acc: {train_top1_acc} %, \ val_class_loss: {val_class_loss}, val_top5_acc: {val_top5_acc} %, val_top1_acc: {val_top1_acc} %'.format( epoch = epoch, lr = lr, train_class_loss = class_loss_meter.value()[0], train_top5_acc = class_acc_top5_meter.value()[0], train_top1_acc = class_acc_top1_meter.value()[0], val_class_loss = val_class_loss, val_top5_acc = val_top5_acc, val_top1_acc = val_top1_acc )) # adjust lr if (epoch in opt.lr_decay_step_list) or (opt.use_file_signal_to_adjust_lr and os.path.exists(opt.signal_file)): lr = lr * opt.lr_decay for param_group in optimizer.param_groups: param_group['lr'] = lr
x = F.relu(x) x = self.pool(x) x = self.conv2(x) x = F.relu(x) x = self.pool(x) x = x.view(-1, 16 * 5 * 5) x = self.fc1(x) x = F.relu(x) x = self.mb(x) x = self.fc2(x) x = F.relu(x) x = self.fc3(x) return x net = ResNet50() net = net.to(device) print(torch.cuda.is_available()) import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) step_per_epoch = len(trainloader) total_epoch = 100 for epoch in range(total_epoch): # loop over the dataset multiple times net.train() running_loss = 0.0
def main(_): print("FLAGS values:", tf.app.flags.FLAGS.flag_values_dict()) tf.logging.set_verbosity(tf.logging.INFO) config = tf.ConfigProto() if FLAGS.model == 'denoiser': config.gpu_options.per_process_gpu_memory_fraction = 0.2 else: config.gpu_options.allow_growth = True if FLAGS.model == 'denoiser': from models import Denoiser model = Denoiser() with tf.Graph().as_default(): # Prepare graph with tf.Session(config=config).as_default(): if FLAGS.model == 'inception-v3': from models import InceptionV3 model = InceptionV3() elif FLAGS.model == 'vgg-16': from models import VGG16 model = VGG16() elif FLAGS.model == 'resnet-50': from models import ResNet50 model = ResNet50() elif FLAGS.model == 'jpeg': from models import JPEG model = JPEG() elif FLAGS.model == 'random': from models import Random model = Random() if FLAGS.method != 'uniform': from surrogate_model import ResNet152 model_s = ResNet152(source_image_size=model.image_size, use_smoothed_grad=model.use_smoothed_grad) image_size = model.image_size # ---Setting hyperparameters--- if FLAGS.norm == 'l2': epsilon = 1e-3 eps = np.sqrt(epsilon * image_size * image_size * 3) learning_rate = 2.0 / np.sqrt(image_size * image_size * 3) else: epsilon = 0.05 eps = epsilon learning_rate = 0.005 if model.use_larger_step_size: ini_sigma = 1e-3 else: ini_sigma = 1e-4 # ----------------------------- if not model.predictions_is_correct: l = open(os.path.join(FLAGS.input_dir, 'labels')).readlines() gts = {} for i in l: i = i.strip().split(' ') gts[i[0]] = int(i[1]) + (model.num_classes - 1000) success = 0 queries = [] correct = 0 names_images = load_images(FLAGS.input_dir, model.image_size) for filename, image in names_images: output_logging = open(os.path.join(FLAGS.output_dir, 'logging'), 'a') sigma = ini_sigma np.random.seed(0) tf.set_random_seed(0) adv_image = image.copy() label = model.get_pred(image) l = model.get_loss(image, label) print(filename, 'original prediction:', label, 'loss:', l) if not model.predictions_is_correct: correct += (label[0] == gts[filename]) if label[0] != gts[filename]: output_logging.write(filename + ' original misclassified.\n') output_logging.close() continue lr = learning_rate last_loss = [] total_q = 0 ite = 0 while total_q <= FLAGS.max_queries: total_q += 1 if FLAGS.show_true and hasattr(model, 'get_grad'): true = np.squeeze(model.get_grad(adv_image, label)) print("Grad norm", np.sqrt(np.sum(true * true))) if ite % 2 == 0 and sigma != ini_sigma: print( "sigma has been increased before; checking if sigma could be set back to ini_sigma" ) rand = np.random.normal(size=adv_image.shape) rand = rand / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(rand)))) rand_loss = model.get_loss(adv_image + ini_sigma * rand, label) total_q += 1 rand = np.random.normal(size=adv_image.shape) rand = rand / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(rand)))) rand_loss2 = model.get_loss(adv_image + ini_sigma * rand, label) total_q += 1 if (rand_loss - l)[0] != 0 and (rand_loss2 - l)[0] != 0: print("set sigma back to ini_sigma") sigma = ini_sigma if FLAGS.method != 'uniform': if model.num_classes < model_s.num_classes: s_label = label + 1 elif model.num_classes > model_s.num_classes: s_label = label - 1 else: s_label = label prior = np.squeeze(model_s.get_grad(adv_image, s_label)) if FLAGS.show_true and hasattr(model, 'get_grad'): alpha = np.sum(true * prior) / np.maximum( 1e-12, np.sqrt(np.sum(true * true) * np.sum(prior * prior))) print("alpha =", alpha) prior = prior / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(prior)))) if FLAGS.method in ['biased', 'average']: start_iter = 3 if ite % 10 == 0 or ite == start_iter: # Estimate norm of true gradient periodically when ite == 0/10/20...; # since gradient norm may change fast in the early iterations, we also # estimate the gradient norm when ite == 3. s = 10 pert = np.random.normal(size=(s, ) + adv_image.shape) for i in range(s): pert[i] = pert[i] / \ np.maximum( 1e-12, np.sqrt(np.mean(np.square(pert[i])))) eval_points = adv_image + sigma * pert losses = model.get_loss(eval_points, np.repeat(label, s)) total_q += s norm_square = np.average(((losses - l) / sigma)**2) while True: prior_loss = model.get_loss(adv_image + sigma * prior, label) total_q += 1 diff_prior = (prior_loss - l)[0] if diff_prior == 0: # Avoid the numerical issue in finite difference sigma *= 2 print("multiply sigma by 2") else: break est_alpha = diff_prior / sigma / \ np.maximum( np.sqrt(np.sum(np.square(prior)) * norm_square), 1e-12) print("Estimated alpha =", est_alpha) alpha = est_alpha if alpha < 0: prior = -prior alpha = -alpha q = FLAGS.samples_per_draw n = image_size * image_size * 3 d = 50 * 50 * 3 gamma = 3.5 A_square = d / n * gamma return_prior = False if FLAGS.method == 'average': if FLAGS.dataprior: alpha_nes = np.sqrt(A_square * q / (d + q - 1)) else: alpha_nes = np.sqrt(q / (n + q - 1)) if alpha >= 1.414 * alpha_nes: return_prior = True elif FLAGS.method == 'biased': if FLAGS.dataprior: best_lambda = A_square * ( A_square - alpha**2 * (d + 2 * q - 2)) / (A_square**2 + alpha**4 * d**2 - 2 * A_square * alpha**2 * (q + d * q - 1)) else: best_lambda = (1 - alpha**2) * ( 1 - alpha**2 * (n + 2 * q - 2)) / (alpha**4 * n * (n + 2 * q - 2) - 2 * alpha**2 * n * q + 1) print('best_lambda = ', best_lambda) if best_lambda < 1 and best_lambda > 0: lmda = best_lambda else: if alpha**2 * (n + 2 * q - 2) < 1: lmda = 0 else: lmda = 1 if np.abs(alpha) >= 1: lmda = 1 print('lambda = ', lmda) if lmda == 1: return_prior = True elif FLAGS.method == 'fixed_biased': lmda = FLAGS.fixed_const if not return_prior: if FLAGS.dataprior: pert = np.random.normal(size=(q, 50, 50, 3)) pert = np.array([ cv2.resize(pert[i], adv_image.shape[:2], interpolation=cv2.INTER_NEAREST) for i in range(q) ]) else: pert = np.random.normal(size=(q, ) + adv_image.shape) for i in range(q): if FLAGS.method in ['biased', 'fixed_biased']: pert[i] = pert[i] - np.sum( pert[i] * prior) * prior / np.maximum( 1e-12, np.sum(prior * prior)) pert[i] = pert[i] / \ np.maximum( 1e-12, np.sqrt(np.mean(np.square(pert[i])))) pert[i] = np.sqrt(1 - lmda) * \ pert[i] + np.sqrt(lmda) * prior else: pert[i] = pert[i] / \ np.maximum( 1e-12, np.sqrt(np.mean(np.square(pert[i])))) while True: eval_points = adv_image + sigma * pert losses = model.get_loss(eval_points, np.repeat(label, q)) total_q += q grad = (losses - l).reshape(-1, 1, 1, 1) * pert grad = np.mean(grad, axis=0) norm_grad = np.sqrt(np.mean(np.square(grad))) if norm_grad == 0: # Avoid the numerical issue in finite difference sigma *= 5 print("estimated grad == 0, multiply sigma by 5") else: break grad = grad / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(grad)))) if FLAGS.method == 'average': while True: diff_prior = ( model.get_loss(adv_image + sigma * prior, label) - l)[0] total_q += 1 diff_nes = ( model.get_loss(adv_image + sigma * grad, label) - l)[0] total_q += 1 diff_prior = max(0, diff_prior) if diff_prior == 0 and diff_nes == 0: sigma *= 2 print("multiply sigma by 2") else: break final = prior * diff_prior + grad * diff_nes final = final / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(final)))) print("diff_prior = {}, diff_nes = {}".format( diff_prior, diff_nes)) elif FLAGS.method == 'fixed_average': diff_prior = ( model.get_loss(adv_image + sigma * prior, label) - l)[0] total_q += 1 if diff_prior < 0: prior = -prior final = FLAGS.fixed_const * prior + \ (1 - FLAGS.fixed_const) * grad final = final / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(final)))) else: final = grad def print_loss(model, direction): length = [1e-4, 1e-3] les = [] for ss in length: les.append(( model.get_loss(adv_image + ss * direction, label) - l)[0]) print("losses", les) if FLAGS.show_loss: if FLAGS.method in ['average', 'fixed_average']: lprior = model.get_loss(adv_image + lr * prior, label) - l print_loss(model, prior) lgrad = model.get_loss(adv_image + lr * grad, label) - l print_loss(model, grad) lfinal = model.get_loss(adv_image + lr * final, label) - l print_loss(model, final) print(lprior, lgrad, lfinal) elif FLAGS.method in ['biased', 'fixed_biased']: lprior = model.get_loss(adv_image + lr * prior, label) - l print_loss(model, prior) lgrad = model.get_loss(adv_image + lr * grad, label) - l print_loss(model, grad) print(lprior, lgrad) else: final = prior if FLAGS.show_true and hasattr(model, 'get_grad'): if FLAGS.method in ['average', 'fixed_average' ] and not return_prior: print( "NES angle =", np.sum(true * grad) / np.maximum( 1e-12, np.sqrt( np.sum(true * true) * np.sum(grad * grad)))) print( "angle =", np.sum(true * final) / np.maximum( 1e-12, np.sqrt(np.sum(true * true) * np.sum(final * final)))) if FLAGS.norm == 'l2': adv_image = adv_image + lr * final / \ np.maximum(1e-12, np.sqrt(np.mean(np.square(final)))) norm = max(1e-12, np.linalg.norm(adv_image - image)) factor = min(1, eps / norm) adv_image = image + (adv_image - image) * factor else: adv_image = adv_image + lr * np.sign(final) adv_image = np.clip(adv_image, image - eps, image + eps) adv_image = np.clip(adv_image, 0, 1) adv_label = model.get_pred(adv_image) l = model.get_loss(adv_image, label) print('queries:', total_q, 'loss:', l, 'learning rate:', lr, 'sigma:', sigma, 'prediction:', adv_label, 'distortion:', np.max(np.abs(adv_image - image)), np.linalg.norm(adv_image - image)) ite += 1 if adv_label != label: print('Stop at queries:', total_q) success += 1 queries.append(total_q) imsave(os.path.join(FLAGS.output_dir, filename), adv_image) output_logging.write(filename + ' succeed; queries: ' + str(total_q) + '\n') break else: imsave(os.path.join(FLAGS.output_dir, filename), adv_image) output_logging.write(filename + ' fail.\n') output_logging.close() if model.predictions_is_correct: total = FLAGS.number_images else: total = correct print('Success rate:', success / total, 'Queries', queries) output_logging = open(os.path.join(FLAGS.output_dir, 'logging'), 'a') output_logging.write('Success rate: ' + str(success / total) + ', Queries on success: ' + str(np.mean(queries))) output_logging.close()
else: labels.append(int(label)) camera_id.append(int(camera[0])) return camera_id, labels gallery_path = image_datasets['gallery'].imgs query_path = image_datasets['query'].imgs gallery_cam, gallery_label = get_id(gallery_path) query_cam, query_label = get_id(query_path) ###################################################################### # Load Collected data Trained model print('----------test-----------') model_structure = ResNet50(751, feat_size, metric, margin, scalar) model = load_network(model_structure).model # Change to test mode model = model.eval() model = model.cuda() # Extract feature gallery_feature = extract_feature(model, dataloaders['gallery']) query_feature = extract_feature(model, dataloaders['query']) # Save to Matlab for check result = { 'gallery_f': gallery_feature.numpy(), 'gallery_label': gallery_label,
def main(args): # Parsing command line arguments print("========================================================") print("Process %s, running on %s: starting (%s)" % ( os.getpid(), os.name, time.asctime())) print("========================================================") if args.cnn_model == 'vgg': image_model = VGG19(pretrained=True) else: image_model = ResNet50(pretrained = True) caption_model = LSTMBranch() if torch.cuda.is_available() and args.use_gpu == True: image_model = image_model.cuda() caption_model = caption_model.cuda() # Get the learnable parameters image_trainables = [p for p in image_model.parameters() if p.requires_grad] caption_trainables = [p for p in caption_model.parameters() if p.requires_grad] params = image_trainables + caption_trainables transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))]) # Obtain the data loader (from file). Note that it runs much faster than before! print("Dataset being used: ", args.dataset) if args.dataset == 'flickr': data_loader_train = get_loader_flickr(transform=transform, mode='train', batch_size=args.batch_size, parse_mode=args.parse_mode) data_loader_val = get_loader_flickr(transform=transform, mode='val', batch_size=args.batch_size, parse_mode=args.parse_mode) elif args.dataset == 'coco': data_loader_train = get_loader_coco(transform=transform, mode='train', batch_size=args.batch_size) data_loader_val = get_loader_coco(transform=transform, mode='val', batch_size=args.batch_size) else: data_loader_train = get_loader_genome(transform=transform, mode='train', batch_size=args.batch_size) data_loader_val = get_loader_genome(transform=transform, mode='train', batch_size=args.batch_size) # Load saved model start_epoch, best_loss = load_checkpoint(image_model, caption_model, args.resume) # optimizer = torch.optim.Adam(params=params, lr=0.01) optimizer = torch.optim.SGD(params=params, lr=args.lr, momentum=0.9) total_train_step = math.ceil( len(data_loader_train.dataset.caption_lengths) / data_loader_train.batch_sampler.batch_size) # print("Total number of training steps are :", total_train_step) print("========================================================") print("Total number of epochs to train: ", args.n_epochs) print("Loss Type: ", args.loss_type) if args.loss_type == 'triplet': print("Sampling strategy: ", args.sampler) print("Margin for triplet loss: ", args.margin) print("Learning Rate: ", args.lr) print("Score Type for similarity: ", args.score_type) print("========================================================") epoch = start_epoch best_epoch = start_epoch # while (epoch - best_epoch) < args.no_gain_stop and (epoch <= args.n_epochs): while epoch <= args.n_epochs: adjust_learning_rate(args.lr, args.lr_decay, optimizer, epoch) print("========================================================") print("Epoch: %d Training starting" % epoch) print("Learning rate : ", get_lr(optimizer)) train_loss = train(data_loader_train, data_loader_val, image_model, caption_model, args.loss_type, optimizer, epoch, args.score_type, args.sampler, args.margin, total_train_step, args.batch_size, args.use_gpu) print('---------------------------------------------------------') print("Epoch: %d Validation starting" % epoch) val_loss = validate(caption_model, image_model, data_loader_val, epoch, args.loss_type, args.score_type, args.sampler, args.margin, args.use_gpu) print("Epoch: ", epoch) print("Training Loss: ", float(train_loss.data)) print("Validation Loss: ", float(val_loss.data)) print("========================================================") save_checkpoint({ 'epoch': epoch, 'best_loss': min(best_loss, val_loss), 'image_model': image_model.state_dict(), 'caption_model': caption_model.state_dict() }, val_loss < best_loss) if (val_loss) < best_loss: best_epoch = epoch best_loss = val_loss epoch += 1 print("Back to main") resume_filename = 'runs/%s/' % (args.name) + 'model_best.pth.tar' if os.path.exists(resume_filename): epoch, best_loss1 = load_checkpoint(image_model, caption_model, args.resume) val_loss1 = validate(caption_model, image_model, data_loader_val, epoch, args.loss_type, args.score_type, args.sampler, args.margin, args.use_gpu) print("========================================================") print("========================================================") print("Final Loss : ", float(val_loss1.data)) print("========================================================") print("========================================================") else: resume_filename = 'runs/%s/' % (args.name) + 'checkpoint.pth.tar' print("Using last run epoch.") epoch, best_loss1 = load_checkpoint(image_model, caption_model, args.resume) val_loss1 = validate(caption_model, image_model, data_loader_val, epoch, args.loss_type, args.score_type, args.sampler, args.margin, args.use_gpu) print("========================================================") print("========================================================") print("Final Loss : ", float(val_loss1.data)) print("========================================================") print("========================================================")
def root_path(): return os.path.dirname(sys.argv[0]) def quantize_model(model_, path): converter = tf.lite.TFLiteConverter.from_keras_model(model_) converter.optimizations = [tf.lite.Optimize.DEFAULT] quantized_model = converter.convert() quantized_path = path + '.optimized' open(quantized_path, "wb").write(quantized_model) print(f'\nQuantized model saved as {quantized_path}\n') return if __name__ == '__main__': model_name = 'ResNet50_256x256_Wayne_Reilly' weights_name = 'weights.cat_acc_best.hdf5' input_shape = (256, 256, 3) classes = 24 model = ResNet50(input_shape=input_shape, classes=classes, name='ResNet50') model.load_weights( os.path.join(root_path(), 'models', model_name, weights_name)) quantize_model(model, os.path.join(root_path(), 'models', model_name)) sys.exit(0)
time_elapsed // 60, time_elapsed % 60)) return model def save_network(network, epoch_label): save_filename = 'net_%s.pth' % epoch_label save_path = os.path.join('./logs', name, save_filename) torch.save(network.cpu().state_dict(), save_path) if torch.cuda.is_available: network.cuda() if __name__ == '__main__': model = ResNet50(len(class_names), feat_size, metric, margin, scalar, dropout).cuda() xent_criterion = nn.CrossEntropyLoss() tri_criterion = TripletLoss() criterion = [xent_criterion, tri_criterion] # SGD_Step if optim_type == 'SGD_Step': optimizer = optim.SGD(params=model.parameters(), lr=0.01, weight_decay=5e-4, momentum=0.9, nesterov=True) lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=40, gamma=0.1) #lr_scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[20, 60, 70, 80], gamma=0.1) # SGD_Warmup
"target_update_frequency":target_update_frequency, "replay_buffer_capacity":replay_buffer_capacity, "replay_buffer_minimum_number_samples": replay_buffer_minimum_number_samples, "object_detection_threshold": object_detection_threshold, "maximum_num_entities_per_image": maximum_num_entities_per_image, "maximum_adaptive_action_space_size": maximum_adaptive_action_space_size} # create semantic action graph print("Loading graph.pickle...") semantic_action_graph = pickle.load(open("graph.pickle", "rb")) print("Done!") # create VGG model for state featurization print("Loading image embedding model...") if args.image_embedding_model_type == "resnet": im_emb_model = ResNet50() elif args.image_embedding_model_type == "vgg": im_emb_model = VGG16() else: print("--image_embedding_model_type must be either resnet or vgg") sys.exit(0) print("Done!") # create Faster-RCNN model for state featurization print("Loading Fast-RCNN...") model_file = 'VGGnet_fast_rcnn_iter_70000.h5' model_frcnn = FasterRCNN() network.load_net(model_file, model_frcnn) model_frcnn.cuda() model_frcnn.eval() print("Done!")
model_path, map_location=torch.device("cpu"))) model_state_dict = {} for name, module in state_dict.items(): fields = name.split(".") if "mask" in name: continue if "weight_orig" in name: orig_weight = module mask = state_dict[".".join(fields[:-1] + ["weight_mask"])] m = orig_weight * mask k = ".".join(fields[1:-1] + ["weight"]) else: m = module k = ".".join(fields[1:]) model_state_dict[k] = m model = ResNet50() conv_runtime_dict = {} orig_pointer = nn.Module.__call__ def _get_sparsity(m): return float(torch.sum(m == 0)) / float(m.numel()) def _instrument(*args, **kwargs): global ctr print("instrumented! len(args) = {}".format(len(args))) if len(args) != 2: raise ValueError("Not sure what to do with args != 2...") begin = time.time()
def train(**kwargs): config.parse(kwargs) # ============================================ Visualization ============================================= vis = Visualizer(port=2333, env=config.env) vis.log('Use config:') for k, v in config.__class__.__dict__.items(): if not k.startswith('__'): vis.log(f"{k}: {getattr(config, k)}") # ============================================= Prepare Data ============================================= train_data = SlideWindowDataset(config.train_paths, phase='train', useRGB=config.useRGB, usetrans=config.usetrans, balance=config.data_balance) val_data = SlideWindowDataset(config.test_paths, phase='val', useRGB=config.useRGB, usetrans=config.usetrans, balance=False) print('Training Images:', train_data.__len__(), 'Validation Images:', val_data.__len__()) dist = train_data.dist() print('Train Data Distribution:', dist) train_dataloader = DataLoader(train_data, batch_size=config.batch_size, shuffle=True, num_workers=config.num_workers) val_dataloader = DataLoader(val_data, batch_size=config.batch_size, shuffle=False, num_workers=config.num_workers) # ============================================= Prepare Model ============================================ # model = AlexNet(num_classes=config.num_classes) # model = Vgg16(num_classes=config.num_classes) # model = Modified_Vgg16(num_classes=config.num_classes) # model = ResNet18(num_classes=config.num_classes) model = ResNet50(num_classes=config.num_classes) # model = DenseNet121(num_classes=config.num_classes) # model = ShallowNet(num_classes=config.num_classes) # model = Customed_ShallowNet(num_classes=config.num_classes) # model = Modified_AGVgg16(num_classes=2) # model = AGResNet18(num_classes=2) print(model) if config.load_model_path: model.load(config.load_model_path) if config.use_gpu: model.cuda() if config.parallel: model = torch.nn.DataParallel( model, device_ids=[x for x in range(config.num_of_gpu)]) # =========================================== Criterion and Optimizer ===================================== # weight = torch.Tensor([1, 1]) # weight = torch.Tensor([dist['1']/(dist['0']+dist['1']), dist['0']/(dist['0']+dist['1'])]) # weight需要将二者反过来,多于二分类可以取倒数 # weight = torch.Tensor([1, 3.5]) # weight = torch.Tensor([1, 5]) weight = torch.Tensor([1, 7]) vis.log(f'loss weight: {weight}') print('loss weight:', weight) weight = weight.cuda() criterion = torch.nn.CrossEntropyLoss(weight=weight) lr = config.lr optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=config.weight_decay) # ================================================== Metrics =============================================== softmax = functional.softmax loss_meter = meter.AverageValueMeter() epoch_loss = meter.AverageValueMeter() train_cm = meter.ConfusionMeter(config.num_classes) # ====================================== Saving and Recording Configuration ================================= previous_auc = 0 if config.parallel: save_model_dir = config.save_model_dir if config.save_model_dir else model.module.model_name save_model_name = config.save_model_name if config.save_model_name else model.module.model_name + '_best_model.pth' else: save_model_dir = config.save_model_dir if config.save_model_dir else model.model_name save_model_name = config.save_model_name if config.save_model_name else model.model_name + '_best_model.pth' save_epoch = 1 # 用于记录验证集上效果最好模型对应的epoch process_record = { 'epoch_loss': [], 'train_avg_se': [], 'train_se_0': [], 'train_se_1': [], 'val_avg_se': [], 'val_se_0': [], 'val_se_1': [], 'AUC': [] } # 用于记录实验过程中的曲线,便于画曲线图 # ================================================== Training =============================================== for epoch in range(config.max_epoch): print( f"epoch: [{epoch+1}/{config.max_epoch}] {config.save_model_name[:-4]} ==================================" ) train_cm.reset() epoch_loss.reset() # ****************************************** train **************************************** model.train() for i, (image, label, image_path) in tqdm(enumerate(train_dataloader)): loss_meter.reset() # ------------------------------------ prepare input ------------------------------------ if config.use_gpu: image = image.cuda() label = label.cuda() # ---------------------------------- go through the model -------------------------------- score = model(image) # ----------------------------------- backpropagate ------------------------------------- optimizer.zero_grad() loss = criterion(score, label) loss.backward() optimizer.step() # ------------------------------------ record loss ------------------------------------ loss_meter.add(loss.item()) epoch_loss.add(loss.item()) train_cm.add(softmax(score, dim=1).detach(), label.detach()) if (i + 1) % config.print_freq == 0: vis.plot('loss', loss_meter.value()[0]) train_se = [ 100. * train_cm.value()[0][0] / (train_cm.value()[0][0] + train_cm.value()[0][1]), 100. * train_cm.value()[1][1] / (train_cm.value()[1][0] + train_cm.value()[1][1]) ] # *************************************** validate *************************************** model.eval() if (epoch + 1) % 1 == 0: Best_T, val_cm, val_spse, val_accuracy, AUC = val( model, val_dataloader) # ------------------------------------ save model ------------------------------------ if AUC > previous_auc and epoch + 1 > 5: if config.parallel: if not os.path.exists( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0])): os.makedirs( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0])) model.module.save( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0], save_model_name)) else: if not os.path.exists( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0])): os.makedirs( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0])) model.save( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0], save_model_name)) previous_auc = AUC save_epoch = epoch + 1 # ---------------------------------- recond and print --------------------------------- process_record['epoch_loss'].append(epoch_loss.value()[0]) process_record['train_avg_se'].append(np.average(train_se)) process_record['train_se_0'].append(train_se[0]) process_record['train_se_1'].append(train_se[1]) process_record['val_avg_se'].append(np.average(val_spse)) process_record['val_se_0'].append(val_spse[0]) process_record['val_se_1'].append(val_spse[1]) process_record['AUC'].append(AUC) vis.plot_many({ 'epoch_loss': epoch_loss.value()[0], 'train_avg_se': np.average(train_se), 'train_se_0': train_se[0], 'train_se_1': train_se[1], 'val_avg_se': np.average(val_spse), 'val_se_0': val_spse[0], 'val_se_1': val_spse[1], 'AUC': AUC }) vis.log( f"epoch: [{epoch+1}/{config.max_epoch}] =========================================" ) vis.log( f"lr: {optimizer.param_groups[0]['lr']}, loss: {round(loss_meter.value()[0], 5)}" ) vis.log( f"train_avg_se: {round(np.average(train_se), 4)}, train_se_0: {round(train_se[0], 4)}, train_se_1: {round(train_se[1], 4)}" ) vis.log( f"val_avg_se: {round(sum(val_spse)/len(val_spse), 4)}, val_se_0: {round(val_spse[0], 4)}, val_se_1: {round(val_spse[1], 4)}" ) vis.log(f"AUC: {AUC}") vis.log(f'train_cm: {train_cm.value()}') vis.log(f'Best Threshold: {Best_T}') vis.log(f'val_cm: {val_cm}') print("lr:", optimizer.param_groups[0]['lr'], "loss:", round(epoch_loss.value()[0], 5)) print('train_avg_se:', round(np.average(train_se), 4), 'train_se_0:', round(train_se[0], 4), 'train_se_1:', round(train_se[1], 4)) print('val_avg_se:', round(np.average(val_spse), 4), 'val_se_0:', round(val_spse[0], 4), 'val_se_1:', round(val_spse[1], 4)) print('AUC:', AUC) print('train_cm:') print(train_cm.value()) print('Best Threshold:', Best_T, 'val_cm:') print(val_cm) # ------------------------------------ save record ------------------------------------ if os.path.exists( os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0])): write_json(file=os.path.join('checkpoints', save_model_dir, save_model_name.split('.')[0], 'process_record.json'), content=process_record) # if (epoch+1) % 5 == 0: # lr = lr * config.lr_decay # for param_group in optimizer.param_groups: # param_group['lr'] = lr vis.log(f"Best Epoch: {save_epoch}") print("Best Epoch:", save_epoch)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform) trainloader = torch.utils.data.DataLoader(testset, batch_size=16, shuffle=True, num_workers=0) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') import torch.nn as nn import torch.nn.functional as F net = ResNet50(RCV_CONFIG) net = net.to(device) print(torch.cuda.is_available()) import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) step_per_epoch = len(trainloader) total_epoch = 100 best_acc = 0.0 for epoch in range(total_epoch): # loop over the dataset multiple times net.train()
import torch from models import ResNet50 file = "save/models/ResNet50_vanilla/ckpt_epoch_240.pth" ff = torch.load(file, map_location="cpu") model = ResNet50(num_classes=10) model.load_state_dict(ff["model"])