├── Experiments_Codes ├── README.md ├── Visualization.ipynb ├── module_spectrum.py ├── radialProfile.py └── train_spectrum.py ├── LICENSE ├── README.md └── imgs ├── .gitkeep ├── celeba.png ├── formula.PNG └── formula2.png /Experiments_Codes/README.md: -------------------------------------------------------------------------------- 1 | # Codes 2 | 3 | This folder contains the following files: 4 | 13 | -------------------------------------------------------------------------------- /Experiments_Codes/Visualization.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 5, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "LOAD\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "import numpy as np\n", 18 | "import matplotlib.pyplot as plt\n", 19 | "\n", 20 | "dcgan = np.load(\"DCGAN.npz\")\n", 21 | "dcgan = np.moveaxis(dcgan, 1,2)\n", 22 | "dcgan = np.moveaxis(dcgan, 2,3)\n", 23 | "\n", 24 | "dragan = np.load(\"DRAGAN.npz\")\n", 25 | "dragan = np.moveaxis(dragan, 1,2)\n", 26 | "dragan = np.moveaxis(dragan, 2,3)\n", 27 | "\n", 28 | "lsgan = np.load(\"LSGAN.npz\")\n", 29 | "lsgan = np.moveaxis(lsgan, 1,2)\n", 30 | "lsgan = np.moveaxis(lsgan, 2,3)\n", 31 | "\n", 32 | "wgan = np.load(\"WGAN.npz\")\n", 33 | "wgan = np.moveaxis(wgan, 1,2)\n", 34 | "wgan = np.moveaxis(wgan, 2,3)\n", 35 | "\n", 36 | "print(\"LOAD\")" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "import radialProfile\n", 46 | "import glob\n", 47 | "import cv2\n", 48 | "from scipy.interpolate import griddata\n", 49 | "\n", 50 | "## real data\n", 51 | "N = 88\n", 52 | "epsilon = 1e-8\n", 53 | "number_iter = 1000\n", 54 | "psd1D_total = np.zeros([number_iter, N])\n", 55 | "y = []\n", 56 | "error = []\n", 57 | "\n", 58 | "\n", 59 | "\n", 60 | "def RGB2gray(rgb):\n", 61 | " r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]\n", 62 | " gray = 0.2989 * r + 0.5870 * g + 0.1140 * b\n", 63 | " return gray\n", 64 | "\n", 65 | "# real\n", 66 | "psd1D_org_mean = np.zeros(N)\n", 67 | "psd1D_org_std = np.zeros(N)\n", 68 | "\n", 69 | "cont = 0\n", 70 | "rootdir = '/DATASETS/resized_celebA_128/celebA/'\n", 71 | "\n", 72 | "#-----------------\n", 73 | "# ----Original------\n", 74 | "#-----------------\n", 75 | "for filename in glob.glob(rootdir+\"*.jpg\"): \n", 76 | " img = cv2.imread(filename,0)\n", 77 | "\n", 78 | " f = np.fft.fft2(img)\n", 79 | " fshift = np.fft.fftshift(f)\n", 80 | " fshift += epsilon\n", 81 | "\n", 82 | " magnitude_spectrum = 20*np.log(np.abs(fshift))\n", 83 | "\n", 84 | " # Calculate the azimuthally averaged 1D power spectrum\n", 85 | " psd1D = radialProfile.azimuthalAverage(magnitude_spectrum)\n", 86 | " \n", 87 | " # Calculate the azimuthally averaged 1D power spectrum\n", 88 | " points = np.linspace(0,N,num=psd1D.size) # coordinates of a\n", 89 | " xi = np.linspace(0,N,num=N) # coordinates for interpolation\n", 90 | " interpolated = griddata(points,psd1D,xi,method='cubic')\n", 91 | " \n", 92 | " interpolated = (interpolated-np.min(interpolated))/(np.max(interpolated)-np.min(interpolated))\n", 93 | " psd1D_total[cont,:] = interpolated \n", 94 | " \n", 95 | " cont+=1\n", 96 | " \n", 97 | " if cont == number_iter:\n", 98 | " break\n", 99 | "\n", 100 | "\n", 101 | "for x in range(N):\n", 102 | " psd1D_org_mean[x] = np.mean(psd1D_total[:,x])\n", 103 | " psd1D_org_std[x] = np.std(psd1D_total[:,x])\n", 104 | "\n", 105 | "#-----------------\n", 106 | "# ----dcgan-------\n", 107 | "#-----------------\n", 108 | "psd1D_org_mean2= np.zeros(N)\n", 109 | "psd1D_org_std2= np.zeros(N)\n", 110 | "cont = 0\n", 111 | "\n", 112 | "\n", 113 | "for i in range(dcgan.shape[0]): \n", 114 | " \n", 115 | " img = RGB2gray(dcgan[i])\n", 116 | " f = np.fft.fft2(img)\n", 117 | " fshift = np.fft.fftshift(f)\n", 118 | " fshift += epsilon\n", 119 | "\n", 120 | " magnitude_spectrum = 20*np.log(np.abs(fshift))\n", 121 | "\n", 122 | " # Calculate the azimuthally averaged 1D power spectrum\n", 123 | " psd1D = radialProfile.azimuthalAverage(magnitude_spectrum)\n", 124 | " psd1D = (psd1D-np.min(psd1D))/(np.max(psd1D)-np.min(psd1D))\n", 125 | " psd1D_total[cont,:] = psd1D \n", 126 | "\n", 127 | " cont+=1\n", 128 | " \n", 129 | " if cont == number_iter:\n", 130 | " break\n", 131 | "\n", 132 | "\n", 133 | "for x in range(N):\n", 134 | " psd1D_org_mean2[x] = np.mean(psd1D_total[:,x])\n", 135 | " psd1D_org_std2[x]= np.std(psd1D_total[:,x])\n", 136 | " \n", 137 | "#-----------------\n", 138 | "# ----dragan------\n", 139 | "#-----------------\n", 140 | "psd1D_org_mean3= np.zeros(N)\n", 141 | "psd1D_org_std3= np.zeros(N)\n", 142 | "cont = 0\n", 143 | "\n", 144 | "\n", 145 | "for i in range(dragan.shape[0]): \n", 146 | " \n", 147 | " img = RGB2gray(dragan[i])\n", 148 | " f = np.fft.fft2(img)\n", 149 | " fshift = np.fft.fftshift(f)\n", 150 | " fshift += epsilon\n", 151 | "\n", 152 | " magnitude_spectrum = 20*np.log(np.abs(fshift))\n", 153 | "\n", 154 | " # Calculate the azimuthally averaged 1D power spectrum\n", 155 | " psd1D = radialProfile.azimuthalAverage(magnitude_spectrum)\n", 156 | " psd1D = (psd1D-np.min(psd1D))/(np.max(psd1D)-np.min(psd1D))\n", 157 | " psd1D_total[cont,:] = psd1D \n", 158 | "\n", 159 | " cont+=1\n", 160 | " \n", 161 | " if cont == number_iter:\n", 162 | " break\n", 163 | "\n", 164 | "\n", 165 | "for x in range(N):\n", 166 | " psd1D_org_mean3[x] = np.mean(psd1D_total[:,x])\n", 167 | " psd1D_org_std3[x]= np.std(psd1D_total[:,x])\n", 168 | " \n", 169 | "\n", 170 | "#-----------------\n", 171 | "# ----lsgan------\n", 172 | "#-----------------\n", 173 | "psd1D_org_mean4= np.zeros(N)\n", 174 | "psd1D_org_std4= np.zeros(N)\n", 175 | "cont = 0\n", 176 | "\n", 177 | "\n", 178 | "for i in range(lsgan.shape[0]): \n", 179 | " \n", 180 | " img = RGB2gray(lsgan[i])\n", 181 | " f = np.fft.fft2(img)\n", 182 | " fshift = np.fft.fftshift(f)\n", 183 | " fshift += epsilon\n", 184 | "\n", 185 | " magnitude_spectrum = 20*np.log(np.abs(fshift))\n", 186 | "\n", 187 | " # Calculate the azimuthally averaged 1D power spectrum\n", 188 | " psd1D = radialProfile.azimuthalAverage(magnitude_spectrum)\n", 189 | " psd1D = (psd1D-np.min(psd1D))/(np.max(psd1D)-np.min(psd1D))\n", 190 | " psd1D_total[cont,:] = psd1D \n", 191 | "\n", 192 | " cont+=1\n", 193 | " \n", 194 | " if cont == number_iter:\n", 195 | " break\n", 196 | " \n", 197 | "for x in range(N):\n", 198 | " psd1D_org_mean4[x] = np.mean(psd1D_total[:,x])\n", 199 | " psd1D_org_std4[x]= np.std(psd1D_total[:,x]) \n", 200 | "\n", 201 | " \n", 202 | "#-----------------\n", 203 | "# ----wgan-gp-----\n", 204 | "#-----------------\n", 205 | "psd1D_org_mean5= np.zeros(N)\n", 206 | "psd1D_org_std5= np.zeros(N)\n", 207 | "cont = 0\n", 208 | "\n", 209 | "\n", 210 | "for i in range(wgan.shape[0]): \n", 211 | " \n", 212 | " img = RGB2gray(wgan[i])\n", 213 | " f = np.fft.fft2(img)\n", 214 | " fshift = np.fft.fftshift(f)\n", 215 | " fshift += epsilon\n", 216 | "\n", 217 | " magnitude_spectrum = 20*np.log(np.abs(fshift))\n", 218 | "\n", 219 | " # Calculate the azimuthally averaged 1D power spectrum\n", 220 | " psd1D = radialProfile.azimuthalAverage(magnitude_spectrum)\n", 221 | " psd1D = (psd1D-np.min(psd1D))/(np.max(psd1D)-np.min(psd1D))\n", 222 | " psd1D_total[cont,:] = psd1D \n", 223 | "\n", 224 | " cont+=1\n", 225 | " \n", 226 | " if cont == number_iter:\n", 227 | " break\n", 228 | "\n", 229 | "for x in range(N):\n", 230 | " psd1D_org_mean5[x] = np.mean(psd1D_total[:,x])\n", 231 | " psd1D_org_std5[x]= np.std(psd1D_total[:,x]) \n", 232 | "\n", 233 | " \n", 234 | "y.append(psd1D_org_mean)\n", 235 | "y.append(psd1D_org_mean2)\n", 236 | "y.append(psd1D_org_mean3)\n", 237 | "y.append(psd1D_org_mean4)\n", 238 | "y.append(psd1D_org_mean5)\n", 239 | "\n", 240 | "error.append(psd1D_org_std)\n", 241 | "error.append(psd1D_org_std2)\n", 242 | "error.append(psd1D_org_std3)\n", 243 | "error.append(psd1D_org_std4)\n", 244 | "error.append(psd1D_org_std5)\n", 245 | "\n", 246 | "print(\"DONE\")" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": 7, 252 | "metadata": {}, 253 | "outputs": [ 254 | { 255 | "data": { 256 | "text/plain": [ 257 | "" 258 | ] 259 | }, 260 | "execution_count": 7, 261 | "metadata": {}, 262 | "output_type": "execute_result" 263 | }, 264 | { 265 | "data": { 266 | "image/png": "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\n", 267 | "text/plain": [ 268 | "
" 269 | ] 270 | }, 271 | "metadata": { 272 | "needs_background": "light" 273 | }, 274 | "output_type": "display_data" 275 | } 276 | ], 277 | "source": [ 278 | "x = np.arange(0, N, 1)\n", 279 | "fig, ax = plt.subplots(figsize=(15, 9))\n", 280 | "ax.plot(x, y[0], alpha=0.5, color='red', label='real', linewidth =2.0)\n", 281 | "ax.fill_between(x, y[0] - error[0], y[0] + error[0], color='red', alpha=0.2)\n", 282 | "\n", 283 | "ax.plot(x, y[1], alpha=0.5, color='blue', label='DCGAN', linewidth = 2.0)\n", 284 | "ax.fill_between(x, y[1] - error[1], y[1] + error[1], color='blue', alpha=0.2)\n", 285 | "\n", 286 | "ax.plot(x, y[2], alpha=0.5, color='green', label='DRAGAN', linewidth = 2.0)\n", 287 | "ax.fill_between(x, y[2] - error[2], y[2] + error[2], color='green', alpha=0.2)\n", 288 | "\n", 289 | "ax.plot(x, y[3], alpha=0.5, color='black', label='LSGAN', linewidth = 2.0)\n", 290 | "ax.fill_between(x, y[3] - error[3], y[3] + error[3], color='black', alpha=0.2)\n", 291 | "\n", 292 | "ax.plot(x, y[4], alpha=0.5, color='yellow', label='WGAN-GP', linewidth = 2.0)\n", 293 | "ax.fill_between(x, y[4] - error[4], y[4] + error[4], color='yellow', alpha=0.2)\n", 294 | "\n", 295 | "\n", 296 | "plt.xlabel('Spatial Frequency', fontsize=25)\n", 297 | "plt.ylabel('Power Spectrum', fontsize=25)\n", 298 | "plt.tick_params(axis='x', labelsize=20)\n", 299 | "plt.tick_params(axis='y', labelsize=20)\n", 300 | "\n", 301 | "ax.legend(loc='best', prop={'size': 25})" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [] 310 | } 311 | ], 312 | "metadata": { 313 | "kernelspec": { 314 | "display_name": "Python 3", 315 | "language": "python", 316 | "name": "python3" 317 | }, 318 | "language_info": { 319 | "codemirror_mode": { 320 | "name": "ipython", 321 | "version": 3 322 | }, 323 | "file_extension": ".py", 324 | "mimetype": "text/x-python", 325 | "name": "python", 326 | "nbconvert_exporter": "python", 327 | "pygments_lexer": "ipython3", 328 | "version": "3.6.7" 329 | } 330 | }, 331 | "nbformat": 4, 332 | "nbformat_minor": 4 333 | } 334 | -------------------------------------------------------------------------------- /Experiments_Codes/module_spectrum.py: -------------------------------------------------------------------------------- 1 | import functools 2 | 3 | import torchlib 4 | 5 | from torch import nn 6 | 7 | 8 | def _get_norm_layer_2d(norm): 9 | if norm == 'none': 10 | return torchlib.Identity 11 | elif norm == 'batch_norm': 12 | return nn.BatchNorm2d 13 | elif norm == 'instance_norm': 14 | return functools.partial(nn.InstanceNorm2d, affine=True) 15 | elif norm == 'layer_norm': 16 | return lambda num_features: nn.GroupNorm(1, num_features) 17 | else: 18 | raise NotImplementedError 19 | 20 | 21 | class ConvGenerator(nn.Module): 22 | 23 | def __init__(self, 24 | input_dim=128, 25 | output_channels=3, 26 | dim=32, 27 | n_upsamplings=4, 28 | norm='batch_norm'): 29 | super().__init__() 30 | 31 | Norm = _get_norm_layer_2d(norm) 32 | 33 | def dconv_norm_relu(in_dim, out_dim, kernel_size=4, stride=2, padding=1): 34 | return nn.Sequential( 35 | nn.ConvTranspose2d(in_dim, out_dim, kernel_size, stride=stride, padding=padding, bias=False or Norm == torchlib.Identity), 36 | Norm(out_dim), 37 | nn.ReLU() 38 | ) 39 | 40 | layers = [] 41 | 42 | # 1: 1x1 -> 4x4 43 | d = min(dim * 2 ** (n_upsamplings - 1), dim * 16) 44 | layers.append(dconv_norm_relu(input_dim, d, kernel_size=4, stride=1, padding=0)) 45 | 46 | # 2: upsamplings, 4x4 -> 8x8 -> 16x16 -> ... 47 | for i in range(n_upsamplings - 1): 48 | d_last = d 49 | d = min(dim * 2 ** (n_upsamplings - 2 - i), dim * 16) 50 | layers.append(dconv_norm_relu(d_last, d, kernel_size=4, stride=2, padding=1)) 51 | 52 | #layers.append(nn.ConvTranspose2d(d, d, kernel_size=4, stride=2, padding=1)) 53 | layers.append(nn.Upsample(scale_factor=2, mode='nearest')) 54 | layers.append(nn.Conv2d(d, d, kernel_size=5, stride=1, padding=2)) 55 | layers.append(nn.Conv2d(d, d, kernel_size=5, stride=1, padding=2)) 56 | layers.append(nn.Conv2d(d, output_channels, kernel_size=5, stride=1, padding=2)) 57 | 58 | layers.append(nn.Tanh()) 59 | 60 | self.net = nn.Sequential(*layers) 61 | 62 | def forward(self, z): 63 | x = self.net(z) 64 | return x 65 | 66 | 67 | class ConvDiscriminator(nn.Module): 68 | 69 | def __init__(self, 70 | input_channels=3, 71 | dim=32, 72 | n_downsamplings=4, 73 | norm='batch_norm'): 74 | super().__init__() 75 | 76 | Norm = _get_norm_layer_2d(norm) 77 | 78 | def conv_norm_lrelu(in_dim, out_dim, kernel_size=4, stride=2, padding=1): 79 | return nn.Sequential( 80 | nn.Conv2d(in_dim, out_dim, kernel_size, stride=stride, padding=padding, bias=False or Norm == torchlib.Identity), 81 | Norm(out_dim), 82 | nn.LeakyReLU(0.2) 83 | ) 84 | 85 | layers = [] 86 | 87 | # 1: downsamplings, ... -> 16x16 -> 8x8 -> 4x4 88 | d = dim 89 | layers.append(nn.Conv2d(input_channels, d, kernel_size=4, stride=2, padding=1)) 90 | layers.append(nn.LeakyReLU(0.2)) 91 | 92 | for i in range(n_downsamplings - 1): 93 | d_last = d 94 | d = min(dim * 2 ** (i + 1), dim * 16) 95 | layers.append(conv_norm_lrelu(d_last, d, kernel_size=4, stride=2, padding=1)) 96 | 97 | # 2: logit 98 | layers.append(nn.Conv2d(d, 1, kernel_size=4, stride=1, padding=0)) 99 | 100 | self.net = nn.Sequential(*layers) 101 | 102 | def forward(self, x): 103 | y = self.net(x) 104 | return y 105 | -------------------------------------------------------------------------------- /Experiments_Codes/radialProfile.py: -------------------------------------------------------------------------------- 1 | # from https://www.astrobetter.com/blog/2010/03/03/fourier-transforms-of-images-in-python/ 2 | import numpy as np 3 | 4 | def azimuthalAverage(image, center=None): 5 | """ 6 | Calculate the azimuthally averaged radial profile. 7 | 8 | image - The 2D image 9 | center - The [x,y] pixel coordinates used as the center. The default is 10 | None, which then uses the center of the image (including 11 | fracitonal pixels). 12 | 13 | """ 14 | # Calculate the indices from the image 15 | y, x = np.indices(image.shape) 16 | 17 | if not center: 18 | center = np.array([(x.max()-x.min())/2.0, (y.max()-y.min())/2.0]) 19 | 20 | r = np.hypot(x - center[0], y - center[1]) 21 | 22 | # Get sorted radii 23 | ind = np.argsort(r.flat) 24 | r_sorted = r.flat[ind] 25 | i_sorted = image.flat[ind] 26 | 27 | # Get the integer part of the radii (bin size = 1) 28 | r_int = r_sorted.astype(int) 29 | 30 | # Find all pixels that fall within each radial bin. 31 | deltar = r_int[1:] - r_int[:-1] # Assumes all radii represented 32 | rind = np.where(deltar)[0] # location of changed radius 33 | nr = rind[1:] - rind[:-1] # number of radius bin 34 | 35 | # Cumulative sum to figure out sums for each radius bin 36 | csim = np.cumsum(i_sorted, dtype=float) 37 | tbin = csim[rind[1:]] - csim[rind[:-1]] 38 | 39 | radial_prof = tbin / nr 40 | 41 | return radial_prof 42 | -------------------------------------------------------------------------------- /Experiments_Codes/train_spectrum.py: -------------------------------------------------------------------------------- 1 | 2 | import functools 3 | 4 | import imlib as im 5 | import numpy as np 6 | import pylib as py 7 | import torch 8 | from torch import nn 9 | import torchlib 10 | import torchprob as gan 11 | import tqdm 12 | from torch.autograd import Variable 13 | 14 | import data 15 | import module_spectrum as module 16 | import radialProfile 17 | 18 | 19 | # ============================================================================== 20 | # = param = 21 | # ============================================================================== 22 | 23 | # command line 24 | py.arg('--dataset', default='celeba', choices=['cifar10', 'fashion_mnist', 'mnist', 'celeba', 'anime', 'custom']) 25 | py.arg('--batch_size', type=int, default=64) 26 | py.arg('--epochs', type=int, default=10) 27 | py.arg('--lr', type=float, default=0.0002) 28 | py.arg('--lambda_freq', type=float, default=1e-5) 29 | py.arg('--beta_1', type=float, default=0.5) 30 | py.arg('--n_d', type=int, default=1) # # d updates per g update 31 | py.arg('--z_dim', type=int, default=128) 32 | py.arg('--adversarial_loss_mode', default='gan', choices=['gan', 'hinge_v1', 'hinge_v2', 'lsgan', 'wgan']) 33 | py.arg('--gradient_penalty_mode', default='none', choices=['none', 'dragan', 'dragan-lp', 'wgan-gp', 'wgan-lp']) 34 | py.arg('--gradient_penalty_weight', type=float, default=10.0) 35 | py.arg('--experiment_name', default='none') 36 | py.arg('--gradient_penalty_d_norm', default='layer_norm', choices=['instance_norm', 'layer_norm']) # !!! 37 | args = py.args() 38 | 39 | N = 88 40 | epsilon = 1e-8 41 | 42 | # output_dir 43 | if args.experiment_name == 'none': 44 | args.experiment_name = '%s_%s_9_15' % (args.dataset, args.adversarial_loss_mode) 45 | if args.gradient_penalty_mode != 'none': 46 | args.experiment_name += '_%s' % args.gradient_penalty_mode 47 | output_dir = py.join('output', args.experiment_name) 48 | py.mkdir(output_dir) 49 | 50 | 51 | # others 52 | use_gpu = torch.cuda.is_available() 53 | device = torch.device("cuda" if use_gpu else "cpu") 54 | 55 | 56 | # ============================================================================== 57 | # = data = 58 | # ============================================================================== 59 | 60 | # setup dataset 61 | if args.dataset in ['cifar10', 'fashion_mnist', 'mnist']: # 32x32 62 | data_loader, shape = data.make_32x32_dataset(args.dataset, args.batch_size, pin_memory=use_gpu) 63 | n_G_upsamplings = n_D_downsamplings = 3 64 | 65 | elif args.dataset == 'celeba': # 64x64 66 | img_paths = py.glob('/DATASETS/resized_celebA_128/celebA', '*.jpg') 67 | data_loader, shape = data.make_celeba_dataset(img_paths, args.batch_size, pin_memory=use_gpu) 68 | n_G_upsamplings = n_D_downsamplings = 5 69 | 70 | elif args.dataset == 'anime': # 64x64 71 | img_paths = py.glob('data/faces', '*.jpg') 72 | data_loader, shape = data.make_anime_dataset(img_paths, args.batch_size, pin_memory=use_gpu) 73 | n_G_upsamplings = n_D_downsamplings = 4 74 | 75 | elif args.dataset == 'custom': 76 | # ====================================== 77 | # = custom = 78 | # ====================================== 79 | img_paths = ... # image paths of custom dataset 80 | data_loader = data.make_custom_dataset(img_paths, args.batch_size, pin_memory=use_gpu) 81 | n_G_upsamplings = n_D_downsamplings = ... # 3 for 32x32 and 4 for 64x64 82 | # ====================================== 83 | # = custom = 84 | # ====================================== 85 | 86 | 87 | # ============================================================================== 88 | # = model = 89 | # ============================================================================== 90 | 91 | # setup the normalization function for discriminator 92 | if args.gradient_penalty_mode == 'none': 93 | d_norm = 'batch_norm' 94 | else: # cannot use batch normalization with gradient penalty 95 | d_norm = args.gradient_penalty_d_norm 96 | 97 | # networks 98 | G = module.ConvGenerator(args.z_dim, shape[-1], n_upsamplings=n_G_upsamplings).to(device) 99 | D = module.ConvDiscriminator(shape[-1], n_downsamplings=n_D_downsamplings, norm=d_norm).to(device) 100 | print(G) 101 | print(D) 102 | 103 | # adversarial_loss_functions 104 | d_loss_fn, g_loss_fn = gan.get_adversarial_losses_fn(args.adversarial_loss_mode) 105 | 106 | criterion_freq = nn.BCELoss() 107 | 108 | # optimizer 109 | G_optimizer = torch.optim.Adam(G.parameters(), lr=args.lr, betas=(args.beta_1, 0.999)) 110 | D_optimizer = torch.optim.Adam(D.parameters(), lr=args.lr, betas=(args.beta_1, 0.999)) 111 | 112 | def RGB2gray(rgb): 113 | r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2] 114 | gray = 0.2989 * r + 0.5870 * g + 0.1140 * b 115 | return gray 116 | 117 | # ============================================================================== 118 | # = train step = 119 | # ============================================================================== 120 | 121 | def train_G(x_real): 122 | G.train() 123 | D.train() 124 | 125 | z = torch.randn(args.batch_size, args.z_dim, 1, 1).to(device) 126 | x_fake = G(z) 127 | 128 | x_fake_d_logit = D(x_fake) 129 | g_loss = g_loss_fn(x_fake_d_logit) 130 | 131 | # fake image 1d power spectrum 132 | psd1D_img = np.zeros([x_fake.shape[0], N]) 133 | for t in range(x_fake.shape[0]): 134 | gen_imgs = x_fake.permute(0,2,3,1) 135 | img_numpy = gen_imgs[t,:,:,:].cpu().detach().numpy() 136 | img_gray = RGB2gray(img_numpy) 137 | fft = np.fft.fft2(img_gray) 138 | fshift = np.fft.fftshift(fft) 139 | fshift += epsilon 140 | magnitude_spectrum = 20*np.log(np.abs(fshift)) 141 | psd1D = radialProfile.azimuthalAverage(magnitude_spectrum) 142 | psd1D = (psd1D-np.min(psd1D))/(np.max(psd1D)-np.min(psd1D)) 143 | psd1D_img[t,:] = psd1D 144 | 145 | psd1D_img = torch.from_numpy(psd1D_img).float() 146 | psd1D_img = Variable(psd1D_img, requires_grad=True).to(device) 147 | 148 | # real image 1d power spectrum 149 | psd1D_rec = np.zeros([x_real.shape[0], N]) 150 | for t in range(x_real.shape[0]): 151 | gen_imgs = x_real.permute(0,2,3,1) 152 | img_numpy = gen_imgs[t,:,:,:].cpu().detach().numpy() 153 | img_gray = RGB2gray(img_numpy) 154 | fft = np.fft.fft2(img_gray) 155 | fshift = np.fft.fftshift(fft) 156 | fshift += epsilon 157 | magnitude_spectrum = 20*np.log(np.abs(fshift)) 158 | psd1D = radialProfile.azimuthalAverage(magnitude_spectrum) 159 | psd1D = (psd1D-np.min(psd1D))/(np.max(psd1D)-np.min(psd1D)) 160 | psd1D_rec[t,:] = psd1D 161 | 162 | psd1D_rec = torch.from_numpy(psd1D_rec).float() 163 | psd1D_rec = Variable(psd1D_rec, requires_grad=True).to(device) 164 | 165 | loss_freq = criterion_freq(psd1D_rec,psd1D_img.detach()) 166 | loss_freq *= g_loss 167 | 168 | G_loss = g_loss + args.lambda_freq*loss_freq 169 | 170 | G.zero_grad() 171 | G_loss.backward() 172 | G_optimizer.step() 173 | 174 | return {'g_loss': G_loss} 175 | 176 | 177 | def train_D(x_real): 178 | G.train() 179 | D.train() 180 | 181 | z = torch.randn(args.batch_size, args.z_dim, 1, 1).to(device) 182 | x_fake = G(z).detach() 183 | 184 | x_real_d_logit = D(x_real) 185 | x_fake_d_logit = D(x_fake) 186 | 187 | x_real_d_loss, x_fake_d_loss = d_loss_fn(x_real_d_logit, x_fake_d_logit) 188 | gp = gan.gradient_penalty(functools.partial(D), x_real, x_fake, mode=args.gradient_penalty_mode) 189 | 190 | D_loss = (x_real_d_loss + x_fake_d_loss) + gp * args.gradient_penalty_weight 191 | 192 | D.zero_grad() 193 | D_loss.backward() 194 | D_optimizer.step() 195 | 196 | return {'d_loss': x_real_d_loss + x_fake_d_loss, 'gp': gp} 197 | 198 | 199 | @torch.no_grad() 200 | def sample(z): 201 | G.eval() 202 | return G(z) 203 | 204 | 205 | # ============================================================================== 206 | # = run = 207 | # ============================================================================== 208 | 209 | # load checkpoint if exists 210 | ckpt_dir = py.join(output_dir, 'Checkpoints') 211 | py.mkdir(ckpt_dir) 212 | try: 213 | ckpt = torchlib.load_checkpoint(ckpt_dir) 214 | ep, it_d, it_g = ckpt['ep'], ckpt['it_d'], ckpt['it_g'] 215 | D.load_state_dict(ckpt['D']) 216 | G.load_state_dict(ckpt['G']) 217 | D_optimizer.load_state_dict(ckpt['D_optimizer']) 218 | G_optimizer.load_state_dict(ckpt['G_optimizer']) 219 | except: 220 | ep, it_d, it_g = 0, 0, 0 221 | 222 | 223 | # sample 224 | sample_dir = py.join(output_dir, 'samples_training') 225 | py.mkdir(sample_dir) 226 | 227 | # main loop 228 | z = torch.randn(100, args.z_dim, 1, 1).to(device) # a fixed noise for sampling 229 | 230 | for ep_ in tqdm.trange(args.epochs, desc='Epoch Loop'): 231 | if ep_ < ep: 232 | continue 233 | ep += 1 234 | 235 | # train for an epoch 236 | for x_real in tqdm.tqdm(data_loader, desc='Inner Epoch Loop'): 237 | x_real = x_real.to(device) 238 | 239 | D_loss_dict = train_D(x_real) 240 | it_d += 1 241 | 242 | if it_d % args.n_d == 0: 243 | G_loss_dict = train_G(x_real) 244 | it_g += 1 245 | 246 | # sample 247 | if it_g % 100 == 0: 248 | x_fake = sample(z) 249 | x_fake = np.transpose(x_fake.data.cpu().numpy(), (0, 2, 3, 1)) 250 | img = im.immerge(x_fake, n_rows=10).squeeze() 251 | im.imwrite(img, py.join(sample_dir, 'iter-%09d.jpg' % it_g)) 252 | 253 | # save checkpoint 254 | torchlib.save_checkpoint({'ep': ep, 'it_d': it_d, 'it_g': it_g, 255 | 'D': D.state_dict(), 256 | 'G': G.state_dict(), 257 | 'D_optimizer': D_optimizer.state_dict(), 258 | 'G_optimizer': G_optimizer.state_dict()}, 259 | py.join(ckpt_dir, 'Epoch_(%d).ckpt' % ep), 260 | max_keep=args.epochs) 261 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU General Public License is a free, copyleft license for 11 | software and other kinds of works. 12 | 13 | The licenses for most software and other practical works are designed 14 | to take away your freedom to share and change the works. By contrast, 15 | the GNU General Public License is intended to guarantee your freedom to 16 | share and change all versions of a program--to make sure it remains free 17 | software for all its users. We, the Free Software Foundation, use the 18 | GNU General Public License for most of our software; it applies also to 19 | any other work released this way by its authors. You can apply it to 20 | your programs, too. 21 | 22 | When we speak of free software, we are referring to freedom, not 23 | price. Our General Public Licenses are designed to make sure that you 24 | have the freedom to distribute copies of free software (and charge for 25 | them if you wish), that you receive source code or can get it if you 26 | want it, that you can change the software or use pieces of it in new 27 | free programs, and that you know you can do these things. 28 | 29 | To protect your rights, we need to prevent others from denying you 30 | these rights or asking you to surrender the rights. Therefore, you have 31 | certain responsibilities if you distribute copies of the software, or if 32 | you modify it: responsibilities to respect the freedom of others. 33 | 34 | For example, if you distribute copies of such a program, whether 35 | gratis or for a fee, you must pass on to the recipients the same 36 | freedoms that you received. You must make sure that they, too, receive 37 | or can get the source code. And you must show them these terms so they 38 | know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: 41 | (1) assert copyright on the software, and (2) offer you this License 42 | giving you legal permission to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains 45 | that there is no warranty for this free software. For both users' and 46 | authors' sake, the GPL requires that modified versions be marked as 47 | changed, so that their problems will not be attributed erroneously to 48 | authors of previous versions. 49 | 50 | Some devices are designed to deny users access to install or run 51 | modified versions of the software inside them, although the manufacturer 52 | can do so. This is fundamentally incompatible with the aim of 53 | protecting users' freedom to change the software. The systematic 54 | pattern of such abuse occurs in the area of products for individuals to 55 | use, which is precisely where it is most unacceptable. Therefore, we 56 | have designed this version of the GPL to prohibit the practice for those 57 | products. If such problems arise substantially in other domains, we 58 | stand ready to extend this provision to those domains in future versions 59 | of the GPL, as needed to protect the freedom of users. 60 | 61 | Finally, every program is threatened constantly by software patents. 62 | States should not allow patents to restrict development and use of 63 | software on general-purpose computers, but in those that do, we wish to 64 | avoid the special danger that patents applied to a free program could 65 | make it effectively proprietary. To prevent this, the GPL assures that 66 | patents cannot be used to render the program non-free. 67 | 68 | The precise terms and conditions for copying, distribution and 69 | modification follow. 70 | 71 | TERMS AND CONDITIONS 72 | 73 | 0. Definitions. 74 | 75 | "This License" refers to version 3 of the GNU General Public License. 76 | 77 | "Copyright" also means copyright-like laws that apply to other kinds of 78 | works, such as semiconductor masks. 79 | 80 | "The Program" refers to any copyrightable work licensed under this 81 | License. Each licensee is addressed as "you". "Licensees" and 82 | "recipients" may be individuals or organizations. 83 | 84 | To "modify" a work means to copy from or adapt all or part of the work 85 | in a fashion requiring copyright permission, other than the making of an 86 | exact copy. The resulting work is called a "modified version" of the 87 | earlier work or a work "based on" the earlier work. 88 | 89 | A "covered work" means either the unmodified Program or a work based 90 | on the Program. 91 | 92 | To "propagate" a work means to do anything with it that, without 93 | permission, would make you directly or secondarily liable for 94 | infringement under applicable copyright law, except executing it on a 95 | computer or modifying a private copy. Propagation includes copying, 96 | distribution (with or without modification), making available to the 97 | public, and in some countries other activities as well. 98 | 99 | To "convey" a work means any kind of propagation that enables other 100 | parties to make or receive copies. Mere interaction with a user through 101 | a computer network, with no transfer of a copy, is not conveying. 102 | 103 | An interactive user interface displays "Appropriate Legal Notices" 104 | to the extent that it includes a convenient and prominently visible 105 | feature that (1) displays an appropriate copyright notice, and (2) 106 | tells the user that there is no warranty for the work (except to the 107 | extent that warranties are provided), that licensees may convey the 108 | work under this License, and how to view a copy of this License. If 109 | the interface presents a list of user commands or options, such as a 110 | menu, a prominent item in the list meets this criterion. 111 | 112 | 1. Source Code. 113 | 114 | The "source code" for a work means the preferred form of the work 115 | for making modifications to it. "Object code" means any non-source 116 | form of a work. 117 | 118 | A "Standard Interface" means an interface that either is an official 119 | standard defined by a recognized standards body, or, in the case of 120 | interfaces specified for a particular programming language, one that 121 | is widely used among developers working in that language. 122 | 123 | The "System Libraries" of an executable work include anything, other 124 | than the work as a whole, that (a) is included in the normal form of 125 | packaging a Major Component, but which is not part of that Major 126 | Component, and (b) serves only to enable use of the work with that 127 | Major Component, or to implement a Standard Interface for which an 128 | implementation is available to the public in source code form. A 129 | "Major Component", in this context, means a major essential component 130 | (kernel, window system, and so on) of the specific operating system 131 | (if any) on which the executable work runs, or a compiler used to 132 | produce the work, or an object code interpreter used to run it. 133 | 134 | The "Corresponding Source" for a work in object code form means all 135 | the source code needed to generate, install, and (for an executable 136 | work) run the object code and to modify the work, including scripts to 137 | control those activities. However, it does not include the work's 138 | System Libraries, or general-purpose tools or generally available free 139 | programs which are used unmodified in performing those activities but 140 | which are not part of the work. For example, Corresponding Source 141 | includes interface definition files associated with source files for 142 | the work, and the source code for shared libraries and dynamically 143 | linked subprograms that the work is specifically designed to require, 144 | such as by intimate data communication or control flow between those 145 | subprograms and other parts of the work. 146 | 147 | The Corresponding Source need not include anything that users 148 | can regenerate automatically from other parts of the Corresponding 149 | Source. 150 | 151 | The Corresponding Source for a work in source code form is that 152 | same work. 153 | 154 | 2. Basic Permissions. 155 | 156 | All rights granted under this License are granted for the term of 157 | copyright on the Program, and are irrevocable provided the stated 158 | conditions are met. This License explicitly affirms your unlimited 159 | permission to run the unmodified Program. The output from running a 160 | covered work is covered by this License only if the output, given its 161 | content, constitutes a covered work. This License acknowledges your 162 | rights of fair use or other equivalent, as provided by copyright law. 163 | 164 | You may make, run and propagate covered works that you do not 165 | convey, without conditions so long as your license otherwise remains 166 | in force. You may convey covered works to others for the sole purpose 167 | of having them make modifications exclusively for you, or provide you 168 | with facilities for running those works, provided that you comply with 169 | the terms of this License in conveying all material for which you do 170 | not control copyright. Those thus making or running the covered works 171 | for you must do so exclusively on your behalf, under your direction 172 | and control, on terms that prohibit them from making any copies of 173 | your copyrighted material outside their relationship with you. 174 | 175 | Conveying under any other circumstances is permitted solely under 176 | the conditions stated below. Sublicensing is not allowed; section 10 177 | makes it unnecessary. 178 | 179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 180 | 181 | No covered work shall be deemed part of an effective technological 182 | measure under any applicable law fulfilling obligations under article 183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 184 | similar laws prohibiting or restricting circumvention of such 185 | measures. 186 | 187 | When you convey a covered work, you waive any legal power to forbid 188 | circumvention of technological measures to the extent such circumvention 189 | is effected by exercising rights under this License with respect to 190 | the covered work, and you disclaim any intention to limit operation or 191 | modification of the work as a means of enforcing, against the work's 192 | users, your or third parties' legal rights to forbid circumvention of 193 | technological measures. 194 | 195 | 4. Conveying Verbatim Copies. 196 | 197 | You may convey verbatim copies of the Program's source code as you 198 | receive it, in any medium, provided that you conspicuously and 199 | appropriately publish on each copy an appropriate copyright notice; 200 | keep intact all notices stating that this License and any 201 | non-permissive terms added in accord with section 7 apply to the code; 202 | keep intact all notices of the absence of any warranty; and give all 203 | recipients a copy of this License along with the Program. 204 | 205 | You may charge any price or no price for each copy that you convey, 206 | and you may offer support or warranty protection for a fee. 207 | 208 | 5. Conveying Modified Source Versions. 209 | 210 | You may convey a work based on the Program, or the modifications to 211 | produce it from the Program, in the form of source code under the 212 | terms of section 4, provided that you also meet all of these conditions: 213 | 214 | a) The work must carry prominent notices stating that you modified 215 | it, and giving a relevant date. 216 | 217 | b) The work must carry prominent notices stating that it is 218 | released under this License and any conditions added under section 219 | 7. This requirement modifies the requirement in section 4 to 220 | "keep intact all notices". 221 | 222 | c) You must license the entire work, as a whole, under this 223 | License to anyone who comes into possession of a copy. This 224 | License will therefore apply, along with any applicable section 7 225 | additional terms, to the whole of the work, and all its parts, 226 | regardless of how they are packaged. This License gives no 227 | permission to license the work in any other way, but it does not 228 | invalidate such permission if you have separately received it. 229 | 230 | d) If the work has interactive user interfaces, each must display 231 | Appropriate Legal Notices; however, if the Program has interactive 232 | interfaces that do not display Appropriate Legal Notices, your 233 | work need not make them do so. 234 | 235 | A compilation of a covered work with other separate and independent 236 | works, which are not by their nature extensions of the covered work, 237 | and which are not combined with it such as to form a larger program, 238 | in or on a volume of a storage or distribution medium, is called an 239 | "aggregate" if the compilation and its resulting copyright are not 240 | used to limit the access or legal rights of the compilation's users 241 | beyond what the individual works permit. Inclusion of a covered work 242 | in an aggregate does not cause this License to apply to the other 243 | parts of the aggregate. 244 | 245 | 6. Conveying Non-Source Forms. 246 | 247 | You may convey a covered work in object code form under the terms 248 | of sections 4 and 5, provided that you also convey the 249 | machine-readable Corresponding Source under the terms of this License, 250 | in one of these ways: 251 | 252 | a) Convey the object code in, or embodied in, a physical product 253 | (including a physical distribution medium), accompanied by the 254 | Corresponding Source fixed on a durable physical medium 255 | customarily used for software interchange. 256 | 257 | b) Convey the object code in, or embodied in, a physical product 258 | (including a physical distribution medium), accompanied by a 259 | written offer, valid for at least three years and valid for as 260 | long as you offer spare parts or customer support for that product 261 | model, to give anyone who possesses the object code either (1) a 262 | copy of the Corresponding Source for all the software in the 263 | product that is covered by this License, on a durable physical 264 | medium customarily used for software interchange, for a price no 265 | more than your reasonable cost of physically performing this 266 | conveying of source, or (2) access to copy the 267 | Corresponding Source from a network server at no charge. 268 | 269 | c) Convey individual copies of the object code with a copy of the 270 | written offer to provide the Corresponding Source. This 271 | alternative is allowed only occasionally and noncommercially, and 272 | only if you received the object code with such an offer, in accord 273 | with subsection 6b. 274 | 275 | d) Convey the object code by offering access from a designated 276 | place (gratis or for a charge), and offer equivalent access to the 277 | Corresponding Source in the same way through the same place at no 278 | further charge. You need not require recipients to copy the 279 | Corresponding Source along with the object code. If the place to 280 | copy the object code is a network server, the Corresponding Source 281 | may be on a different server (operated by you or a third party) 282 | that supports equivalent copying facilities, provided you maintain 283 | clear directions next to the object code saying where to find the 284 | Corresponding Source. Regardless of what server hosts the 285 | Corresponding Source, you remain obligated to ensure that it is 286 | available for as long as needed to satisfy these requirements. 287 | 288 | e) Convey the object code using peer-to-peer transmission, provided 289 | you inform other peers where the object code and Corresponding 290 | Source of the work are being offered to the general public at no 291 | charge under subsection 6d. 292 | 293 | A separable portion of the object code, whose source code is excluded 294 | from the Corresponding Source as a System Library, need not be 295 | included in conveying the object code work. 296 | 297 | A "User Product" is either (1) a "consumer product", which means any 298 | tangible personal property which is normally used for personal, family, 299 | or household purposes, or (2) anything designed or sold for incorporation 300 | into a dwelling. In determining whether a product is a consumer product, 301 | doubtful cases shall be resolved in favor of coverage. For a particular 302 | product received by a particular user, "normally used" refers to a 303 | typical or common use of that class of product, regardless of the status 304 | of the particular user or of the way in which the particular user 305 | actually uses, or expects or is expected to use, the product. A product 306 | is a consumer product regardless of whether the product has substantial 307 | commercial, industrial or non-consumer uses, unless such uses represent 308 | the only significant mode of use of the product. 309 | 310 | "Installation Information" for a User Product means any methods, 311 | procedures, authorization keys, or other information required to install 312 | and execute modified versions of a covered work in that User Product from 313 | a modified version of its Corresponding Source. The information must 314 | suffice to ensure that the continued functioning of the modified object 315 | code is in no case prevented or interfered with solely because 316 | modification has been made. 317 | 318 | If you convey an object code work under this section in, or with, or 319 | specifically for use in, a User Product, and the conveying occurs as 320 | part of a transaction in which the right of possession and use of the 321 | User Product is transferred to the recipient in perpetuity or for a 322 | fixed term (regardless of how the transaction is characterized), the 323 | Corresponding Source conveyed under this section must be accompanied 324 | by the Installation Information. But this requirement does not apply 325 | if neither you nor any third party retains the ability to install 326 | modified object code on the User Product (for example, the work has 327 | been installed in ROM). 328 | 329 | The requirement to provide Installation Information does not include a 330 | requirement to continue to provide support service, warranty, or updates 331 | for a work that has been modified or installed by the recipient, or for 332 | the User Product in which it has been modified or installed. Access to a 333 | network may be denied when the modification itself materially and 334 | adversely affects the operation of the network or violates the rules and 335 | protocols for communication across the network. 336 | 337 | Corresponding Source conveyed, and Installation Information provided, 338 | in accord with this section must be in a format that is publicly 339 | documented (and with an implementation available to the public in 340 | source code form), and must require no special password or key for 341 | unpacking, reading or copying. 342 | 343 | 7. Additional Terms. 344 | 345 | "Additional permissions" are terms that supplement the terms of this 346 | License by making exceptions from one or more of its conditions. 347 | Additional permissions that are applicable to the entire Program shall 348 | be treated as though they were included in this License, to the extent 349 | that they are valid under applicable law. If additional permissions 350 | apply only to part of the Program, that part may be used separately 351 | under those permissions, but the entire Program remains governed by 352 | this License without regard to the additional permissions. 353 | 354 | When you convey a copy of a covered work, you may at your option 355 | remove any additional permissions from that copy, or from any part of 356 | it. (Additional permissions may be written to require their own 357 | removal in certain cases when you modify the work.) You may place 358 | additional permissions on material, added by you to a covered work, 359 | for which you have or can give appropriate copyright permission. 360 | 361 | Notwithstanding any other provision of this License, for material you 362 | add to a covered work, you may (if authorized by the copyright holders of 363 | that material) supplement the terms of this License with terms: 364 | 365 | a) Disclaiming warranty or limiting liability differently from the 366 | terms of sections 15 and 16 of this License; or 367 | 368 | b) Requiring preservation of specified reasonable legal notices or 369 | author attributions in that material or in the Appropriate Legal 370 | Notices displayed by works containing it; or 371 | 372 | c) Prohibiting misrepresentation of the origin of that material, or 373 | requiring that modified versions of such material be marked in 374 | reasonable ways as different from the original version; or 375 | 376 | d) Limiting the use for publicity purposes of names of licensors or 377 | authors of the material; or 378 | 379 | e) Declining to grant rights under trademark law for use of some 380 | trade names, trademarks, or service marks; or 381 | 382 | f) Requiring indemnification of licensors and authors of that 383 | material by anyone who conveys the material (or modified versions of 384 | it) with contractual assumptions of liability to the recipient, for 385 | any liability that these contractual assumptions directly impose on 386 | those licensors and authors. 387 | 388 | All other non-permissive additional terms are considered "further 389 | restrictions" within the meaning of section 10. If the Program as you 390 | received it, or any part of it, contains a notice stating that it is 391 | governed by this License along with a term that is a further 392 | restriction, you may remove that term. If a license document contains 393 | a further restriction but permits relicensing or conveying under this 394 | License, you may add to a covered work material governed by the terms 395 | of that license document, provided that the further restriction does 396 | not survive such relicensing or conveying. 397 | 398 | If you add terms to a covered work in accord with this section, you 399 | must place, in the relevant source files, a statement of the 400 | additional terms that apply to those files, or a notice indicating 401 | where to find the applicable terms. 402 | 403 | Additional terms, permissive or non-permissive, may be stated in the 404 | form of a separately written license, or stated as exceptions; 405 | the above requirements apply either way. 406 | 407 | 8. Termination. 408 | 409 | You may not propagate or modify a covered work except as expressly 410 | provided under this License. Any attempt otherwise to propagate or 411 | modify it is void, and will automatically terminate your rights under 412 | this License (including any patent licenses granted under the third 413 | paragraph of section 11). 414 | 415 | However, if you cease all violation of this License, then your 416 | license from a particular copyright holder is reinstated (a) 417 | provisionally, unless and until the copyright holder explicitly and 418 | finally terminates your license, and (b) permanently, if the copyright 419 | holder fails to notify you of the violation by some reasonable means 420 | prior to 60 days after the cessation. 421 | 422 | Moreover, your license from a particular copyright holder is 423 | reinstated permanently if the copyright holder notifies you of the 424 | violation by some reasonable means, this is the first time you have 425 | received notice of violation of this License (for any work) from that 426 | copyright holder, and you cure the violation prior to 30 days after 427 | your receipt of the notice. 428 | 429 | Termination of your rights under this section does not terminate the 430 | licenses of parties who have received copies or rights from you under 431 | this License. If your rights have been terminated and not permanently 432 | reinstated, you do not qualify to receive new licenses for the same 433 | material under section 10. 434 | 435 | 9. Acceptance Not Required for Having Copies. 436 | 437 | You are not required to accept this License in order to receive or 438 | run a copy of the Program. Ancillary propagation of a covered work 439 | occurring solely as a consequence of using peer-to-peer transmission 440 | to receive a copy likewise does not require acceptance. However, 441 | nothing other than this License grants you permission to propagate or 442 | modify any covered work. These actions infringe copyright if you do 443 | not accept this License. Therefore, by modifying or propagating a 444 | covered work, you indicate your acceptance of this License to do so. 445 | 446 | 10. Automatic Licensing of Downstream Recipients. 447 | 448 | Each time you convey a covered work, the recipient automatically 449 | receives a license from the original licensors, to run, modify and 450 | propagate that work, subject to this License. You are not responsible 451 | for enforcing compliance by third parties with this License. 452 | 453 | An "entity transaction" is a transaction transferring control of an 454 | organization, or substantially all assets of one, or subdividing an 455 | organization, or merging organizations. If propagation of a covered 456 | work results from an entity transaction, each party to that 457 | transaction who receives a copy of the work also receives whatever 458 | licenses to the work the party's predecessor in interest had or could 459 | give under the previous paragraph, plus a right to possession of the 460 | Corresponding Source of the work from the predecessor in interest, if 461 | the predecessor has it or can get it with reasonable efforts. 462 | 463 | You may not impose any further restrictions on the exercise of the 464 | rights granted or affirmed under this License. For example, you may 465 | not impose a license fee, royalty, or other charge for exercise of 466 | rights granted under this License, and you may not initiate litigation 467 | (including a cross-claim or counterclaim in a lawsuit) alleging that 468 | any patent claim is infringed by making, using, selling, offering for 469 | sale, or importing the Program or any portion of it. 470 | 471 | 11. Patents. 472 | 473 | A "contributor" is a copyright holder who authorizes use under this 474 | License of the Program or a work on which the Program is based. The 475 | work thus licensed is called the contributor's "contributor version". 476 | 477 | A contributor's "essential patent claims" are all patent claims 478 | owned or controlled by the contributor, whether already acquired or 479 | hereafter acquired, that would be infringed by some manner, permitted 480 | by this License, of making, using, or selling its contributor version, 481 | but do not include claims that would be infringed only as a 482 | consequence of further modification of the contributor version. For 483 | purposes of this definition, "control" includes the right to grant 484 | patent sublicenses in a manner consistent with the requirements of 485 | this License. 486 | 487 | Each contributor grants you a non-exclusive, worldwide, royalty-free 488 | patent license under the contributor's essential patent claims, to 489 | make, use, sell, offer for sale, import and otherwise run, modify and 490 | propagate the contents of its contributor version. 491 | 492 | In the following three paragraphs, a "patent license" is any express 493 | agreement or commitment, however denominated, not to enforce a patent 494 | (such as an express permission to practice a patent or covenant not to 495 | sue for patent infringement). To "grant" such a patent license to a 496 | party means to make such an agreement or commitment not to enforce a 497 | patent against the party. 498 | 499 | If you convey a covered work, knowingly relying on a patent license, 500 | and the Corresponding Source of the work is not available for anyone 501 | to copy, free of charge and under the terms of this License, through a 502 | publicly available network server or other readily accessible means, 503 | then you must either (1) cause the Corresponding Source to be so 504 | available, or (2) arrange to deprive yourself of the benefit of the 505 | patent license for this particular work, or (3) arrange, in a manner 506 | consistent with the requirements of this License, to extend the patent 507 | license to downstream recipients. "Knowingly relying" means you have 508 | actual knowledge that, but for the patent license, your conveying the 509 | covered work in a country, or your recipient's use of the covered work 510 | in a country, would infringe one or more identifiable patents in that 511 | country that you have reason to believe are valid. 512 | 513 | If, pursuant to or in connection with a single transaction or 514 | arrangement, you convey, or propagate by procuring conveyance of, a 515 | covered work, and grant a patent license to some of the parties 516 | receiving the covered work authorizing them to use, propagate, modify 517 | or convey a specific copy of the covered work, then the patent license 518 | you grant is automatically extended to all recipients of the covered 519 | work and works based on it. 520 | 521 | A patent license is "discriminatory" if it does not include within 522 | the scope of its coverage, prohibits the exercise of, or is 523 | conditioned on the non-exercise of one or more of the rights that are 524 | specifically granted under this License. You may not convey a covered 525 | work if you are a party to an arrangement with a third party that is 526 | in the business of distributing software, under which you make payment 527 | to the third party based on the extent of your activity of conveying 528 | the work, and under which the third party grants, to any of the 529 | parties who would receive the covered work from you, a discriminatory 530 | patent license (a) in connection with copies of the covered work 531 | conveyed by you (or copies made from those copies), or (b) primarily 532 | for and in connection with specific products or compilations that 533 | contain the covered work, unless you entered into that arrangement, 534 | or that patent license was granted, prior to 28 March 2007. 535 | 536 | Nothing in this License shall be construed as excluding or limiting 537 | any implied license or other defenses to infringement that may 538 | otherwise be available to you under applicable patent law. 539 | 540 | 12. No Surrender of Others' Freedom. 541 | 542 | If conditions are imposed on you (whether by court order, agreement or 543 | otherwise) that contradict the conditions of this License, they do not 544 | excuse you from the conditions of this License. If you cannot convey a 545 | covered work so as to satisfy simultaneously your obligations under this 546 | License and any other pertinent obligations, then as a consequence you may 547 | not convey it at all. For example, if you agree to terms that obligate you 548 | to collect a royalty for further conveying from those to whom you convey 549 | the Program, the only way you could satisfy both those terms and this 550 | License would be to refrain entirely from conveying the Program. 551 | 552 | 13. Use with the GNU Affero General Public License. 553 | 554 | Notwithstanding any other provision of this License, you have 555 | permission to link or combine any covered work with a work licensed 556 | under version 3 of the GNU Affero General Public License into a single 557 | combined work, and to convey the resulting work. The terms of this 558 | License will continue to apply to the part which is the covered work, 559 | but the special requirements of the GNU Affero General Public License, 560 | section 13, concerning interaction through a network will apply to the 561 | combination as such. 562 | 563 | 14. Revised Versions of this License. 564 | 565 | The Free Software Foundation may publish revised and/or new versions of 566 | the GNU General Public License from time to time. Such new versions will 567 | be similar in spirit to the present version, but may differ in detail to 568 | address new problems or concerns. 569 | 570 | Each version is given a distinguishing version number. If the 571 | Program specifies that a certain numbered version of the GNU General 572 | Public License "or any later version" applies to it, you have the 573 | option of following the terms and conditions either of that numbered 574 | version or of any later version published by the Free Software 575 | Foundation. If the Program does not specify a version number of the 576 | GNU General Public License, you may choose any version ever published 577 | by the Free Software Foundation. 578 | 579 | If the Program specifies that a proxy can decide which future 580 | versions of the GNU General Public License can be used, that proxy's 581 | public statement of acceptance of a version permanently authorizes you 582 | to choose that version for the Program. 583 | 584 | Later license versions may give you additional or different 585 | permissions. However, no additional obligations are imposed on any 586 | author or copyright holder as a result of your choosing to follow a 587 | later version. 588 | 589 | 15. Disclaimer of Warranty. 590 | 591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 599 | 600 | 16. Limitation of Liability. 601 | 602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 610 | SUCH DAMAGES. 611 | 612 | 17. Interpretation of Sections 15 and 16. 613 | 614 | If the disclaimer of warranty and limitation of liability provided 615 | above cannot be given local legal effect according to their terms, 616 | reviewing courts shall apply local law that most closely approximates 617 | an absolute waiver of all civil liability in connection with the 618 | Program, unless a warranty or assumption of liability accompanies a 619 | copy of the Program in return for a fee. 620 | 621 | END OF TERMS AND CONDITIONS 622 | 623 | How to Apply These Terms to Your New Programs 624 | 625 | If you develop a new program, and you want it to be of the greatest 626 | possible use to the public, the best way to achieve this is to make it 627 | free software which everyone can redistribute and change under these terms. 628 | 629 | To do so, attach the following notices to the program. It is safest 630 | to attach them to the start of each source file to most effectively 631 | state the exclusion of warranty; and each file should have at least 632 | the "copyright" line and a pointer to where the full notice is found. 633 | 634 | 635 | Copyright (C) 636 | 637 | This program is free software: you can redistribute it and/or modify 638 | it under the terms of the GNU General Public License as published by 639 | the Free Software Foundation, either version 3 of the License, or 640 | (at your option) any later version. 641 | 642 | This program is distributed in the hope that it will be useful, 643 | but WITHOUT ANY WARRANTY; without even the implied warranty of 644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 645 | GNU General Public License for more details. 646 | 647 | You should have received a copy of the GNU General Public License 648 | along with this program. If not, see . 649 | 650 | Also add information on how to contact you by electronic and paper mail. 651 | 652 | If the program does terminal interaction, make it output a short 653 | notice like this when it starts in an interactive mode: 654 | 655 | Copyright (C) 656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 657 | This is free software, and you are welcome to redistribute it 658 | under certain conditions; type `show c' for details. 659 | 660 | The hypothetical commands `show w' and `show c' should show the appropriate 661 | parts of the General Public License. Of course, your program's commands 662 | might be different; for a GUI interface, you would use an "about box". 663 | 664 | You should also get your employer (if you work as a programmer) or school, 665 | if any, to sign a "copyright disclaimer" for the program, if necessary. 666 | For more information on this, and how to apply and follow the GNU GPL, see 667 | . 668 | 669 | The GNU General Public License does not permit incorporating your program 670 | into proprietary programs. If your program is a subroutine library, you 671 | may consider it more useful to permit linking proprietary applications with 672 | the library. If this is what you want to do, use the GNU Lesser General 673 | Public License instead of this License. But first, please read 674 | . 675 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # [Watch your Up-Convolution: CNN Based Generative Deep Neural Networks are Failing to Reproduce Spectral Distributions](https://arxiv.org/abs/2003.01826) 2 | 3 | This repository provides the official Python implementation of Watch your Up-Convolution: CNN Based Generative Deep Neural Networks are Failing to Reproduce Spectral Distributions (Paper: [https://arxiv.org/abs/2003.01826](https://arxiv.org/abs/2003.01826)). 4 | 5 | 6 | 7 | Common up-convolution methods are inducing 8 | heavy spectral distortions into generated images. (Left) 9 | Statistics (mean and variance) after azimuthal 10 | integration over the power-spectrum of real and GAN generated images. 11 | (Right) Results of the same experiments as above, adding 12 | our proposed spectral loss during GAN training. 13 | 14 | 15 | ## Spectral Regularization 16 | 17 | Since common generative network architectures are 18 | mostly exclusively using image-space based loss functions, 19 | it is not possible to capture and correct spectral distortions 20 | directly. Hence, we extend existing GAN architectures in two ways: 21 | 22 |
    23 |
  • Spectral loss term
    • 24 |

    25 | 26 |

    27 |
  • Replace last last up-convolution unit.
    • 28 |

    29 | 30 |

    31 |
32 | 33 | ## Dependencies 34 | Tested on Python 3.6.x. 35 | * [Pytorch](https://pytorch.org/get-started/previous-versions/) (1.1.0) 36 | * [NumPy](http://www.numpy.org/) (1.16.2) 37 | * [Opencv](https://opencv.org/opencv-4-0/) (4.0.0) 38 | * [Matplotlib](https://matplotlib.org/) (3.1.1) 39 | 40 | ## Downloading Dataset 41 | 42 | Link to download [CelebA](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html) dataset. 43 | 44 | ## Training Netwroks 45 | 46 | ### Training vanilla models 47 | We train different GAN models using this [repo](https://github.com/LynnHo/DCGAN-LSGAN-WGAN-GP-DRAGAN-Pytorch). Then, we employ our Visualization script to analyse the frequency behaviour. 48 | 49 | ### Training Spectral Regularization models 50 | Make the following changes to incorporate the regularizer. Then, train the model. 51 |
    52 |
  • Substitue train.py for train_spectrum.py
    • 53 |
  • Substitue module.py for module_spectrum.py
    • 54 |
55 | 56 | Click [here](/Experiments_Codes) to go the Regularization implementation. 57 | 58 | # Deepfake detection 59 | Experiments and code for the deepfake detection parts of the paper can be found in the repository of our prior Arxiv pre-print. 60 | * Paper: [https://arxiv.org/abs/1911.00686](https://arxiv.org/abs/1911.00686) 61 | * Code: [https://github.com/cc-hpc-itwm/DeepFakeDetection](https://github.com/cc-hpc-itwm/DeepFakeDetection) 62 | 63 | # Citation 64 | If this work is useful for your research, please cite our [paper](https://arxiv.org/abs/2003.01826): 65 | ``` 66 | @misc{durall2020upconv, 67 | title={Watch your Up-Convolution: CNN Based Generative Deep Neural Networks are Failing to Reproduce Spectral Distributions}, 68 | author={Ricard Durall and Margret Keuper and Janis Keuper}, 69 | year={2020}, 70 | eprint={2003.01826}, 71 | archivePrefix={arXiv}, 72 | primaryClass={cs.LG} 73 | } 74 | ``` 75 | -------------------------------------------------------------------------------- /imgs/.gitkeep: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /imgs/celeba.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cc-hpc-itwm/UpConv/999b8569d830fce9b46d6f6e5e075e196e017d9c/imgs/celeba.png -------------------------------------------------------------------------------- /imgs/formula.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cc-hpc-itwm/UpConv/999b8569d830fce9b46d6f6e5e075e196e017d9c/imgs/formula.PNG -------------------------------------------------------------------------------- /imgs/formula2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cc-hpc-itwm/UpConv/999b8569d830fce9b46d6f6e5e075e196e017d9c/imgs/formula2.png --------------------------------------------------------------------------------