def load_data_transformers(resize_reso=512, crop_reso=448, swap_num=[7, 7]): center_resize = 600 Normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) data_transforms = { 'swap': transforms.Compose([ transforms.Randomswap((swap_num[0], swap_num[1])), ]), 'common_aug': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=15), transforms.RandomCrop((crop_reso,crop_reso)), transforms.RandomHorizontalFlip(), ]), 'train_totensor': transforms.Compose([ transforms.Resize((crop_reso, crop_reso)), # ImageNetPolicy(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'val_totensor': transforms.Compose([ transforms.Resize((crop_reso, crop_reso)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'test_totensor': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.CenterCrop((crop_reso, crop_reso)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'None': None, } return data_transforms
def classifier_batch(input_imgs, net): """ :param img_addr: a string that contains the address to the image :param boundary: optional, used for cropping the function should be a tuple of 4 int elements: (x_min, y_min, x_max, y_max) :param net: well-trained model :returns: a tuple (predict class, confidence score) predict class: from 1 to 196 """ crop_size = (224, 224) # size of cropped images for 'See Better' ''' transform = transforms.Compose([ transforms.Resize(size=(224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) ''' transform = transforms.Compose([ transforms.Resize(size=(224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.485, 0.485], std=[0.225, 0.225, 0.225]) ]) input_ = [] for input_path in input_imgs: #input_img = Image.open(input_path).convert('RGB') #print(input_path) tmp =cv2.imread(input_path) tmp=cv2.resize(tmp, (224,224)) input_img = Image.fromarray(tmp) input_img = transform(input_img) input_img = torch.unsqueeze(input_img, 0) input_.append(input_img) X = torch.cat(input_, dim=0) X = X.to(torch.device("cuda")) outputs = net(X) #print(outputs[0].shape,outputs[1].shape,outputs[2].shape,Config.numcls, ) y_pred = outputs[0]# + outputs[1][:,0:Config.numcls] + outputs[1][:,Config.numcls:2*Config.numcls] #print(y_pred) if True: result_ = [] for y in y_pred: _, pred_idx = y.topk(1, 0, True, True) s = torch.nn.Softmax(dim=0) confidence_score = max(s(y)).item() y_pred = pred_idx.item() result_.append((y_pred, confidence_score)) return result_
def _val_image_transform(self): transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) return transform
def img_transforms(img, label, crop_size): img, label = random_crop(img, label, crop_size) img_tfs = tfs.Compose([ tfs.ToTensor(), tfs.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) img = img_tfs(img) label = image2label(label) label = torch.from_numpy(label) return img, label
def __init__(self, model_root_pre_path='', dataset='FER2013', tr_using_crop=False, *args, **kwargs): self.model_root_pre_path = model_root_pre_path self.model = ACCNN(7, pre_trained=True, dataset=dataset, root_pre_path=model_root_pre_path, fold=5, virtualize=True, using_fl=False).to(DEVICE) self.model_fl = ACCNN(7, pre_trained=True, dataset=dataset, root_pre_path=model_root_pre_path, fold=5, virtualize=True, using_fl=True).to(DEVICE) self.tr_using_crop = tr_using_crop if self.tr_using_crop: crop_img_size = int(self.model.input_size * 1.2) self.transform_test = transforms.Compose([ transforms.Resize(crop_img_size), transforms.TenCrop(self.model.input_size), transforms.Lambda(lambda crops: torch.stack([ transforms.Normalize(IMG_MEAN, IMG_STD) (transforms.ToTensor()(crop)) for crop in crops ])), ]) else: self.transform_test = transforms.Compose([ transforms.Resize(int(self.model.input_size)), transforms.ToTensor(), transforms.Normalize(IMG_MEAN, IMG_STD), ])
def _train_image_transform(self): transform = transforms.Compose([ transforms.Resize(256), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(0.2), transforms.ColorJitter(0.1, 0, 0, 0), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) return transform
def load_transforms(args, random_chance=1): # s determins random offset factor. If random_chance==0 (e.g. during testing), then we want no random offset. if random_chance == 0: s = 0 else: s = 1 transforms = tfs.ComposeMRI([ tfs.LoadNifti(), tfs.RandomScaling(scale_range=[.95, 1.05]), #.95,1.05 tfs.RandomRotation(angle_interval=[-10, 10], rotation_axis=None), #-10,10 tfs.ApplyAffine(so=2, chance=random_chance), tfs.Gamma(gamma_range=[.9, 1.1], chance=random_chance), #.9,1.1 tfs.ReturnImageData(), tfs.Crop(dims=args['img_dim'], offset=[0, -0, 0], rand_offset=5 * s), tfs.ReduceSlices(2, 2), tfs.PrcCap(), tfs.UnitInterval(), tfs.ToTensor(), ]) return transforms
def load_data_transformers(resize_reso=512, crop_reso=448, swap_num=[7, 7]): center_resize = 600 Normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) data_transforms = { 'swap': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=15), transforms.RandomCrop((crop_reso, crop_reso)), transforms.RandomHorizontalFlip(), transforms.Randomswap((swap_num[0], swap_num[1])), ]), 'food_swap': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=90), #transforms.RandomCrop((crop_reso, crop_reso)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomResizedCrop(size=crop_reso, scale=(0.75, 1)), transforms.Randomswap((swap_num[0], swap_num[1])), ]), 'food_unswap': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=90), #transforms.RandomCrop((crop_reso, crop_reso)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomResizedCrop(size=crop_reso, scale=(0.75, 1)), ]), 'unswap': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=15), transforms.RandomCrop((crop_reso, crop_reso)), transforms.RandomHorizontalFlip(), ]), 'train_totensor': transforms.Compose([ transforms.Resize((crop_reso, crop_reso)), #ImageNetPolicy(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'val_totensor': transforms.Compose([ transforms.Resize((crop_reso, crop_reso)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'test_totensor': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.CenterCrop((crop_reso, crop_reso)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]), 'None': None, 'Centered_swap': transforms.Compose([ transforms.CenterCrop((center_resize, center_resize)), transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=15), transforms.RandomCrop((crop_reso, crop_reso)), transforms.RandomHorizontalFlip(), transforms.Randomswap((swap_num[0], swap_num[1])), ]), 'Centered_unswap': transforms.Compose([ transforms.CenterCrop((center_resize, center_resize)), transforms.Resize((resize_reso, resize_reso)), transforms.RandomRotation(degrees=15), transforms.RandomCrop((crop_reso, crop_reso)), transforms.RandomHorizontalFlip(), ]), 'Tencrop': transforms.Compose([ transforms.Resize((resize_reso, resize_reso)), transforms.TenCrop((crop_reso, crop_reso)), transforms.Lambda(lambda crops: torch.stack( [transforms.ToTensor()(crop) for crop in crops])), ]) } return data_transforms
pre_trained=True, dataset=dataset, fold=fold, virtualize=True, using_fl=fl).to(DEVICE) print("------------%s Model Already be Prepared------------" % net_name) input_img_size = net.input_size IMG_MEAN = [0.449] IMG_STD = [0.226] transform_train = transforms.Compose([ transforms.Resize( input_img_size ), # 缩放将图片的最小边缩放为 input_img_size,因此如果输入是非正方形的,那么输出也不是正方形的 transforms.RandomHorizontalFlip(), transforms.RandomRotation(30), transforms.ToTensor(), transforms.Normalize(IMG_MEAN, IMG_STD), ]) transform_test = transforms.Compose([ transforms.Resize( input_img_size ), # 缩放将图片的最小边缩放为 input_img_size,因此如果输入是非正方形的,那么输出也不是正方形的 transforms.ToTensor(), transforms.Normalize(IMG_MEAN, IMG_STD), ]) print("------------Preparing Data...----------------") if dataset == "JAFFE": test_data = JAFFE(is_train=False, transform=transform_test, target_type=target_type, using_fl=fl)
import torch from model import fcn from data.voc import VocSegDataset, img_transforms, COLORMAP, inverse_normalization, CLASSES from PIL import Image import transforms.transforms as tfs import numpy as np import cv2 from data import voc num_classes = len(CLASSES) model = fcn.FcnResNet(num_classes) model.load_state_dict(torch.load('FCN_resnet34.pkl')) input_shape = (320, 480) img_tfs = tfs.Compose([ tfs.ToTensor(), tfs.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) img = Image.open(r'E:\DataSet\VOC2012\JPEGImages\2007_000033.jpg') # img = Image.open(r'H:/20180706204556.png').convert('RGB') label_img = Image.open( r'E:\DataSet\VOC2012\SegmentationClass\2007_000033.png').convert('RGB') img, label_img = voc.random_crop(img, label_img, (320, 480)) img.show() label_img.show() img = img_tfs(img) img = img.view(1, img.shape[0], img.shape[1], img.shape[2]) result = model(img) print(result.shape)
def startup(self, args): i_debug = 18 if 1 == i_debug: # 为无锡所招标预留功能开发 app = WxsApp() app.startup(args) return print('模型热力图绘制应用 v0.1.0') os.environ['CUDA_VISIBLE_DEVICES'] = '2' args = self.parse_args() # arg_dict = vars(args) args.train_num_workers = 0 args.val_num_workers = 0 print(args, flush=True) Config = LoadConfig(args, 'train') Config.cls_2 = args.cls_2 Config.cls_2xmul = args.cls_mul assert Config.cls_2 ^ Config.cls_2xmul transformers = load_data_transformers(args.resize_resolution, args.crop_resolution, args.swap_num) # inital dataloader train_set = dataset(Config = Config,\ anno = Config.train_anno,\ common_aug = transformers["common_aug"],\ swap = transformers["swap"],\ swap_size=args.swap_num, \ totensor = transformers["train_totensor"],\ train = True) trainval_set = dataset(Config = Config,\ anno = Config.val_anno,\ common_aug = transformers["None"],\ swap = transformers["None"],\ swap_size=args.swap_num, \ totensor = transformers["val_totensor"],\ train = False, train_val = True) val_set = dataset(Config = Config,\ anno = Config.val_anno,\ common_aug = transformers["None"],\ swap = transformers["None"],\ swap_size=args.swap_num, \ totensor = transformers["test_totensor"],\ test=True) dataloader = {} dataloader['train'] = torch.utils.data.DataLoader(train_set,\ batch_size=args.train_batch,\ shuffle=True,\ num_workers=args.train_num_workers,\ collate_fn=collate_fn4train if not Config.use_backbone else collate_fn4backbone, drop_last=True if Config.use_backbone else False, pin_memory=True) setattr(dataloader['train'], 'total_item_len', len(train_set)) dataloader['trainval'] = torch.utils.data.DataLoader(trainval_set,\ batch_size=args.val_batch,\ shuffle=False,\ num_workers=args.val_num_workers,\ collate_fn=collate_fn4val if not Config.use_backbone else collate_fn4backbone, drop_last=True if Config.use_backbone else False, pin_memory=True) setattr(dataloader['trainval'], 'total_item_len', len(trainval_set)) setattr(dataloader['trainval'], 'num_cls', Config.num_brands) dataloader['val'] = torch.utils.data.DataLoader(val_set,\ batch_size=args.val_batch,\ shuffle=False,\ num_workers=args.val_num_workers,\ collate_fn=collate_fn4test if not Config.use_backbone else collate_fn4backbone, drop_last=True if Config.use_backbone else False, pin_memory=True) setattr(dataloader['val'], 'total_item_len', len(val_set)) setattr(dataloader['val'], 'num_cls', Config.num_brands) cudnn.benchmark = True print('Choose model and train set', flush=True) print('Choose model and train set', flush=True) model = MainModel(Config) # load model if (args.resume is None) and (not args.auto_resume): print('train from imagenet pretrained models ...', flush=True) else: if not args.resume is None: resume = args.resume print('load from pretrained checkpoint %s ...' % resume, flush=True) elif args.auto_resume: resume = self.auto_load_resume(Config.save_dir) print('load from %s ...' % resume, flush=True) else: raise Exception("no checkpoints to load") model_dict = model.state_dict() pretrained_dict = torch.load(resume) print('train.py Ln193 resume={0};'.format(resume)) pretrained_dict = { k[7:]: v for k, v in pretrained_dict.items() if k[7:] in model_dict } model_dict.update(pretrained_dict) model.load_state_dict(model_dict) print('Set cache dir', flush=True) time = datetime.datetime.now() filename = '%s_%d%d%d_%s' % (args.cam, time.month, time.day, time.hour, Config.dataset) save_dir = os.path.join(Config.save_dir, filename) print('save_dir: {0} + {1};'.format(Config.save_dir, filename)) if not os.path.exists(save_dir): os.makedirs(save_dir) model.cuda() cam_main_model = model cam_model = model.model model = nn.DataParallel(model) # optimizer prepare if Config.use_backbone: ignored_params = list(map(id, model.module.classifier.parameters())) \ + list(map(id, model.module.brand_clfr.parameters())) else: ignored_params1 = list( map(id, model.module.classifier.parameters())) ignored_params1x = list( map(id, model.module.brand_clfr.parameters())) ignored_params2 = list( map(id, model.module.classifier_swap.parameters())) ignored_params3 = list(map(id, model.module.Convmask.parameters())) ignored_params = ignored_params1 + ignored_params1x + ignored_params2 + ignored_params3 print('the num of new layers:', len(ignored_params), flush=True) base_params = filter(lambda p: id(p) not in ignored_params, model.module.parameters()) lr_ratio = args.cls_lr_ratio base_lr = args.base_lr momentum = 0.9 if Config.use_backbone: optimizer = optim.SGD( [{ 'params': base_params }, { 'params': model.module.classifier.parameters(), 'lr': base_lr }, { 'params': model.module.brand_clfr.parameters(), 'lr': base_lr }], lr=base_lr, momentum=momentum) else: optimizer = optim.SGD([ { 'params': base_params }, { 'params': model.module.classifier.parameters(), 'lr': lr_ratio * base_lr }, { 'params': model.module.brand_clfr.parameters(), 'lr': lr_ratio * base_lr }, { 'params': model.module.classifier_swap.parameters(), 'lr': lr_ratio * base_lr }, { 'params': model.module.Convmask.parameters(), 'lr': lr_ratio * base_lr }, ], lr=base_lr, momentum=momentum) exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=args.decay_step, gamma=0.1) # ******************* # ******************* print('model: {0};'.format(cam_model)) print('avgpoo: {0};'.format(cam_main_model.avgpool)) headers = { 'avgpool': cam_main_model.avgpool, 'classifier': cam_main_model.brand_clfr } grad_cam = GradCam(model=cam_model, feature_module=cam_model[7], \ target_layer_names=["2"], headers=headers, use_cuda=True) # 读入图片数据 img = None img_file = '/media/ps/0A9AD66165F33762/yantao/dcl/support/ds_files/wxs_ds/head/car/d00/d00/d00/d00/d96/SC7168CH5_冀B591C5_02_120000100604_120000702916290242.jpg' with open(img_file, 'rb') as f: with Image.open(f) as img: img = img.convert('RGB') crop_reso = 224 to_tensor = transforms.Compose([ transforms.Resize((crop_reso, crop_reso)), # ImageNetPolicy(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) img_obj = to_tensor(img) input = img_obj.reshape(1, 3, 224, 224) input.cuda() input.requires_grad_(True) print('input: {0};'.format(input.shape)) # If None, returns the map for the highest scoring category. # Otherwise, targets the requested index. target_index = None mask = grad_cam(input, target_index) # self.show_cam_on_image(img_file, mask) # gb_model = GuidedBackpropReLUModel(model=cam_main_model, use_cuda=True) gb = gb_model(input, index=target_index) gb = gb.transpose((1, 2, 0)) cam_mask = cv2.merge([mask, mask, mask]) cam_gb = self.deprocess_image(cam_mask * gb) gb = self.deprocess_image(gb) cv2.imwrite('gb.jpg', gb) cv2.imwrite('cam_gb.jpg', cam_gb) print('^_^ The End! 002 ^_^')
IMG_MEAN = [0.449] IMG_STD = [0.226] # for RGB images # IMG_MEAN = [0.485, 0.456, 0.406] # IMG_STD = [0.229, 0.224, 0.225] crop_img_size = int(net.input_size * 1.2) input_img_size = net.input_size transform_using_crop = opt.tr_using_crop if transform_using_crop: transform_train = transforms.Compose([ transforms.Resize(crop_img_size), transforms.TenCrop(input_img_size), transforms.Lambda(lambda crops: torch.stack([ transforms.Normalize(IMG_MEAN, IMG_STD) (transforms.ToTensor()(transforms.RandomHorizontalFlip()( transforms.RandomRotation(30)(crop)))) for crop in crops ])), ]) transform_test = transforms.Compose([ transforms.Resize(crop_img_size), transforms.TenCrop(input_img_size), transforms.Lambda(lambda crops: torch.stack([ transforms.Normalize(IMG_MEAN, IMG_STD) (transforms.ToTensor()(crop)) for crop in crops ])), ]) else: transform_train = transforms.Compose([ transforms.Resize( input_img_size ), # 缩放将图片的最小边缩放为 input_img_size,因此如果输入是非正方形的,那么输出也不是正方形的