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)
