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 display_transform(): return Compose( [ToPILImage(), Resize(400), CenterCrop(400), Grayscale(), ToTensor()])
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 __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 get_transform(args): if args.transform == 'resize': rgb_transforms = Compose( [scale_rgb_to_256_factor, ToTensor(), AddNoise((3, 256, 1024))]) gt_transforms = Compose( [scale_gt_to_256_factor, ToTensor(), to_longTensor_gt]) elif args.transform == 'crop': rgb_transforms = Compose( [center_crop_to_256_factor, ToTensor(), AddNoise((3, 256, 1024))]) gt_transforms = Compose( [center_crop_to_256_factor, ToTensor(), to_longTensor_gt]) else: raise ValueError('the value (%s) for --transform is not valid.' % args.transform) torchvision_transforms = [] if args.phase == 'train': grayscale = Grayscale(num_output_channels=3) grayscale.probability = 0.075 torchvision_transforms.append(grayscale) colorJitter = ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2) colorJitter.probability = 0.1 torchvision_transforms.append(colorJitter) return rgb_transforms, torchvision_transforms, gt_transforms elif args.phase == 'test': return rgb_transforms
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) ])