def main(): best_acc1 = 0 #TODO multi gpu if args.model == 'TNet26': model = TNet.Resnet26() elif args.model == 'TNet38': model = TNet.Resnet38() elif args.model == 'TNet50': model = TNet.Resnet50() elif args.model == 'Resnet26': model = jtmodels.__dict__['resnet26']() elif args.model == 'Resnet38': model = jtmodels.__dict__['resnet38']() elif args.model == 'Resnet50': model = jtmodels.__dict__['resnet50']() elif args.model == 'SAN10': model = san(sa_type = 0, layers=[2, 1, 2, 4, 1], kernels=[3, 7, 7, 7, 7], num_classes = 1000) elif args.model == 'SAN_TCN10': model = san_tcn(sa_type = 0, layers=[2, 1, 2, 4, 1], kernels=[3, 7, 7, 7, 7], num_classes = 1000) else: print("Model not found!") exit(0) if (args.use_pytorch_conv_init): pytorch_conv_init(model) model_path = os.path.join(args.save_path, 'model_best.pk') model.load(model_path) mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225] # val_transform = transform.Compose([transform.Resize(256), transform.CenterCrop(224), transform.ImageNormalize(mean, std)]) # [transform diff from val!vvvv] val_transform = transform.Compose([transform.Resize(224), transform.ImageNormalize(mean, std)]) val_loader = ImageFolder('input_images', val_transform).set_attrs(batch_size=args.batch_size_val, shuffle=False, num_workers=args.workers) test(val_loader, model)
def build_transform(self): """ Creates a basic transformation that was used to train the models """ cfg = self.cfg # we are loading images with OpenCV, so we don't need to convert them # to BGR, they are already! So all we need to do is to normalize # by 255 if we want to convert to BGR255 format, or flip the channels # if we want it to be in RGB in [0-1] range. if cfg.INPUT.TO_BGR255: to_bgr_transform = T.Lambda(lambda x: x * 255) else: to_bgr_transform = T.Lambda(lambda x: x[[2, 1, 0]]) normalize_transform = T.ImageNormalize( mean=cfg.INPUT.PIXEL_MEAN, std=cfg.INPUT.PIXEL_STD ) min_size = cfg.INPUT.MIN_SIZE_TEST max_size = cfg.INPUT.MAX_SIZE_TEST transform = T.Compose( [ T.ToPILImage(), Resize(min_size, max_size), T.ToTensor(), to_bgr_transform, normalize_transform, ] ) return transform
def __init__(self, root, lmdir, maskdir, cmaskdir, mode="test", load_h=512, load_w=512): super().__init__() transform_ = [ transform.Resize((load_h, load_w), Image.BICUBIC), transform.ImageNormalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ] self.transform = transform.Compose(transform_) transform_mask_ = [ transform.Resize((load_h, load_w), Image.BICUBIC), transform.Gray(), ] self.transform_mask = transform.Compose(transform_mask_) self.files_A = sorted(glob.glob(root + "/*.*")) self.total_len = len(self.files_A) self.batch_size = None self.shuffle = False self.drop_last = False self.num_workers = None self.buffer_size = 512*1024*1024 self.lmdir = lmdir self.maskdir = maskdir self.cmaskdir = cmaskdir self.load_h = load_h
def get_transform(params, gray = False, mask = False): transform_ = [] # resize transform_.append(transform.Resize((params['load_h'], params['load_w']), Image.BICUBIC)) # flip if params['flip']: transform_.append(transform.Lambda(lambda img: transform.hflip(img))) if gray: transform_.append(transform.Gray()) if mask: transform_.append(transform.ImageNormalize([0.,], [1.,])) else: if not gray: transform_.append(transform.ImageNormalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])) else: transform_.append(transform.ImageNormalize([0.5,], [0.5,])) return transform.Compose(transform_)
def get_dataset(): dataset = ImageFolder(traindir).set_attrs(batch_size=256, shuffle=False) dataset.set_attrs(transform=transform.Compose([ transform.Resize(224), transform.ImageNormalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]), num_workers=0) return dataset
def __init__(self, root, hr_shape): hr_height, hr_width = hr_shape # transform for low resolution images and high resolution images self.lr_transform = transform.Compose([ transform.Resize((hr_height // 4, hr_height // 4), Image.BICUBIC), transform.ImageNormalize(mean, std), ]) self.hr_transform = transform.Compose([ transform.Resize((hr_height, hr_height), Image.BICUBIC), transform.ImageNormalize(mean, std), ]) self.files = sorted(glob.glob(root + "/*.*")) self.total_len = len(self.files) self.batch_size = None self.shuffle = False self.drop_last = False self.num_workers = None self.buffer_size = 512 * 1024 * 1024
def __init__(self, root, input_shape, mode="train"): self.transform = transform.Compose([ transform.Resize(input_shape[-2:]), transform.ImageNormalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ]) self.files = sorted(glob.glob(os.path.join(root, mode) + "/*.*")) self.total_len = len(self.files) self.batch_size = None self.shuffle = False self.drop_last = False self.num_workers = None self.buffer_size = 512 * 1024 * 1024
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=8) parser.add_argument('--epochs', type=int, default=50) parser.add_argument('--num_classes', type=int, default=130) parser.add_argument('--lr', type=float, default=2e-3) parser.add_argument('--weight_decay', type=float, default=1e-5) parser.add_argument('--resume', type=bool, default=True) parser.add_argument('--eval', type=bool, default=False) parser.add_argument('--dataroot', type=str, default='/content/drive/MyDrive/dogfl/data/TEST_A/') parser.add_argument('--model_path', type=str, default='./best_model.bin') parser.add_argument('--out_file', type=str, default='./result.json') args = parser.parse_args() root_dir = args.dataroot transform_test = transform.Compose([ transform.Resize((512, 512)), transform.CenterCrop(448), transform.ToTensor(), transform.ImageNormalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) name_list = [] for _, _, _name_list in os.walk(root_dir): name_list = _name_list val_loader = TsinghuaDogExam(root_dir, batch_size=args.batch_size, train=False, name_list=name_list, shuffle=False, transform=transform_test) model = Net(num_classes=args.num_classes) if args.resume: model.load(args.model_path) print('model loaded', args.model_path) top5_class_list = evaluate(model, val_loader) # label start from 1, however it doesn't pred_result = dict(zip(name_list, top5_class_list)) with open(args.out_file, 'w') as fout: json.dump(pred_result, fout, ensure_ascii=False, indent=4)
def get_transform(new_size=None): """ obtain the image transforms required for the input data :param new_size: size of the resized images :return: image_transform => transform object from TorchVision """ # from torchvision.transforms import ToTensor, Normalize, Compose, Resize, RandomHorizontalFlip if new_size is not None: image_transform = transform.Compose([ transform.RandomHorizontalFlip(), transform.Resize(new_size), transform.ToTensor(), transform.ImageNormalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) else: image_transform = transform.Compose([ transform.RandomHorizontalFlip(), transform.ToTensor(), transform.ImageNormalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) return image_transform
def test_normalize(self): def samples_from_standard_normal(tensor): p_value = stats.kstest(list(tensor.reshape(-1).data), 'norm', args=(0, 1)).pvalue return p_value > 0.0001 random_state = random.getstate() random.seed(42) for channels in [1, 3]: img = jt.random((channels, 10, 10)) mean = [img[c].mean().item() for c in range(channels)] std = [img[c].std().item() for c in range(channels)] normalized = transform.ImageNormalize(mean, std)(img) self.assertTrue(samples_from_standard_normal(normalized)) random.setstate(random_state)
def build_transform(): if cfg.INPUT.TO_BGR255: to_bgr_transform = T.Lambda(lambda x: x * 255) else: to_bgr_transform = T.Lambda(lambda x: x[[2, 1, 0]]) normalize_transform = T.ImageNormalize(mean=cfg.INPUT.PIXEL_MEAN, std=cfg.INPUT.PIXEL_STD) min_size = cfg.INPUT.MIN_SIZE_TEST max_size = cfg.INPUT.MAX_SIZE_TEST transform = T.Compose([ T.ToPILImage(), Resize(min_size, max_size), T.ToTensor(), to_bgr_transform, normalize_transform, ]) return transform
def transforms_imagenet_eval(img_size=224, crop_pct=0.9, interpolation=Image.BICUBIC, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): crop_pct = crop_pct or 0.875 if isinstance(img_size, tuple): assert len(img_size) == 2 if img_size[-1] == img_size[-2]: # fall-back to older behaviour so Resize scales to shortest edge if target is square scale_size = int(math.floor(img_size[0] / crop_pct)) else: scale_size = tuple([int(x / crop_pct) for x in img_size]) else: scale_size = int(math.floor(img_size / crop_pct)) return transforms.Compose([ Resize(scale_size, interpolation), transforms.CenterCrop(img_size), transforms.ToTensor(), transforms.ImageNormalize(mean=mean, std=std) ])
def test_dataset(): root = '/home/gmh/dataset/TsinghuaDog' part = 'train' # from torchvision import transforms rgb_mean = [0.5, 0.5, 0.5] rgb_std = [0.5, 0.5, 0.5] transform_val = transform.Compose([ transform.Resize((299, 299)), transform.ToTensor(), transform.ImageNormalize(rgb_mean, rgb_std), ]) dataloader = TsinghuaDog(root, batch_size=16, train=False, part=part, shuffle=True, transform=transform_val) # def __init__(self, root_dir, batch_size, part='train', train=True, shuffle=False, transform=None, num_workers=1): for images, labels in dataloader: # print(images.size(),labels.size(),labels) pass
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=8) parser.add_argument('--epochs', type=int, default=50) parser.add_argument('--num_classes', type=int, default=130) parser.add_argument('--lr', type=float, default=2e-3) parser.add_argument('--weight_decay', type=float, default=1e-5) parser.add_argument('--resume', type=bool, default=False) parser.add_argument('--eval', type=bool, default=False) parser.add_argument('--dataroot', type=str, default='/content/drive/MyDrive/dogflg/data2/') parser.add_argument('--model_path', type=str, default='./best_model.bin') parser.add_argument('--sampleratio', type=float, default=0.8) args = parser.parse_args() transform_train = transform.Compose([ transform.Resize((512, 512)), transform.RandomCrop(448), transform.RandomHorizontalFlip(), transform.ToTensor(), transform.ImageNormalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) root_dir = args.dataroot train_loader = TsinghuaDog(root_dir, batch_size=args.batch_size, train=True, part='train', shuffle=True, transform=transform_train, sample_rate=args.sampleratio) transform_test = transform.Compose([ transform.Resize((512, 512)), transform.RandomCrop(448), transform.ToTensor(), transform.ImageNormalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) val_loader = TsinghuaDog(root_dir, batch_size=args.batch_size, train=False, part='val', shuffle=False, transform=transform_test, sample_rate=args.sampleratio) epochs = args.epochs model = Net(num_classes=args.num_classes) lr = args.lr weight_decay = args.weight_decay optimizer = SGD(model.parameters(), lr=lr, momentum=0.9) if args.resume: model.load(args.model_path) # random save for test # model.save(args.model_path) if args.eval: evaluate(model, val_loader, save_path=args.model_path) return for epoch in range(epochs): train(model, train_loader, optimizer, epoch) evaluate(model, val_loader, epoch, save_path=args.model_path)
# 损失函数:平方误差 # 调用方法:adversarial_loss(网络输出A, 分类标签B) # 计算结果:(A-B)^2 adversarial_loss = nn.MSELoss() generator = Generator() discriminator = Discriminator() # 导入MNIST数据集 from jittor.dataset.mnist import MNIST import jittor.transform as transform transform = transform.Compose([ transform.Resize(opt.img_size), transform.Gray(), transform.ImageNormalize(mean=[0.5], std=[0.5]), ]) dataloader = MNIST(train=True, transform=transform).set_attrs(batch_size=opt.batch_size, shuffle=True) optimizer_G = nn.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) optimizer_D = nn.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) from PIL import Image
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=8) parser.add_argument('--epochs', type=int, default=50) parser.add_argument('--num_classes', type=int, default=130) parser.add_argument('--lr', type=float, default=2e-3) parser.add_argument('--weight_decay', type=float, default=1e-5) parser.add_argument('--resume', type=bool, default=True) parser.add_argument('--eval', type=bool, default=False) parser.add_argument('--dataroot', type=str, default='/content/drive/MyDrive/dogfl/data/TEST_A/') parser.add_argument('--model_path', type=str, default='model/res152_8/model.bin:model/res152_10/model.bin:model/seres152_8/model.bin:model/seres152_10/model.bin') parser.add_argument('--model_name', type=str, default='Net1_z:Net1_z:Net10_z:Net10_z') parser.add_argument('--out_file', type=str, default='./result.json') args = parser.parse_args() root_dir = args.dataroot transform_test = transform.Compose([ transform.Resize((256, 256)), transform.CenterCrop(224), transform.ToTensor(), transform.ImageNormalize(0.485, 0.229), ]) model_zoo = args.model_path.split(':') model_name_class = args.model_name.split(':') print(model_zoo, model_name_class) zoo_pred_result = [] i = 0 for model_path_ in model_zoo: name_list = [] for _, _, _name_list in os.walk(root_dir): name_list = _name_list val_loader = TsinghuaDogExam(root_dir, batch_size=args.batch_size, train=False, name_list=name_list, shuffle=False, transform=transform_test) model = eval(model_name_class[i])(num_classes=args.num_classes) if args.resume: model.load(model_path_) top5_class_list = evaluate(model, val_loader) # label start from 1, however it doesn't pred_result = dict(zip(name_list, top5_class_list)) zoo_pred_result.append(pred_result) i += 1 # vote the best president = zoo_pred_result[0] vote_result = {} for key in president.keys(): val_list = [] for i in range(5): candiates = [model[key][i] for model in zoo_pred_result] val, n = Counter(candiates).most_common()[0] val_list.append(val) vote_result[key] = val_list with open(args.out_file, 'w') as fout: json.dump(vote_result, fout, ensure_ascii=False, indent=4)
# Calculate output of image discriminator (PatchGAN) patch_h, patch_w = int(opt.mask_size / 2**3), int(opt.mask_size / 2**3) patch = (1, patch_h, patch_w) # Loss function adversarial_loss = nn.MSELoss() pixelwise_loss = nn.L1Loss() # Initialize generator and discriminator generator = Generator(channels=opt.channels) discriminator = Discriminator(channels=opt.channels) # Dataset loader transforms_ = [ transform.Resize((opt.img_size, opt.img_size), mode=Image.BICUBIC), transform.ImageNormalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ] dataloader = ImageDataset("../../data/%s" % opt.dataset_name, transforms_=transforms_).set_attrs( batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_cpu, ) test_dataloader = ImageDataset("../../data/%s" % opt.dataset_name, transforms_=transforms_, mode="val").set_attrs( batch_size=12, shuffle=True, num_workers=1, ) test_iter = iter(test_dataloader)
# Calculate number of epochs wrt batch size args.epochs = args.epochs * 128 // args.batch_size args.schedule = [x * 128 // args.batch_size for x in args.schedule] # Init dataset if not os.path.isdir(args.data_path): os.makedirs(args.data_path) mean = [x / 255 for x in [125.3, 123.0, 113.9]] std = [x / 255 for x in [63.0, 62.1, 66.7]] train_transform = transform.Compose([ transform.RandomHorizontalFlip(), RandomCrop(32, padding=4), ToTensor(), transform.ImageNormalize(mean, std) ]) test_transform = transform.Compose( [ToTensor(), transform.ImageNormalize(mean, std)]) if args.dataset == 'cifar10': train_data = CIFAR10(args.data_path, train=True, transform=train_transform, batch_size=args.batch_size, num_workers=args.prefetch) test_data = CIFAR10(args.data_path, train=False, transform=test_transform, shuffle=False, num_workers=args.prefetch,
# Optimizers optimizer_G = nn.Adam( E1.parameters() + E2.parameters() + G1.parameters() + G2.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2), ) optimizer_D1 = nn.Adam(D1.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) optimizer_D2 = nn.Adam(D2.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) # Image transformations transform_ = [ transform.Resize(int(opt.img_height * 1.12), Image.BICUBIC), transform.RandomCrop((opt.img_height, opt.img_width)), transform.RandomHorizontalFlip(), transform.ImageNormalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ] dataloader = ImageDataset("../../data/%s" % opt.dataset_name, transforms_=transform_, unaligned=True).set_attrs(batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_cpu) val_dataloader = ImageDataset("../../data/%s" % opt.dataset_name, transforms_=transform_, unaligned=True, mode="test").set_attrs(batch_size=5, shuffle=True, num_workers=1)
args = parser.parse_args() if not os.path.isdir(args.logdir): os.mkdir(args.logdir) logging.basicConfig(filename=os.path.join(args.logdir, 'log.txt'), level=logging.INFO) logging.info(sys.argv) jt.flags.use_cuda = 1 if args.cuda else 0 train_transform = transform.Compose([ transform.RandomHorizontalFlip(), transform.RandomCropAndResize(32, scale=(0.5, 1)), transform.ImageNormalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010]) ]) test_transform = transform.Compose([ transform.ImageNormalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010]) ]) trainloader = CIFAR10(train=True, shuffle=True, batch_size=64, transform=train_transform) testloader = CIFAR10(train=False, shuffle=False, batch_size=100, transform=test_transform)