def untangled_res(self, x, input): # B, 1(Green), H, W x_G = x[:, 1:2, :, :] input_G = input[:, 1:2, :, :] input_G = F.interpolate(input_G, scale_factor=2, mode='bicubic') lpass_G = kornia.gaussian_blur2d(input_G, (5, 5), (1.5, 1.5)) residual_lp = lpass_G - input_G residual_out = x_G - input_G res_product = residual_lp * residual_out res_product = res_product + 0.5 # texture - 1 , artifact - 0, flat - 0.5 texture = torch.ones_like(res_product) # G channel artifact = torch.zeros_like(res_product) # G channel res_product = torch.where(res_product < 0.5, texture, res_product) # 纹理异号 texture_mask = torch.where(res_product == 1, texture, artifact) # 纹理mask res_product = torch.where(res_product > 0.5, artifact, res_product) # 噪声同号 res_product = res_product + texture_mask return res_product
def gaussian_blur(hms, kernel): """ Heatmap distribution modulation the heatmaps predicted by a human pose estimation model do not exhibit good-shaped Gaussian structure compared to the training heatmap data. we propose to exploit a Gaussian kernel K with the same variation as the training data to smooth out the effects of multiple peaks in the heatmap while keeping the original maximum activation location. params: @ hms: numpy.ndarray([batch_size, 21(num_joints), height, width]) @ kernel: int """ border = (kernel - 1) // 2 batch_size = hms.shape[0] num_joints = hms.shape[1] height = hms.shape[2] width = hms.shape[3] sigma = (kernel - 1) // 3 for i in range(batch_size): for j in range(num_joints): origin_max = torch.max(hms[i, j]) dr = torch.zeros( (height + 2 * border, width + 2 * border)) # zero-padding dr[border:-border, border:-border] = hms[i, j].clone() dr = kornia.gaussian_blur2d( dr.view(1, 1, dr.shape[0], dr.shape[1]), (kernel, kernel), (sigma, sigma)) hms[i, j] = dr[0, 0, border:-border, border:-border].clone() hms[i, j] *= origin_max / torch.max(hms[i, j]) return hms
def set_binary_maps_as_target(dataset: Dataset, invert: bool = False, binary_images: List[np.ndarray] = None, smoothen_labels: bool = False) -> Dataset: if binary_images is None: binary_images = parse_binary_maps(copy.deepcopy(dataset.observations), invert=invert) binary_images = torch.stack([torch.as_tensor(b).unsqueeze(0) for b in binary_images], dim=0) # smoothen binary maps to punish line predictions close to line less severely if smoothen_labels: binary_images = gaussian_blur2d(binary_images, kernel_size=(11, 11), sigma=(4, 4)) dataset.actions = [b.squeeze() for b in binary_images] return dataset
def usm(x, kernel_size=(7, 7), amount=1.0, threshold=0): res = x.clone() blurred = gaussian_blur2d(x, kernel_size=kernel_size, sigma=(1.0, 1.0)) sharpened = res * (amount + 1.0) - amount * blurred if threshold > 0: sharpened = torch.where(torch.abs(res - blurred) < threshold, sharpened, res) return F.relu(sharpened, inplace=True)
def forward(self, x): if self.filter_type == 'Median_Filter': x_denoised = kornia.median_blur(x, (self.ksize, self.ksize)) elif self.filter_type == 'Mean_Filter': x_denoised = kornia.box_blur(x, (self.ksize, self.ksize)) elif self.filter_type == 'Gaussian_Filter': x_denoised = kornia.gaussian_blur2d( x, (self.ksize, self.ksize), (0.3 * ((x.shape[3] - 1) * 0.5 - 1) + 0.8, 0.3 * ((x.shape[2] - 1) * 0.5 - 1) + 0.8)) new_x = x + self.conv(x_denoised) return new_x
def forward(self, x): if self.filter_type == 'Median_Filter': x_denoised = kornia.median_blur(x, (self.ksize, self.ksize)) elif self.filter_type == 'Mean_Filter': x_denoised = kornia.box_blur(x, (self.ksize, self.ksize)) elif self.filter_type == 'Gaussian_Filter': x_denoised = kornia.gaussian_blur2d( x, (self.ksize, self.ksize), (0.3 * ((x.shape[3] - 1) * 0.5 - 1) + 0.8, 0.3 * ((x.shape[2] - 1) * 0.5 - 1) + 0.8)) elif self.filter_type == "NonLocal_Filter": x_denoised = self.non_local_op(x, self.embed, self.softmax) new_x = x + self.conv_1x1(x_denoised) return new_x
def smooth_noise(img: torch.Tensor, ksize: int, std: float, p: float = 1.0, inplace: bool = True) -> torch.Tensor: """ Smoothens (blurs) the given noise images with a Gaussian kernel. :param img: torch tensor (n x c x h x w). :param ksize: the kernel size used for the Gaussian kernel. :param std: the standard deviation used for the Gaussian kernel. :param p: the chance smoothen an image, on average smoothens p * n images. :param inplace: whether to apply the operation inplace. """ if not inplace: img = img.clone() ksize = ksize if ksize % 2 == 1 else ksize - 1 picks = torch.from_numpy(np.random.binomial(1, p, size=img.size(0))).bool() if picks.sum() > 0: img[picks] = gaussian_blur2d(img[picks], (ksize, ) * 2, (std, ) * 2) return img
def main(): try: img_bgr: np.ndarray = cv2.imread('model8.png', cv2.IMREAD_COLOR) x_bgr: torch.Tensor = kornia.image_to_tensor(img_bgr) x_rgb: torch.Tensor = kornia.bgr_to_rgb(x_bgr) x_rgb = x_rgb.expand(2, -1, -1, -1) x_rgb = x_rgb.float() / 255. imshow(x_rgb) # Box Blur x_blur: torch.Tensor = kornia.box_blur(x_rgb, (9, 9)) imshow(x_blur) # Median Blur x_blur: torch.Tensor = kornia.median_blur(x_rgb, (5, 5)) imshow(x_blur) # Gaussian Blur x_blur: torch.Tensor = kornia.gaussian_blur2d(x_rgb, (11, 11), (11., 11.)) imshow(x_blur) except: print("Error found")
def Blur(x): return kornia.gaussian_blur2d(x, (3, 3), (1.0, 1.0))
def _image_processing(self, imgs: Tensor, input_shape: torch.Size, blur: bool = False, maxres: int = 64, qu: float = None, norm: str = 'local', colorize: bool = False, ref: Tensor = None, cmap: str = 'jet') -> Tensor: """ Applies basic image processing techniques, including resizing, blurring, colorizing, and normalizing. The resize operation resizes the images automatically to match the input_shape. Other transformations are optional. Can be used to create pseudocolored heatmaps! :param imgs: a tensor of some images. :param input_shape: the shape of the inputs images the data loader returns. :param blur: whether to blur the image (has no effect for FCDD anomaly scores, where the anomaly scores are upsampled using a Gaussian kernel anyway). :param maxres: maximum allowed resolution in pixels (images are downsampled if they exceed this threshold). :param norm: what type of normalization to apply. None: no normalization. 'local': normalizes each image w.r.t. itself only. 'global': normalizes each image w.r.t. to ref (ref defaults to imgs). :param qu: quantile used for normalization, qu=1 yields the typical 0-1 normalization. :param colorize: whether to colorize grayscaled images using colormaps (-> pseudocolored heatmaps!). :param ref: a tensor of images used for global normalization (defaults to imgs). :param cmap: the colormap that is used to colorize grayscaled images. :return: transformed tensor of images """ imgs = imgs.detach().clone() assert imgs.dim() == len(input_shape) == 4 # n x c x h x w std = self.gauss_std if qu is None: qu = self.quantile # upsample if necessary (img.shape != input_shape) if imgs.shape[2:] != input_shape[2:]: assert isinstance(self.net, ReceptiveNet), \ 'Some images are not of full resolution, and network is not a receptive net. This should not occur! ' imgs = self.net.receptive_upsample(imgs, reception=True, std=std) # blur if requested if blur: if isinstance(self.net, ReceptiveNet): r = self.net.reception['r'] elif self.objective == 'hsc': r = self.net.fcdd_cls(self.net.in_shape, bias=True).reception['r'] elif self.objective == 'ae': enc = self.net.encoder if isinstance(enc, ReceptiveNet): r = enc.reception['r'] else: r = enc.fcdd_cls(enc.in_shape, bias=True).reception['r'] else: raise NotImplementedError() r = (r - 1) if r % 2 == 0 else r std = std or kernel_size_to_std(r) imgs = gaussian_blur2d(imgs, (r, ) * 2, (std, ) * 2) # downsample if resolution exceeds the limit given with maxres if maxres < max(imgs.shape[2:]): assert imgs.shape[-2] == imgs.shape[ -1], 'Image provided is no square!' imgs = F.interpolate(imgs, (maxres, maxres), mode='nearest') # apply requested normalization if norm is not None: apply_norm = { 'local': self.__local_norm, 'global': self.__global_norm } imgs = apply_norm[norm](imgs, qu, ref) # if image is grayscaled, colorize, i.e. provide a pseudocolored heatmap! if colorize: imgs = imgs.mean(1).unsqueeze(1) imgs = colorize_img([ imgs, ], norm=False, cmap=cmap)[0] else: imgs = imgs.repeat(1, 3, 1, 1) if imgs.size(1) == 1 else imgs return imgs
# Create batch and normalize x_rgb = x_rgb.expand(2, -1, -1, -1) # 4xCxHxW x_rgb = x_rgb.float() / 255. def imshow(input: torch.Tensor): out: torch.Tensor = torchvision.utils.make_grid(input, nrow=2, padding=1) out_np: np.array = kornia.tensor_to_image(out) plt.imshow(out_np) plt.axis('off') ############################# # Show original imshow(x_rgb) ############################# # Box Blur x_blur: torch.Tensor = kornia.box_blur(x_rgb, (9, 9)) imshow(x_blur) ############################# # Media Blur x_blur: torch.Tensor = kornia.median_blur(x_rgb, (5, 5)) imshow(x_blur) ############################# # Gaussian Blur x_blur: torch.Tensor = kornia.gaussian_blur2d(x_rgb, (11, 11), (11., 11.)) imshow(x_blur)
def test_diag(self, device, dtype): input = torch.tensor( [[[[0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.]], [[0., 0., 0., 0, 0], [0., 0., 1, 0, 0.], [0., 1, 1.2, 1.1, 0.], [0., 0., 1., 0, 0.], [0., 0., 0., 0, 0.]], [ [0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.], ]]], device=device, dtype=dtype) input = kornia.gaussian_blur2d(input, (5, 5), (0.5, 0.5)).unsqueeze(0) softargmax = kornia.geometry.ConvQuadInterp3d(10) expected_val = torch.tensor( [[[[[0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.]], [[2.2504e-04, 2.3146e-02, 1.6808e-01, 2.3188e-02, 2.3628e-04], [2.3146e-02, 1.8118e-01, 7.4338e-01, 1.8955e-01, 2.5413e-02], [1.6807e-01, 7.4227e-01, 1.1086e+01, 8.0414e-01, 1.8482e-01], [2.3146e-02, 1.8118e-01, 7.4338e-01, 1.8955e-01, 2.5413e-02], [2.2504e-04, 2.3146e-02, 1.6808e-01, 2.3188e-02, 2.3628e-04]], [[0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.]]]]], device=device, dtype=dtype) expected_coord = torch.tensor( [[[[[[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]], [[1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0]], [[2.0, 2.0, 2.0, 2.0, 2.0], [2.0, 2.0, 2.0, 2.0, 2.0], [2.0, 2.0, 2.0, 2.0, 2.0], [2.0, 2.0, 2.0, 2.0, 2.0], [2.0, 2.0, 2.0, 2.0, 2.0]]], [[[0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0]], [[0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0]], [[0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0], [0.0, 1.0, 2.0, 3.0, 4.0]]], [[[0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0, 1.0], [2.0, 2.0, 2.0, 2.0, 2.0], [3.0, 3.0, 3.0, 3.0, 3.0], [4.0, 4.0, 4.0, 4.0, 4.0]], [[0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0, 1.0], [2.0, 2.0, 2.0495, 2.0, 2.0], [3.0, 3.0, 3.0, 3.0, 3.0], [4.0, 4.0, 4.0, 4.0, 4.0]], [[0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0, 1.0], [2.0, 2.0, 2.0, 2.0, 2.0], [3.0, 3.0, 3.0, 3.0, 3.0], [4.0, 4.0, 4.0, 4.0, 4.0]]]]]], device=device, dtype=dtype) coords, val = softargmax(input) assert_allclose(val, expected_val, atol=1e-4, rtol=1e-4) assert_allclose(coords, expected_coord, atol=1e-4, rtol=1e-4)
def backward_G(self,epoch): self.loss_G_GAN_A = 0 self.loss_G_GAN_B = 0 self.loss_G_GAN_flash_B = 0 self.loss_G_GAN_flash_A = 0 # comment loss on recrations # self.loss_G_GAN_recA = 0 # self.loss_G_GAN_recB = 0 self.loss_cycle_A = 0 self.loss_cycle_B = 0 # self.loss_G_L1_A_comp = 0 # self.loss_G_L1_B_comp = 0 self.loss_G_L1_A_comp_color = 0 self.loss_G_L1_B_comp_color = 0 self.loss_color_dslr_A = 0 self.loss_color_dslr_B = 0 if self.opt.D_flash: fake_AC = torch.cat((self.real_A, self.flash_from_decomposition), 1) pred_fake = self.netD_Flash(fake_AC) self.loss_G_GAN_flash_A = self.criterionGAN(pred_fake, True) fake_BC = torch.cat((self.real_B, self.flash_from_generation), 1) pred_fake = self.netD_Flash(fake_BC) self.loss_G_GAN_flash_B = self.criterionGAN(pred_fake, True) else: fake_AB = torch.cat((self.real_A, self.fake_B), 1) pred_fake = self.netD_Decompostion(fake_AB) self.loss_G_GAN_A = self.criterionGAN(pred_fake, True) fake_AB_B = torch.cat((self.real_B, self.fake_A), 1) pred_fake = self.netD_Generation(fake_AB_B) self.loss_G_GAN_B = self.criterionGAN(pred_fake, True) # fake_AB = torch.cat((self.real_A, self.rec_A), 1) # pred_fake = self.netD_Decompostion(fake_AB) # self.loss_G_GAN_recA = self.criterionGAN(pred_fake, True) # fake_AB_B = torch.cat((self.real_B, self.rec_B), 1) # pred_fake = self.netD_Generation(fake_AB_B) # self.loss_G_GAN_recB = self.criterionGAN(pred_fake, True) # ## Flash L1 loss # if self.opt.lambda_comp != 0: # self.loss_G_L1_A_comp = self.criterionL1(self.flash_from_decomposition, self.real_C) * self.opt.lambda_comp # self.loss_G_L1_B_comp = self.criterionL1(self.flash_from_generation, self.real_C) * self.opt.lambda_comp ## Flash Color Loss if self.opt.lambda_color_uv != 0: fake_C_A = kornia.rgb_to_yuv(self.flash_from_decomposition)[:,1:2,:,:] fake_C_B = kornia.rgb_to_yuv(self.flash_from_generation)[:,1:2,:,:] real_C_color = kornia.rgb_to_yuv(self.real_C)[:,1:2,:,:] self.loss_G_L1_A_comp_color = self.criterionL1(fake_C_A, real_C_color) * self.opt.lambda_color_uv self.loss_G_L1_B_comp_color = self.criterionL1(fake_C_B, real_C_color) * self.opt.lambda_color_uv if epoch >= self.opt.cycle_epoch: self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * self.opt.lambda_A self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * self.opt.lambda_B if self.opt.dslr_color_loss: real_A_blurred = kornia.gaussian_blur2d(self.real_A, (21, 21), (3, 3)) real_B_blurred = kornia.gaussian_blur2d(self.real_B, (21, 21), (3, 3)) fake_A_blurred = kornia.gaussian_blur2d(self.fake_A, (21, 21), (3, 3)) fake_B_blurred = kornia.gaussian_blur2d(self.fake_B, (21, 21), (3, 3)) self.loss_color_dslr_A = self.criterionL1(real_A_blurred, fake_A_blurred) * self.opt.dslr_color_loss self.loss_color_dslr_B = self.criterionL1(real_B_blurred, fake_B_blurred) * self.opt.dslr_color_loss self.loss_G_L1_A = self.criterionL1(self.fake_A, self.real_A) * self.opt.lambda_L1 self.loss_G_L1_B = self.criterionL1(self.fake_B, self.real_B) * self.opt.lambda_L1 self.loss_G =self.loss_color_dslr_A + self.loss_color_dslr_B + \ self.loss_G_L1_B_comp_color + self.loss_G_L1_A_comp_color +\ self.loss_G_GAN_flash_A + self.loss_G_GAN_flash_B +\ self.loss_G_GAN_B + self.loss_G_GAN_A +\ self.loss_cycle_A + self.loss_cycle_B +\ self.loss_G_L1_A+ self.loss_G_L1_B self.loss_G.backward()
def train(epoch): epoch_loss_g = 0 epoch_loss_d = 0 netG.train() for iteration, batch in enumerate(training_loader, 1): inputs, target, info, pqf = batch[0].to(device), batch[1].to( device), batch[2].to(device), batch[3].to(device) real_labels = torch.ones((target.size(0), 1, 4, 4)).to(device) fake_labels = torch.zeros((target.size(0), 1, 4, 4)).to(device) optimizer_netG.zero_grad() ########################## # training generator # ########################## # LR to HR i4, i3, i2, i1, i0 = netG(inputs, info, pqf) b, _, h4, w4 = i4.size() b, _, h3, w3 = i3.size() b, _, h2, w2 = i2.size() b, _, h1, w1 = i1.size() target_4 = F.interpolate(target, size=(h4, w4), mode='bilinear', align_corners=False) target_3 = F.interpolate(target, size=(h3, w3), mode='bilinear', align_corners=False) target_2 = F.interpolate(target, size=(h2, w2), mode='bilinear', align_corners=False) target_1 = F.interpolate(target, size=(h1, w1), mode='bilinear', align_corners=False) i0_lp = kornia.gaussian_blur2d(i0, (5, 5), (1.0, 1.0)) i0_hp = i0 - i0_lp i0_hp = 0.5 + i0_hp * 0.5 target_lp = kornia.gaussian_blur2d(target, (5, 5), (1.0, 1.0)) target_hp = target - target_lp target_hp = 0.5 + target_hp * 0.5 # loss_c1 = criterion_c(i4, target_4) # loss_c2 = criterion_c(i3, target_3) loss_c3 = criterion_c(i2, target_2) loss_c4 = criterion_c(i1, target_1) loss_c5 = criterion_c(i0_lp, target_lp) loss_c6 = criterion_c(i0, target) loss_gdl = criterion_g(i0, target) loss_lpips = loss_fn.forward(i0 * 2 - 1, target * 2 - 1) loss_lpips = torch.mean(loss_lpips) score_real = netD(target_hp) score_fake = netD(i0_hp) discriminator_rf = score_real - score_fake.mean() discriminator_fr = score_fake - score_real.mean() adversarial_loss_rf = criterion_adv(discriminator_rf, fake_labels) adversarial_loss_fr = criterion_adv(discriminator_fr, real_labels) loss_adv = (adversarial_loss_fr + adversarial_loss_rf) / 2 netG_loss = loss_c3 * 0.08 + loss_c4 * 0.1 + loss_c5 * 1 + loss_c6 * 1 + loss_gdl + loss_lpips * 1.2 + loss_adv * 0.002 epoch_loss_g += netG_loss.item() netG_loss.backward() optimizer_netG.step() print('===========> G_Epoch[{}]({}/{}): Loss: {:.6f}'.format( epoch, iteration, len(training_loader), netG_loss)) ########################## # training discriminator # ########################## ''' optimizer_netD.zero_grad() score_real = netD(target_hp) score_fake = netD(i0_hp.detach()) discriminator_rf = score_real - score_fake.mean() discriminator_fr = score_fake - score_real.mean() adversarial_loss_rf = criterion_adv(discriminator_rf, real_labels) adversarial_loss_fr = criterion_adv(discriminator_fr, fake_labels) netD_loss = (adversarial_loss_fr + adversarial_loss_rf) / 2 epoch_loss_d += netD_loss.item() netD_loss.backward() optimizer_netD.step() print('===> D_Epoch[{}]({}/{}): Loss: {:.6f}'.format(epoch, iteration, len(training_loader), netD_loss.item())) ''' print('===> Epoch {} Complete: Avg. G_Loss: {:.6f}'.format( epoch, epoch_loss_g / len(training_loader))) # print('===> Epoch {} Complete: Avg. D_Loss: {:.6f}'.format(epoch, epoch_loss_d / len(training_loader))) logging.info('Epoch Avg. GLoss : {:.6f}'.format(epoch_loss_g / len(training_loader)))
def fit_on_blur(self, root_dir, num_epochs, batch_size, val_split=0.1, num_workers=4): image_datasets = datasets.ImageFolder(root_dir, self.data_transforms) image_datasets.classes = [ self.translate[i] for i in image_datasets.classes ] train_size = int((1 - val_split) * len(image_datasets)) train, valid = torch.utils.data.random_split( image_datasets, [train_size, len(image_datasets) - train_size]) dataloaders = { 'train': torch.utils.data.DataLoader(train, batch_size=batch_size, shuffle=True, num_workers=num_workers), 'val': torch.utils.data.DataLoader(valid, batch_size=batch_size, shuffle=True, num_workers=num_workers) } criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(self.parameters(), lr=0.0001) epoch_bar = tqdm.tqdm(range(num_epochs), desc='Epochs---', position=0) self.train_epoch_loss = [] self.val_epoch_loss = [] train_acc = 0. val_acc = 0. for epoch in epoch_bar: self.train() pbar = tqdm.tqdm(dataloaders['train'], desc='Epoch= {}'.format(epoch + 1), position=1) running_loss = 0.0 val_loss = 0.0 total = 0 correct = 0 for inputs, labels in pbar: inputs = inputs.to(self.device) labels = labels.to(self.device) inputs = torch.stack([ kornia.gaussian_blur2d(inputs[i].view(1, 3, 224, 224), kernel_size=(25, 25), sigma=(4, 4)).view(3, 224, 224) for i in range(len(inputs)) ]) # zero the parameter gradients optimizer.zero_grad() labels_hat = self(inputs) _, predicted = torch.max(labels_hat.data, 1) loss = criterion(labels_hat, labels) total += labels.size(0) correct += (predicted == labels).sum().item() pbar.set_postfix(train_run_loss='{:.4f}'.format(loss.item())) running_loss += loss.item() loss.backward() optimizer.step() self.train_epoch_loss.append(running_loss / len(dataloaders['train'])) train_acc = 100 * correct / total epoch_bar.set_postfix(train_acc='{:.4f}'.format(train_acc), val_acc='{:.4f}'.format(val_acc)) # pbar = tqdm.tqdm(dataloaders['val'],desc='Epoch={}, train_epoch_loss= {}'.format(epoch+1,epoch_loss)) total = 0 correct = 0 with torch.no_grad(): self.eval() for inputs, labels in dataloaders['val']: inputs = inputs.to(self.device) inputs = torch.stack([ kornia.gaussian_blur2d(inputs[i].view(1, 3, 224, 224), kernel_size=(25, 25), sigma=(4, 4)).view(3, 224, 224) for i in range(len(inputs)) ]) labels = labels.to(self.device) labels_hat = self(inputs) _, predicted = torch.max(labels_hat.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() loss = criterion(labels_hat, labels) val_loss += loss.item() self.val_epoch_loss.append(val_loss / len(dataloaders['val'])) val_acc = 100 * correct / total epoch_bar.set_postfix(train_acc='{:.4f}'.format(train_acc), val_acc='{:.4f}'.format(val_acc))
def op_script(img): return kornia.gaussian_blur2d(img, (5, 5), (1.2, 1.2), "replicate")
def test_diag(self, device): input = torch.tensor([[[[0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.]], [[0., 0., 0., 0, 0], [0., 0., 1, 0, 0.], [0., 1, 1.2, 1.1, 0.], [0., 0., 1., 0, 0.], [0., 0., 0., 0, 0.]], [ [0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.], ]]]).to(device) input = kornia.gaussian_blur2d(input, (5, 5), (0.5, 0.5)).unsqueeze(0) softargmax = kornia.geometry.ConvQuadInterp3d(1) expected_val = torch.tensor( [[[[[0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.]], [[2.2504e-04, 2.3146e-02, 1.6808e-01, 2.3188e-02, 2.3628e-04], [2.3146e-02, 1.8118e-01, 7.4338e-01, 1.8955e-01, 2.5413e-02], [1.6807e-01, 7.4227e-01, 2.1722e+00, 8.0414e-01, 1.8482e-01], [2.3146e-02, 1.8118e-01, 7.4338e-01, 1.8955e-01, 2.5413e-02], [2.2504e-04, 2.3146e-02, 1.6808e-01, 2.3188e-02, 2.3628e-04]], [[0., 0., 0., 0, 0], [0., 0., 0.0, 0, 0.], [0., 0, 0., 0, 0.], [0., 0., 0, 0, 0.], [0., 0., 0., 0, 0.]]]]]).to(device) expected_coord = torch.tensor( [[[[[[0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000]], [[1.0000, 1.0000, 1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0688, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000, 1.0000, 1.0000], [1.0000, 1.0000, 1.0000, 1.0000, 1.0000]], [[2.0000, 2.0000, 2.0000, 2.0000, 2.0000], [2.0000, 2.0000, 2.0000, 2.0000, 2.0000], [2.0000, 2.0000, 2.0000, 2.0000, 2.0000], [2.0000, 2.0000, 2.0000, 2.0000, 2.0000], [2.0000, 2.0000, 2.0000, 2.0000, 2.0000]]], [[[0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000]], [[0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 1.8366, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000]], [[0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000], [0.0000, 1.0000, 2.0000, 3.0000, 4.0000]]], [[[0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [1.0000, 1.0000, 1.0000, 1.0000, 1.0000], [2.0000, 2.0000, 2.0000, 2.0000, 2.0000], [3.0000, 3.0000, 3.0000, 3.0000, 3.0000], [4.0000, 4.0000, 4.0000, 4.0000, 4.0000]], [[0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [1.0000, 1.0000, 1.0000, 1.0000, 1.0000], [2.0000, 2.0000, 2.0244, 2.0000, 2.0000], [3.0000, 3.0000, 3.0000, 3.0000, 3.0000], [4.0000, 4.0000, 4.0000, 4.0000, 4.0000]], [[0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [1.0000, 1.0000, 1.0000, 1.0000, 1.0000], [2.0000, 2.0000, 2.0000, 2.0000, 2.0000], [3.0000, 3.0000, 3.0000, 3.0000, 3.0000], [4.0000, 4.0000, 4.0000, 4.0000, 4.0000]]]]]]).to(device) coords, val = softargmax(input) assert_allclose(val, expected_val) assert_allclose(coords, expected_coord)
def gaussian_blur_mask(image: torch.Tensor, num_channels: int) -> torch.Tensor: mask = torch.stack([torch.as_tensor(image)] * num_channels, dim=0) kernel_size = int(np.random.choice(list(range(4))) * 2 + 1) # select random (but odd) kernel size sigma = np.random.uniform(0.1, 3) # select deviation return gaussian_blur2d(mask.unsqueeze(0), kernel_size=(kernel_size, kernel_size), sigma=(sigma, sigma)).squeeze(0).permute(1, 2, 0).clamp(0, 1)