def build_transform(is_train, args):
resize_im = args.input_size > 32
if is_train:
# this should always dispatch to transforms_imagenet_train
transform = create_transform(
input_size=args.input_size,
is_training=True,
color_jitter=args.color_jitter,
auto_augment=args.aa,
interpolation=args.train_interpolation,
re_prob=args.reprob,
re_mode=args.remode,
re_count=args.recount,
)
if not resize_im:
# replace RandomResizedCropAndInterpolation with
# RandomCrop
transform.transforms[0] = transforms.RandomCrop(args.input_size,
padding=4)
return transform
t = []
if resize_im:
size = int((256 / 224) * args.input_size)
t.append(
transforms.Resize(
size,
interpolation=3), # to maintain same ratio w.r.t. 224 images
)
t.append(transforms.CenterCrop(args.input_size))
t.append(transforms.ToTensor())
t.append(transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD))
return transforms.Compose(t)
def build_transform(is_train, config):
resize_im = config.DATA.IMG_SIZE > 32
if is_train:
# this should always dispatch to transforms_imagenet_train
transform = create_transform(
input_size=config.DATA.IMG_SIZE,
is_training=True,
color_jitter=config.AUG.COLOR_JITTER
if config.AUG.COLOR_JITTER > 0 else None,
auto_augment=config.AUG.AUTO_AUGMENT
if config.AUG.AUTO_AUGMENT != 'none' else None,
re_prob=config.AUG.REPROB,
re_mode=config.AUG.REMODE,
re_count=config.AUG.RECOUNT,
interpolation=config.DATA.INTERPOLATION,
)
if not resize_im:
# replace RandomResizedCropAndInterpolation with
# RandomCrop
transform.transforms[0] = transforms.RandomCrop(
config.DATA.IMG_SIZE, padding=4)
return transform
t = []
if resize_im:
if config.TEST.CROP:
size = int((256 / 224) * config.DATA.IMG_SIZE)
t.append(
transforms.Resize(size,
interpolation=_pil_interp(
config.DATA.INTERPOLATION)),
# to maintain same ratio w.r.t. 224 images
)
t.append(transforms.CenterCrop(config.DATA.IMG_SIZE))
else:
t.append(
transforms.Resize(
(config.DATA.IMG_SIZE, config.DATA.IMG_SIZE),
interpolation=_pil_interp(config.DATA.INTERPOLATION)))
t.append(transforms.ToTensor())
if config.DATA.DATASET == 'imagenet':
t.append(
transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD))
elif config.DATA.DATASET == 'cifar100':
CIFAR100_TRAIN_MEAN = (0.5070751592371323, 0.48654887331495095,
0.4409178433670343)
CIFAR100_TRAIN_STD = (0.2673342858792401, 0.2564384629170883,
0.27615047132568404)
t.append(transforms.Normalize(CIFAR100_TRAIN_MEAN, CIFAR100_TRAIN_STD))
return transforms.Compose(t)
def build_transform(is_train, config):
resize_im = config.DATA.IMG_SIZE > 32
if is_train:
# this should always dispatch to transforms_imagenet_train
transform = create_transform(
input_size=config.DATA.IMG_SIZE,
is_training=True,
hflip=config.AUG.RANDOM_HORIZONTAL_FLIP,
vflip=config.AUG.RANDOM_VERTICAL_FLIP,
scale=config.AUG.SCALE,
color_jitter=config.AUG.COLOR_JITTER
if config.AUG.COLOR_JITTER > 0 else None,
auto_augment=config.AUG.AUTO_AUGMENT
if config.AUG.AUTO_AUGMENT != 'none' else None,
re_prob=config.AUG.REPROB,
re_mode=config.AUG.REMODE,
re_count=config.AUG.RECOUNT,
interpolation=config.DATA.INTERPOLATION,
)
if not resize_im:
# replace RandomResizedCropAndInterpolation with
# RandomCrop
transform.transforms[0] = transforms.RandomCrop(
config.DATA.IMG_SIZE, padding=4)
return transform
t = []
if resize_im:
if config.TEST.CROP:
size = int((256 / 224) * config.DATA.IMG_SIZE)
t.append(
transforms.Resize(size,
interpolation=_pil_interp(
config.DATA.INTERPOLATION)),
# to maintain same ratio w.r.t. 224 images
)
t.append(transforms.CenterCrop(config.DATA.IMG_SIZE))
else:
t.append(
transforms.Resize(
(config.DATA.IMG_SIZE, config.DATA.IMG_SIZE),
interpolation=_pil_interp(config.DATA.INTERPOLATION)))
t.append(transforms.ToTensor())
t.append(transforms.Normalize(config.DATA.MEAN, config.DATA.STD))
return transforms.Compose(t)
def build_transform(is_train, args):
resize_im = args.input_size > 32
imagenet_default_mean_and_std = args.imagenet_default_mean_and_std
mean = IMAGENET_INCEPTION_MEAN if not imagenet_default_mean_and_std else IMAGENET_DEFAULT_MEAN
std = IMAGENET_INCEPTION_STD if not imagenet_default_mean_and_std else IMAGENET_DEFAULT_STD
if is_train:
# this should always dispatch to transforms_imagenet_train
transform = create_transform(
input_size=args.input_size,
is_training=True,
color_jitter=args.color_jitter,
auto_augment=args.aa,
interpolation=args.train_interpolation,
re_prob=args.reprob,
re_mode=args.remode,
re_count=args.recount,
mean=mean,
std=std,
)
if not resize_im:
# replace RandomResizedCropAndInterpolation with
# RandomCrop
transform.transforms[0] = transforms.RandomCrop(args.input_size,
padding=4)
return transform
t = []
if resize_im:
if args.crop_pct is None:
if args.input_size < 384:
args.crop_pct = 224 / 256
else:
args.crop_pct = 1.0
size = int(args.input_size / args.crop_pct)
t.append(
transforms.Resize(
size,
interpolation=3), # to maintain same ratio w.r.t. 224 images
)
t.append(transforms.CenterCrop(args.input_size))
t.append(transforms.ToTensor())
t.append(transforms.Normalize(mean, std))
return transforms.Compose(t)
_entry('xception', 'Xception', '1610.02357'),
]
for m in model_list:
model_name = m['model']
# create model from name
model = create_model(model_name, pretrained=True)
param_count = sum([m.numel() for m in model.parameters()])
print('Model %s, %s created. Param count: %d' % (model_name, m['paper_model_name'], param_count))
# get appropriate transform for model's default pretrained config
data_config = resolve_data_config(m['args'], model=model, verbose=True)
if m['ttp']:
model = TestTimePoolHead(model, model.default_cfg['pool_size'])
data_config['crop_pct'] = 1.0
input_transform = create_transform(**data_config)
# Run the benchmark
ImageNet.benchmark(
model=model,
paper_model_name=m['paper_model_name'],
paper_arxiv_id=m['paper_arxiv_id'],
input_transform=input_transform,
batch_size=m['batch_size'],
num_gpu=NUM_GPU,
data_root=os.environ.get('IMAGENET_DIR', './imagenet')
)
def create_loader(dataset,
input_size,
batch_size,
is_training=False,
use_prefetcher=True,
rand_erase_prob=0.,
rand_erase_mode='const',
rand_erase_count=1,
color_jitter=0.4,
auto_augment=None,
interpolation='bilinear',
mean=IMAGENET_DEFAULT_MEAN,
std=IMAGENET_DEFAULT_STD,
num_workers=1,
distributed=False,
crop_pct=None,
collate_fn=None,
fp16=False,
tf_preprocessing=False,
world_size=None,
rank=None):
"""Create data loader for timm."""
dataset.transform = create_transform(
input_size,
is_training=is_training,
use_prefetcher=use_prefetcher,
color_jitter=color_jitter,
auto_augment=auto_augment,
interpolation=interpolation,
mean=mean,
std=std,
crop_pct=crop_pct,
tf_preprocessing=tf_preprocessing,
)
sampler = None
if distributed:
if is_training:
sampler = torch.utils.data.distributed.DistributedSampler(
dataset, num_replicas=world_size, rank=rank)
else:
# This will add extra duplicate entries to result in equal num
# of samples per-process, will slightly alter validation results
sampler = OrderedDistributedSampler(dataset,
num_replicas=world_size,
rank=rank)
if collate_fn is None:
collate_fn = fast_collate if use_prefetcher else torch.utils.data.dataloader.default_collate
loader = torch.utils.data.DataLoader(
dataset,
batch_size=batch_size,
shuffle=sampler is None and is_training,
num_workers=num_workers,
sampler=sampler,
collate_fn=collate_fn,
drop_last=is_training,
)
if use_prefetcher:
loader = PrefetchLoader(loader,
re_prob=rand_erase_prob if is_training else 0.,
re_mode=rand_erase_mode,
re_count=rand_erase_count,
mean=mean,
std=std,
fp16=fp16)
return loader
def build_transforms(cfg, is_train=True):
if cfg.MODEL.ARCH.startswith('inception'):
assert cfg.INPUT.IMAGE_SIZE == 299, "Invalid image size for Inception models!"
if cfg.AUG.TIMM_AUG.USE_TRANSFORM and is_train:
logging.info('=> use timm transform for training')
timm_cfg = cfg.AUG.TIMM_AUG
transforms = create_transform(
input_size=cfg.INPUT.IMAGE_SIZE,
is_training=True,
use_prefetcher=False,
no_aug=False,
re_prob=timm_cfg.RE_PROB,
re_mode=timm_cfg.RE_MODE,
re_count=timm_cfg.RE_COUNT,
scale=cfg.AUG.SCALE,
ratio=cfg.AUG.RATIO,
hflip=timm_cfg.HFLIP,
vflip=timm_cfg.VFLIP,
color_jitter=timm_cfg.COLOR_JITTER,
auto_augment=timm_cfg.AUTO_AUGMENT,
interpolation='bicubic' if cfg.INPUT.INTERPOLATION==3 else 'bilinear',
mean=cfg.INPUT.MEAN,
std=cfg.INPUT.STD,
)
return transforms
# assert isinstance(cfg.DATASET.OUTPUT_SIZE, (list, tuple)), 'DATASET.OUTPUT_SIZE should be list or tuple'
normalize = T.Normalize(mean=cfg.INPUT.MEAN, std=cfg.INPUT.STD)
transforms = None
if is_train:
if cfg.FINETUNE.FINETUNE and not cfg.FINETUNE.USE_TRAIN_AUG:
# precrop, crop = get_resolution(cfg.INPUT.IMAGE_SIZE)
crop = cfg.INPUT.IMAGE_SIZE
precrop = int(crop / cfg.INPUT.CROP_PCT)
transforms = T.Compose([
T.Resize(precrop,
interpolation=cfg.INPUT.INTERPOLATION
),
T.RandomCrop((crop, crop)),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalize,
])
else:
aug = cfg.AUG
scale = aug.SCALE
ratio = aug.RATIO
ts = [
T.RandomResizedCrop(
cfg.INPUT.IMAGE_SIZE, scale=scale, ratio=ratio, interpolation=cfg.INPUT.INTERPOLATION
),
T.RandomHorizontalFlip(),
]
cj = aug.COLOR_JITTER
if cj[-1] > 0.0:
ts.append(T.RandomApply([T.ColorJitter(*cj[:-1])], p=cj[-1]))
gs = aug.GRAY_SCALE
if gs > 0.0:
ts.append(T.RandomGrayscale(gs))
gb = aug.GAUSSIAN_BLUR
if gb > 0.0:
ts.append(T.RandomApply([GaussianBlur([.1, 2.])], p=gb))
ts.append(T.ToTensor())
ts.append(normalize)
transforms = T.Compose(ts)
else:
transforms = T.Compose([
T.Resize(int(cfg.INPUT.IMAGE_SIZE / cfg.INPUT.CROP_PCT), interpolation=cfg.INPUT.INTERPOLATION),
T.CenterCrop(cfg.INPUT.IMAGE_SIZE),
T.ToTensor(),
normalize,
])
return transforms
def run_models(model_names=None, model_list=None, data_root=None, run=True, force=True):
"""
local mod on sotabench
"""
if model_list is None or data_root is None:
print("model_list not found")
print("data_root", data_root)
return None
out = []
# models in bench
for i, m in enumerate(model_list):
model_name = m['model']
if model_names is None or model_name in model_names:
# create model from name
model = create_model(model_name, pretrained=True)
data_config = resolve_data_config(m['args'], model=model, verbose=True)
if m['ttp']:
model, _ = apply_test_time_pool(model, data_config)
batch_size = m['batch_size']
mean = data_config['mean']
std = data_config['std']
input_size = data_config['input_size']
interpolation = data_config['interpolation']
crop_pct = 1.0 if m['ttp'] else data_config['crop_pct']
print("Model: %s (%s)"%(model_name, m['paper_model_name']))
print(' params: %d'%sum([m.numel() for m in model.parameters()]))
print(" batch_size\t", batch_size)
print(" mean \t", mean)
print(" std \t", std)
print(" input_size\t", input_size)
print(" interpolation\t", interpolation)
print(" crop_pct\t", crop_pct)
if model_names is None or not run:
continue
xform = create_transform(input_size=input_size,
interpolation=interpolation,
mean=mean,
std=std,
crop_pct=crop_pct,
use_prefetcher=False)
print(type(model), model.__class__, list(model.parameters())[0].dtype,
list(model.parameters())[0].device)
print(type(xform))
print(xform)
# force Flag ensures local benchmark is computed regardless of the value in sotabench
# requires https://github.com/xvdp/torchbench
res = ImageNet.benchmark(model=model,
paper_model_name=model_name,
data_root=data_root,
input_transform=xform,
batch_size=batch_size,
num_gpu=1,
pin_memory=True,
force=force)
out.append(res)
torch.cuda.empty_cache()
return out
