예제 #1
0
 def __getitem__(self, idx):
     (image, mask) = self.pair[idx]
     x_tensor, y_tensor = self.ToTensor(
         image, MyFunctions.ImageRescale(mask, [0, 1]))
     return x_tensor, y_tensor
 def __getitem__(self, idx):
     (image, mask) = self.pair[idx]
     # only load the original noisy image channel
     x_tensor, y_tensor = self.ToTensor(
         image[0, :, :], MyFunctions.ImageRescale(mask, [0, 1]))
     return x_tensor, y_tensor
예제 #3
0
volume_sf = np.zeros([486, 1024, 500], dtype=np.float32)
volume_dn = np.zeros([486, 1024, 500], dtype=np.float32)

for step, [img, mask] in enumerate(test_loader):

    model.eval()
    with torch.no_grad():
        x = Variable(img).to(device)
        pred_y = model(x)

        pred_y = pred_y.detach().cpu().numpy()
        x = img.numpy()
        y = mask.numpy()

        volume_x[step, :, :] = x[0, 0, :, :500]
        volume_y[step, :, :] = MyFunctions.ImageRescale(
            y[0, 0, :, :500], [0, 255])
        volume_sf[step, :, :] = x[0, 2, :, :500]
        volume_dn[step, :, :] = MyFunctions.ImageRescale(
            pred_y[0, 0, :, :500], [0, 255])

        if step % 20 == 0:
            plt.figure(figsize=(18, 15))
            plt.subplot(1, 4, 1), plt.axis('off'),
            plt.imshow(x[0, 0, :, :], cmap='gray'), plt.title('noisy input')
            plt.subplot(1, 4, 2), plt.axis('off'),
            plt.imshow(x[0, 2, :, :], cmap='gray'), plt.title('self-fusion')
            plt.subplot(1, 4, 4), plt.axis('off'),
            plt.imshow(y[0, 0, :, :], cmap='gray'), plt.title('5-average')
            plt.subplot(1, 4, 3), plt.axis('off'),
            plt.imshow(pred_y[0, 0, :, :], cmap='gray'), plt.title('denoise')
            plt.show()
예제 #4
0
                   G_error.item(), D_x, D_G_z1, D_G_z2))
            print(
                'BCE_loss: %.4f\tL1_loss: %.4f\tL2_loss: %.4f' %
                (BCE_loss(output, label).item(), alpha *
                 L1_loss(fake_y, y).item(), beta * MSE_loss(fake_y, y).item()))

        netG.eval()

        if step == 0:
            with torch.no_grad():
                # Train data denoising
                denoise_train = netG(x).detach().cpu().numpy()
                noise_train = train_x.numpy()
                avg_train = train_y.numpy()

                img_x = MyFunctions.ImageRescale(noise_train[0, 0, :, :500],
                                                 [0, 255])
                img_y = MyFunctions.ImageRescale(avg_train[0, 0, :, :500],
                                                 [0, 255])
                img_sf = MyFunctions.ImageRescale(noise_train[0, 2, :, :500],
                                                  [0, 255])
                img_dn = MyFunctions.ImageRescale(denoise_train[0, 0, :, :500],
                                                  [0, 255])

                plt.figure(figsize=(18, 15))
                plt.subplot(1, 4, 1), plt.axis('off'),
                plt.imshow(img_x, cmap='gray'), plt.title('noisy')
                plt.subplot(1, 4, 2), plt.axis('off'),
                plt.imshow(img_sf, cmap='gray'), plt.title('self-fused')
                plt.subplot(1, 4, 3), plt.axis('off'),
                plt.imshow(img_dn, cmap='gray'), plt.title('denoised')
                plt.subplot(1, 4, 4), plt.axis('off'),