def __getitem__(self, index):
visible_image = Image.open(self.visible_image_filenames[index])
infrared_image = Image.open(self.infrared_image_filenames[index])
visible_image = ToTensor()(
Grayscale(num_output_channels=3)(visible_image))
infrared_image = ToTensor()(
Grayscale(num_output_channels=3)(infrared_image))
data = torch.cat(
(infrared_image[0].unsqueeze(0), visible_image[0].unsqueeze(0)))
return data, infrared_image, visible_image
def __init__(self, testing, use_images, image_dir=None):
self.testing = testing # use test set
self.use_images = use_images # use images rather than one-hot vectors
self.image_dir = image_dir # directory with images
self.grid = Grid()
# Create 1 fixed mapping from locs to idxs
locs = self.grid.locs
idxs = [idx for idx in range(len(locs))]
self.loc2idx = {loc: idx for loc, idx in zip(locs, idxs)}
self.n_states = len(idxs)
# Prepare tensors for each idx
idx2tensor = {}
if self.use_images:
# Tensors are images
transform = Compose([Grayscale(num_output_channels=1), ToTensor()])
face_images = ImageFolder(self.image_dir, transform)
for idx in idxs:
idx2tensor[idx] = face_images[idx][0] # [1, 64, 64]
else:
# Tensors are one-hot vectors
for idx in idxs:
idx2tensor[idx] = torch.tensor(idx).type(torch.long) # [16]
self.idx2tensor = idx2tensor
def get_image_tensor_grad(filename,
width_LR=None,
height_LR=None,
factor=None):
img = Image.open(filename).convert('RGB')
if width_LR is None or height_LR is None or factor is None:
return img
transform_HR = Compose([
Resize((height_LR * factor, width_LR * factor)),
ToTensor(),
])
transform_LR = Compose([
Resize((height_LR, width_LR)),
ToTensor(),
])
transform_GS = Compose([
Grayscale(),
])
img_HR = transform_HR(img)
img_LR = transform_LR(img)
grayscaleImg = transform_GS(img_LR)
return img_LR, img_HR, grayscaleImg
def preprocess(images, progress_bar=False):
'''
Performs preprocessing on a batch of images (bs, h, w, c) or on a single image (h, w, c).
It doesn't handle flickering!! (there no flickering in breakout)
Use grayscale instead of luminance.
'''
size_preprocessed_image = 84
transformations = Compose([
Lambda(lambda image: image.reshape(
[image.shape[2], image.shape[0], image.shape[1]])),
ToPILImage(),
Grayscale(),
Resize((size_preprocessed_image, size_preprocessed_image)),
ToTensor()
])
if len(images.shape) == 4:
batch_size = images.shape[0]
preprocessed_images = []
if progress_bar:
for i in tqdm(range(batch_size)):
preprocessed_images.append(transformations(images[i]))
else:
for i in range(batch_size):
preprocessed_images.append(transformations(images[i]))
preprocessed_images = torch.stack(preprocessed_images).squeeze()
preprocessed_images = torch.unsqueeze(preprocessed_images, 0)
if len(preprocessed_images.shape) < 4:
preprocessed_images = torch.unsqueeze(preprocessed_images, 0)
else:
raise ValueError('tensor s dimension should be 4')
return preprocessed_images
def __init__(self,
images: ImageStreamer,
labels: Iterable,
encode: bool,
binarize: bool,
transform: Callable = None,
num_output_channels=3):
# pylint: disable=E1102,E1101
self.transformer = ToTensor() if transform is None else transform
self.encoder = LabelEncoder()
self.binarizer = LabelBinarizer()
self.num_output_channels = num_output_channels
self.grayscale = Grayscale(
num_output_channels=self.num_output_channels)
if encode:
labels = self.encoder.fit_transform(labels)
if binarize:
self.binarizer.fit(labels)
self.labels = torch.tensor(self.binarizer.transform(labels),
dtype=torch.long)
else:
self.labels = torch.tensor(labels, dtype=torch.long)
self.images = images
if len(labels) != len(images):
raise ValueError(
'Number of images ({:d}) != number of labels({:d})'.format(
len(images), len(labels)))
def __getitem__(self, index):
image = Image.open(os.path.join(
self.root,
self.list_paths[index])) # Open image from the given path.
# Get transform list
list_transforms = list()
if self.crop_size > 0:
list_transforms.append(RandomCrop(
(self.crop_size, self.crop_size)))
if self.flip:
coin = random.random() > 0.5
if coin:
list_transforms.append(RandomHorizontalFlip())
transforms = Compose(list_transforms)
image = transforms(image) # Implement common transform
input_image = Grayscale(num_output_channels=1)(
image) # For input image, we need to make it B/W.
input_tensor, target_tensor = ToTensor()(input_image), ToTensor()(
image) # Make input, target as torch.Tensor
input_tensor = Normalize(mean=[0.5], std=[0.5])(
input_tensor) # As the input tensor has only one channel,
# Normalize parameters also have one value each.
target_tensor = Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])(
target_tensor) # As the target tensor has
# three channels Normalize parameters also have three values each.
return input_tensor, target_tensor
def display_transform():
return Compose(
[ToPILImage(),
Resize(400),
CenterCrop(400),
Grayscale(),
ToTensor()])
def __getitem__(self, index):
visible_image = Image.open(self.visible_image_filenames[index])
infrared_image = Image.open(self.infrared_image_filenames[index])
w, h = visible_image.size
crop_size = calculate_valid_crop_size(min(w, h), self.upscale_factor)
visible_image1 = CenterCrop(crop_size)(visible_image)
infrared_image1 = CenterCrop(crop_size)(infrared_image)
visible_image1 = ToTensor()(
Grayscale(num_output_channels=3)(visible_image1))
infrared_image1 = ToTensor()(
Grayscale(num_output_channels=3)(infrared_image1))
data = torch.cat(
(infrared_image1[0].unsqueeze(0), visible_image1[0].unsqueeze(0)))
return data, infrared_image1, visible_image1
def get_transforms(kmeans):
clusters = kmeans.kmeans.n_clusters
_transform_colorisation = Compose([
Resize((32, 32)),
ToNumpy(),
ConvertChannel(),
QuantizeAB(kmeans),
OneHotEncoding(clusters),
ToTensor()
])
transform_colorisation = Compose([
Lambda(lambda batch: torch.stack(
[_transform_colorisation(im) for im in batch]))
])
_transform_training = Compose([
Resize((256, 256)),
Grayscale(),
ToTensor(),
Normalize(mean=config.IMAGE_MEAN, std=config.IMAGE_STD)
])
transform_training = Compose([
Lambda(lambda batch: torch.stack(
[_transform_training(im) for im in batch]))
])
_transform_testing = Compose(
[Resize((256, 256)),
ToNumpy(), ConvertChannel()])
transform_testing = Compose(
[Lambda(lambda batch: [_transform_testing(im) for im in batch])])
return [transform_training, transform_colorisation, transform_testing]
def transform_image_only(image):
if random.random() > 0.5:
# random change the colors of the picture
image = RandomChoice(
[Grayscale(num_output_channels=3),
ColorJitter(1, 1, 1)])(image)
return image
def preprocess(images):
'''
Performs preprocessing on a batch of images (bs, h, w, c) or on a single image (h, w, c).
It doesn't handle flickering!! (there is no flickering in breakout)
Use grayscale instead of luminance.
'''
size_preprocessed_image = 84
transformations = Compose([
Lambda(lambda image: image.permute(2, 0, 1)),
ToPILImage(),
Grayscale(),
Resize((size_preprocessed_image, size_preprocessed_image)),
ToTensor()
])
if len(images.shape) == 3:
images = images.unsqueeze(0)
assert len(images.shape) == 4
batch_size = images.shape[0]
preprocessed_images = []
for i in range(batch_size):
preprocessed_images.append(transformations(images[i]).squeeze(0))
preprocessed_images = torch.stack(preprocessed_images).permute(
1, 2, 0).squeeze()
if len(preprocessed_images.shape) == 3:
preprocessed_images, _ = torch.max(preprocessed_images,
dim=2,
keepdim=False)
return preprocessed_images
def get_data_loaders(train_batch_size=256, val_batch_size=64):
mnist = MNIST(download=True, train=True, root=".").train_data.float()
# Ugly method to hardcode convert 1 channel grayscale to 3 channel RGB-like
# but it is still gray input (due to MNIST from torchvision)
data_transform = Compose([
Resize((224, 224)),
Grayscale(3),
ToTensor(),
Normalize((mnist.mean() / 255, ), (mnist.std() / 255, ))
])
train_loader = DataLoader(MNIST(download=True,
root=".",
transform=data_transform,
train=True),
batch_size=train_batch_size,
shuffle=True)
val_loader = DataLoader(MNIST(download=True,
root=".",
transform=data_transform,
train=False),
batch_size=val_batch_size,
shuffle=False)
return train_loader, val_loader
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(p=0.5),
RandomVerticalFlip(p=0.5),
Grayscale(),
ToTensor(),
])
def __init__(self, dcm_path, device):
self.dcm_path = dcm_path
self.patientId = self.get_patientid(dcm_path)
self.n_obs = len(self.patientId)
self.device = device
self.tsfm = Compose(
[ToPILImage(), Resize(224),
Grayscale(3), ToTensor()])
def create_datagen(data_dir, batch_size=8):
transform = Compose([Grayscale(), ToTensor()])
dataset = ImageFolder(data_dir, transform=transform)
dataloader = DataLoader(dataset,
batch_size=batch_size,
shuffle=True,
num_workers=8)
return dataloader
def __getitem__(self, idx):
img, _ = super().__getitem__(idx)
gray_img = Grayscale(1)(img)
if self.colored_transform is not None:
img = self.colored_transform(img)
if self.gray_transform is not None:
gray_img = self.gray_transform(gray_img)
return img, gray_img
def preprocess_state(img: np.ndarray) -> tensor:
img = img[35:190, 2:158]
img[img == 144] = 0
img[img == 109] = 0
img[img == 72] = 0
img[img != 0] = 255
transform = Compose([ToPILImage(), Grayscale(), Resize(80), ToTensor()])
return transform(img)
def __init__(self):
"""
Create Env Racing Car
"""
self.env = gym.make('CarRacing-v0')
self.env.seed(args.seed)
self.reward_threshold = self.env.spec.reward_threshold
self.transform = Compose([ToPILImage(), Grayscale(), ToTensor()])
def __init__(self, **kwargs):
self.cc = ConfigurationContainer.instance()
settings = self.cc.settings['dataloader']
self.use_batch = settings.get('use_batch', False)
self.batch_size = settings.get('batch_size', None) if self.use_batch else None
self._logger = logging.getLogger(__name__)
# 1) CARGAR IMAGENES DESDE EL FILESYSTEM
# Se cargan las imagenes en una lista de tuplas <tensor,int> donde:
# tensor.shape = (1, HEIGHT, WIDTH)
# int es el indice de la clase asociada a dicho tensor
transforms = [Grayscale(num_output_channels=1), Resize(size=[HEIGHT, WIDTH], interpolation=Image.NEAREST), ToTensor(), Normalize(mean=(0.5,), std=(0.5,)), ]
#transforms = [Resize(size=[HEIGHT, WIDTH], interpolation=Image.NEAREST), ToTensor()]
dataset = ImageFolder(root="data/datasets/base_dir/train_dir", transform=Compose(transforms))
#dataset = ImageFolder(root="data/datasets/base_dir/train_dir")
print(len(dataset))
# Se separan las tuplas en lista de tensores y lista de labels
labels_dict = {}
tensor_list = []
labels_list = []
for img in dataset:
tensor_list.append(img[0])
labels_list.append(img[1])
if not img[1] in labels_dict:
labels_dict[img[1]] = 0
if labels_dict[img[1]] < ELEMENTS_PER_LABEL:
tensor_list.append(img[0])
labels_list.append(img[1])
labels_dict[img[1]] = labels_dict[img[1]] + 1
print("Original dataset size: " + str(len(tensor_list)))
print("Original dataset size2: " + str(len(labels_list)))
print("labels_dict = " + str(labels_dict))
# 3) REMOVER BATCH INCOMPLETO
# Remuevo los ultimos elementos que no completan un batch
if self.use_batch:
reminder = len(tensor_list) % self.batch_size
if reminder > 0:
tensor_list = tensor_list[:-reminder]
# 4) UNIFICAR LISTA EN TENSOR UNICO
# Se conVierte la lista de tensores en un unico tensor de dimension (len(tensor_list), 1, HEIGHT, WIDTH)
stacked_tensor = torch.stack(tensor_list)
self._logger.debug('Final dataset shape: {}'.format(stacked_tensor.shape))
print("Final dataset shape: " + str(stacked_tensor.shape))
self.data = stacked_tensor
self.labels = labels_list
def color_aug(image_batch): aug = torch.zeros_like(image_batch) for i in range(image_batch.shape[0]): aug[i] = ToTensor()(Grayscale()(ToPILImage(mode='RGB')(image_batch[i].cpu()))) if(FLAGS.cuda): aug = aug.cuda() return aug
def one_to_three(img):
if img.shape[0] != 3:
transform = transforms.Compose(
[transforms.ToPILImage(),
Grayscale(num_output_channels=3)])
return transform(img)
else:
transform = transforms.ToPILImage()
return transform(img)
def test_three_channel_grey():
to_grey = Grayscale()
data = CIFAR10('/home/duane/PycharmProjects/iic/data')
orig, label = data[100]
grey = to_grey(orig)
color = three_channel_grey(grey)
show(orig, grey, color)
def __init__(self, **kwargs):
# 1) CARGAR IMAGENES DESDE EL FILESYSTEM
# Se cargan las imagenes en una lista de tuplas <tensor,int> donde:
# tensor.shape = (1, HEIGHT, WIDTH)
# int es el indice de la clase asociada a dicho tensor
transforms = [
Grayscale(num_output_channels=1),
Resize(size=[HEIGHT, WIDTH], interpolation=Image.NEAREST),
ToTensor()
]
dataset = ImageFolder(root="datasets/covid",
transform=Compose(transforms))
# Se separan las tuplas en lista de tensores y lista de labels
tensor_list = []
labels_list = []
for img in dataset:
tensor_list.append(img[0])
labels_list.append(img[1])
print("Original dataset size: " + str(len(tensor_list)))
# 2) AUGMENTATION
if GAUSSIAN_AUGMENTATION is not None:
tensor_list, labels_list = gaussian_augmentation(
tensor_list, labels_list, GAUSSIAN_AUGMENTATION[0],
GAUSSIAN_AUGMENTATION[1], GAUSSIAN_AUGMENTATION[2])
print("Dataset size after Gaussian augmentation: " +
str(len(tensor_list)))
if SMOTE_AUGMENTATION is not None:
tensor_list, labels_list = smote_augmentation(
tensor_list, labels_list, SMOTE_AUGMENTATION)
print("Dataset size after SMOTE augmentation: " +
str(len(tensor_list)))
# 3) REMOVER BATCH INCOMPLETO
# Remuevo los ultimos elementos que no completan un batch
reminder = len(tensor_list) % BATCH_SIZE
tensor_list = tensor_list[:-reminder]
# 4) UNIFICAR LISTA EN TENSOR UNICO
# Se conVierte la lista de tensores en un unico tensor de dimension (len(tensor_list), 1, HEIGHT, WIDTH)
stacked_tensor = torch.stack(tensor_list)
print("Final dataset shape: " + str(stacked_tensor.shape))
self.data = stacked_tensor
self.labels = labels_list
def __init__(self, img_pairs, crop_size, patch_size):
self.img_pairs = img_pairs
self.crop_size = crop_size
self.patch_size = patch_size
self.transforms = Compose(
[Grayscale(), CenterCrop(self.crop_size),
ToTensor()])
self.double_transform = DoubleRandomPatch(self.crop_size,
self.patch_size)
def test_gradient_color():
to_grey = Grayscale()
data = CIFAR10('/home/duane/PycharmProjects/iic/data', download=True)
orig, label = data[5880]
grad_color = gradient(orig)
grey = to_grey(grad_color)
grad = gradient_grey(grey)
for i in range(5):
grad = gradient_grey(grad)
show(orig, grad_color, grad)
def test_connectedness_color():
to_grey = Grayscale()
data = CIFAR10('/home/duane/PycharmProjects/iic/data')
orig, label = data[100]
grad = gradient(orig)
grey = to_grey(grad)
image_np = np.asarray(grey)
connected = connectedness(grey, 20.0, 0.5)
image_np_con = np.asarray(connected)
show(orig, grey, connected)
def train(name, batch_size, epochs, lrate, workers, device, validation,
ground_truth):
train_set = ImageFolder(ground_truth,
transform=Compose([Grayscale(),
ToTensor()]))
val_set = ImageFolder(validation,
transform=Compose([Grayscale(),
ToTensor()]))
train_data_loader = DataLoader(dataset=train_set,
num_workers=workers,
batch_size=batch_size,
shuffle=True)
val_data_loader = DataLoader(dataset=val_set,
num_workers=workers,
batch_size=batch_size)
device = torch.device(device)
model = PatchNet().to(device)
criterion = nn.CrossEntropyLoss()
model.train()
optimizer = optim.Adam(model.parameters())
for epoch in range(epochs):
epoch_loss = 0
with click.progressbar(train_data_loader,
label='epoch {}'.format(epoch)) as bar:
for sample in bar:
input, target = sample[0].to(device), sample[1].to(device)
optimizer.zero_grad()
o = model(input)
loss = criterion(o, target)
epoch_loss += loss.item()
loss.backward()
optimizer.step()
torch.save(model.state_dict(), '{}_{}.ckpt'.format(name, epoch))
print("epoch {} complete: avg. loss: {:.4f}".format(
epoch, epoch_loss / len(train_data_loader)))
val_loss = evaluate(model, criterion, device, val_data_loader)
print("epoch {} validation loss: {:.4f}".format(epoch, val_loss))
def __getitem__(self, index):
hr_image = Image.open(self.image_filenames[index])
w, h = hr_image.size
w = int(np.floor(w / self.blocksize) * self.blocksize)
h = int(np.floor(h / self.blocksize) * self.blocksize)
crop_size = (h, w)
hr_image = CenterCrop(crop_size)(hr_image)
hr_image = Grayscale()(hr_image)
return ToTensor()(hr_image), ToTensor()(hr_image)
def __init__(self, dataset_dir, crop_size=256):
super(test_dataset_for_folder, self).__init__()
# self.blocksize = blocksize
self.high_res_length = crop_size
self.image_filenames = [join(dataset_dir, x) for x in listdir(dataset_dir) if is_image_file(x)]
self.test_compose = Compose([
# CenterCrop(crop_size),
Grayscale(),
ToTensor(),
Resize(crop_size),
# transforms.Normalize(mean=0.5, std=0.5)
])
def pyramid_transform(img_size, mean=0, std=1):
transform = Compose([
Resize([img_size, img_size]),
RandomHorizontalFlip(),
Grayscale(),
ToTensor(),
Normalize(mean=(mean), std=(std)),
])
def final_transform(img):
return transform(img)
return final_transform
