def test_wavedecn_coeff_ravel(): # verify round trip is correct: # wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn # This is done for wavedec{1, 2, n} rng = np.random.RandomState(1234) params = {'wavedec': {'d': 1, 'dec': pywt.wavedec, 'rec': pywt.waverec}, 'wavedec2': {'d': 2, 'dec': pywt.wavedec2, 'rec': pywt.waverec2}, 'wavedecn': {'d': 3, 'dec': pywt.wavedecn, 'rec': pywt.waverecn}} N = 12 for f in params: x1 = rng.randn(*([N] * params[f]['d'])) for mode in pywt.Modes.modes: for wave in wavelist: w = pywt.Wavelet(wave) maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len) if maxlevel == 0: continue coeffs = params[f]['dec'](x1, w, mode=mode) coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes, output_format=f) x1r = params[f]['rec'](coeffs2, w, mode=mode) assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def hdot(self, x): """ Implements the adjoint i.e. image to coeffs. Per basis and band coefficients are raveled and padded so they can be stacked into a single array. """ beta = x[0] alpha = x[1] coeffs = np.zeros((self.nbasis + 1, self.nband, self.nmax)) coeffs[0] = np.pad(beta.reshape(self.nband, self.nx * self.ny), ((0, 0), (0, self.nmax - self.nx * self.ny)), mode='constant') for b in range(self.nbasis): base = self.bases[b] for l in range(self.nband): # decompose alphal = pywt.wavedecn(alpha[l], base, mode='zero', level=self.nlevels) # ravel and pad tmp, _, _ = pywt.ravel_coeffs(alphal) coeffs[b + 1, l] = np.pad(tmp / self.sqrtP, (0, self.nmax - self.ntot[b]), mode='constant') return coeffs
def scales(self): """Get the scales of each coefficient. Returns ------- scales : ``range`` element The scale of each coefficient, given by an integer. 0 for the lowest resolution and self.nlevels for the highest. """ if self.impl == 'pywt': if self.__variant == 'forward': discr_space = self.domain wavelet_space = self.range else: discr_space = self.range wavelet_space = self.domain shapes = pywt.wavedecn_shapes(discr_space.shape, self.pywt_wavelet, mode=self.pywt_pad_mode, level=self.nlevels, axes=self.axes) coeff_list = [np.full(shapes[0], 0)] for i in range(1, 1 + len(shapes[1:])): coeff_list.append( {k: np.full(shapes[i][k], i) for k in shapes[i].keys()}) coeffs = pywt.ravel_coeffs(coeff_list, axes=self.axes)[0] return wavelet_space.element(coeffs) else: raise RuntimeError("bad `impl` '{}'".format(self.impl))
def test_wavedecn_coeff_ravel(): # verify round trip is correct: # wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn # This is done for wavedec{1, 2, n} rng = np.random.RandomState(1234) params = {'wavedec': {'d': 1, 'dec': pywt.wavedec, 'rec': pywt.waverec}, 'wavedec2': {'d': 2, 'dec': pywt.wavedec2, 'rec': pywt.waverec2}, 'wavedecn': {'d': 3, 'dec': pywt.wavedecn, 'rec': pywt.waverecn}} N = 12 for f in params: x1 = rng.randn(*([N] * params[f]['d'])) for mode in pywt.Modes.modes: for wave in wavelist: w = pywt.Wavelet(wave) maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len) if maxlevel == 0: continue coeffs = params[f]['dec'](x1, w, mode=mode) coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes, output_format=f) x1r = params[f]['rec'](coeffs2, w, mode=mode) assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def decompose(self, y): """ WaveletTransformer.decompose(self, y) Computes and returns the 1d ravelled wavelet transform of y using the wavelet specified by self.wname. Inputs ------ y : self.dim numpy array A signal given a numpy array with ndim = self.dim wname : str Returns ------- coef_ravelled : 1d numpy array slices : list shapes : list Example ------- >>> # not tested: >>> x0 = np.random.randn(128) >>> wt = WaveletTransformer('db1', x0.ndim) >>> coefs, *aux_data = wt.decompose(x0) >>> print(coefs.ndim) """ assert (y.ndim == self.dim ), f"Expected y of dimension {self.dim} but got {y.ndim}." return wt.ravel_coeffs(self._wavedec(y, self.wname))
def __init__(self, imsize=None, nlevels=2, bases=['self', 'db1', 'db2', 'db3']): """ Sets up operators to move between wavelet coefficients in each basis and the image x. Parameters ---------- nband - number of bands nx - number of pixels in x-dimension ny - number of pixels in y-dimension nlevels - The level of the decomposition. Default=2 basis - List holding basis names. Default is db1-4 wavelets Supports any subset of ['self', 'db1', 'db2', 'db3', 'db4', 'db5', 'db6', 'db7', 'db8'] Returns ======= Psi - list of operators performing coeff to image where each entry corresponds to one of the basis elements. Psi_t - list of operators performing image to coeff where each entry corresponds to one of the basis elements. """ self.real_type = np.float64 if imsize is None: raise ValueError("You must initialise imsize") else: self.nband, self.nx, self.ny = imsize self.nlevels = nlevels self.P = len(bases) self.sqrtP = np.sqrt(self.P) self.bases = bases self.nbasis = len(bases) # do a mock decomposition to get max coeff size x = np.random.randn(self.nx, self.ny) self.ntot = [] self.iy = {} self.sy = {} for i, b in enumerate(bases): if b == 'self': alpha = x.flatten() y, iy, sy = x.flatten(), 0, 0 else: alpha = pywt.wavedecn(x, b, mode='zero', level=self.nlevels) y, iy, sy = pywt.ravel_coeffs(alpha) self.iy[b] = iy self.sy[b] = sy self.ntot.append(y.size) # get padding info self.nmax = np.asarray(self.ntot).max() self.padding = [] for i in range(self.nbasis): self.padding.append(slice(0, self.ntot[i]))
def _call(self, x): """Return wavelet transform of ``x``.""" if self.impl == 'pywt': coeffs = pywt.wavedecn( x, wavelet=self.pywt_wavelet, level=self.nlevels, mode=self.pywt_pad_mode, axes=self.axes) return pywt.ravel_coeffs(coeffs, axes=self.axes)[0] else: raise RuntimeError("bad `impl` '{}'".format(self.impl))
def test_swt_ravel_and_unravel(): # When trim_approx=True, all swt functions can user pywt.ravel_coeffs for ndim, _swt, _iswt, ravel_type in [(1, pywt.swt, pywt.iswt, 'swt'), (2, pywt.swt2, pywt.iswt2, 'swt2'), (3, pywt.swtn, pywt.iswtn, 'swtn')]: x = np.ones((16, ) * ndim) c = _swt(x, 'sym2', level=3, trim_approx=True) arr, slices, shapes = pywt.ravel_coeffs(c) c = pywt.unravel_coeffs(arr, slices, shapes, output_format=ravel_type) r = _iswt(c, 'sym2') assert_allclose(x, r)
def DWT_analyze(self, x, level=None, wavelet=None): if level is None: level = self.levels if wavelet is None: wavelet = self.wavelet decomposition_0 = pywt.wavedec(x[:, 0], wavelet=wavelet, level=level, mode="per") decomposition_1 = pywt.wavedec(x[:, 1], wavelet=wavelet, level=level, mode="per") coefs_0, slices, shapes = pywt.ravel_coeffs(decomposition_0) if self.slices is None: self.slices = slices if self.shapes is None: self.shapes = shapes if self.size is None: self.size = len(coefs_0) coefs_1, _, _ = pywt.ravel_coeffs(decomposition_1) coefs_0 = np.rint(coefs_0).astype(np.int32) coefs_1 = np.rint(coefs_1).astype(np.int32) return np.concatenate((coefs_0, coefs_1))
def test_unravel_invalid_inputs(): coeffs = pywt.wavedecn(np.ones(2), 'haar') arr, slices, shapes = pywt.ravel_coeffs(coeffs) # empty list for slices or shapes assert_raises(ValueError, pywt.unravel_coeffs, arr, slices, []) assert_raises(ValueError, pywt.unravel_coeffs, arr, [], shapes) # unequal length for slices/shapes assert_raises(ValueError, pywt.unravel_coeffs, arr, slices[:-1], shapes) # invalid format name assert_raises(ValueError, pywt.unravel_coeffs, arr, slices, shapes, 'foo')
def test_unravel_invalid_inputs(): coeffs = pywt.wavedecn(np.ones(2), 'haar') arr, slices, shapes = pywt.ravel_coeffs(coeffs) # empty list for slices or shapes assert_raises(ValueError, pywt.unravel_coeffs, arr, slices, []) assert_raises(ValueError, pywt.unravel_coeffs, arr, [], shapes) # unequal length for slices/shapes assert_raises(ValueError, pywt.unravel_coeffs, arr, slices[:-1], shapes) # invalid format name assert_raises(ValueError, pywt.unravel_coeffs, arr, slices, shapes, 'foo')
def _hdot_internal(x, bases, ntot, nmax, nlevels, sqrtP, nx, ny, real_type): nband = x.shape[0] nbasis = len(bases) alpha = np.zeros((nbasis, nband, nmax), dtype=real_type) for b in range(nbasis): base = bases[b] for l in range(nband): # decompose alphal = pywt.wavedecn(x[l], base, mode='zero', level=nlevels) # ravel and pad tmp, _, _ = pywt.ravel_coeffs(alphal) alpha[b, l] = np.pad(tmp / sqrtP, (0, nmax - ntot[b]), mode='constant') return alpha
def test_ravel_wavedec2_with_lists(): x1 = np.ones((8, 8)) wav = pywt.Wavelet('haar') coeffs = pywt.wavedec2(x1, wav) # list [cHn, cVn, cDn] instead of tuple is okay coeffs[1:] = [list(c) for c in coeffs[1:]] coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes, output_format='wavedec2') x1r = pywt.waverec2(coeffs2, wav) assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4) # wrong length list will cause a ValueError coeffs[1:] = [list(c[:-1]) for c in coeffs[1:]] # truncate diag coeffs assert_raises(ValueError, pywt.ravel_coeffs, coeffs)
def test_ravel_wavedec2_with_lists(): x1 = np.ones((8, 8)) wav = pywt.Wavelet('haar') coeffs = pywt.wavedec2(x1, wav) # list [cHn, cVn, cDn] instead of tuple is okay coeffs[1:] = [list(c) for c in coeffs[1:]] coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes, output_format='wavedec2') x1r = pywt.waverec2(coeffs2, wav) assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4) # wrong length list will cause a ValueError coeffs[1:] = [list(c[:-1]) for c in coeffs[1:]] # truncate diag coeffs assert_raises(ValueError, pywt.ravel_coeffs, coeffs)
def test_waverecn_coeff_ravel_odd(): # verify round trip is correct: # wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn rng = np.random.RandomState(1234) x1 = rng.randn(35, 33) for mode in pywt.Modes.modes: for wave in ['haar', ]: w = pywt.Wavelet(wave) maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len) if maxlevel == 0: continue coeffs = pywt.wavedecn(x1, w, mode=mode) coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes) x1r = pywt.waverecn(coeffs2, w, mode=mode) # truncate reconstructed values to original shape x1r = x1r[tuple([slice(s) for s in x1.shape])] assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def test_waverecn_coeff_ravel_odd(): # verify round trip is correct: # wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn rng = np.random.RandomState(1234) x1 = rng.randn(35, 33) for mode in pywt.Modes.modes: for wave in ['haar', ]: w = pywt.Wavelet(wave) maxlevel = pywt.dwt_max_level(np.min(x1.shape), w.dec_len) if maxlevel == 0: continue coeffs = pywt.wavedecn(x1, w, mode=mode) coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes) x1r = pywt.waverecn(coeffs2, w, mode=mode) # truncate reconstructed values to original shape x1r = x1r[tuple([slice(s) for s in x1.shape])] assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def wave(im): w = pywt.wavedec2(im, "bior3.5", level=2) h, s, sh= pywt.ravel_coeffs(w) e = [] h0 = h[s[0]] h0 = np.array(h0).reshape(sh[0][0],sh[0][1]) e0 = (1/(sh[0][0]*sh[0][1]))*sum(ndimage.laplace(h0).ravel()**2) e.append(e0) for key in s[1].keys(): hi = h[s[1][key]] e.append((1/len(hi))*sum(hi**2)) for key in s[2].keys(): hi = h[s[2][key]] e.append((1/len(hi))*sum(hi**2)) return e
def __init__(self, nband, nx, ny): """ Sets up operators to move between wavelet coefficients in each basis and the image x. Parameters ---------- nband - number of bands nx - number of pixels in x-dimension ny - number of pixels in y-dimension nlevels - The level of the decomposition. Default=2 bases - List holding basis names. Default is db1-8 wavelets """ self.real_type = np.float64 self.nband = nband self.nx = nx self.ny = ny self.nlevels = 3 self.bases = ['db1', 'db2', 'db3', 'db4', 'db5', 'db6', 'db7', 'db8'] self.P = len(self.bases) self.sqrtP = np.sqrt(self.P) self.nbasis = len(self.bases) # do a mock decomposition to get coefficient info x = np.random.randn(nx, ny) self.ntot = [] self.iy = {} self.sy = {} for i, b in enumerate(self.bases): alpha = pywt.wavedecn(x, b, mode='zero', level=self.nlevels) y, iy, sy = pywt.ravel_coeffs(alpha) self.iy[b] = iy self.sy[b] = sy self.ntot.append(y.size) # get padding info self.nmax = np.asarray(self.ntot).max() self.dpadding = slice(0, nx * ny) # Dirac slices/padding self.padding = [] for i in range(self.nbasis): self.padding.append(slice(0, self.ntot[i]))
def hdot(self, x): """ This implements the adjoint of Psi_func i.e. image to coeffs. Per basis and band coefficients are raveled padded so they can be stacked into a single array. """ alpha = np.zeros((self.nbasis, self.nband, self.nmax)) for b in range(self.nbasis): base = self.bases[b] for l in range(self.nband): if base == 'self': # just pad image to have same shape as flattened wavelet coefficients alpha[b, l] = np.pad(x[l].reshape(self.nx*self.ny)/self.sqrtP, (0, self.nmax-self.ntot[b]), mode='constant') else: # decompose alphal = pywt.wavedecn(x[l], base, mode='zero', level=self.nlevels) # ravel and pad tmp, _, _ = pywt.ravel_coeffs(alphal) alpha[b, l] = np.pad(tmp/self.sqrtP, (0, self.nmax-self.ntot[b]), mode='constant') return alpha
def test_wavedecn_coeff_ravel_zero_level(): # verify round trip is correct: # wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn # This is done for wavedec{1, 2, n} rng = np.random.RandomState(1234) params = {'wavedec': {'d': 1, 'dec': pywt.wavedec, 'rec': pywt.waverec}, 'wavedec2': {'d': 2, 'dec': pywt.wavedec2, 'rec': pywt.waverec2}, 'wavedecn': {'d': 3, 'dec': pywt.wavedecn, 'rec': pywt.waverecn}} N = 16 for f in params: x1 = rng.randn(*([N] * params[f]['d'])) for mode in pywt.Modes.modes: w = pywt.Wavelet('db2') coeffs = params[f]['dec'](x1, w, mode=mode, level=0) coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes, output_format=f) x1r = params[f]['rec'](coeffs2, w, mode=mode) assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def test_wavedecn_coeff_ravel_zero_level(): # verify round trip is correct: # wavedecn - >ravel_coeffs-> unravel_coeffs -> waverecn # This is done for wavedec{1, 2, n} rng = np.random.RandomState(1234) params = {'wavedec': {'d': 1, 'dec': pywt.wavedec, 'rec': pywt.waverec}, 'wavedec2': {'d': 2, 'dec': pywt.wavedec2, 'rec': pywt.waverec2}, 'wavedecn': {'d': 3, 'dec': pywt.wavedecn, 'rec': pywt.waverecn}} N = 16 for f in params: x1 = rng.randn(*([N] * params[f]['d'])) for mode in pywt.Modes.modes: w = pywt.Wavelet('db2') coeffs = params[f]['dec'](x1, w, mode=mode, level=0) coeff_arr, slices, shapes = pywt.ravel_coeffs(coeffs) coeffs2 = pywt.unravel_coeffs(coeff_arr, slices, shapes, output_format=f) x1r = params[f]['rec'](coeffs2, w, mode=mode) assert_allclose(x1, x1r, rtol=1e-4, atol=1e-4)
def dir_op(self, x): if (self.wav == 'dirac'): return np.ravel(x) if (self.wav == 'fourier'): return np.ravel(np.fft.fftn(x)) if (self.wav == "dct"): return np.ravel(scipy.fft.dctn(x, norm='ortho')) if (self.shape[0] % 2 == 1): raise Exception("Signal shape should be even dimensions.") if (len(self.shape) > 1): if (self.shape[1] % 2 == 1): raise Exception("Signal shape should be even dimensions.") coeffs = pywt.wavedecn(x, wavelet=self.wav, level=self.levels, mode='periodic', axes=self.axes) arr, self.coeff_slices, self.coeff_shapes = pywt.ravel_coeffs( coeffs, axes=self.axes) return arr
def pansharpenWavelet(self): '''function pansharpenWavelet(self): This is an instance method that returns a Python list of 3 or 4 NumPy arrays containing the pan-sharpened Red,Green,Blue, and optionally, NIR bands. These bands will have been created using the Wavelet pan-sharpening method Returns: list: Python list[] containing 3 or 4 NumPy arrays using wavelet method. ''' # set number of output bands (3 or 4, depending on if NIR is passed-in) if self.NIR is not None: d = 4 else: d = 3 # get 2D dimensions of output imagery nrows, ncols = self.pan.shape # create 3D data cube to perform wavelet pan-sharpening if d == 3: image = np.zeros((nrows, ncols, d), dtype=np.float16) image[:, :, 0] = self.red image[:, :, 1] = self.green image[:, :, 2] = self.blue elif d == 4: image = np.zeros((nrows, ncols, d), dtype=np.float16) image[:, :, 0] = self.red image[:, :, 1] = self.green image[:, :, 2] = self.blue image[:, :, 3] = self.NIR else: return [] level = 0 wavelet_type = 'haar' coeffs = pywt.wavedec2(self.pan, wavelet=wavelet_type, level=level) panvec, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs) reconstvec = np.tile(panvec.T, (d, 1)).T n = panvec.shape[0] lowresvec = np.zeros((n, d), dtype=np.float16) for band in range(d): lowresCoeffs = pywt.wavedec2(image[:, :, band], wavelet=wavelet_type, level=level) lowresArr, arrSlices = pywt.coeffs_to_array(lowresCoeffs) lowresvec[:, band] = np.reshape(lowresArr, (nrows * ncols, )) for j in range(0, coeff_shapes[0][0] * coeff_shapes[0][1]): reconstvec[j, :] = lowresvec[j, :] sharpened = np.zeros((nrows, ncols, d), dtype=np.float16) for band in range(d): p = np.reshape(reconstvec[:, band], (nrows, ncols)) fcoeffs = pywt.wavedec2(p, wavelet_type, level=level) out = pywt.waverec2(fcoeffs, wavelet_type) sharpened[:, :, band] = out redsharp = sharpened[:, :, 0] greensharp = sharpened[:, :, 1] bluesharp = sharpened[:, :, 2] if d == 4: NIRsharp = sharpened[:, :, 3] return [redsharp, greensharp, bluesharp, NIRsharp] elif d == 3: return [redsharp, greensharp, bluesharp] else: return []
# import matlab file using scipy wheat = scipy.io.loadmat('./wheat.mat') Xwave = np.zeros((0, 0)) X = wheat['WHEAT_SPECTRA'] (nVar, nSamp) = (len(X[0]), len(X)) wavelet = pywt.Wavelet('sym2') Lmax = pywt.dwt_max_level(nVar, wavelet) wavelets = [ 'db2', 'db3', 'db4', 'db5', 'db6', 'db7', 'db8', 'db9', 'db10', 'coif1', 'coif2', 'coif3', 'coif4', 'coif5', 'sym4', 'sym5', 'sym6', 'sym7', 'sym8', 'sym9', 'sym10' ] Lmaxs = [] for wave in wavelets: Lmaxs.append(pywt.dwt_max_level(nVar, wave)) Xwave = np.zeros((nSamp, 711)) # for each line in the dataset for i in range(0, nSamp): # coeffs is list of arrays with coefficients cA5 and cD5 to cD1 coeffs = wavedec(X[i, :], wavelet, level=4) # flatten coefficients into one line array C = pywt.ravel_coeffs(coeffs) C = C[0] # add coefficients to matrix of wavelet coefficients Xwave[i, 0:len(C)] = C
def train(args): mel_list = glob.glob(os.path.join(args.train_dir, '*.mel')) trainset = MelDataset(args.seq_len, mel_list, args.hop_length) train_loader = DataLoader(trainset, batch_size=args.batch_size, num_workers=0, shuffle=True, drop_last=True) test_mel = glob.glob(os.path.join(args.valid_dir, '*.mel')) testset = [] for i in range(args.test_num): mel = torch.load(test_mel[i]) mel = mel[:, :args.test_len] mel = mel.unsqueeze(0) testset.append(mel) G = Generator(80) D = MultiScale() G = G.cuda() D = D.cuda() g_optimizer = optim.Adam(G.parameters(), lr=1e-4, betas=(0.5, 0.9)) d_optimizer = optim.Adam(D.parameters(), lr=1e-4, betas=(0.5, 0.9)) step, epochs = 0, 0 if args.load_dir is not None: #print("Loading checkpoint") ckpt = torch.load(args.load_dir) G.load_state_dict(ckpt['G']) g_optimizer.load_state_dict(ckpt['g_optimizer']) D.load_state_dict(ckpt['D']) d_optimizer.load_state_dict(ckpt['d_optimizer']) step = ckpt['step'] epochs = ckpt['epoch'] ('Load Status: Epochs %d, Step %d' % (epochs, step)) torch.backends.cudnn.benchmark = True start = time.time() try: for epoch in itertools.count(epochs): for (mel, audio) in train_loader: mel = mel.cuda() coeffs = pywt.wavedecn(audio.squeeze(), 'db2', level=2) #,mode='symmetric' arr__, coeff_slices__, coeffs_shapes_ = pywt.ravel_coeffs( coeffs) arr__ = numpy.array([[arr__]]) arr3 = torch.from_numpy(arr__).float() audio = arr3.cuda() # Discriminator d_real = D(audio) d_loss_real = 0 for scale in d_real: d_loss_real += F.relu(1 - scale[-1]).mean() fake_audio = G(mel) ############################ fake_audio = (fake_audio.cuda()).detach().cpu().clone().numpy() #print(fake_audio.shape) coeffs2 = pywt.wavedecn(fake_audio.squeeze(), 'db2', level=2) arr2, coeff_slices2, coeff_shapes = pywt.ravel_coeffs(coeffs2) arr2 = numpy.array([[arr2]]) #for n in range(1, len(coeff_slices2)) : # slice_dict = coeff_slices2[n] # shape_dict = coeff_shapes[n] # print('slice : ', slice_dict) # print('shape : ', shape_dict) #print('d : ',coeff_slices2[0]['d'] + coeff_slices2[1]['d'] + coeff_slices2[2]['d']) #print('ad : ',arr2[coeff_slices2[1]['ad']]) #print('dd : ',arr2[coeff_slices2[1]['dd']]) #print(coeff_slices2) fake_audio = torch.from_numpy(arr2).float() #print(fake_audio.shape) ############################ d_fake = D(fake_audio.cuda().detach()) d_loss_fake = 0 for scale in d_fake: d_loss_fake += F.relu(1 + scale[-1]).mean() d_loss = d_loss_real + d_loss_fake D.zero_grad() d_loss.backward() d_optimizer.step() # Generator d_fake = D(fake_audio.cuda()) g_loss = 0 for scale in d_fake: g_loss += -scale[-1].mean() # Feature Matching feature_loss = 0 # feat_weights = 4.0 / 5.0 # discriminator block size + 1 # D_weights = 1.0 / 3.0 # multi scale size # wt = D_weights * feat_weights # not in paper for i in range(1): for j in range(len(d_fake[i]) - 1): feature_loss += F.l1_loss(d_fake[i][j], d_real[i][j].detach()) g_loss += args.lambda_feat * feature_loss G.zero_grad() g_loss.backward() g_optimizer.step() step += 1 if step % 1 == 0: print( 'Epoch: %-5d, Step: %-7d, D_loss: %.05f, G_loss: %.05f, ms/batch: %5.2f' % (epoch, step, d_loss, g_loss, 1000 * (time.time() - start) / args.log_interval)) start = time.time() if step % args.save_interval == 0: root = Path(args.save_dir) with torch.no_grad(): for i, mel_test in enumerate(testset): g_audio = G(mel_test.cuda()) g_audio = g_audio.squeeze().cpu() audio = (g_audio.numpy() * 32768) scipy.io.wavfile.write( root / ('generated-%d-%dk-%d.wav' % (epoch, step // 1000, i)), 22050, audio.astype('int16')) print("Saving checkpoint") torch.save( { 'G': G.state_dict(), 'g_optimizer': g_optimizer.state_dict(), 'D': D.state_dict(), 'd_optimizer': d_optimizer.state_dict(), 'step': step, 'epoch': epoch, }, root / ('ckpt-%dk.pt' % (step // 1000))) except Exception as e: traceback.print_exc()
def pansharpenWavelet(self): '''function pansharpenWavelet(self): This is an instance method that returns a Python list of 3 or 4 NumPy arrays containing the pan-sharpened Red,Green,Blue, and optionally, NIR bands. These bands will have been created using the Wavelet pan-sharpening method Returns: list: Python list[] containing 3 or 4 NumPy arrays using wavelet method. ''' # read Panchromatic,Multispectral Geotiffs into GDAL objects dsPan = gdal.Open(self.pan) dsMulti = gdal.Open(self.multi) # read Panchromatic,Red,Green,Blue bands into 2D NumPy arrays pan = dsPan.GetRasterBand(1).ReadAsArray() blue = dsMulti.GetRasterBand(3).ReadAsArray().astype(float) green = dsMulti.GetRasterBand(2).ReadAsArray().astype(float) red = dsMulti.GetRasterBand(1).ReadAsArray().astype(float) d = dsMulti.RasterCount nrows,ncols = pan.shape if d == 3: image = np.zeros((nrows,ncols,d),dtype=np.float32) image[:,:,0] = red image[:,:,1] = green image[:,:,2] = blue elif d == 4: NIR = dsMulti.GetRasterBand(1).ReadAsArray().astype(float) image[:,:,3] = NIR else: dsPan,dsMulti = None,None return [] level = 0 wavelet_type = 'haar' coeffs = pywt.wavedec2( pan, wavelet=wavelet_type, level=level) panvec,coeff_slices,coeff_shapes = pywt.ravel_coeffs(coeffs) reconstvec = np.tile( panvec.T , (d,1)).T n=panvec.shape[0] lowresvec = np.zeros((n,d),dtype=np.float32) for band in range(d): lowresCoeffs = pywt.wavedec2( image[:,:,band], wavelet=wavelet_type, level=level) lowresArr,arrSlices = pywt.coeffs_to_array(lowresCoeffs) lowresvec[:,band] = np.reshape(lowresArr,(nrows*ncols,)) for j in range( 0 , coeff_shapes[0][0] * coeff_shapes[0][1] ): reconstvec[ j,:] = lowresvec[j,:] sharpened = np.zeros((nrows,ncols,d),dtype=np.float32) for band in range(d): p = np.reshape( reconstvec[:,band], (nrows,ncols)) fcoeffs = pywt.wavedec2(p,wavelet_type,level=level) out=pywt.waverec2(fcoeffs,wavelet_type) sharpened[:,:,band] = out redsharp = sharpened[:,:,0] greensharp = sharpened[:,:,1] bluesharp = sharpened[:,:,2] if d == 4: NIRsharp = sharpened[:,:,3] return [redsharp,greensharp,bluesharp,NIRsharp] elif d == 3: return [redsharp,greensharp,bluesharp] else: return []
+-------------------------------+-------------------------------+ """ cam = pywt.data.camera() coeffs = pywt.wavedecn(cam, wavelet="db2", level=3) # Concatenating all coefficients into a single n-d array arr, coeff_slices = pywt.coeffs_to_array(coeffs) # Splitting concatenated coefficient array back into its components coeffs_from_arr = pywt.array_to_coeffs(arr, coeff_slices) cam_recon = pywt.waverecn(coeffs_from_arr, wavelet='db2') # Raveling coefficients to a 1D array arr, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs) # Unraveling coefficients from a 1D array coeffs_from_arr = pywt.unravel_coeffs(arr, coeff_slices, coeff_shapes) cam_recon2 = pywt.waverecn(coeffs_from_arr, wavelet='db2') # Multilevel: n-d coefficient shapes shapes = pywt.wavedecn_shapes((64, 32), 'db2', mode='periodization') # Multilevel: Total size of all coefficients size = pywt.wavedecn_size(shapes) print(size) print()