def mnist_aug_loader(train_size, test_size, args):
transform_train = transforms.Compose([
transforms.RandomCrop(28, padding=4),
# https://github.com/hwalsuklee/tensorflow-mnist-cnn/blob/master/mnist_data.py
#transforms.RandomAffine(translate=0.12),
transforms.RandomRotation((-15, 15)),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, )),
#transforms.RandomErasing(probability=args.p, sh=args.sh, r1=args.r1, mean=[0.4914]),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, )),
])
trainset = datasets.MNIST('./data/MNIST',
train=True,
download=True,
transform=transform_train)
train_loader = data.DataLoader(trainset,
batch_size=train_size,
shuffle=True)
testset = datasets.MNIST(root='./data/MNIST',
train=False,
download=False,
transform=transform_test)
test_loader = data.DataLoader(testset, batch_size=test_size, shuffle=False)
return train_loader, test_loader
def fashion_mnist_aug_loader(train_size, test_size, args):
transform_train = transforms.Compose([
transforms.RandomCrop(28, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, )),
transforms.RandomErasing(probability=args.p,
sh=args.sh,
r1=args.r1,
mean=[0.4914]),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, )),
])
trainset = datasets.FashionMNIST('./data/MNIST-FASHION',
train=True,
download=True,
transform=transform_train)
train_loader = data.DataLoader(trainset,
batch_size=train_size,
shuffle=True)
testset = datasets.FashionMNIST(root='./data/MNIST-FASHION',
train=False,
download=False,
transform=transform_test)
test_loader = data.DataLoader(testset, batch_size=test_size, shuffle=False)
return train_loader, test_loader
def train(args):
train_transforms = transforms.Compose([
transforms.Resize(args.image_shape),
transforms.RandomHorizontalFlip(),
transforms.Normalize()
])
eval_transforms = transforms.Compose(
[transforms.Resize(args.image_shape),
transforms.Normalize()])
train_dataset = Dataset(
data_dir=args.data_dir,
file_list=args.train_list,
transforms=train_transforms,
num_workers='auto',
buffer_size=100,
parallel_method='thread',
shuffle=True)
eval_dataset = None
if args.val_list is not None:
eval_dataset = Dataset(
data_dir=args.data_dir,
file_list=args.val_list,
transforms=eval_transforms,
num_workers='auto',
buffer_size=100,
parallel_method='thread',
shuffle=False)
if args.model_type == 'HumanSegMobile':
model = HumanSegMobile(num_classes=2)
elif args.model_type == 'HumanSegLite':
model = HumanSegLite(num_classes=2)
elif args.model_type == 'HumanSegServer':
model = HumanSegServer(num_classes=2)
else:
raise ValueError(
"--model_type: {} is set wrong, it shold be one of ('HumanSegMobile', "
"'HumanSegLite', 'HumanSegServer')".format(args.model_type))
model.train(
num_epochs=args.num_epochs,
train_dataset=train_dataset,
train_batch_size=args.batch_size,
eval_dataset=eval_dataset,
save_interval_epochs=args.save_interval_epochs,
save_dir=args.save_dir,
pretrained_weights=args.pretrained_weights,
resume_weights=args.resume_weights,
learning_rate=args.learning_rate,
use_vdl=args.use_vdl)
def build_model(self):
""" DataLoader """
train_transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.Resize((self.img_size + 30, self.img_size + 30)),
transforms.RandomCrop(self.img_size),
transforms.ToTensor(),
transforms.Normalize(mean=0.5, std=0.5)
])
test_transform = transforms.Compose([
transforms.Resize((self.img_size, self.img_size)),
transforms.ToTensor(),
transforms.Normalize(mean=0.5, std=0.5)
])
self.trainA_loader = paddle.batch(
a_reader(shuffle=True, transforms=train_transform),
self.batch_size)()
self.trainB_loader = paddle.batch(
b_reader(shuffle=True, transforms=train_transform),
self.batch_size)()
self.testA_loader = a_test_reader(transforms=test_transform)
self.testB_loader = b_test_reader(transforms=test_transform)
""" Define Generator, Discriminator """
self.genA2B = ResnetGenerator(input_nc=3,
output_nc=3,
ngf=self.ch,
n_blocks=self.n_res,
img_size=self.img_size,
light=self.light)
self.genB2A = ResnetGenerator(input_nc=3,
output_nc=3,
ngf=self.ch,
n_blocks=self.n_res,
img_size=self.img_size,
light=self.light)
self.disGA = Discriminator(input_nc=3, ndf=self.ch, n_layers=7)
self.disGB = Discriminator(input_nc=3, ndf=self.ch, n_layers=7)
self.disLA = Discriminator(input_nc=3, ndf=self.ch, n_layers=5)
self.disLB = Discriminator(input_nc=3, ndf=self.ch, n_layers=5)
""" Define Loss """
self.L1_loss = L1Loss()
self.MSE_loss = MSELoss()
self.BCE_loss = BCEWithLogitsLoss()
""" Trainer """
self.G_optim = self.optimizer_setting(self.genA2B.parameters() +
self.genB2A.parameters())
self.D_optim = self.optimizer_setting(self.disGA.parameters() +
self.disGB.parameters() +
self.disLA.parameters() +
self.disLB.parameters())
""" Define Rho clipper to constraint the value of rho in AdaILN and ILN"""
self.Rho_clipper = RhoClipper(0, 1)
def __init__(self, args, use_gpu):
super(DataManager, self).__init__()
self.args = args
self.use_gpu = use_gpu
print("Initializing dataset {}".format(args.dataset))
dataset = mini_dataset.miniImageNet_load()
transform_train = T.Compose([
T.RandomCrop(84, padding=8),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
transform_test = T.Compose([
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
pin_memory = True if use_gpu else False
self.trainloader = DataLoader(
sample_train.FewShotDataset_train(name='train_loader',
dataset=dataset.train,
labels2inds=dataset.train_labels2inds,
labelIds=dataset.train_labelIds,
nKnovel=args.nKnovel,
nExemplars=args.nExemplars,
nTestNovel=args.train_nTestNovel,
epoch_size=args.train_epoch_size,
transform=transform_train,
load=args.load,
),
batch_size=args.train_batch, shuffle=True, num_workers=args.workers,
pin_memory=pin_memory, drop_last=True,
)
self.testloader = DataLoader(
sample_test.FewShotDataset_test(name='test_loader',
dataset=dataset.test,
labels2inds=dataset.test_labels2inds,
labelIds=dataset.test_labelIds,
nKnovel=args.nKnovel,
nExemplars=args.nExemplars,
nTestNovel=args.nTestNovel,
epoch_size=args.epoch_size,
transform=transform_test,
load=args.load,
),
batch_size=args.test_batch, shuffle=False, num_workers=args.workers,
pin_memory=pin_memory, drop_last=False,
)
def build_dataset(path_to_imgs, path_to_json_train, path_to_json_test):
data_transforms = {
'train':
transforms.Compose([
transforms.Resize(256),
transforms.CustomCrop(),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
TID_train = TIDLoader(path_to_imgs, path_to_json_train,
data_transforms['train'])
TID_test = TIDLoader(path_to_imgs, path_to_json_test,
data_transforms['val'])
"""
Since ground truth distributions were in train-test split (no val data),
train data is split in two parts.Only 76 % of original train data is used
for training, remaining is added to original test data. THis test data is
then split into validation and test data.
In short, the total number of images available in TID2013 (3k)
are split in a ratio of 70-20-10 (train-val-test).
"""
train_len = len(TID_train)
idx = list(range(train_len))
random.shuffle(idx)
split_idx = idx[:int(0.76 * train_len)]
train_split = Subset(TID_train, split_idx)
split_idx = idx[int(0.76 * train_len):]
train_val_split = Subset(TID_train, split_idx)
val_split = ConcatDataset([train_val_split, TID_test])
val_len = len(val_split)
val_idx = list(range(val_len))
random.shuffle(val_idx)
val_split_idx = val_idx[:int(0.75 * val_len)]
final_val_split = Subset(val_split, val_split_idx)
test_split_idx = val_idx[int(0.75 * val_len):]
test_split = Subset(val_split, test_split_idx)
return train_split, final_val_split, test_split
def get(args):
""" Entry point. Call this function to get all Charades dataloaders """
normalize = arraytransforms.Normalize(mean=[0.502], std=[1.0])
train_file = args.train_file
val_file = args.val_file
train_dataset = Charadesflow(args.data,
'train',
train_file,
args.cache,
transform=transforms.Compose([
arraytransforms.RandomResizedCrop(224),
arraytransforms.ToTensor(),
normalize,
transforms.Lambda(lambda x: torch.cat(x)),
]))
val_transforms = transforms.Compose([
arraytransforms.Resize(256),
arraytransforms.CenterCrop(224),
arraytransforms.ToTensor(),
normalize,
transforms.Lambda(lambda x: torch.cat(x)),
])
val_dataset = Charadesflow(args.data,
'val',
val_file,
args.cache,
transform=val_transforms)
valvideo_dataset = Charadesflow(args.data,
'val_video',
val_file,
args.cache,
transform=val_transforms)
return train_dataset, val_dataset, valvideo_dataset
def __init__(self, file_path, transform=None, downsampling=2, phase='train', store_img_infor_root=None, store_matrix_root=None, store_baseline_root=None, store_focal_root=None, interval=1):
self.file_path = file_path
self.transform = transform
self.downsampling = downsampling
self.store_img_infor_root = store_img_infor_root
self.store_matrix_root = store_matrix_root
self.store_baseline_root = store_baseline_root
self.store_focal_root = store_focal_root
self.phase = phase
self.interval = interval
self.valid_transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])
if self.store_matrix_root is None:
self.store_matrix_root = './{}_repro_matrixes.npz'.format(self.phase)
if self.store_img_infor_root is None:
self.store_img_infor_root = './{}_imgs_path.csv'.format(self.phase)
if self.store_baseline_root is None:
self.store_baseline_root = './{}_baselines.npy'.format(self.phase)
if self.store_focal_root is None:
self.store_focal_root = './{}_focal.npy'.format(self.phase)
if os.path.exists(self.store_img_infor_root) and os.path.exists(self.store_matrix_root) and os.path.exists(self.store_baseline_root) and os.path.exists(self.store_focal_root):
pass
else:
print("No Image information csv!!!")
exit()
self.rec_imgs_and_gts_names = pd.read_csv(self.store_img_infor_root)
# self.reprojecton_matrixs = np.load(self.store_matrix_root, allow_pickle=True)
baseline = np.load(self.store_baseline_root)
self.baseline = baseline.tolist()
focal = np.load(self.store_focal_root)
self.focal = focal.tolist()
def get_transform(train):
base_size = 520
crop_size = 480
min_size = int((0.5 if train else 1.0) * base_size)
max_size = int((2.0 if train else 1.0) * base_size)
transforms = []
transforms.append(T.RandomResize(min_size, max_size))
if train:
transforms.append(
T.RandomColorJitter(brightness=0.25,
contrast=0.25,
saturation=0.25,
hue=0.25))
transforms.append(T.RandomGaussianSmoothing(radius=[0, 5]))
transforms.append(T.RandomRotation(degrees=30, fill=0))
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomPerspective(fill=0))
transforms.append(T.RandomCrop(crop_size, fill=0))
transforms.append(T.RandomGrayscale(p=0.1))
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
def main():
normalize = trans.Normalize(mean=[0.4001, 0.4401, 0.4687],
std=[0.229, 0.224, 0.225])
transform = trans.Compose([
trans.Scale((224,224)),
trans.ToTensor(),
normalize,
])
classes = {int(key): value for (key, value)
in parse_json(configs.class_info_dir).items()}
vgg_cam = models.vgg_cam()
vgg_cam = vgg_cam.cuda()
checkpoint = torch.load(configs.best_ckpt_dir)
vgg_cam.load_state_dict(checkpoint['state_dict'])
# hook the feature extractor
features_blobs = []
def hook_feature(module, input, output):
features_blobs.append(output.data.cpu().numpy())
finalconv_name = 'classifier' # this is the last conv layer of the network
vgg_cam._modules.get(finalconv_name).register_forward_hook(hook_feature)
# get the softmax weight
params = list(vgg_cam.parameters())
weight_softmax = np.squeeze(params[-1].data.cpu().numpy())
img_path = 'playing_guitar_023.jpg'
save_fig_dir = 'cam_' + img_path
img_pil = Image.open(img_path)
img_tensor = transform(img_pil)
img_variable = Variable(img_tensor.unsqueeze(0).cuda())
transformed_img = img_variable.data.cpu().numpy()[0]
transformed_img = untransform(transformed_img)
outputs, _ = vgg_cam(img_variable)
h_x = F.softmax(outputs).data.squeeze()
probs, idx = h_x.sort(0, True)
top_number = 5
prob = probs.cpu().numpy()[:top_number]
idx_ = idx.cpu().numpy()[:top_number]
OUT_CAM = returnCAM(features_blobs[-1],weight_softmax,idx_,prob)
plt.figure(1, figsize=(8, 6))
ax = plt.subplot(231)
ax.imshow(transformed_img[:,:,(2,1,0)])
for b_index, (idx,prob_in,cam) in enumerate(zip(idx_,prob,OUT_CAM)):
cl = str(classes[idx])
height, width, _ = transformed_img.shape
heatmap = cv2.applyColorMap(cv2.resize(cam, (width, height)), cv2.COLORMAP_JET)
result = heatmap * 0.3 + transformed_img * 0.7
ax = plt.subplot(2,3,b_index+2)
ax.imshow(result.astype(np.uint8)[:,:,(2,1,0)])
ax.set_title(('{}:{}').format(cl,('%.3f' % prob_in)), fontsize=8)
plt.savefig(save_fig_dir)
def main(cfgs):
trans_in_train = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
dataset_train = data.dataset(cfgs, flag='train', trans=trans_in_train)
trainer.trainer(cfgs, dataset_train)
def get_iterator(mode):
normalize = transforms.Normalize(mean=[x / 255.0 for x in [125.3, 123.0, 113.9]], std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
kwargs = {'num_workers': 4, 'pin_memory': True}
transform_augment = transforms.Compose([
# transforms.RandomResizedCrop(args.size, scale=(0.8, 1.2)), # random scale 0.8-1 of original image area, crop to args.size
transforms.RandomResizedCrop(size),
transforms.RandomRotation(15), # random rotation -15 to +15 degrees
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
transform = transforms.Compose([transforms.Resize((size, size)),
transforms.ToTensor(),
normalize,
])
if mode:
dataset = Dataset.MURA(split="train", transform=(transform_augment if augment else transform), type=type)
loader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=True,
**kwargs)
else:
dataset = Dataset.MURA(split="test", transform=transform, type=type)
loader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=False,
**kwargs)
return loader
def get_transforms(train=False, rescale_size=(256, 256), yolo=False):
transforms = []
if train:
transforms.append(my_T.Rescale(rescale_size, yolo))
transforms.append(my_T.Normalize())
transforms.append(my_T.ToTensor())
return my_T.Compose(transforms)
def get_transform():
transforms = []
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
def make_dataset_dataloader(args, jsons, spk2genders, split='train'):
if split == 'train':
load_dir = os.path.join(args.temp_root, args.bucket_load_dir)
else:
load_dir = None
gender_dataset = gender_subset.ESPnetGenderBucketDataset(
os.path.join(args.temp_root, jsons[split]),
os.path.join(args.temp_root, args.tok_file),
os.path.join(args.temp_root, spk2genders[split]),
load_dir=load_dir,
num_buckets=args.n_buckets)
if args.normalize == 'utt':
gender_dataset.transform = transforms.Normalize()
elif args.normalize == 'spk':
gender_dataset.transform = transforms.SpeakerNormalize(
os.path.join(args.temp_root, args.bucket_load_dir,
f'{split}_stats/spk2meanstd.pkl'))
elif args.normalize == 'gndr':
gender_dataset.transform = transforms.GenderNormalize(
os.path.join(args.temp_root, args.bucket_load_dir,
f'{split}_stats/gndr2meanstd.pkl'),
gender_dataset.utt2gender)
gender_dataloader = torch.utils.data.DataLoader(
gender_dataset,
batch_sampler=dataset.BucketBatchSampler(
shuffle=True,
batch_size=args.batch_size,
utt2idx=gender_dataset.utt2idx,
buckets=gender_dataset.buckets),
collate_fn=dataset.collate)
return gender_dataset, gender_dataloader
def get_transform(train, resolution):
transforms = []
# if square resolution, perform some aspect cropping
# otherwise, resize to the resolution as specified
if resolution[0] == resolution[1]:
base_size = resolution[0] + 32
crop_size = resolution[0]
min_size = int((0.5 if train else 1.0) * base_size)
max_size = int((2.0 if train else 1.0) * base_size)
transforms.append(T.RandomResize(min_size, max_size))
# during training mode, perform some data randomization
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomCrop(crop_size))
else:
# transforms.append(T.Resize(resolution))
if train:
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
def _setup_dataloaders(root_dir, return_dataset=False):
"""
Setup dataloaders.
"""
preprocessing = [
aug.NormalizeBboxes(cfg.grid_size),
aug.Bboxes2Matrices(cfg.grid_size, cfg.num_classes),
aug.Resize(cfg.target_size),
aug.Normalize(cfg.mean, cfg.std, 1. / 255),
aug.ToTensor()
]
transforms_train = preprocessing
transforms_val = preprocessing
ds_train = VOCDataset(root_dir, image_set="train")
dl_train = get_dataloader(ds_train,
transforms_train,
cfg.batch_size,
num_workers=4)
ds_val = VOCDataset(root_dir, image_set="val")
dl_val = get_dataloader(ds_val, transforms_val, cfg.batch_size)
if return_dataset:
return dl_train, dl_val, ds_train, ds_val
return dl_train, dl_val
def get_data(data_dir,
source,
target,
height,
width,
batch_size,
re=0,
workers=8):
# def get_data(height, width):
dataset = IU_X_RAY('./dataset/')
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
T.ToTensor(),
normalizer,
])
train_sampler = MRG_sampler(dataset.source_train,
root=dataset.train_images_dir,
transform=train_transformer)
val_sampler = MRG_sampler(dataset.source_valid,
root=dataset.valid_images_dir,
transform=train_transformer)
test_sampler = MRG_sampler(dataset.source_test,
root=dataset.test_images_dir,
transform=train_transformer)
mesh_term_list = list(
set(train_sampler.mesh_term_list) & set(test_sampler.mesh_term_list))
train_sampler.mesh_term_list = mesh_term_list
test_sampler.mesh_term_list = mesh_term_list
print('mesh_term:' + str(len(mesh_term_list)))
train_dataloader = DataLoader(train_sampler,
batch_size=batch_size,
num_workers=workers,
shuffle=True,
pin_memory=True,
drop_last=True)
val_dataloader = DataLoader(val_sampler,
batch_size=batch_size,
num_workers=workers,
shuffle=True,
pin_memory=True,
drop_last=True)
test_dataloader = DataLoader(test_sampler,
batch_size=batch_size,
num_workers=workers,
shuffle=True,
pin_memory=True,
drop_last=True)
return dataset, mesh_term_list, train_dataloader, val_dataloader, test_dataloader
def __init__(self,
img_size: int,
original_size: int,
mean: float = 0,
std: float = 1,
brightness: float = 0.3,
contrast: float = 0.5,
saturation: float = 0.5,
hue: float = 0.3,
rotation_degree: int = 10,
hflip: float = 0.5,
debug: bool = False):
self.original_size = original_size
self.target_size = img_size
self.to_pil = transforms.ToPILImage()
self.color_jitter = transforms.ColorJitter(brightness=brightness,
contrast=contrast,
saturation=saturation,
hue=hue)
self.resize = transforms.Resize(img_size)
self.to_tensor = transforms.ToTensor()
self.normalize = transforms.Normalize(mean, std)
self.r_horizontal_flip = RandomHorizontalFlip(p=hflip)
self.r_rotation = RandomRotation(rotation_degree)
self.debug = debug
def main():
# frames to infer
files = [
"C:\\AML_seg_proj\\CRC-Segmentation\\data\\test\\frames\\frame#1058.npz",
"C:\\AML_seg_proj\\CRC-Segmentation\\data\\test\\frames\\frame#139.npz",
"C:\\AML_seg_proj\\CRC-Segmentation\\data\\test\\frames\\frame#26.npz"
]
chkpt = "C:\\AML_seg_proj\\CRC-Segmentation\\model_large_drop_batch_wce\\model_chkpt_30.pt"
# transforms to apply
composed = Compose([
transforms.MirrorPad(((6, ), (6, ), (0, ))),
transforms.ToTensor(),
transforms.Normalize(means=(0.7942, 0.6693, 0.7722),
stds=(0.1998, 0.3008, 0.2037))
])
# model
#model = UNet((512, 512), (500, 500), 32, 64, 128, 256, 512, droprate=0.5, Norm=torch.nn.BatchNorm2d)
model = UNet((512, 512), (500, 500),
32,
64,
128,
256,
512,
droprate=0.5,
Norm=torch.nn.BatchNorm2d)
model.load_state_dict(torch.load(chkpt, map_location='cpu'))
model.eval()
# evaluate metrics on the fly
dice_sc, px_acc = Dice_Score(), Pixel_Accuracy((500, 500))
# make predictions and write images and masks to disk as png files
with torch.no_grad():
for file in files:
# load img, mask
img, ground_truth = np.load(file)["arr_0"], np.load(
file.replace("frame", "mask"))["arr_0"]
img_copy = img.copy()
# transform img
img, ground_truth = composed([img, ground_truth])
# prediction shape (1, 3, 500, 500)
pred = model(img.unsqueeze(0))
dice, pp_acc = dice_sc(pred, ground_truth.unsqueeze(0)), px_acc(
pred, ground_truth.unsqueeze(0))
print(f"Dice Score: {dice}, PP-Accuracy: {pp_acc}")
# mask shape (1, 500, 500)
mask = (torch.argmax(F.softmax(pred, dim=1),
dim=1).squeeze(0).numpy() / 2 * 255).astype(
np.uint8)
# prep image for writing, shape (1, 3, 512, 512)
img = (img.squeeze(0).numpy() * 255).astype(np.uint8)
identifier = file.split("\\")[-1].replace(".npz", ".png").replace(
"#", "_")
w_PNG(identifier=identifier, np_img=img_copy)
w_PNG(identifier=identifier.replace("frame", "mask"), np_img=mask)
plot_triple(img_copy, ground_truth, mask,
identifier.replace(".png", "_triple.png"))
def __init__(self, batch_size, use_gpu, num_workers):
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
pin_memory = True if use_gpu else False
trainset = torchvision.datasets.MNIST(root='./data/mnist', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(
trainset, batch_size=batch_size, shuffle=True,
num_workers=num_workers, pin_memory=pin_memory,
)
testset = torchvision.datasets.MNIST(root='./data/mnist', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(
testset, batch_size=batch_size, shuffle=False,
num_workers=num_workers, pin_memory=pin_memory,
)
self.trainloader = trainloader
self.testloader = testloader
self.num_classes = 10
def make_lvis_transforms(image_set):
normalize = T.Compose([
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
scales = [480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800]
transform_train = T.Compose([
T.RandomHorizontalFlip(),
T.RandomSelect(
T.RandomResize(scales, max_size=1333),
T.Compose([
T.RandomResize([400, 500, 600]),
T.RandomCrop((384, 384)),
T.RandomResize(scales, max_size=1333),
]),
),
normalize,
])
transform_val = T.Compose(
[T.RandomResize([800], max_size=1333), normalize])
transforms = {
"train": transform_train,
"trainval": transform_train,
"val": transform_val,
"test": transform_val,
}
return transforms[image_set]
def __init__(self, batch_size, use_gpu, num_workers):
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
pin_memory = True if use_gpu else False
trainset = ImageFolder('/home/mg/code/data/GEI_B/train/',
transform=transform,
loader=gei_loader)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
pin_memory=pin_memory)
testset = ImageFolder('/home/mg/code/data/GEI_B/test/',
transform=transform,
loader=gei_loader)
testloader = torch.utils.data.DataLoader(testset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=pin_memory)
self.trainloader = trainloader
self.testloader = testloader
self.num_classes = 62
def make_voc_transforms(image_set, remove_difficult):
normalize = T.Compose([
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
transform_train = T.Compose([
T.RandomHorizontalFlip(),
T.RandomSelect(
T.RandomResize([400, 500, 600], max_size=1000),
T.Compose([
T.RandomResize([400, 500, 600]),
T.RandomCrop((384, 384)),
T.RandomResize([400, 500, 600], max_size=1000),
]),
),
normalize,
T.RemoveDifficult(remove_difficult),
])
transform_val = T.Compose(
[T.RandomResize([600], max_size=1000), normalize])
transforms = {
"train": transform_train,
"trainval": transform_train,
"val": transform_val,
"test": transform_val,
}
return transforms[image_set]
def get_data_loaders(train_batch_size, val_batch_size):
normalize = transforms.Normalize(mean=torch.Tensor([0.5]),
std=torch.Tensor([0.2]))
train_transform = transforms.Compose([
transforms.RandomResizedCrop(256),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.MultiplicativeGaussianNoise(1, 0.01), normalize
])
val_transform = transforms.Compose(
[transforms.Resize((512, 512)),
transforms.ToTensor(), normalize])
train_loader = DataLoader(DWTDataset('dataset',
split='train',
transform=train_transform),
batch_size=train_batch_size,
shuffle=True)
val_loader = DataLoader(DWTDataset('dataset',
split='valid',
transform=val_transform),
batch_size=val_batch_size,
shuffle=False)
return train_loader, val_loader
def get_transform(param):
""" Transform input into required image shape"""
if 'train' == param:
transform_train = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomFlipLeftRight(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
return transform_train
elif 'test' == param:
transform_test = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
return transform_test
def main(check_model, mm=1):
dataset = data_manager.init_img_dataset(
root=args.root,
name=args.dataset,
split_id=args.split_id,
cuhk03_labeled=args.cuhk03_labeled,
cuhk03_classic_split=args.cuhk03_classic_split,
)
transform_train = T.Compose([
T.Random2DTranslation(args.height, args.width),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
transform_test = T.Compose([
T.Resize((args.height, args.width)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
'''trainloader = DataLoader(
ImageDataset(dataset.train, transform=transform_train),
batch_size=args.train_batch, shuffle=True, num_workers=args.workers,
pin_memory=pin_memory, drop_last=True,
)'''
query = ImageDataset(dataset.query, transform=transform_test)
if args.dataset == 'beijing':
query = ImageDataset_forBeijing(dataset.query,
transform=transform_test)
#gallery = ImageDatasetLazy(dataset.gallery, transform=transform_test)
gallery = ImageDataset(dataset.gallery, transform=transform_test)
if args.dataset == 'beijing':
gallery = ImageDataset_forBeijing(dataset.gallery,
transform=transform_test)
if args.evaluate:
#print("Evaluate only")
if mm == 1:
cost, recall, precision = test(query, gallery, check_model, mm)
return cost, recall, precision
else:
cost, recall, precision, delay = test(query, gallery, check_model,
mm)
return cost, recall, precision, delay
def __init__(self):
super().__init__()
self.transforms = T.Compose([
T.PILToTensor(),
T.ConvertImageDtype(torch.float32),
T.Normalize(mean=0.5, std=0.5), # map [0, 1] into [-1, 1]
T.ValidateModelInput(),
])
def __init__(self,
base_size,
mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225)):
self.transforms = T.Compose([
T.RandomResize(base_size, base_size),
T.ToTensor(),
T.Normalize(mean=mean, std=std),
])
def get_transform(pixmean, pixstd):
# Data transforms
logging.info('==> Preparing data..') # Random Crop, Zero out, flip, scale,
transform_train = transforms.Compose([
transforms.RandomCrop(CROPSIZE, padding=4),
transforms.RandomHorizontalFlip(),
transforms.RandomYFlip(),
transforms.RandomZFlip(),
transforms.ZeroOut(4),
transforms.ToTensor(),
transforms.Normalize((pixmean), (pixstd)), # need to cal mean and std, revise norm func
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((pixmean), (pixstd)),
])
return transform_train, transform_test
