def input_transform(self, crop_size): return Compose([ CenterCrop(crop_size), Resize(crop_size // self.upscale_factor), ToTensor(), ])
def main(): import argparse import json import os params = {} params['num_workers'] = 6 params['learning_rate'] = 1e-6 params['momentum'] = 0.9 params['weight_decay'] = 0.0005 params['gamma'] = 0.1 params['step_size'] = 3 params['num_classes'] = 2 params['epochs'] = 50 params['batch_size'] = 4 params['patience'] = 20 params['test_size'] = 0.2 params['image_dir'] = '/home/ktdiedrich/data/lung-xray/CXR_pngs' params['mask_dir'] = '/home/ktdiedrich/data/lung-xray/masks' params['output_dir'] = '/home/ktdiedrich/output/lung-xray/models2' params['checkpoint_epochs'] = 5 parser = argparse.ArgumentParser(description='Detect objects') parser.add_argument("--output_dir", "-o", type=str, help="output directory [{}]".format( params['output_dir']), default=params['output_dir']) parser.add_argument('--image_dir', "-i", type=str, help='images [{}]'.format(params['image_dir']), default=params['image_dir']) parser.add_argument('--mask_dir', "-M", type=str, help='masks of training objects [{}]'.format( params['mask_dir']), default=params['mask_dir']) parser.add_argument("--num_workers", '-w', type=int, action='store', default=params['num_workers'], help="worker threads, default {}".format( params['num_workers'])) parser.add_argument("--num_classes", '-c', type=int, action='store', default=params['num_classes'], help="classes [{}]".format(params['num_classes'])) args = parser.parse_args() params['image_dir'] = args.image_dir params['mask_dir'] = args.mask_dir params['output_dir'] = args.output_dir params['num_workers'] = args.num_workers params['num_classes'] = args.num_classes if not os.path.exists(params['output_dir']): os.makedirs(params['output_dir']) with open(os.path.join(params['output_dir'], 'params.json'), 'w') as fp: json.dump(params, fp) transform_train = Compose( [Resize([h, w]), ToTensor(), Normalize(mean=mean, std=std)]) transform_val = Compose( [Resize([h, w]), ToTensor(), Normalize(mean=mean, std=std)]) mask_transform = Compose([Resize([h, w]), ToTensor()]) train_ds_full = SegmentationDataset(path2img=params['image_dir'], path2masks=params['mask_dir'], transform=transform_train, mask_transform=mask_transform) val_ds_full = SegmentationDataset(path2img=params['image_dir'], path2masks=params['mask_dir'], transform=transform_val, mask_transform=mask_transform) sss = ShuffleSplit(n_splits=1, test_size=params['test_size'], random_state=0) indices = range(len(train_ds_full)) for train_index, val_index in sss.split(indices): print("train = {}".format(len(train_index))) print("-" * 10) print("valid = {}".format(len(val_index))) train_ds = Subset(train_ds_full, train_index) print("Train data subset = {}".format(len(train_ds))) val_ds = Subset(val_ds_full, val_index) print("Valid data subset = {}".format(len(val_ds))) train_dl = DataLoader(train_ds, batch_size=params['batch_size'], shuffle=True, collate_fn=collate_fn, num_workers=params['num_workers']) val_dl = DataLoader(val_ds, batch_size=params['batch_size'], shuffle=False, collate_fn=collate_fn, num_workers=params['num_workers']) model = deeplabv3_resnet50(pretrained=False, num_classes=params['num_classes']) device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') model = model.to(device) # ## Define Loss Function criterion = nn.CrossEntropyLoss(reduction="sum") # ## Optimizer opt = optim.Adam(model.parameters(), lr=params['learning_rate']) lr_scheduler = ReduceLROnPlateau(opt, mode='min', factor=0.5, patience=params['patience'], verbose=1) current_lr = get_lr(opt) print('current lr={}'.format(current_lr)) path2models = os.path.join(params['output_dir']) if not os.path.exists(path2models): os.makedirs(path2models) params_train = { "num_epochs": params['epochs'], "optimizer": opt, "loss_func": criterion, "train_dl": train_dl, "val_dl": val_dl, "output_dir": params['output_dir'], "checkpoint_epochs": params['checkpoint_epochs'], "lr_scheduler": lr_scheduler, "path2weights": os.path.join(path2models, "weights.pt") } model, loss_hist, _ = train_val(model, params_train, device) num_epochs = params_train["num_epochs"] plot_loss(loss_hist=loss_hist, num_epochs=num_epochs, output_dir=params['output_dir'])
from folder2lmdb import ImageFolderLMDB from torch.utils.data import DataLoader from torchvision.transforms import Resize if __name__ == "__main__": transform = Resize((224, 224)) path = "/home/jiang/share/dataset/imagenet/train.lmdb" dataset = ImageFolderLMDB(path, transform) data_loader = DataLoader(dataset, batch_size=256, num_workers=10) for img, label in data_loader: # pass print(img.shape) print(label.shape)
import random import torch.nn as nn from torch.utils.data import DataLoader from torchvision.datasets.mnist import MNIST from torchvision.transforms import Compose, Resize, ToTensor, CenterCrop from einops import rearrange from sklearn.datasets import load_iris from sklearn.linear_model import LogisticRegression from sklearn.preprocessing import StandardScaler MNIST_TRANSFORM = Compose((CenterCrop((16, 16)), Resize(4, 4), ToTensor())) X, y = next( iter( DataLoader( MNIST( "/mnt/hdd_1tb/datasets/mnist/dataset_source", train=True, download=False, transform=MNIST_TRANSFORM, ), shuffle=True, batch_size=60000, ))) X = rearrange(X, "b () h w -> b (h w)").numpy() train_size = 50000 X_train = X[:train_size] y_train = y[:train_size]
if args.model == 'resnet': model = model.segmentNetwork().cuda() resize_dim = (400, 400) convert_to = 'L' elif args.model == 'unet11': model = unet11(out_filters=3).cuda() resize_dim = (224, 224) convert_to = 'RGB' elif args.model == 'unet16': model = unet16(out_filters=3).cuda() resize_dim = (224, 224) convert_to = 'RGB' if args.no_normalize: transforms = Compose([Resize(resize_dim),ToTensor()]) else: transforms = Compose([Resize(resize_dim),ToTensor(),normalize]) convert_to = 'RGB' if args.input_type == 'dicom': dataset = iap.DicomSegment(args.img_path, transforms, convert_to) elif args.input_type == 'png' and args.non_montgomery: dataset = iap.LungTest(args.img_path, transforms, convert_to) elif args.input_type == 'png': dataset = iap.lungSegmentDataset( os.path.join(args.img_path, "CXR_png"), os.path.join(args.img_path, "ManualMask/leftMask/"), os.path.join(args.img_path, "ManualMask/rightMask/"), imagetransform=transforms, labeltransform=Compose([Resize((224, 224)),ToTensor()]),
def __init__(self, mode, roidb_file=VG_SGG_FN, dict_file=VG_SGG_DICT_FN, image_file=IM_DATA_FN, filter_empty_rels=True, num_im=-1, num_val_im=5000, filter_duplicate_rels=True, filter_non_overlap=True, use_proposals=False): """ Torch dataset for VisualGenome :param mode: Must be train, test, or val :param roidb_file: HDF5 containing the GT boxes, classes, and relationships :param dict_file: JSON Contains mapping of classes/relationships to words :param image_file: HDF5 containing image filenames :param filter_empty_rels: True if we filter out images without relationships between boxes. One might want to set this to false if training a detector. :param filter_duplicate_rels: Whenever we see a duplicate relationship we'll sample instead :param num_im: Number of images in the entire dataset. -1 for all images. :param num_val_im: Number of images in the validation set (must be less than num_im unless num_im is -1.) :param proposal_file: If None, we don't provide proposals. Otherwise file for where we get RPN proposals """ if mode not in ('test', 'train', 'val'): raise ValueError("Mode must be in test, train, or val. Supplied {}".format(mode)) self.mode = mode # Initialize self.roidb_file = roidb_file self.dict_file = dict_file self.image_file = image_file self.filter_non_overlap = filter_non_overlap self.filter_duplicate_rels = filter_duplicate_rels and self.mode == 'train' self.split_mask, self.gt_boxes, self.gt_classes, self.relationships = load_graphs_one_shot( self.roidb_file, self.mode, num_im, num_val_im=num_val_im, filter_empty_rels=filter_empty_rels, filter_non_overlap=self.filter_non_overlap and self.is_train, ) self.filenames = load_image_filenames(image_file) self.filenames = [self.filenames[i] for i in np.where(self.split_mask)[0]] self.ind_to_classes, self.ind_to_predicates = load_info(dict_file) if use_proposals: print("Loading proposals", flush=True) p_h5 = h5py.File(PROPOSAL_FN, 'r') rpn_rois = p_h5['rpn_rois'] rpn_scores = p_h5['rpn_scores'] rpn_im_to_roi_idx = np.array(p_h5['im_to_roi_idx'][self.split_mask]) rpn_num_rois = np.array(p_h5['num_rois'][self.split_mask]) self.rpn_rois = [] for i in range(len(self.filenames)): rpn_i = np.column_stack(( rpn_scores[rpn_im_to_roi_idx[i]:rpn_im_to_roi_idx[i] + rpn_num_rois[i]], rpn_rois[rpn_im_to_roi_idx[i]:rpn_im_to_roi_idx[i] + rpn_num_rois[i]], )) self.rpn_rois.append(rpn_i) else: self.rpn_rois = None # You could add data augmentation here. But we didn't. # tform = [] # if self.is_train: # tform.append(RandomOrder([ # Grayscale(), # Brightness(), # Contrast(), # Sharpness(), # Hue(), # ])) tform = [ SquarePad(), Resize(IM_SCALE), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ] self.transform_pipeline = Compose(tform)
'normal', 'calcified densities', 'nodule', 'fibrotic band', 'volume loss', 'pneumothorax', 'infiltrates', 'atelectasis', 'pleural thickening', 'pleural effusion', 'costophrenic angle blunting', 'cardiomegaly', 'aortic elongation', 'mediastinal enlargement', 'mass', 'thoracic cage deformation', 'fracture', 'hemidiaphragm elevation' ] radiographic_findings_opacity = ['opacity'] locations_labels = [ 'loc left', 'loc right', 'loc upper', 'loc middle', 'loc lower', 'loc pleural', 'loc mediastinum' ] # Transforms transforms_train = transforms.Compose([ Resize(512), RandomHorizontalFlip(), RandomRotation(10), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) transforms_train_loc = transforms.Compose([ Resize_loc(512), RandomHorizontalFlip_loc(), RandomRotation_loc(10), ToTensor_loc(), Normalize_loc(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) transforms_test = transforms.Compose([ Resize(512),
# Construct dataset variables image_resolution = (300, 300) # Construct training dataset and loader train_transform = Compose([ Lambda(maybe_blur), Lambda(maybe_darken_a_lot), Lambda(maybe_rotate), Lambda(maybe_random_perspective), Lambda(maybe_random_crop), Lambda(maybe_random_erase), ColorJitter(brightness=(.1, .8), contrast=.05, saturation=.05, hue=.005), Resize(image_resolution), Grayscale(num_output_channels=3), ToTensor(), Normalize((.5, .5, .5), (.5, .5, .5)) ]) train_dataset = UsageBasedDataset(train_root, usage=150, transform=train_transform) train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, pin_memory=True, drop_last=True, num_workers=4) # Construct evaluation transformation
plt.plot(trainErrsTotal, '-', label="train total", color=(0.5, 0, 0.8)) #plt.plot( testErrsTotal, '-', label = "test total", color = (0.5,0.8,0) ) plt.yscale('log') plt.grid(True) plt.legend() plt.savefig("./errors") normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) img_size = (224, 224) composed = Compose([ ToPILImage(), Resize(img_size), RandomHorizontalFlip(), RandomGrayscale(p=0.5), RandomRotation(degrees=30, center=None), ToTensor(), normalize ]) train_dataset = HumpbackWhaleDataset(csv_file='./train.csv', root_dir="./train", transform=composed) #test_dataset = TitanicDataset(csvFile = 'test.csv') train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=100, shuffle=True, num_workers=4)
def observation(self, observation): transforms = Compose([Resize(self.shape), Normalize(0, 255)]) observation = transforms(observation).squeeze(0) return observation
def main(): # batch_size = 100 batch_size = 1 print("here") sk_root = '../256x256/sketch/tx_000000000000' sk_root = '../256x256/photo/tx_000000000000' sk_root ='../test_pair/sketch' in_size = 225 in_size = 224 train_dataset = DataSet.ImageDataset(sk_root, transform=Compose([Resize(in_size), ToTensor()])) train_dataloader = DataLoader(train_dataset, batch_size=batch_size, pin_memory=True, num_workers=os.cpu_count(), shuffle=True, drop_last=True) test_dataset = DataSet.ImageDataset(sk_root, transform=Compose([Resize(in_size), ToTensor()]),train=False) test_dataloader = DataLoader(test_dataset, batch_size=batch_size, pin_memory=True, num_workers=os.cpu_count(), shuffle=True, drop_last=True) num_class = len(train_dataset.classes) embed_size = -1 model = getResnet(num_class=num_class, pretrain=True) model.train() if torch.cuda.is_available(): model = model.cuda() crit = torch.nn.CrossEntropyLoss() optim = torch.optim.Adam(model.parameters()) # optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) # Tensorboard stuff # writer = tb.SummaryWriter('./logs') count = 0 epochs = 2 prints_interval = 1 max_chpt = 3 max_acu = -1 chpt_num = 0 activation = {} def get_activation(name): def hook(model, input, output): activation[name] = output return hook model.avgpool.register_forward_hook(get_activation('avgpool')) for e in range(epochs): print('epoch',e,'started') avg_loss = 0 for i, (X, Y) in enumerate(train_dataloader): activation = {} if torch.cuda.is_available(): X, Y = X.cuda(), Y.cuda() optim.zero_grad() to_image = transforms.ToPILImage() output = model(X) print(activation['avgpool'].shape) loss = crit(output, Y) avg_loss += loss.item() if i == 0: print(loss) if i % prints_interval == 0: print(f'[Training] {i}/{e}/{epochs} -> Loss: {avg_loss/(i+1)}') # writer.add_scalar('train-loss', loss.item(), count) loss.backward() optim.step() count += 1 print('epoch',e,'loss',avg_loss/len(train_dataloader)) correct, total, accuracy= 0, 0, 0 # model.eval() for i, (X, Y) in enumerate(test_dataloader): if torch.cuda.is_available(): X, Y = X.cuda(), Y.cuda() output = model(X) _, predicted = torch.max(output, 1) total += Y.size(0) correct += (predicted == Y).sum().item() accuracy = (correct / total) * 100 print(f'[Testing] -/{e}/{epochs} -> Accuracy: {accuracy} %',total,correct) # model.train() if accuracy >= max_acu: path = 'checkpoint'+str(chpt_num)+'.pt' max_acu = accuracy chpt_num= (chpt_num+1)%max_chpt set_checkpoint(epoch=e,model=model,optimizer=optim,train_loss=avg_loss/len(train_dataloader),accurate=accuracy,path=path) path = 'best.pt' set_checkpoint(epoch=e,model=model,optimizer=optim,train_loss=avg_loss/len(train_dataloader),accurate=accuracy,path=path)
#64*4,8,8 => 64*8,4,4 Conv2d(config.DISCRIMINATOR_FEATURES_NUM * 4, config.DISCRIMINATOR_FEATURES_NUM * 8, kernel_size=4, stride=2, padding=1, bias=False), BatchNorm2d(config.DISCRIMINATOR_FEATURES_NUM * 8), LeakyReLU(0.2, inplace=True), Conv2d(config.DISCRIMINATOR_FEATURES_NUM * 8, 1, kernel_size=4, stride=1, padding=0, bias=False), Sigmoid() ) def forward(self, input): return self.mainNetwork(input).view(-1) if PHRASE == "TRAIN": transforms = Compose([ Resize(config.IMAGE_SIZE), CenterCrop(config.IMAGE_SIZE), ToTensor(), Normalize((0.5,0.5,0.5), (0.5,0.5,0.5)) ]) dataset = ImageFolder(config.DATA_PATH, transform=transforms) dataLoader = DataLoader(dataset=dataset, batch_size=config.BATCH_SIZE, shuffle=True,num_workers=config.NUM_WORKERS_LOAD_IMAGE, drop_last=True) netG, netD = DataParallel(GeneratorNet()), DataParallel(DiscriminatorNet()) map_location = lambda storage, loc: storage optimizer_generator = Adam(netG.parameters(), config.LR_GENERATOR, betas=(config.BETA1, 0.999)) optimizer_discriminator = Adam(netD.parameters(), config.LR_DISCRIMINATOR,betas=(config.BETA1, 0.999)) criterion = BCELoss()
from torch.autograd import Variable from torch.utils.data import DataLoader from torchvision.transforms import Compose, CenterCrop, Normalize, Resize from torchvision.transforms import ToTensor, ToPILImage from dataset import cityscapes from erfnet import ERFNet from transform import Relabel, ToLabel, Colorize from iouEval import iouEval, getColorEntry NUM_CHANNELS = 3 NUM_CLASSES = 20 image_transform = ToPILImage() input_transform_cityscapes = Compose([ Resize(512, Image.BILINEAR), ToTensor(), ]) target_transform_cityscapes = Compose([ Resize(512, Image.NEAREST), ToLabel(), Relabel(255, 19), #ignore label to 19 ]) def main(args): modelpath = args.loadDir + args.loadModel weightspath = args.loadDir + args.loadWeights print("Loading model: " + modelpath)
def input_transform(crop_size, upscale_factor): return Compose([ CenterCrop(crop_size), Resize(crop_size // upscale_factor, interpolation=Image.BICUBIC) ])
test_dataset=test_set, n_experiences=n_experiences, task_labels=False, per_exp_classes=per_exp_classes, seed=seed, fixed_class_order=fixed_class_order, shuffle=shuffle, train_transform=train_transform, eval_transform=eval_transform, ) def _get_cub200_dataset(root): train_set = CUB200(root, train=True) test_set = CUB200(root, train=False) return train_set, test_set __all__ = ["SplitCUB200"] if __name__ == "__main__": import sys benchmark_instance = SplitCUB200(5, train_transform=Compose( [ToTensor(), Resize((128, 128))])) check_vision_benchmark(benchmark_instance, show_without_transforms=False) sys.exit(0)
NetD = Discriminator() BCE_LOSS = BCELoss() G_optimizer = Adam(NetG.parameters(), lr=CONFIG["LEARNING_RATE"], betas=(0.5, 0.999)) D_optimizer = Adam(NetD.parameters(), lr=CONFIG["LEARNING_RATE"], betas=(0.5, 0.999)) if CONFIG["GPU_NUMS"] > 0: NetG = NetG.cuda() NetD = NetD.cuda() BCE_LOSS = BCE_LOSS.cuda() transform = Compose([ Resize((CONFIG["IMAGE_SIZE"], CONFIG["IMAGE_SIZE"])), ToTensor(), Normalize(mean=[0.5] * 3, std=[0.5] * 3) ]) train_loader = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder( root=CONFIG["DATA_PATH"], transform=transform), batch_size=CONFIG["BATCH_SIZE"], shuffle=True) def one_hot(target): y = torch.zeros(target.size()[0], 10) for i in range(target.size()[0]): y[i, target[i]] = 1
import os import inspect from functools import partial from hyperseg.datasets.cityscapes import CityscapesDataset from torchvision.transforms import Resize from hyperseg.test import main if __name__ == '__main__': project_dir = os.path.dirname(inspect.getabsfile(main)) exp_name = os.path.splitext(os.path.basename(__file__))[ 0] # Make sure the config and model have the same base name exp_dir = os.path.join('tests', exp_name) model = os.path.join('weights', exp_name + '.pth') data_dir = 'data/cityscapes' # Download from: https://www.cityscapes-dataset.com test_dataset = partial(CityscapesDataset, data_dir, 'val', 'fine', 'semantic') img_transforms = [Resize([768, 1536])] os.chdir(project_dir) os.makedirs(exp_dir, exist_ok=True) main(exp_dir, model=model, test_dataset=test_dataset, img_transforms=img_transforms, forced=True)
siamese_net = SiameseNet(emb_net) clsf_net = ResidualNetwork(emb_net=emb_net, nb_classes=15) assert id(emb_net) == id(siamese_net.emb_net) assert id(emb_net) == id(clsf_net.emb_net) # Dataset from utils.datasets import DeepFashionDataset from torchvision.transforms import Compose from torchvision.transforms import Resize from torchvision.transforms import ToTensor from torchvision.transforms import Normalize from config.deep_fashion import DeepFashionConfig as cfg from torch.utils.data import DataLoader from utils.datasets import Siamesize trans = Compose([ Resize(cfg.sizes), ToTensor(), Normalize(cfg.mean, cfg.std), ]) # dataset train_ds = DeepFashionDataset(cfg.root_dir, 'train', transform=trans) val_ds = DeepFashionDataset(cfg.root_dir, 'val', transform=trans) siamese_train_ds = Siamesize(train_ds) # loader loader_kwargs = { 'pin_memory': True, 'batch_size': 100, 'num_workers': 4, } s_train_loader = DataLoader(siamese_train_ds, **loader_kwargs) train_loader = DataLoader(val_ds, **loader_kwargs)
def create_image_dataloader(batch_size, target_image_size, data_location): target_dimensions = (target_image_size, target_image_size) transformations = Compose([Resize(target_dimensions), ToTensor()]) image_folder = ImageFolder(root=data_location, transform=transformations) return DataLoader(image_folder, batch_size=batch_size, shuffle=True)
def get_transform(target_size=224): return Compose([ Resize((target_size, target_size)), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])
def train_lr_transform(crop_size, upscale_factor): return Compose([ ToPILImage(), Resize(crop_size // upscale_factor, interpolation=Image.BICUBIC), ToTensor() ])
def display_transform(): return Compose([ToPILImage(), Resize(448), CenterCrop(448), ToTensor()])
def __init__(self, opt, val=False): super(CustomImageNet1K, self).__init__() dir_dataset = os.path.join(opt.path_ImageNet, "Val" if val else "Train") #list_dir = sorted(glob(os.path.join(dir_dataset, '*'))) #self.list_input = [] #sorted(glob(os.path.join(dir_dataset, 'val' if val else 'train', '*'))) #.JPEG'))) #for dir in list_dir: # self.list_input.extend(glob(os.path.join(dir_dataset, dir, "*.JPEG"))) self.list_input = sorted(glob(os.path.join(dir_dataset, "*.JPEG"))) assert len(self.list_input) > 0, "Please check the path of dataset. Current path is set as {}".format(dir_dataset) if val: # path_label = "/mnt/home/gishin/training_WNID2class.txt" path_label = opt.path_label_val dict_WNID2label = dict() # with open(path_label, 'r') as txt_file: # csv_file = reader(txt_file, delimiter=',') # print(csv_file) # for i, row in enumerate(csv_file): # if i != 0: # if int(row[1]) - 1 == 1000: # break # dict_WNID2label.update({row[0]: int(row[1]) - 1}) # -1 is for making the label start from 0. # else: # pass # self.label = dict_WNID2label # print(len(self.list_input)) # path_label = os.path.join("/mnt/home/gishin/ILSVRC2012_validation_ground_truth.txt") label = list() with open(path_label, 'r') as txt_file: for i, row in enumerate(txt_file): dict_WNID2label.update({i: int(row) - 1}) # label.append(int(row) - 1) self.label = dict_WNID2label self.transform = Compose([Resize(256), CenterCrop(224), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]) else: # path_label = "/mnt/home/gishin/training_WNID2class.txt" path_label = opt.path_label_train dict_WNID2label = dict() with open(path_label, 'r') as txt_file: csv_file = reader(txt_file, delimiter=',') for i, row in enumerate(csv_file): if i != 0: if int(row[1]) - 1 == 1000: break dict_WNID2label.update({row[0]: int(row[1]) - 1}) # -1 is for making the label start from 0. else: pass self.label = dict_WNID2label self.transform = Compose([RandomResizedCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]) self.val = val
def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit=True, pretrained=True, model_path=None): if name not in _MODELS: raise RuntimeError( f"Model {name} not found; available models = {available_models()}") if not model_path: model_path = _download(_MODELS[name]) model = torch.jit.load(model_path, map_location=device if jit else "cpu").eval() n_px = model.input_resolution.item() transform = Compose([ Resize(n_px, interpolation=Image.BICUBIC), CenterCrop(n_px), lambda image: image.convert("RGB"), ToTensor(), Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), ]) if not jit: model = build_model(model.state_dict(), pretrained).to(device) return model, transform # patch the device names device_holder = torch.jit.trace( lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) device_node = [ n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n) ][-1] def patch_device(module): graphs = [module.graph] if hasattr(module, "graph") else [] if hasattr(module, "forward1"): graphs.append(module.forward1.graph) for graph in graphs: for node in graph.findAllNodes("prim::Constant"): if "value" in node.attributeNames() and str( node["value"]).startswith("cuda"): node.copyAttributes(device_node) model.apply(patch_device) patch_device(model.encode_image) patch_device(model.encode_text) # patch dtype to float32 on CPU if device == "cpu": float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] float_node = float_input.node() def patch_float(module): graphs = [module.graph] if hasattr(module, "graph") else [] if hasattr(module, "forward1"): graphs.append(module.forward1.graph) for graph in graphs: for node in graph.findAllNodes("aten::to"): inputs = list(node.inputs()) for i in [ 1, 2 ]: # dtype can be the second or third argument to aten::to() if inputs[i].node()["value"] == 5: inputs[i].node().copyAttributes(float_node) model.apply(patch_float) patch_float(model.encode_image) patch_float(model.encode_text) model.float() return model, transform
self.sigma = sigma def forward(self, tensor): kernel_size = int( randrange(self.kernel_size[0] - 1, self.kernel_size[1])) * 2 + 1 return gaussian_blur( tensor, (kernel_size, kernel_size), [torch.empty(1).uniform_(self.sigma[0], self.sigma[1]).item()]) def __repr__(self): return self.__class__.__name__ + f"(kernel_size={self.kernel_size}, sigma={self.sigma})" clean_transform = Compose( [Grayscale(), Resize((90, 90)), ToTensor(), Normalize((0.5), (0.5))]) noise_transform = Compose([ Grayscale(), Resize((90, 90)), RandomApply(RandomAffine(degrees=(-20, 20), fillcolor=255)), RandomApply(RandomAffine(degrees=0, scale=(0.85, 1.15), fillcolor=255)), RandomApply(RandomAffine(degrees=0, translate=(0.1, 0.1), fillcolor=255)), RandomApply(ColorJitter(brightness=0.1, )), ToTensor(), RandomApply(RandomGaussianNoise()), RandomApply(RandomGaussianBlur(kernel_size=(1, 5))), Normalize((0.5), (0.5)) ])
def forward_hook(module, inputs, outputs): print('%s input shape: %s, output shape: %s' % (module.name, repr(inputs[0].shape), repr(outputs[0].shape))) def backward_hook(module, grad_in, grad_out): print('in %s backward hook' % module.name) if __name__ == '__main__': model = resnet18() model.cuda() dataset = CIFAR100('../../data/', train=True, transform=Compose([Resize((224, 224)), ToTensor()])) loader = DataLoader(dataset) x, y = next(iter(loader)) x = x.to(0) from tacklebox.hook_management import HookManager hookmngr = HookManager() hookmngr.register_forward_hook(forward_hook, conv=model.conv1, activate=False) hookmngr.register_forward_pre_hook(pre_hook, model.conv1, activate=False) hookmngr.register_backward_hook(backward_hook, model.conv1)
from utils.common import load_yaml Modular = False ### if Modular: # Modularity and Abstract from PIL import Image from torchvision.transforms import Compose, CenterCrop, Normalize, Resize from torchvision.transforms import ToTensor, ToPILImage from eval.erfnet import ERFNet from eval.transform import Relabel, Colorize NUM_CLASSES = 20 image_transform = ToPILImage() input_transform_cityscapes = Compose([ Resize((160, 384), Image.BILINEAR), ToTensor(), #Normalize([.485, .456, .406], [.229, .224, .225]), ]) cityscapes_trainIds2labelIds = Compose([ Relabel(19, 255), Relabel(18, 33), Relabel(17, 32), Relabel(16, 31), Relabel(15, 28), Relabel(14, 27), Relabel(13, 26), Relabel(12, 25), Relabel(11, 24), Relabel(10, 23),
HR = 'E:/pngs_cut20/gt' # (3840, 2160) 3840/960 = 2160/540 = 4 L_files = glob.glob(os.path.join(LR, "*")) H_files = glob.glob(os.path.join(HR, "*")) # L_files = L_files[0:100] ##################### # H_files = H_files[0:100] ##################### L_files = np.array(L_files) H_files = np.array(H_files) train_val_scale = 0.95 train_L = L_files[0:int(len(L_files) * train_val_scale)] train_H = H_files[0:int(len(H_files) * train_val_scale)] val_L = L_files[int(len(L_files) * train_val_scale):] val_H = H_files[int(len(H_files) * train_val_scale):] print(len(train_L),len(val_L)) train_set = DatasetFromFolder(train_L, train_H, input_transform=Compose( [Resize((216, 384), interpolation=Image.BICUBIC), transforms.ToTensor()]), target_transform=transforms.ToTensor()) val_set = DatasetFromFolder(val_L, val_H, input_transform=Compose( [Resize((216, 384), interpolation=Image.BICUBIC), transforms.ToTensor()]), target_transform=transforms.ToTensor()) train_loader = DataLoader(dataset=train_set, num_workers=num_workers, batch_size=BATCH_SIZE, drop_last=True,shuffle=True) val_loader = DataLoader(dataset=val_set, num_workers=num_workers, batch_size=BATCH_SIZE, drop_last=True,shuffle=False) #准备模型 seed = random.randint(1, 10000) torch.manual_seed(seed) if cuda: torch.cuda.manual_seed(seed) cudnn.benchmark = True model = VDSR()
def main(args): normalize = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) transform = Compose([Resize(256), CenterCrop(224), ToTensor(), normalize]) dataset = ImageDataset(args.image_folder, transform=transform, return_paths=True) # n_images = len(dataset) dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, pin_memory=True, num_workers=0) model = models.resnet50(pretrained=True).to(args.device) model.eval() config = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1, allow_soft_placement=True, device_count={'CPU': 1}) sess = tf.Session(config=config) x_op = tf.placeholder(tf.float32, shape=( None, 3, 224, 224, )) tf_model = convert_pytorch_model_to_tf(model, args.device) cleverhans_model = CallableModelWrapper(tf_model, output_layer='logits') # compute clip_min and clip_max suing a full black and a full white image clip_min = normalize(torch.zeros(3, 1, 1)).min().item() clip_max = normalize(torch.ones(3, 1, 1)).max().item() eps = args.eps / 255. eps_iter = 20 nb_iter = 10 args.ord = np.inf if args.ord < 0 else args.ord grad_params = {'eps': eps, 'ord': args.ord} common_params = {'clip_min': clip_min, 'clip_max': clip_max} iter_params = {'eps_iter': eps_iter / 255., 'nb_iter': nb_iter} attack_name = '' if args.attack == 'fgsm': attack_name = '_L{}_eps{}'.format(args.ord, args.eps) attack_op = FastGradientMethod(cleverhans_model, sess=sess) attack_params = {**common_params, **grad_params} elif args.attack == 'iter': attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps, eps_iter, nb_iter) attack_op = BasicIterativeMethod(cleverhans_model, sess=sess) attack_params = {**common_params, **grad_params, **iter_params} elif args.attack == 'm-iter': attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps, eps_iter, nb_iter) attack_op = MomentumIterativeMethod(cleverhans_model, sess=sess) attack_params = {**common_params, **grad_params, **iter_params} elif args.attack == 'pgd': attack_name = '_L{}_eps{}_epsi{}_i{}'.format(args.ord, args.eps, eps_iter, nb_iter) attack_op = MadryEtAl(cleverhans_model, sess=sess) attack_params = {**common_params, **grad_params, **iter_params} elif args.attack == 'jsma': attack_op = SaliencyMapMethod(cleverhans_model, sess=sess) attack_params = {'theta': eps, 'symbolic_impl': False, **common_params} elif args.attack == 'deepfool': attack_op = DeepFool(cleverhans_model, sess=sess) attack_params = common_params elif args.attack == 'cw': attack_op = CarliniWagnerL2(cleverhans_model, sess=sess) attack_params = common_params elif args.attack == 'lbfgs': attack_op = LBFGS(cleverhans_model, sess=sess) target = np.zeros((1, 1000)) target[0, np.random.randint(1000)] = 1 y = tf.placeholder(tf.float32, target.shape) attack_params = {'y_target': y, **common_params} attack_name = args.attack + attack_name print('Running [{}]. Params: {}'.format(args.attack.upper(), attack_params)) adv_x_op = attack_op.generate(x_op, **attack_params) adv_preds_op = tf_model(adv_x_op) preds_op = tf_model(x_op) n_success = 0 n_processed = 0 progress = tqdm(dataloader) for paths, x in progress: progress.set_description('ATTACK') z, adv_x, adv_z = sess.run([preds_op, adv_x_op, adv_preds_op], feed_dict={ x_op: x, y: target }) src, dst = np.argmax(z, axis=1), np.argmax(adv_z, axis=1) success = src != dst success_paths = np.array(paths)[success] success_adv_x = adv_x[success] success_src = src[success] success_dst = dst[success] n_success += success_adv_x.shape[0] n_processed += x.shape[0] progress.set_postfix( {'Success': '{:3.2%}'.format(n_success / n_processed)}) progress.set_description('SAVING') for p, a, s, d in zip(success_paths, success_adv_x, success_src, success_dst): path = '{}_{}_src{}_dst{}.npz'.format(p, attack_name, s, d) path = os.path.join(args.out_folder, path) np.savez_compressed(path, img=a)
BCE_LOSS = BCELoss() if CONFIG["GPU_NUMS"] > 0: Net_D.cuda() Net_G.cuda() BCE_LOSS = BCE_LOSS.cuda() G_optimizer = Adam(Net_G.parameters(), lr=CONFIG["LEARNING_RATE"], betas=CONFIG["BETAS"]) D_optimizer = Adam(Net_D.parameters(), lr=CONFIG["LEARNING_RATE"], betas=CONFIG["BETAS"]) ''' 数据读入与预处理 ''' transforms = Compose([ Resize(CONFIG["IMAGE_SIZE"]), CenterCrop(CONFIG["IMAGE_SIZE"]), ToTensor(), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = ImageFolder(root='/input/Faces/Eyeglasses', transform=transforms) train_loader = torch.utils.data.DataLoader(dataset, batch_size=CONFIG["BATCH_SIZE"], shuffle=True) def one_hot(target): y = torch.zeros(target.size()[0], 10) for i in range(target.size()[0]):