def model_predict(model, input_track, sample_size, trans_fw=None, trans_bw=None): dim = sample_size n_batches = int(len(input_track) / dim) - 1 pred_batches = input_track[0:n_batches * dim].reshape((-1, dim)) pred_batches_shifted = input_track[dim // 2:n_batches * dim + dim // 2].reshape((-1, dim)) print("FFT transforming...") if trans_fw is not None: pred_batches, pred_batches_shifted = map(lambda x: parallel_apply_along_axis(trans_fw, 0, x), (pred_batches, pred_batches_shifted)) if trans_bw is None: trans_bw = lambda x: x xfp = x_fade_profile(dim) print("Predicting and transforming...") pred_batches, pred_batches_shifted = map(lambda x: parallel_apply_along_axis(trans_bw, 0, model.predict(x)), (pred_batches, pred_batches_shifted)) print("Applying x-fade and mixing...") x0 = np.array([xfp * batch for batch in pred_batches]).reshape(-1) x1 = np.array([xfp * batch for batch in pred_batches_shifted]).reshape(-1) return mix_at(x0, x1, dim // 2)
def forward_stft(data, stft_sample_size=4096, stft_stride=256, window=None): stft_ix = np.arange(0, len(data) - stft_sample_size, stft_stride) stft_samples = [] for ix in stft_ix: sample = data[ix:ix + stft_sample_size] stft_samples.append(sample) stft_samples = np.array(stft_samples) if window is not None: if len(window) != stft_sample_size: raise ValueError(f"Number of samples in window parameter should match the sample size ({stft_sample_size})") stft_samples *= np.outer(np.ones(stft_samples.shape[0]), window) transformed = parallel_apply_along_axis(rfft, 0, stft_samples) return transformed
def backward_stft(data, stft_stride, window=None): n_stft_samples = data.shape[0] stft_sample_size = data.shape[1] overlap_factor = stft_stride / stft_sample_size stft_samples = parallel_apply_along_axis(irfft, 0, data) stft_samples *= overlap_factor out = np.zeros(stft_stride * n_stft_samples + stft_sample_size) for ii, sample in enumerate(stft_samples): i_begin = ii*stft_stride i_end = i_begin + stft_sample_size out[i_begin:i_end] += sample return out
def apply_fourier_on_input(input_track, window_size): n_batches = int(len(input_track) / window_size) batches = input_track[0:n_batches*window_size].reshape((-1, window_size)) return parallel_apply_along_axis(rfft, 0, batches)
def decoder_predict(decoder_model, encoded_x, trans_bw): return parallel_apply_along_axis(trans_bw, 0, decoder_model.predict(encoded_x)).reshape(-1)