def __call__(self, rgb_img, label_img, depth_img=None):
w, h = rgb_img.size
pad_along_w = max(0, int((1 + self.crop_size[0] - w) / 2))
pad_along_h = max(0, int((1 + self.crop_size[1] - h) / 2))
# padd the images
rgb_img = Pad(padding=(pad_along_w, pad_along_h),
fill=0,
padding_mode='constant')(rgb_img)
if label_img is not None:
label_img = Pad(padding=(pad_along_w, pad_along_h),
fill=self.ignore_idx,
padding_mode='constant')(label_img)
if depth_img is not None:
depth_img = Pad(padding=(pad_along_w, pad_along_h),
fill=0,
padding_mode='constant')(depth_img)
i, j, h, w = self.get_params(rgb_img, self.crop_size)
rgb_img = F.crop(rgb_img, i, j, h, w)
if label_img is not None:
label_img = F.crop(label_img, i, j, h, w)
if depth_img is not None:
depth_img = F.crop(depth_img, i, j, h, w)
if depth_img is not None:
return rgb_img, label_img, depth_img
else:
return rgb_img, label_img
def adapt_size(cell):
origin_h, origin_w = cell.shape
if origin_h > origin_w:
cell = gen_ToPILImage(cell)
h2 = char_hw
w2 = int((char_hw / origin_h) * origin_w)
cell = Resize((h2, w2), interpolation=PIL.Image.NEAREST)(cell)
pad = char_hw - w2
if (pad == 0):
pass
elif (pad % 2 == 1):
cell = Pad((pad // 2 + 1, 0, pad // 2, 0), 0)(cell)
else:
cell = Pad((pad // 2, 0, pad // 2, 0), 0)(cell)
else:
cell = gen_ToPILImage(cell)
w2 = char_hw
h2 = int((char_hw / origin_w) * origin_h)
cell = Resize((h2, w2), interpolation=PIL.Image.NEAREST)(cell)
pad = char_hw - h2
if (pad == 0):
pass
elif (pad % 2 == 1):
cell = Pad((0, pad // 2 + 1, 0, pad // 2), 0)(cell)
else:
cell = Pad((0, pad // 2, 0, pad // 2), 0)(cell)
return gen_ToTensor(np.array(cell))
def __init__(self,
num_views,
random_seed,
dataset,
additional_face=True,
jittering=False):
if dataset == 1:
self.ids = np.load('../Datasets/voxceleb1_ori/train.npy')
if dataset == 2:
self.ids = np.load('../Datasets/voxceleb1_ori/val.npy')
if dataset == 3:
self.ids = np.load('../Datasets/voxceleb1_ori/test.npy')
self.rng = np.random.RandomState(random_seed)
self.num_views = num_views
#self.base_file = os.environ['VOX_CELEB_LOCATION'] + '/%s/'
self.base_file = VOX_CELEB_LOCATION + '/%s/'
crop = 200
if jittering == True:
precrop = crop + 24
crop = self.rng.randint(crop, precrop)
self.pose_transform = Compose([
Scale((256, 256)),
Pad((20, 80, 20, 30)),
CenterCrop(precrop),
RandomCrop(crop),
Scale((256, 256)),
ToTensor()
])
self.transform = Compose([
Scale((256, 256)),
Pad((24, 24, 24, 24)),
CenterCrop(precrop),
RandomCrop(crop),
Scale((256, 256)),
ToTensor()
])
else:
precrop = crop + 24
self.pose_transform = Compose([
Scale((256, 256)),
Pad((20, 80, 20, 30)),
CenterCrop(crop),
Scale((256, 256)),
ToTensor()
])
self.transform = Compose([
Scale((256, 256)),
Pad((24, 24, 24, 24)),
CenterCrop(precrop),
Scale((256, 256)),
ToTensor()
])
def detect_image(img: Image, img_size: int, model: Darknet, conf_thresh: float,
nms_thresh: float):
# scale and pad image
ratio = min(img_size / img.size[0], img_size / img.size[1])
imw = round(img.size[0] * ratio)
imh = round(img.size[1] * ratio)
img_transforms = Compose([
Resize((imh, imw)),
Pad(
(
max(int((imh - imw) / 2), 0),
max(int((imw - imh) / 2), 0),
max(int((imh - imw) / 2), 0),
max(int((imw - imh) / 2), 0),
),
(128, 128, 128),
),
ToTensor(),
])
# convert image to Tensor
image_tensor = img_transforms(img).float()
image_tensor = image_tensor.unsqueeze_(0)
input_img = Variable(image_tensor.type(Tensor))
# run inference on the model and get detections
with torch.no_grad():
detections = model(input_img)
detections = non_max_suppression(detections, 80, conf_thresh,
nms_thresh)
return detections[0]
def get_train_test_loaders(dataset_name, path, batch_size, num_workers):
assert dataset_name in datasets.__dict__, "Unknown dataset name {}".format(dataset_name)
fn = datasets.__dict__[dataset_name]
train_transform = Compose([
Pad(2),
RandomCrop(32),
RandomHorizontalFlip(),
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)),
])
test_transform = Compose([
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)),
])
train_ds = fn(root=path, train=True, transform=train_transform, download=True)
test_ds = fn(root=path, train=False, transform=test_transform, download=False)
train_loader = DataLoader(train_ds, batch_size=batch_size, num_workers=num_workers, pin_memory=True)
test_loader = DataLoader(test_ds, batch_size=batch_size * 2, num_workers=num_workers, pin_memory=True)
return train_loader, test_loader
def setUpClass(cls):
transform = Compose([Pad(2), ToTensor()])
cls.train_mnist = MNIST(join(dirname(__file__), "tmp/mnist"), True, transform, download=True)
cls.test_mnist = MNIST(join(dirname(__file__), "tmp/mnist"), False, transform, download=True)
cls.input_size = cls.train_mnist[0][0].shape
cls.output_size = 10
cls.random_error = 1 - (1 / cls.output_size)
def get_test_transform(length=T):
trans_list = [ToPILImage(),
Pad((length // 2, 0)),
TenCrop((1, length)),
Lambda(lambda crops: torch.stack([ToTensor()(crop) for crop in crops])),
Centring(MAX_INT)]
return transforms.Compose([ConvertToTuple(default_transforms) for default_transforms in trans_list])
def save_sample_sheet(cgn, u_fixed, sample_path, ep_str):
cgn.eval()
dev = u_fixed.to(cgn.get_device())
ys = [15, 251, 330, 382, 385, 483, 559, 751, 938, 947, 999]
to_save = []
with torch.no_grad():
for y in ys:
# generate
y_vec = cgn.get_class_vec(y, sz=1)
inp = (u_fixed.to(dev), y_vec.to(dev), cgn.truncation)
x_gt, mask, premask, foreground, background, bg_mask = cgn(inp)
x_gen = mask * foreground + (1 - mask) * background
# build class grid
to_plot = [premask, foreground, background, x_gen, x_gt]
grid = make_grid(torch.cat(to_plot).detach().cpu(),
nrow=len(to_plot),
padding=2,
normalize=True)
# add unnormalized mask
mask = Pad(2)(mask[0].repeat(3, 1, 1)).detach().cpu()
grid = torch.cat([mask, grid], 2)
# save to disk
to_save.append(grid)
del to_plot, mask, premask, foreground, background, x_gen, x_gt
# save the image
path = join(sample_path, f'cls_sheet_' + ep_str + '.png')
torchvision.utils.save_image(torch.cat(to_save, 1), path)
cgn.train()
def get_train_transform(length=T):
trans_list = [ToPILImage(),
Pad((length // 2, 0)),
RandomCrop((1, length)),
ToTensor(),
Centring(MAX_INT)]
return transforms.Compose([ConvertToTuple(default_transforms) for default_transforms in trans_list])
def __call__(self, img):
"""
Args:
img (PIL Image): Image to be scaled.
Returns:
PIL Image: Rescaled image.
"""
width, height = img.size
if width >= height:
new_image = np.zeros((width, width))
size_diff = width - height
return Pad(padding=(0, int(size_diff / 2))).__call__(img)
if height > width:
new_image = np.zeros((height, height))
size_diff = height - width
return Pad(padding=(int(size_diff / 2), 0)).__call__(img)
def get_train_test_loaders(path,
batch_size,
num_workers,
distributed=False,
pin_memory=True):
train_transform = Compose([
Pad(4),
RandomCrop(32, fill=128),
RandomHorizontalFlip(),
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
test_transform = Compose([
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
if not os.path.exists(path):
os.makedirs(path)
download = True
else:
download = True if len(os.listdir(path)) < 1 else False
train_ds = datasets.CIFAR10(root=path,
train=True,
download=download,
transform=train_transform)
test_ds = datasets.CIFAR10(root=path,
train=False,
download=False,
transform=test_transform)
train_sampler = None
test_sampler = None
if distributed:
train_sampler = DistributedSampler(train_ds)
test_sampler = DistributedSampler(test_ds, shuffle=False)
train_labelled_loader = DataLoader(
train_ds,
batch_size=batch_size,
sampler=train_sampler,
num_workers=num_workers,
pin_memory=pin_memory,
drop_last=True,
)
test_loader = DataLoader(
test_ds,
batch_size=batch_size * 2,
sampler=test_sampler,
num_workers=num_workers,
pin_memory=pin_memory,
)
return train_labelled_loader, test_loader
def get_train_transform(length=None):
transforms = [
ToPILImage(),
Pad((length // 2, 0)),
RandomCrop((1, length)),
ToTensor(),
Centring(MAX_INT)
]
return torchvision.transforms.Compose(transforms)
def get_augmentation(augmentation, dataset, data_shape):
c, h, w = data_shape
if augmentation is None:
pil_transforms = []
elif augmentation == 'horizontal_flip':
pil_transforms = [RandomHorizontalFlip(p=0.5)]
elif augmentation == 'neta':
assert h==w
pil_transforms = [Pad(int(math.ceil(h * 0.04)), padding_mode='edge'),
RandomAffine(degrees=0, translate=(0.04, 0.04)),
CenterCrop(h)]
elif augmentation == 'eta':
assert h==w
pil_transforms = [RandomHorizontalFlip(),
Pad(int(math.ceil(h * 0.04)), padding_mode='edge'),
RandomAffine(degrees=0, translate=(0.04, 0.04)),
CenterCrop(h)]
return pil_transforms
def get_test_transform(length=None):
transforms = [
ToPILImage(),
Pad((length // 2, 0)),
TenCrop((1, length)),
Lambda(
lambda crops: torch.stack([ToTensor()(crop) for crop in crops])),
Centring(MAX_INT)
]
return torchvision.transforms.Compose(transforms)
def __init__(self, input_size=(1920, 1080), side: int = 416):
self.scale = np.max(input_size) / side
if input_size[0] > input_size[1]:
self.pad = (0, int(input_size[0] - input_size[1]) // 2)
else:
self.pad = (int(input_size[1] - input_size[0]) // 2, 0)
super().__init__(
[Pad(self.pad, fill=0),
Resize((side, side)),
ToTensor()])
def SliceStack(height: int = 40, width : int = 40):
offsets = [0, 25, 55, 80]
transes = Compose([
Pad(12),
CenterCrop(64),
ToTensor(),
Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
def stack(img):
crops = [F.crop(img, 0, offset, height, width) for offset in offsets]
return torch.stack([transes(crop) for crop in crops])
return stack
def __init__(self, root, train=True, download=False, process=False):
transforms = Compose([
Pad(padding=4),
RandomCrop(size=32),
RandomHorizontalFlip(p=0.5),
ToTensor()
])
super(WrappedQuickDraw, self).__init__(root,
train,
download,
process,
transforms=transforms)
def estimate(tenOrig):
global netNetwork
if netNetwork is None:
netNetwork = Network('bsds500').cuda().eval()
# end
intPadWidth = 32
tenInput = Pad(intPadWidth, padding_mode='edge')(tenOrig).float()
intWidth = tenInput.shape[2]
intHeight = tenInput.shape[1]
tenOutput = torch.zeros(tenOrig.shape)
arrShift = [100, 150, 200]
for intShift in arrShift:
tenInf = netNetwork(tenInput.cuda().view(1, 3, intHeight, intWidth),
intShift)[0, :, :, :].cpu()
tenOutput = torch.maximum(
tenOutput,
CenterCrop(tenOrig.shape[1:3])(tenInf).float())
return tenOutput
def get_train_transforms(jitter, dataset):
if dataset == STL10:
crop_size = 88
else:
crop_size = 32
if not jitter:
return Compose([
ToTensor(),
Pad(2),
RandomCrop(crop_size),
RandomHorizontalFlip(p=0.5)
])
else:
return Compose([
RandomChoice([
ColorJitter(brightness=(0.3, 1.0)),
ColorJitter(contrast=(0.3, 1.0))
]),
ToTensor(),
Pad(2),
RandomCrop(crop_size),
RandomHorizontalFlip(p=0.5)
])
def CreateMnistDataloader(path, batch_size):
transform = Compose([Pad(padding=2), ToTensor()])
trainset = torchvision.datasets.MNIST(root=path, train=True,
download=False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
shuffle=True, num_workers=2)
testset = torchvision.datasets.MNIST(root=path, train=False,
download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
shuffle=False, num_workers=2)
return trainloader, testloader
def _build(self, ):
self.pad = Pad(self.kernel_size // 2, padding_mode=self.padding_mode)
self.feature_embedding = nn.Sequential(
nn.Conv2d(self.in_channels, self.embedding_size, self.kernel_size),
nn.Dropout(self.dropout),
nn.Flatten(),
nn.BatchNorm1d(self.embedding_size),
nn.ReLU(),
)
self.positional_embedding = nn.Linear(2, self.embedding_size)
self.sequence_module = nn.LSTM(
self.embedding_size,
self.hidden_size,
num_layers=1,
batch_first=True,
)
self.mdn_module = MixtureDensityNetwork(
self.hidden_size,
sample_size=self.embedding_size + 2,
n_components=self.n_components,
forward_mode=MixtureDensityNetwork.FORWARD_SAMPLE)
def validate_dir(root: str,
checkpoint_path: str,
position: int,
ignore_case: bool = True,
batch_size: int = 100):
assert position >= 0 and position <= 3
checkpoint = torch.load(checkpoint_path)
classes = checkpoint['classes']
model = resnet18(pretrained=False)
model.fc = nn.Linear(model.fc.in_features, len(checkpoint['classes']))
model.load_state_dict(checkpoint['model'])
model = model.cuda()
transes = Compose([
SliceCrop(position),
Pad(12),
CenterCrop(64),
ToTensor(),
Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
dataset = ImageFolder(root,
position,
checkpoint['classes'],
transform=transes)
dataloader = DataLoader(dataset,
shuffle=False,
num_workers=4,
batch_size=batch_size)
def classes_map(ignore_case):
low_classes = torch.tensor([classes.index(c.lower())
for c in classes]).cuda()
def tmap(preds: torch.LongTensor, y: torch.LongTensor):
if not ignore_case:
return preds, y
return low_classes[preds], low_classes[y]
return tmap
with torch.no_grad():
acc = validate(model, dataloader, classes_map(ignore_case))
print(f'validate acc: {acc:.3f}')
def __init__(self,
root,
train=True,
transform=None,
target_transform=None,
download=False,
pad=32,
translate=0.4):
super().__init__(root,
train=train,
target_transform=target_transform,
download=download)
self._transform = transform
self.p = pad
self.sz = (2 * self.p) + 32
self._pad = Pad(pad)
self._affine = RandomAffine(0, translate=(translate, translate))
def __init__(self, root, train=True, download=False, *args, **kwargs):
if train:
transforms = Compose([
Pad(padding=4),
RandomCrop(size=32),
RandomHorizontalFlip(p=0.5),
ToTensor(),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
else:
transforms = Compose([
RandomHorizontalFlip(p=0.5),
ToTensor(),
Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
super(WrappedCIFAR100, self).__init__(
root=root, train=train, transform=transforms,
download=download, *args, **kwargs)
def data(ctx, bsize, train, force_trainset, datapath, regex, dataset, download, shuffle, workers):
if regex is not None:
rvalid = re.compile(regex)
def is_valid_file(fpath):
return rvalid.fullmatch(fpath) is not None
else:
is_valid_file = None
if dataset == 'CIFAR10':
transf = Compose(([RandomCrop(32, padding=4), RandomHorizontalFlip()] if train else []) + [ToTensor(), Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
dset = CIFAR10(root=datapath, train=train or force_trainset, transform=transf, download=download)
elif dataset == 'MNIST':
transf = Compose([Pad(2), ToTensor(), Normalize(0.4734, 0.2009)])
dset = MNIST(root=datapath, train=train or force_trainset, transform=transf, download=download)
elif dataset == 'Imagenet-12':
transf = Compose(([RandomResizedCrop(224), RandomHorizontalFlip()] if train else [CenterCrop(224)]) + [ToTensor(), Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))])
dset = ImageFolder(root=datapath, transform=transf, is_valid_file=is_valid_file)
else:
raise RuntimeError('No such dataset!')
loader = DataLoader(dset, bsize, shuffle=shuffle, num_workers=workers)
ctx.obj.loader = loader
def __init__(self, train=True):
super(CustomCIFAR100, self).__init__()
self.cifar_100 = CIFAR100(root='datasets', train=train, download=True)
# self._cifar10_train => index[0] = data, index[1] = label, format = PIL
tensors = list()
for i in range(len(self.cifar_100)):
tensors.append(ToTensor()(
self.cifar_100[i][0]).numpy()) # cifar100
# ToTensor 는 들어온 이미지나 ndarray(H, W, C)를 (C, H, W)의 텐서로 바꿔서 돌려줌
mean = np.mean(tensors,
axis=(0, 2,
3)) # 채널 별 평균 구하기. ToTensor를 썼기 때문에 index=1이 채널
std = np.std(tensors,
axis=(0, 2,
3)) # 채널 별 표준편차 구하기. ToTensor를 썼기 때문에 index=1이 채널
print("mean: {}, std: {}".format(mean, std))
transform = [RandomHorizontalFlip()]
transform += [Pad(4), RandomCrop(32)]
transform += [ToTensor(), Normalize(mean=mean, std=std)]
self.transform = Compose(transform)
def test_dataset_generation(self):
transform = Compose([Pad(2), ToTensor()])
train_mnist = MNIST(join(dirname(__file__), "tmp/mnist"),
True,
transform,
download=True)
input_size = train_mnist[0][0].shape
number_of_classes = 10
resnet = ResNet(20, input_size, number_of_classes)
# Find a minimiser for the network
optim_wrapper = ModelWrapper(
DataModel(CompareModel(resnet, NLLLoss()), {"train": train_mnist}))
optim_wrapper.to("cuda")
optim_config = OptimConfig(100, SGD, {"lr": 0.1}, None, None,
EvalConfig(128))
minimum = find_minimum(optim_wrapper, optim_config)
optim_wrapper.set_coords_no_grad(minimum["coords"])
nim = NetworkInputModel(resnet, input_size, 0)
nim.cuda()
resnet.cuda()
dataset = nim.generate_dataset(train_mnist, number_of_classes)
self.assertEqual(len(dataset), 100)
import ignite.distributed as idist
from torchvision import datasets
from torchvision.transforms import (
Compose,
Normalize,
Pad,
RandomCrop,
RandomHorizontalFlip,
ToTensor,
)
train_transform = Compose(
[
Pad(4),
RandomCrop(32, fill=128),
RandomHorizontalFlip(),
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
]
)
eval_transform = Compose(
[
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
]
)
def get_datasets(path):
local_rank = idist.get_local_rank()
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision.transforms import ToTensor, Normalize, Compose, Pad, Lambda
from horch.config import cfg
from horch.datasets import train_test_split, CombineDataset
from horch.nas.darts.model_search_gdas import Network
from horch.nas.darts.trainer import DARTSTrainer
from horch.train import manual_seed
from horch.train.metrics import TrainLoss, Loss
from horch.train.metrics.classification import Accuracy
manual_seed(0)
train_transform = Compose([
Pad(2),
ToTensor(),
Normalize((0.1307, ), (0.3081, )),
Lambda(lambda x: x.expand(3, -1, -1))
])
root = '/Users/hrvvi/Code/study/pytorch/datasets'
ds_all = MNIST(root=root, train=True, download=True, transform=train_transform)
ds = train_test_split(ds_all, test_ratio=0.001, random=True)[1]
ds_train, ds_val = train_test_split(ds, test_ratio=0.5, random=True)
ds = CombineDataset(ds_train, ds_val)
train_loader = DataLoader(ds, batch_size=2, pin_memory=True, num_workers=2)
val_loader = DataLoader(ds_val, batch_size=2, pin_memory=True, num_workers=2)
batch_size = args.batch_size
epoch = args.num_epoch
save_path = 'model_save/'
#normalize for ImageNet
normalize = torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
crop = 200
rng = np.random.RandomState(args.random_seed)
precrop = crop + 24
crop = rng.randint(crop, precrop)
transformations = Compose([
Scale((256, 256)),
Pad((24, 24, 24, 24)),
CenterCrop(precrop),
RandomCrop(crop),
Scale((256, 256)),
ToTensor(), normalize
])
#define a batch-wise l2 loss
def criterion_l2(input_f, target_f):
# return a per batch l2 loss
res = (input_f - target_f)
res = res * res
return res.sum(dim=2)
