def test_ten_crop(device): script_ten_crop = torch.jit.script(F.ten_crop) img_tensor, pil_img = _create_data(32, 34, device=device) cropped_pil_images = F.ten_crop(pil_img, [10, 11]) cropped_tensors = F.ten_crop(img_tensor, [10, 11]) for i in range(10): _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) cropped_tensors = script_ten_crop(img_tensor, [10, 11]) for i in range(10): _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) for i in range(len(batch_tensors)): img_tensor = batch_tensors[i, ...] tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) assert len(tuple_transformed_imgs) == len(tuple_transformed_batches) for j in range(len(tuple_transformed_imgs)): true_transformed_img = tuple_transformed_imgs[j] transformed_img = tuple_transformed_batches[j][i, ...] assert_equal(true_transformed_img, transformed_img) # scriptable function test s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): assert_equal(transformed_batch, s_transformed_batch)
def test_ten_crop(self): script_ten_crop = torch.jit.script(F.ten_crop) img_tensor, pil_img = self._create_data(32, 34, device=self.device) cropped_pil_images = F.ten_crop(pil_img, [10, 11]) cropped_tensors = F.ten_crop(img_tensor, [10, 11]) for i in range(10): self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) cropped_tensors = script_ten_crop(img_tensor, [10, 11]) for i in range(10): self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) for i in range(len(batch_tensors)): img_tensor = batch_tensors[i, ...] tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) for j in range(len(tuple_transformed_imgs)): true_transformed_img = tuple_transformed_imgs[j] transformed_img = tuple_transformed_batches[j][i, ...] self.assertTrue(true_transformed_img.equal(transformed_img)) # scriptable function test s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): self.assertTrue(transformed_batch.equal(s_transformed_batch))
def apply_ten_crop(out_img_dir, out_lab_dir, out_den_dir, aug_img_id, img, label, den): if (img.shape[0] < TC_MIN_DIM_APPLY): tgt_wd = int(img.shape[1] * TC_MIN_DIM_APPLY / img.shape[0]) img, den = resize_img_den(img, den, TC_MIN_DIM_APPLY, tgt_wd) if (img.shape[1] < TC_MIN_DIM_APPLY): tgt_ht = int(img.shape[0] * TC_MIN_DIM_APPLY / img.shape[1]) img, den = resize_img_den(img, den, tgt_ht, TC_MIN_DIM_APPLY) img = np.transpose(img, [2, 0, 1]) imgs = F.ten_crop(torch.Tensor(img), TC_INTER_DIM) dens = F.ten_crop(torch.Tensor(den), TC_INTER_DIM) for i in range(len(imgs)): img = np.transpose(imgs[i].numpy(), (1, 2, 0)) den = dens[i].numpy() img, den = resize_img_den(img, den, TC_FINAL_DIM, TC_FINAL_DIM) out_img_path = osp.join(out_img_dir, str(aug_img_id + i + 1).zfill(7) + '.jpg') out_lab_path = osp.join(out_lab_dir, str(aug_img_id + i + 1).zfill(7) + '.json') out_den_path = osp.join(out_den_dir, str(aug_img_id + i + 1).zfill(7) + '.npy') cv2.imwrite(out_img_path, img) np.save(out_den_path, den) return aug_img_id + 10
def test_ten_crop(self): script_ten_crop = torch.jit.script(F.ten_crop) img_tensor, pil_img = self._create_data(32, 34, device=self.device) cropped_pil_images = F.ten_crop(pil_img, [10, 11]) cropped_tensors = F.ten_crop(img_tensor, [10, 11]) for i in range(10): self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) cropped_tensors = script_ten_crop(img_tensor, [10, 11]) for i in range(10): self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i])
def test_ten_crop(self): script_ten_crop = torch.jit.script(F_t.ten_crop) img_tensor = torch.randint(0, 255, (1, 32, 32), dtype=torch.uint8) img_tensor_clone = img_tensor.clone() cropped_tensor = F_t.ten_crop(img_tensor, [10, 10]) cropped_pil_image = F.ten_crop(transforms.ToPILImage()(img_tensor), [10, 10]) self.assertTrue(torch.equal(cropped_tensor[0], (transforms.ToTensor()(cropped_pil_image[0]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[1], (transforms.ToTensor()(cropped_pil_image[2]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[2], (transforms.ToTensor()(cropped_pil_image[1]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[3], (transforms.ToTensor()(cropped_pil_image[3]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[4], (transforms.ToTensor()(cropped_pil_image[4]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[5], (transforms.ToTensor()(cropped_pil_image[5]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[6], (transforms.ToTensor()(cropped_pil_image[7]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[7], (transforms.ToTensor()(cropped_pil_image[6]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[8], (transforms.ToTensor()(cropped_pil_image[8]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(cropped_tensor[9], (transforms.ToTensor()(cropped_pil_image[9]) * 255).to(torch.uint8))) self.assertTrue(torch.equal(img_tensor, img_tensor_clone)) # scriptable function test cropped_script = script_ten_crop(img_tensor, [10, 10]) for cropped_script_img, cropped_tensor_img in zip(cropped_script, cropped_tensor): self.assertTrue(torch.equal(cropped_script_img, cropped_tensor_img))
def __call__(self, img, target=None, mask=None): if target is not None and mask is None: return F.ten_crop(img, self.size), F.ten_crop(target, self.size) if target is not None and mask is not None: return F.ten_crop(img, self.size), F.ten_crop( target, self.size), F.ten_crop(mask, self.size) return F.ten_crop(img, self.size, self.vertical_flip)
def __call__(self, clip): """ Args: img (PIL.Image or numpy.ndarray): List of images to be cropped in format (h, w, c) in numpy.ndarray Returns: PIL.Image or numpy.ndarray: Cropped list of images """ cropped = [] for frame in clip: cropped += list(vF.ten_crop(frame, self.size)) return cropped
def test_ten_crop(self): img_tensor = torch.randint(0, 255, (1, 32, 32), dtype=torch.uint8) img_tensor_clone = img_tensor.clone() cropped_tensor = F_t.ten_crop(img_tensor, [10, 10]) cropped_pil_image = F.ten_crop(transforms.ToPILImage()(img_tensor), [10, 10]) self.assertTrue( torch.equal(cropped_tensor[0], (transforms.ToTensor()(cropped_pil_image[0]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[1], (transforms.ToTensor()(cropped_pil_image[2]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[2], (transforms.ToTensor()(cropped_pil_image[1]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[3], (transforms.ToTensor()(cropped_pil_image[3]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[4], (transforms.ToTensor()(cropped_pil_image[4]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[5], (transforms.ToTensor()(cropped_pil_image[5]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[6], (transforms.ToTensor()(cropped_pil_image[7]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[7], (transforms.ToTensor()(cropped_pil_image[6]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[8], (transforms.ToTensor()(cropped_pil_image[8]) * 255).to( torch.uint8))) self.assertTrue( torch.equal(cropped_tensor[9], (transforms.ToTensor()(cropped_pil_image[9]) * 255).to( torch.uint8))) self.assertTrue(torch.equal(img_tensor, img_tensor_clone))
def __call__(self, img): crops = [] for scale in self.scales: if min(img.size) != scale: r_img = trans_func.resize(img, scale) else: r_img = img.copy() w, h = r_img.size square_crops_coord = [(0, 0, scale, scale), (int(round((h - scale) / 2.)), int(round((w - scale) / 2.)), scale, scale), (h - scale, w - scale, scale, scale)] for upper, left, height, width in square_crops_coord: square = trans_func.crop(r_img, upper, left, height, width) sq_ten_crops = trans_func.ten_crop(square, self.crop_size) sq_crop = trans_func.resize(square, self.crop_size) sq_crop_mirror = trans_func.hflip(sq_crop) crops.extend((sq_crop, sq_crop_mirror) + sq_ten_crops) return crops
def __call__(self, img: Image.Image): target_size = np.array(img.size) # import numpy as np # # o_size = np.array((80., 120.)) # t_size = np.array((224., 224.)) # # def crop(o_size, t_size): # if o_size[0] < t_size[0] or o_size[1] < t_size[1]: # raise RuntimeError("Crop failed.") # return True # # def resizedCrop(o_size, t_size): # if o_size[0] < t_size[0] or o_size[1] < t_size[1]: # ratio = max(t_size) / min(o_size) # o_size = o_size * ratio # return True # # resizedCrop(o_size, t_size) if min(target_size) > min(self.size): ratio = min(target_size) / min(self.size) return F.ten_crop(img, self.size, self.vertical_flip)
def __call__(self, img): return F.ten_crop(img, self.size, self.vertical_flip)
def ten_crop(img): imgs = Fe.ten_crop(img, crop_img_size) return torch.stack( [Fe.normalize(Fe.to_tensor(x), mean=mean, std=std) for x in imgs], 0)
def crop_transform(img): imgs = Fe.ten_crop(img, 224) return torch.stack( [Fe.normalize(Fe.to_tensor(x), mean=mean, std=std) for x in imgs], 0)
def img_features(paths, cnn="vgg16", resize=None, crop_size=224, tencrop=False): """ Slow, but simple batchsize 1 image extractor. paths: str list, list of image paths cnn: str, which pre-trained cnn to use resize: int or tuple, if int then rescale such that smaller side is resize length if tuple then just interpolate to target size. crop_size: int, size of the square cropped from the resized image """ if tencrop and not crop_size: print("If tencrop is True please provide crop size") raise NameError out_dim = 4096 FEATS = np.zeros((len(paths), out_dim), dtype="float32") if cnn == "vgg16": base_model = VGG16(weights="imagenet") model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc2').output) preprocess_input = preprocess_vgg16 elif cnn == "vgg19": base_model = VGG19(weights="imagenet") model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc2').output) preprocess_input = preprocess_vgg19 # Run VGG trained on both Places365 and ImageNet #TODO Doesnt work :D i think because of keras version compat elif cnn == "hybrid": base_model = VGG16_Hubrid_1365(weights='places') model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc2').output) preprocess_input = preprocess_vgg16hybrid else: raise NotImplementedError model.trainable = False # Saving space for i, img_path in tqdm(list(enumerate(paths))): # Read image and resize with bilinear interpolation if given image = keras_image.load_img(img_path) if resize: image = F.resize(image, resize) # Take center crop and forward pass if crop_size and not tencrop: image = F.center_crop(image, crop_size) x = keras_image.img_to_array(image) x = np.expand_dims(x, axis=0) x = preprocess_input(x) features = model.predict(x).squeeze() # Apply 10crop strategy from order-embeddings https://arxiv.org/abs/1511.06361 elif tencrop: X = [] imgs = F.ten_crop(image, crop_size) for img in imgs: x = keras_image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) feat = model.predict(x).squeeze() X.append(feat) # Take average mean over all crops features = np.array(X) features = np.mean(features, axis=0) # No cropping case else: x = keras_image.img_to_array(image) x = np.expand_dims(x, axis=0) x = preprocess_input(x) features = model.predict(x).squeeze() FEATS[i] = features image.close() return FEATS