def Modellist(model_name, num_classes=1000, use_attention=None): if model_name == 'vgg11': return vgg.VGG11(num_classes, use_attention=use_attention) elif model_name == 'vgg13': return vgg.VGG13(num_classes, use_attention=use_attention) elif model_name == 'vgg16': return vgg.VGG16(num_classes, use_attention=use_attention) elif model_name == 'vgg19': return vgg.VGG19(num_classes, use_attention=use_attention) elif model_name == 'resnet18': return resnet.ResNet18(num_classes, use_attention=use_attention) elif model_name == 'resnet34': return resnet.ResNet34(num_classes, use_attention=use_attention) elif model_name == 'resnet50': return resnet.ResNet50(num_classes, use_attention=use_attention) elif model_name == 'resnet101': return resnet.ResNet101(num_classes, use_attention=use_attention) elif model_name == 'resnet152': return resnet.ResNet152(num_classes, use_attention=use_attention) elif model_name == 'densenet121': return densenet.DenseNet121(num_classes, use_attention=use_attention) elif model_name == 'densenet169': return densenet.DenseNet169(num_classes, use_attention=use_attention) elif model_name == 'densenet201': return densenet.DenseNet201(num_classes, use_attention=use_attention) elif model_name == 'densenet161': return densenet.DenseNet161(num_classes, use_attention=use_attention) elif model_name == 'mobilenetv3_small': return mobilenetv3.mobilenetv3_small(num_classes) elif model_name == 'mobilenetv3_large': return mobilenetv3.mobilenetv3_large(num_classes) elif model_name == 'efficientnet_b0': return efficientnet.efficientnet_b0(num_classes, use_attention=use_attention) elif model_name == 'efficientnet_b1': return efficientnet.efficientnet_b1(num_classes, use_attention=use_attention) elif model_name == 'efficientnet_b2': return efficientnet.efficientnet_b2(num_classes, use_attention=use_attention) elif model_name == 'efficientnet_b3': return efficientnet.efficientnet_b3(num_classes, use_attention=use_attention) elif model_name == 'efficientnet_b4': return efficientnet.efficientnet_b4(num_classes, use_attention=use_attention) elif model_name == 'efficientnet_b5': return efficientnet.efficientnet_b5(num_classes, use_attention=use_attention) elif model_name == 'efficientnet_b6': return efficientnet.efficientnet_b6(num_classes, use_attention=use_attention) else: raise ValueError("The model_name does not exist.")
def __init__(self, model, num_workers, lr, job_name): self.lock = threading.Lock() self.logger = Logger(job_name=job_name, file_dir=f"./measurement/logs/{job_name}_ps.log").logger self.cm_t1_start = np.zeros(num_workers) self.future_model = torch.futures.Future() self.batch_update_size = num_workers self.curr_update_size = 0 self.stop_flag = False if model == 'resnet20': self.model = resnet3.resnet20() elif model == 'resnet56': self.model = resnet3.resnet56() elif model == 'resnet18': self.model = resnet.ResNet18() elif model == 'resnet50': self.model = resnet.ResNet50() elif model == 'vgg13': self.model = vgg.VGG13() elif model == 'vgg16': self.model = vgg.VGG16() elif model == 'densenet121': self.model = densenet.DenseNet121() elif model == 'alexnet': self.model = alexnet.AlexNet() elif model == 'googlenet': self.model = googlenet.GoogLeNet() elif model == 'mobilenet': self.model = mobilenetv2.MobileNetV2() self.lr = lr for p in self.model.parameters(): p.grad = torch.zeros_like(p) self.optimizer = optim.SGD(self.model.parameters(), lr=lr, momentum=0.9) self.info_socketm = znet.SocketMsger.tcp_connect(DORKER0_IP, INFO_PORT) self.info_socketm.send("PS") self.info_socketm.send(f"1.0\n/home/ubuntu/measurement/logs/{job_name}_info0.log\n{job_name}") self.ps_launched_lock = threading.Lock() self.ps_launched = False
import model.mobilenetv3 as mbnet import model.xception as xception import model.resnet as resnet import cv2 from solver import * label_table = {0: "自然", 1: "高兴", 2: "悲伤", 3: "惊讶", 4: "恐惧", 5: "恶心", 6: "愤怒"} color_table = [(100, 100, 0)] * 2 + [(0, 0, 155)] * 5 detector = CV2FaceDetector('ckpt/haarcascade_frontalface_default.xml') # model = get_trained_model(mbnet.MobileNetV3_Small(), "ckpt/checkpoint_best.pth.tar") # model = get_trained_model(xception.Xception(), "ckpt/checkpoint_best.pth.tar") model = get_trained_model(resnet.ResNet50(), "ckpt/checkpoint_best_resnet50.pth.tar") smoother = LinearExponentialSmoothing(1) classifier = ExpressionClassifier(model, label_table, smoother) action_classifier = ActionClassifier() cam_solver = CameraSolver(detector, classifier, action_classifier) vizor = CV2Visualizer(label_table=classifier.express_table, act_label_table=action_classifier.table, color_table=color_table) # cam_id = 0 # 本机摄像头 cam_id = 'rtsp://*****:*****@192.168.24.64:554/Streaming/Channels/101' # RTSP视频流 cam_solver.start(cam_id) while True: rt = cam_solver.get_solved_frame() if rt: vizor.update(*rt) vizor.show()
import model.mobilenetv3 as mbnet import model.xception as xception import model.resnet as resnet import cv2 from solver import * label_table = {0:"自然", 1:"高兴", 2:"悲伤", 3:"惊讶", 4:"恐惧", 5:"恶心", 6:"愤怒"} color_table = [(100, 100, 0)]* 2 + [(0,0,155)]*5 detector = CV2FaceDetector('ckpt/haarcascade_frontalface_default.xml') # model = get_trained_model(mbnet.MobileNetV3_Small(), "ckpt/checkpoint_best.pth.tar") # model = get_trained_model(xception.Xception(), "ckpt/checkpoint_best.pth.tar") model = get_trained_model(resnet.ResNet50(), "ckpt/checkpoint_best_resnet50.pth.tar") smoother = LinearExponentialSmoothing(1) classifier = ExpressionClassifier(model, label_table, smoother) # action_classifier = ActionClassifier() cam_solver = CameraSolver(detector, classifier, None) vizor = CV2Visualizer(label_table=classifier.express_table, act_label_table=None, color_table=color_table) cam_id = 0 # 本机摄像头 # cam_id = 'rtsp://*****:*****@192.168.24.64:554/Streaming/Channels/101' # RTSP视频流 cam_solver.start(cam_id) while True: rt = cam_solver.get_solved_frame() if rt: vizor.update(*rt) vizor.show() cv2.waitKey(10) cam_solver.close()
def main(train_path, num_rois, hf=True, vf=False, rot_90=False, num_epoches=2000, output_weight_path='weights/{}faster_rcnn.hdf5'.format( time.localtime(time.time()))): C = config.Config() C.num_rois = int(num_rois) C.use_horizontal_flips = hf C.use_vertical_flips = vf C.rot_90 = rot_90 C.model_path = output_weight_path all_imgs, class_count, class_mapping = get_data(train_path) if 'bg' not in class_count: class_count['bg'] = 0 class_mapping['bg'] = len(class_mapping) C.class_mapping = class_mapping inv_map = {v: k for k, v in class_mapping.items()} print('classes_count:', class_count) print('class_mapping', class_mapping) train_imgs = [s for s in all_imgs if s['type'] == 'train'] val_imgs = [s for s in all_imgs if s['type'] == 'val'] test_imgs = [s for s in all_imgs if s['type'] == 'test'] print("the number of train", len(train_imgs)) print('the number of val', len(val_imgs)) print('the number of test', len(test_imgs)) data_gen_train = data_generators.get_anchor_gt(train_imgs, class_count, C, K.image_dim_ordering(), mode='train') data_gen_val = data_generators.get_anchor_gt(val_imgs, class_count, C, K.image_dim_ordering(), mode='val') input_shape_img = (None, None, 3) img_input = Input(shape=input_shape_img) roi_input = Input(shape=(C.num_rois, 4)) shared_layers = resnet.ResNet50(img_input, trainable=True) #RPN built on the base layers num_anchors = len(C.anchor_box_scales) * len(C.anchor_box_ratios) rpn = resnet.rpn(shared_layers, num_anchors) classifier = resnet.classifier(shared_layers, roi_input, C.num_rois, nb_classes=len(class_count), trainable=True) model_rpn = Model(img_input, rpn[:2]) model_classifier = Model([img_input, roi_input], classifier) model_all = Model([img_input, roi_input], rpn[:2] + classifier) try: print('loading weights') model_rpn.load_weights(C.base_net_weight) model_classifier.load_weights(C.base_net_weight) except Exception as e: print(e) optimizer = Adam(lr=1e-3) optimizer_classifier = Adam(lr=1e-3) model_rpn.compile(optimizer=optimizer, loss=[ model.losses.rpn_loss_cls(num_anchors), model.losses.rpn_loss_regr(num_anchors) ]) model_classifier.compile( optimizer=optimizer_classifier, loss=[ model.losses.class_loss_cls, model.losses.class_loss_regr(len(class_count) - 1) ], metrics={'dense_class_{}'.format(len(class_count)): 'accuracy'}) model_all.compile(optimizer='sgd', loss='mae') epoch_length = 1000 iter_num = 0 losses = np.zeros((epoch_length, 5)) rpn_accuracy_rpn_monitor = [] rpn_accuracy_for_epoch = [] start_time = time.time() best_loss = np.Inf class_mapping_inv = inv_map print('start training') for epoch_num in range(num_epoches): progbar = generic_utils.Progbar(epoch_length) print('Epoch {}/{}'.format(epoch_num + 1, num_epoches)) while True: try: if len(rpn_accuracy_rpn_monitor) == epoch_length and C.verbose: mean_overlapping_bboxes = float( sum(rpn_accuracy_rpn_monitor)) / len( rpn_accuracy_rpn_monitor) rpn_accuracy_rpn_monitor = [] print( 'Average number of overlapping bounding boxes from RPN = {} for {} previous iterations' .format(mean_overlapping_bboxes, epoch_length)) if mean_overlapping_bboxes == 0: print( 'RPN is not producing bounding boxes that overlap the ground truth boxes. Check RPN settings or keep training.' ) X, Y, img_data = data_gen_train.next() loss_rpn = model_rpn.train_on_batch(X, Y) P_rpn = model_rpn.predict_on_batch(X) R = model.roi_helpers.rpn_to_roi(P_rpn[0], P_rpn[1], C, K.image_dim_ordering(), use_regr=True, overlap_thresh=0.7, max_boxes=300) # note: calc_iou converts from (x1,y1,x2,y2) to (x,y,w,h) format X2, Y1, Y2 = model.roi_helpers.calc_iou( R, img_data, C, class_mapping) if X2 is None: rpn_accuracy_rpn_monitor.append(0) rpn_accuracy_for_epoch.append(0) continue neg_samples = np.where(Y1[0, :, -1] == 1) pos_samples = np.where(Y1[0, :, -1] == 0) if len(neg_samples) > 0: neg_samples = neg_samples[0] else: neg_samples = [] if len(pos_samples) > 0: pos_samples = pos_samples[0] else: pos_samples = [] rpn_accuracy_rpn_monitor.append(len(pos_samples)) rpn_accuracy_for_epoch.append((len(pos_samples))) if C.num_rois > 1: if len(pos_samples) < C.num_rois / 2: selected_pos_samples = pos_samples.tolist() else: selected_pos_samples = np.random.choice( pos_samples, C.num_rois / 2, replace=False).tolist() try: selected_neg_samples = np.random.choice( neg_samples, C.num_rois - len(selected_pos_samples), replace=False).tolist() except: selected_neg_samples = np.random.choice( neg_samples, C.num_rois - len(selected_pos_samples), replace=True).tolist() sel_samples = selected_pos_samples + selected_neg_samples else: # in the extreme case where num_rois = 1, we pick a random pos or neg sample selected_pos_samples = pos_samples.tolist() selected_neg_samples = neg_samples.tolist() if np.random.randint(0, 2): sel_samples = random.choice(neg_samples) else: sel_samples = random.choice(pos_samples) loss_class = model_classifier.train_on_batch( [X, X2[:, sel_samples, :]], [Y1[:, sel_samples, :], Y2[:, sel_samples, :]]) losses[iter_num, 0] = loss_rpn[1] losses[iter_num, 1] = loss_rpn[2] losses[iter_num, 2] = loss_class[1] losses[iter_num, 3] = loss_class[2] losses[iter_num, 4] = loss_class[3] iter_num += 1 progbar.update( iter_num, [('rpn_cls', np.mean(losses[:iter_num, 0])), ('rpn_regr', np.mean(losses[:iter_num, 1])), ('detector_cls', np.mean(losses[:iter_num, 2])), ('detector_regr', np.mean(losses[:iter_num, 0]))]) if iter_num == epoch_length: loss_rpn_cls = np.mean(losses[:, 0]) loss_rpn_regr = np.mean(losses[:, 1]) loss_class_cls = np.mean(losses[:, 2]) loss_class_regr = np.mean(losses[:, 3]) class_acc = np.mean(losses[:, 4]) mean_overlapping_bboxes = float(sum( rpn_accuracy_for_epoch)) / len(rpn_accuracy_for_epoch) rpn_accuracy_for_epoch = [] if C.verbose: print( 'Mean number of bounding boxes from RPN overlapping ground truth boxes: {}' .format(mean_overlapping_bboxes)) print( 'Classifier accuracy for bounding boxes from RPN: {}' .format(class_acc)) print('Loss RPN classifier: {}'.format(loss_rpn_cls)) print('Loss RPN regression: {}'.format(loss_rpn_regr)) print('Loss Detector classifier: {}'.format( loss_class_cls)) print('Loss Detector regression: {}'.format( loss_class_regr)) print('Elapsed time: {}'.format(time.time() - start_time)) curr_loss = loss_rpn_cls + loss_rpn_regr + loss_class_cls + loss_class_regr iter_num = 0 start_time = time.time() if curr_loss < best_loss: if C.verbose: print( 'Total loss decreased from {} to {}, saving weights' .format(best_loss, curr_loss)) best_loss = curr_loss model_all.save_weights(C.model_path) break except Exception as e: print('Exception: {}'.format(e)) continue print('Training complete, exiting.')
trainloader, testset, testloader, trainset_genuine = utils.load_data( config.train_batch_size, config.test_batch_size, config.num_workers, dataset='CIFAR10', attack_set_size=config.attack_set_size, binary=config.binary_dataset) # classes = ('plane', 'car', 'bird', 'cat', 'deer', # 'dog', 'frog', 'horse', 'ship', 'truck') # Model print('==> Building model..') # net = VGG('VGG19') if config.binary_dataset: net = resnet.ResNet50(num_classes=1) #net = keskar_models.C1(num_classes=1) else: net = resnet.ResNet50() #net = keskar_models.C1(num_classes=10) # net = resnet.ResNet50() # net = PreActResNet18() # net = GoogLeNet() # net = DenseNet121() # net = ResNeXt29_2x64d() # net = MobileNet() # net = MobileNetV2() # net = DPN92() # net = ShuffleNetG2() # net = SENet18() # net = ShuffleNetV2(1)
def main(): # Load the parameters from json file args = parser.parse_args() json_path = os.path.join(args.model_dir, 'params.json') assert os.path.isfile( json_path), "No json configuration file found at {}".format(json_path) params = utils.Params(json_path) # Set the random seed for reproducible experiments random.seed(230) torch.manual_seed(230) np.random.seed(230) torch.cuda.manual_seed(230) warnings.filterwarnings("ignore") # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders, considering full-set vs. sub-set scenarios if params.subset_percent < 1.0: train_dl = data_loader.fetch_subset_dataloader('train', params) else: train_dl = data_loader.fetch_dataloader('train', params) dev_dl = data_loader.fetch_dataloader('dev', params) logging.info("- done.") """ Load student and teacher model """ if "distill" in params.model_version: # Specify the student models if params.model_version == "cnn_distill": # 5-layers Plain CNN print("Student model: {}".format(params.model_version)) model = net.Net(params).cuda() elif params.model_version == "shufflenet_v2_distill": print("Student model: {}".format(params.model_version)) model = shufflenet.shufflenetv2(class_num=args.num_class).cuda() elif params.model_version == "mobilenet_v2_distill": print("Student model: {}".format(params.model_version)) model = mobilenet.mobilenetv2(class_num=args.num_class).cuda() elif params.model_version == 'resnet18_distill': print("Student model: {}".format(params.model_version)) model = resnet.ResNet18(num_classes=args.num_class).cuda() elif params.model_version == 'resnet50_distill': print("Student model: {}".format(params.model_version)) model = resnet.ResNet50(num_classes=args.num_class).cuda() elif params.model_version == "alexnet_distill": print("Student model: {}".format(params.model_version)) model = alexnet.alexnet(num_classes=args.num_class).cuda() elif params.model_version == "vgg19_distill": print("Student model: {}".format(params.model_version)) model = models.vgg19_bn(num_classes=args.num_class).cuda() elif params.model_version == "googlenet_distill": print("Student model: {}".format(params.model_version)) model = googlenet.GoogleNet(num_class=args.num_class).cuda() elif params.model_version == "resnext29_distill": print("Student model: {}".format(params.model_version)) model = resnext.CifarResNeXt(cardinality=8, depth=29, num_classes=args.num_class).cuda() elif params.model_version == "densenet121_distill": print("Student model: {}".format(params.model_version)) model = densenet.densenet121(num_class=args.num_class).cuda() # optimizer if params.model_version == "cnn_distill": optimizer = optim.Adam(model.parameters(), lr=params.learning_rate * (params.batch_size / 128)) else: optimizer = optim.SGD(model.parameters(), lr=params.learning_rate * (params.batch_size / 128), momentum=0.9, weight_decay=5e-4) iter_per_epoch = len(train_dl) warmup_scheduler = utils.WarmUpLR( optimizer, iter_per_epoch * args.warm) # warmup the learning rate in the first epoch # specify loss function if args.self_training: print( '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>self training>>>>>>>>>>>>>>>>>>>>>>>>>>>>>' ) loss_fn_kd = loss_kd_self else: loss_fn_kd = loss_kd """ Specify the pre-trained teacher models for knowledge distillation Checkpoints can be obtained by regular training or downloading our pretrained models For model which is pretrained in multi-GPU, use "nn.DaraParallel" to correctly load the model weights. """ if params.teacher == "resnet18": print("Teacher model: {}".format(params.teacher)) teacher_model = resnet.ResNet18(num_classes=args.num_class) teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnet18/best.pth.tar' if args.pt_teacher: # poorly-trained teacher for Defective KD experiments teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnet18/0.pth.tar' teacher_model = teacher_model.cuda() elif params.teacher == "alexnet": print("Teacher model: {}".format(params.teacher)) teacher_model = alexnet.alexnet(num_classes=args.num_class) teacher_checkpoint = 'experiments/pretrained_teacher_models/base_alexnet/best.pth.tar' teacher_model = teacher_model.cuda() elif params.teacher == "googlenet": print("Teacher model: {}".format(params.teacher)) teacher_model = googlenet.GoogleNet(num_class=args.num_class) teacher_checkpoint = 'experiments/pretrained_teacher_models/base_googlenet/best.pth.tar' teacher_model = teacher_model.cuda() elif params.teacher == "vgg19": print("Teacher model: {}".format(params.teacher)) teacher_model = models.vgg19_bn(num_classes=args.num_class) teacher_checkpoint = 'experiments/pretrained_teacher_models/base_vgg19/best.pth.tar' teacher_model = teacher_model.cuda() elif params.teacher == "resnet50": print("Teacher model: {}".format(params.teacher)) teacher_model = resnet.ResNet50(num_classes=args.num_class).cuda() teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnet50/best.pth.tar' if args.pt_teacher: # poorly-trained teacher for Defective KD experiments teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnet50/50.pth.tar' elif params.teacher == "resnet101": print("Teacher model: {}".format(params.teacher)) teacher_model = resnet.ResNet101(num_classes=args.num_class).cuda() teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnet101/best.pth.tar' teacher_model = teacher_model.cuda() elif params.teacher == "densenet121": print("Teacher model: {}".format(params.teacher)) teacher_model = densenet.densenet121( num_class=args.num_class).cuda() teacher_checkpoint = 'experiments/pretrained_teacher_models/base_densenet121/best.pth.tar' # teacher_model = nn.DataParallel(teacher_model).cuda() elif params.teacher == "resnext29": print("Teacher model: {}".format(params.teacher)) teacher_model = resnext.CifarResNeXt( cardinality=8, depth=29, num_classes=args.num_class).cuda() teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnext29/best.pth.tar' if args.pt_teacher: # poorly-trained teacher for Defective KD experiments teacher_checkpoint = 'experiments/pretrained_teacher_models/base_resnext29/50.pth.tar' teacher_model = nn.DataParallel(teacher_model).cuda() elif params.teacher == "mobilenet_v2": print("Teacher model: {}".format(params.teacher)) teacher_model = mobilenet.mobilenetv2( class_num=args.num_class).cuda() teacher_checkpoint = 'experiments/pretrained_teacher_models/base_mobilenet_v2/best.pth.tar' elif params.teacher == "shufflenet_v2": print("Teacher model: {}".format(params.teacher)) teacher_model = shufflenet.shufflenetv2( class_num=args.num_class).cuda() teacher_checkpoint = 'experiments/pretrained_teacher_models/base_shufflenet_v2/best.pth.tar' utils.load_checkpoint(teacher_checkpoint, teacher_model) # Train the model with KD logging.info("Starting training for {} epoch(s)".format( params.num_epochs)) train_and_evaluate_kd(model, teacher_model, train_dl, dev_dl, optimizer, loss_fn_kd, warmup_scheduler, params, args, args.restore_file) # non-KD mode: regular training to obtain a baseline model else: print("Train base model") if params.model_version == "cnn": model = net.Net(params).cuda() elif params.model_version == "mobilenet_v2": print("model: {}".format(params.model_version)) model = mobilenet.mobilenetv2(class_num=args.num_class).cuda() elif params.model_version == "shufflenet_v2": print("model: {}".format(params.model_version)) model = shufflenet.shufflenetv2(class_num=args.num_class).cuda() elif params.model_version == "alexnet": print("model: {}".format(params.model_version)) model = alexnet.alexnet(num_classes=args.num_class).cuda() elif params.model_version == "vgg19": print("model: {}".format(params.model_version)) model = models.vgg19_bn(num_classes=args.num_class).cuda() elif params.model_version == "googlenet": print("model: {}".format(params.model_version)) model = googlenet.GoogleNet(num_class=args.num_class).cuda() elif params.model_version == "densenet121": print("model: {}".format(params.model_version)) model = densenet.densenet121(num_class=args.num_class).cuda() elif params.model_version == "resnet18": model = resnet.ResNet18(num_classes=args.num_class).cuda() elif params.model_version == "resnet50": model = resnet.ResNet50(num_classes=args.num_class).cuda() elif params.model_version == "resnet101": model = resnet.ResNet101(num_classes=args.num_class).cuda() elif params.model_version == "resnet152": model = resnet.ResNet152(num_classes=args.num_class).cuda() elif params.model_version == "resnext29": model = resnext.CifarResNeXt(cardinality=8, depth=29, num_classes=args.num_class).cuda() # model = nn.DataParallel(model).cuda() if args.regularization: print( ">>>>>>>>>>>>>>>>>>>>>>>>Loss of Regularization>>>>>>>>>>>>>>>>>>>>>>>>" ) loss_fn = loss_kd_regularization elif args.label_smoothing: print( ">>>>>>>>>>>>>>>>>>>>>>>>Label Smoothing>>>>>>>>>>>>>>>>>>>>>>>>" ) loss_fn = loss_label_smoothing else: print( ">>>>>>>>>>>>>>>>>>>>>>>>Normal Training>>>>>>>>>>>>>>>>>>>>>>>>" ) loss_fn = nn.CrossEntropyLoss() if args.double_training: # double training, compare to self-KD print( ">>>>>>>>>>>>>>>>>>>>>>>>Double Training>>>>>>>>>>>>>>>>>>>>>>>>" ) checkpoint = 'experiments/pretrained_teacher_models/base_' + str( params.model_version) + '/best.pth.tar' utils.load_checkpoint(checkpoint, model) if params.model_version == "cnn": optimizer = optim.Adam(model.parameters(), lr=params.learning_rate * (params.batch_size / 128)) else: optimizer = optim.SGD(model.parameters(), lr=params.learning_rate * (params.batch_size / 128), momentum=0.9, weight_decay=5e-4) iter_per_epoch = len(train_dl) warmup_scheduler = utils.WarmUpLR(optimizer, iter_per_epoch * args.warm) # Train the model logging.info("Starting training for {} epoch(s)".format( params.num_epochs)) train_and_evaluate(model, train_dl, dev_dl, optimizer, loss_fn, params, args.model_dir, warmup_scheduler, args, args.restore_file)
from model import resnet import utils import cv2 import numpy as np import argparse import torch parser = argparse.ArgumentParser(description='GradCAM') parser.add_argument('path', type=str, help='image path') #parser.add_argument('state_dict_path',type=str, help='state_dict_path') args = parser.parse_args() model = resnet.ResNet50() #model.load_state_dict(torch.load(args.state_dict_path)) image_path = args.path img = cv2.imread(image_path, 1) img = np.float32(cv2.resize(img, (224, 224))) / 255 input = utils.preprocess_image(img) use_cuda = torch.cuda.is_available() target_index = None grad_cam = utils.GradCam(model=model, feature_module=model.layer4, \ target_layer_names=["2"], use_cuda=use_cuda) mask = grad_cam(input, target_index) utils.show_cam_on_image(img, mask) gb_model = utils.GuidedBackpropReLUModel(model=model, use_cuda=use_cuda) gb = gb_model(input, index=target_index) gb = gb.transpose((1, 2, 0)) cam_mask = cv2.merge([mask, mask, mask])