Python numpy.abs() Examples
The following are 30
code examples of numpy.abs().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.

Example #1
Source File: test.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 6 votes |
def _project_im_rois(im_rois, scales): """Project image RoIs into the image pyramid built by _get_image_blob. Arguments: im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates scales (list): scale factors as returned by _get_image_blob Returns: rois (ndarray): R x 4 matrix of projected RoI coordinates levels (list): image pyramid levels used by each projected RoI """ im_rois = im_rois.astype(np.float, copy=False) if len(scales) > 1: widths = im_rois[:, 2] - im_rois[:, 0] + 1 heights = im_rois[:, 3] - im_rois[:, 1] + 1 areas = widths * heights scaled_areas = areas[:, np.newaxis] * (scales[np.newaxis, :] ** 2) diff_areas = np.abs(scaled_areas - 224 * 224) levels = diff_areas.argmin(axis=1)[:, np.newaxis] else: levels = np.zeros((im_rois.shape[0], 1), dtype=np.int) rois = im_rois * scales[levels] return rois, levels
Example #2
Source File: test_train.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 6 votes |
def _project_im_rois(im_rois, scales): """Project image RoIs into the image pyramid built by _get_image_blob. Arguments: im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates scales (list): scale factors as returned by _get_image_blob Returns: rois (ndarray): R x 4 matrix of projected RoI coordinates levels (list): image pyramid levels used by each projected RoI """ im_rois = im_rois.astype(np.float, copy=False) if len(scales) > 1: widths = im_rois[:, 2] - im_rois[:, 0] + 1 heights = im_rois[:, 3] - im_rois[:, 1] + 1 areas = widths * heights scaled_areas = areas[:, np.newaxis] * (scales[np.newaxis, :] ** 2) diff_areas = np.abs(scaled_areas - 224 * 224) levels = diff_areas.argmin(axis=1)[:, np.newaxis] else: levels = np.zeros((im_rois.shape[0], 1), dtype=np.int) rois = im_rois * scales[levels] return rois, levels
Example #3
Source File: system_eq.py From BiblioPixelAnimations with MIT License | 6 votes |
def get_audio_data(self): frames = self.rec.get_frames() result = [0] * self.bins if len(frames) > 0: # keeps only the last frame current_frame = frames[-1] # plots the time signal # self.line_top.set_data(self.time_vect, current_frame) # computes and plots the fft signal fft_frame = np.fft.rfft(current_frame) if self.auto_gain: fft_frame /= np.abs(fft_frame).max() else: fft_frame *= (1 + self.gain) / 5000000. fft_frame = np.abs(fft_frame) if self.log_scale: fft_frame = np.log10(np.add(1, np.multiply(10, fft_frame))) result = [min(int(max(i, 0.) * 1023), 1023) for i in fft_frame][0:self.bins] return result
Example #4
Source File: system_eq.py From BiblioPixelAnimations with MIT License | 6 votes |
def get_audio_data(self): frames = self.rec.get_frames() result = [0] * self.bins if len(frames) > 0: # keeps only the last frame current_frame = frames[-1] # plots the time signal # self.line_top.set_data(self.time_vect, current_frame) # computes and plots the fft signal fft_frame = np.fft.rfft(current_frame) if self.auto_gain: fft_frame /= np.abs(fft_frame).max() else: fft_frame *= (1 + self.gain) / 5000000. fft_frame = np.abs(fft_frame) if self.log_scale: fft_frame = np.log10(np.add(1, np.multiply(10, fft_frame))) result = [min(int(max(i, 0.) * 1023), 1023) for i in fft_frame][0:self.bins] return result
Example #5
Source File: LWS.py From Griffin_lim with MIT License | 6 votes |
def main(): data_foler = "data" wavs = [os.path.join(data_foler, file[:-4]) for file in os.listdir(data_foler) if file.endswith(".wav")] outputs_lws = [file + ".lws.gen.wav" for file in wavs] wavs = [audio.load_wav(wav_path + ".wav", hparams.sample_rate) for wav_path in wavs] lws_processor = lws.lws(512, 128, mode="speech") # 512: window length; 128: window shift i = 0 for x in wavs: X = lws_processor.stft(x) # where x is a single-channel waveform X0 = np.abs(X) # Magnitude spectrogram print('{:6}: {:5.2f} dB'.format('Abs(X)', lws_processor.get_consistency(X0))) X1 = lws_processor.run_lws( X0) # reconstruction from magnitude (in general, one can reconstruct from an initial complex spectrogram) print(X1.shape) print('{:6}: {:5.2f} dB'.format('LWS', lws_processor.get_consistency(X1))) print(X1.shape) wav = lws_processor.istft(X1).astype(np.float32) audio.save_wav(wav, outputs_lws[i]) i += 1
Example #6
Source File: dataloader.py From models with MIT License | 6 votes |
def _extract(self, intervals, out, **kwargs): def find_closest(ldm, interval, use_strand=True): """Uses """ # subset the positions to the appropriate strand # and extract the positions ldm_positions = ldm.loc[interval.chrom] if use_strand and interval.strand != ".": ldm_positions = ldm_positions.loc[interval.strand] ldm_positions = ldm_positions.position.values int_midpoint = (interval.end + interval.start) // 2 dist = (ldm_positions - 1) - int_midpoint # -1 for 0, 1 indexed positions if use_strand and interval.strand == "-": dist = - dist return dist[np.argmin(np.abs(dist))] out[:] = np.array([[find_closest(self.landmarks[ldm_name], interval, self.use_strand) for ldm_name in self.columns] for interval in intervals], dtype=float) return out
Example #7
Source File: gla_gpu.py From Deep_VoiceChanger with MIT License | 6 votes |
def __init__(self, parallel, wave_len=254, wave_dif=64, buffer_size=5, loop_num=5, window=np.hanning(254)): self.wave_len = wave_len self.wave_dif = wave_dif self.buffer_size = buffer_size self.loop_num = loop_num self.parallel = parallel self.window = cp.array([window for _ in range(parallel)]) self.wave_buf = cp.zeros((parallel, wave_len+wave_dif), dtype=float) self.overwrap_buf = cp.zeros((parallel, wave_dif*buffer_size+(wave_len-wave_dif)), dtype=float) self.spectrum_buffer = cp.ones((parallel, self.buffer_size, self.wave_len), dtype=complex) self.absolute_buffer = cp.ones((parallel, self.buffer_size, self.wave_len), dtype=complex) self.phase = cp.zeros((parallel, self.wave_len), dtype=complex) self.phase += cp.random.random((parallel, self.wave_len))-0.5 + cp.random.random((parallel, self.wave_len))*1j - 0.5j self.phase[self.phase == 0] = 1 self.phase /= cp.abs(self.phase)
Example #8
Source File: gla_util.py From Deep_VoiceChanger with MIT License | 6 votes |
def __init__(self, wave_len=254, wave_dif=64, buffer_size=5, loop_num=5, window=np.hanning(254)): self.wave_len = wave_len self.wave_dif = wave_dif self.buffer_size = buffer_size self.loop_num = loop_num self.window = window self.wave_buf = np.zeros(wave_len+wave_dif, dtype=float) self.overwrap_buf = np.zeros(wave_dif*buffer_size+(wave_len-wave_dif), dtype=float) self.spectrum_buffer = np.ones((self.buffer_size, self.wave_len), dtype=complex) self.absolute_buffer = np.ones((self.buffer_size, self.wave_len), dtype=complex) self.phase = np.zeros(self.wave_len, dtype=complex) self.phase += np.random.random(self.wave_len)-0.5 + np.random.random(self.wave_len)*1j - 0.5j self.phase[self.phase == 0] = 1 self.phase /= np.abs(self.phase)
Example #9
Source File: dataset.py From Deep_VoiceChanger with MIT License | 6 votes |
def wave2input_image(wave, window, pos=0, pad=0): wave_image = np.hstack([wave[pos+i*sride:pos+(i+pad*2)*sride+dif].reshape(height+pad*2, sride) for i in range(256//sride)])[:,:254] wave_image *= window spectrum_image = np.fft.fft(wave_image, axis=1) input_image = np.abs(spectrum_image[:,:128].reshape(1, height+pad*2, 128), dtype=np.float32) np.clip(input_image, 1000, None, out=input_image) np.log(input_image, out=input_image) input_image += bias input_image /= scale if np.max(input_image) > 0.95: print('input image max bigger than 0.95', np.max(input_image)) if np.min(input_image) < 0.05: print('input image min smaller than 0.05', np.min(input_image)) return input_image
Example #10
Source File: mel_features.py From sklearn-audio-transfer-learning with ISC License | 6 votes |
def stft_magnitude(signal, fft_length, hop_length=None, window_length=None): """Calculate the short-time Fourier transform magnitude. Args: signal: 1D np.array of the input time-domain signal. fft_length: Size of the FFT to apply. hop_length: Advance (in samples) between each frame passed to FFT. window_length: Length of each block of samples to pass to FFT. Returns: 2D np.array where each row contains the magnitudes of the fft_length/2+1 unique values of the FFT for the corresponding frame of input samples. """ frames = frame(signal, window_length, hop_length) # Apply frame window to each frame. We use a periodic Hann (cosine of period # window_length) instead of the symmetric Hann of np.hanning (period # window_length-1). window = periodic_hann(window_length) windowed_frames = frames * window return np.abs(np.fft.rfft(windowed_frames, int(fft_length))) # Mel spectrum constants and functions.
Example #11
Source File: core.py From neuropythy with GNU Affero General Public License v3.0 | 6 votes |
def jacobian(self, p, into=None): # transpose to be 3 x 2 x n p = np.transpose(np.reshape(p, (-1, 3, 2)), (1,2,0)) # First, get the two legs... (dx_ab, dy_ab) = p[1] - p[0] (dx_ac, dy_ac) = p[2] - p[0] (dx_bc, dy_bc) = p[2] - p[1] # now, the area is half the z-value of the cross-product... sarea0 = 0.5 * (dx_ab*dy_ac - dx_ac*dy_ab) # but we want to abs it dsarea0 = np.sign(sarea0) z = np.transpose([[-dy_bc,dx_bc], [dy_ac,-dx_ac], [-dy_ab,dx_ab]], (2,0,1)) z = times(0.5*dsarea0, z) m = numel(p) n = p.shape[2] ii = (np.arange(n) * np.ones([6, n])).T.flatten() z = sps.csr_matrix((z.flatten(), (ii, np.arange(len(ii)))), shape=(n, m)) return safe_into(into, z)
Example #12
Source File: Collection.py From fullrmc with GNU Affero General Public License v3.0 | 6 votes |
def is_integer(number, precision=10e-10): """ Check if number is convertible to integer. :Parameters: #. number (str, number): Input number. #. precision (number): To avoid floating errors, a precision should be given. :Returns: #. result (bool): True if convertible, False otherwise. """ if isinstance(number, (int, long)): return True try: number = float(number) except: return False else: if np.abs(number-int(number)) < precision: return True else: return False
Example #13
Source File: metric.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def update(self, labels, preds): """Updates the internal evaluation result. Parameters ---------- labels : list of `NDArray` The labels of the data. preds : list of `NDArray` Predicted values. """ labels, preds = check_label_shapes(labels, preds, True) for label, pred in zip(labels, preds): label = label.asnumpy() pred = pred.asnumpy() if len(label.shape) == 1: label = label.reshape(label.shape[0], 1) if len(pred.shape) == 1: pred = pred.reshape(pred.shape[0], 1) self.sum_metric += numpy.abs(label - pred).mean() self.num_inst += 1 # numpy.prod(label.shape)
Example #14
Source File: test_quantization.py From dynamic-training-with-apache-mxnet-on-aws with Apache License 2.0 | 6 votes |
def test_quantize_float32_to_int8(): shape = rand_shape_nd(4) data = rand_ndarray(shape, 'default', dtype='float32') min_range = mx.nd.min(data) max_range = mx.nd.max(data) qdata, min_val, max_val = mx.nd.contrib.quantize(data, min_range, max_range, out_type='int8') data_np = data.asnumpy() min_range = min_range.asscalar() max_range = max_range.asscalar() real_range = np.maximum(np.abs(min_range), np.abs(max_range)) quantized_range = 127.0 scale = quantized_range / real_range assert qdata.dtype == np.int8 assert min_val.dtype == np.float32 assert max_val.dtype == np.float32 assert same(min_val.asscalar(), -real_range) assert same(max_val.asscalar(), real_range) qdata_np = (np.sign(data_np) * np.minimum(np.abs(data_np) * scale + 0.5, quantized_range)).astype(np.int8) assert_almost_equal(qdata.asnumpy(), qdata_np, atol = 1)
Example #15
Source File: graph_utils.py From DOTA_models with Apache License 2.0 | 6 votes |
def heuristic_fn_vec(n1, n2, n_ori, step_size): # n1 is a vector and n2 is a single point. dx = (n1[:,0] - n2[0,0])/step_size dy = (n1[:,1] - n2[0,1])/step_size dt = n1[:,2] - n2[0,2] dt = np.mod(dt, n_ori) dt = np.minimum(dt, n_ori-dt) if n_ori == 6: if dx*dy > 0: d = np.maximum(np.abs(dx), np.abs(dy)) else: d = np.abs(dy-dx) elif n_ori == 4: d = np.abs(dx) + np.abs(dy) return (d + dt).reshape((-1,1))
Example #16
Source File: minitaur_gym_env.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def _reward(self): current_base_position = self.minitaur.GetBasePosition() forward_reward = current_base_position[0] - self._last_base_position[0] # Cap the forward reward if a cap is set. forward_reward = min(forward_reward, self._forward_reward_cap) # Penalty for sideways translation. drift_reward = -abs(current_base_position[1] - self._last_base_position[1]) # Penalty for sideways rotation of the body. orientation = self.minitaur.GetBaseOrientation() rot_matrix = pybullet.getMatrixFromQuaternion(orientation) local_up_vec = rot_matrix[6:] shake_reward = -abs(np.dot(np.asarray([1, 1, 0]), np.asarray(local_up_vec))) energy_reward = -np.abs( np.dot(self.minitaur.GetMotorTorques(), self.minitaur.GetMotorVelocities())) * self._time_step objectives = [forward_reward, energy_reward, drift_reward, shake_reward] weighted_objectives = [ o * w for o, w in zip(objectives, self._objective_weights) ] reward = sum(weighted_objectives) self._objectives.append(objectives) return reward
Example #17
Source File: minitaur_gym_env.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def _reward(self): current_base_position = self.minitaur.GetBasePosition() forward_reward = current_base_position[0] - self._last_base_position[0] drift_reward = -abs(current_base_position[1] - self._last_base_position[1]) shake_reward = -abs(current_base_position[2] - self._last_base_position[2]) self._last_base_position = current_base_position energy_reward = np.abs( np.dot(self.minitaur.GetMotorTorques(), self.minitaur.GetMotorVelocities())) * self._time_step reward = ( self._distance_weight * forward_reward - self._energy_weight * energy_reward + self._drift_weight * drift_reward + self._shake_weight * shake_reward) self._objectives.append( [forward_reward, energy_reward, drift_reward, shake_reward]) return reward
Example #18
Source File: minitaur_duck_gym_env.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def _reward(self): current_base_position = self.minitaur.GetBasePosition() forward_reward = current_base_position[0] - self._last_base_position[0] drift_reward = -abs(current_base_position[1] - self._last_base_position[1]) shake_reward = -abs(current_base_position[2] - self._last_base_position[2]) self._last_base_position = current_base_position energy_reward = np.abs( np.dot(self.minitaur.GetMotorTorques(), self.minitaur.GetMotorVelocities())) * self._time_step reward = ( self._distance_weight * forward_reward - self._energy_weight * energy_reward + self._drift_weight * drift_reward + self._shake_weight * shake_reward) self._objectives.append( [forward_reward, energy_reward, drift_reward, shake_reward]) return reward
Example #19
Source File: gym_manipulator_envs.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def _step(self, a): assert (not self.scene.multiplayer) self.robot.apply_action(a) self.scene.global_step() state = self.robot.calc_state() # sets self.to_target_vec potential_old = self.potential self.potential = self.robot.calc_potential() electricity_cost = ( -0.10 * (np.abs(a[0] * self.robot.theta_dot) + np.abs(a[1] * self.robot.gamma_dot)) # work torque*angular_velocity - 0.01 * (np.abs(a[0]) + np.abs(a[1])) # stall torque require some energy ) stuck_joint_cost = -0.1 if np.abs(np.abs(self.robot.gamma) - 1) < 0.01 else 0.0 self.rewards = [float(self.potential - potential_old), float(electricity_cost), float(stuck_joint_cost)] self.HUD(state, a, False) return state, sum(self.rewards), False, {}
Example #20
Source File: run_audio_attack.py From Black-Box-Audio with MIT License | 5 votes |
def db(audio): if len(audio.shape) > 1: maxx = np.max(np.abs(audio), axis=1) return 20 * np.log10(maxx) if np.any(maxx != 0) else np.array([0]) maxx = np.max(np.abs(audio)) return 20 * np.log10(maxx) if maxx != 0 else np.array([0])
Example #21
Source File: insertsizes.py From svviz with MIT License | 5 votes |
def removeOutliers(data, m = 10.): """ a method of trimming outliers from a list/array using outlier-safe methods of calculating the center and variance; only removes the upper tail, not the lower tail """ if len(data) < 2: return data data = numpy.array(data) d_abs = numpy.abs(data - numpy.median(data)) d = data - numpy.median(data) mdev = numpy.median(d_abs) s = d/mdev if mdev else 0. return data[s<m]
Example #22
Source File: insertsizes.py From svviz with MIT License | 5 votes |
def scoreInsertSize(self, isize): if not self.hasInsertSizeDistribution(): return 0 if self._insertSizeKDE is None: self._insertSizeKDE = gaussian_kde(self.insertSizes) # the gaussian kde call is pretty slow with ~50,000 data points in it, so we'll cache the result for a bit of a speed-up isize = abs(isize) if not isize in self._insertSizeScores: self._insertSizeScores[isize] = self._insertSizeKDE(isize) return self._insertSizeScores[isize]
Example #23
Source File: model.py From aospy with Apache License 2.0 | 5 votes |
def _grid_sfc_area(lon, lat, lon_bounds=None, lat_bounds=None): """Calculate surface area of each grid cell in a lon-lat grid.""" # Compute the bounds if not given. if lon_bounds is None: lon_bounds = _bounds_from_array( lon, internal_names.LON_STR, internal_names.LON_BOUNDS_STR) if lat_bounds is None: lat_bounds = _bounds_from_array( lat, internal_names.LAT_STR, internal_names.LAT_BOUNDS_STR) # Compute the surface area. dlon = _diff_bounds(utils.vertcoord.to_radians(lon_bounds, is_delta=True), lon) sinlat_bounds = np.sin(utils.vertcoord.to_radians(lat_bounds, is_delta=True)) dsinlat = np.abs(_diff_bounds(sinlat_bounds, lat)) sfc_area = dlon*dsinlat*(RADIUS_EARTH**2) # Rename the coordinates such that they match the actual lat / lon. try: sfc_area = sfc_area.rename( {internal_names.LAT_BOUNDS_STR: internal_names.LAT_STR, internal_names.LON_BOUNDS_STR: internal_names.LON_STR}) except ValueError: pass # Clean up: correct names and dimension order. sfc_area = sfc_area.rename(internal_names.SFC_AREA_STR) sfc_area[internal_names.LAT_STR] = lat sfc_area[internal_names.LON_STR] = lon return sfc_area.transpose()
Example #24
Source File: doa.py From FRIDA with MIT License | 5 votes |
def polar_distance(x1, x2): """ Given two arrays of numbers x1 and x2, pairs the cells that are the closest and provides the pairing matrix index: x1(index(1,:)) should be as close as possible to x2(index(2,:)). The function outputs the average of the absolute value of the differences abs(x1(index(1,:))-x2(index(2,:))). :param x1: vector 1 :param x2: vector 2 :return: d: minimum distance between d index: the permutation matrix """ x1 = np.reshape(x1, (1, -1), order='F') x2 = np.reshape(x2, (1, -1), order='F') N1 = x1.size N2 = x2.size diffmat = np.arccos(np.cos(x1 - np.reshape(x2, (-1, 1), order='F'))) min_N1_N2 = np.min([N1, N2]) index = np.zeros((min_N1_N2, 2), dtype=int) if min_N1_N2 > 1: for k in range(min_N1_N2): d2 = np.min(diffmat, axis=0) index2 = np.argmin(diffmat, axis=0) index1 = np.argmin(d2) index2 = index2[index1] index[k, :] = [index1, index2] diffmat[index2, :] = float('inf') diffmat[:, index1] = float('inf') d = np.mean(np.arccos(np.cos(x1[:, index[:, 0]] - x2[:, index[:, 1]]))) else: d = np.min(diffmat) index = np.argmin(diffmat) if N1 == 1: index = np.array([1, index]) else: index = np.array([index, 1]) return d, index
Example #25
Source File: bh.py From dustmaps with GNU General Public License v2.0 | 5 votes |
def _lb2RN_mid(self, l, b): R = (np.abs(b) - 10.) / 0.6 N = (np.mod(l, 360.) + 0.15) / 0.3 - 1 return np.round(R).astype('i4'), np.round(N).astype('i4')
Example #26
Source File: radios.py From spectrum_painter with MIT License | 5 votes |
def _clip(self, complex_iq, limit=1.0): # Clips amplitude to level clipped_samples = np.abs(complex_iq) > limit if np.any(clipped_samples): clipped = complex_iq clipped[clipped_samples] = complex_iq[clipped_samples] / np.abs(complex_iq[clipped_samples]) warn('Some samples were clipped') else: clipped = complex_iq return clipped
Example #27
Source File: utils.py From dc_tts with Apache License 2.0 | 5 votes |
def griffin_lim(spectrogram): '''Applies Griffin-Lim's raw.''' X_best = copy.deepcopy(spectrogram) for i in range(hp.n_iter): X_t = invert_spectrogram(X_best) est = librosa.stft(X_t, hp.n_fft, hp.hop_length, win_length=hp.win_length) phase = est / np.maximum(1e-8, np.abs(est)) X_best = spectrogram * phase X_t = invert_spectrogram(X_best) y = np.real(X_t) return y
Example #28
Source File: structures.py From mmdetection with Apache License 2.0 | 5 votes |
def _polygon_area(self, x, y): """Compute the area of a component of a polygon. Using the shoelace formula: https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates Args: x (ndarray): x coordinates of the component y (ndarray): y coordinates of the component Return: float: the are of the component """ # noqa: 501 return 0.5 * np.abs( np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
Example #29
Source File: attack_model_featadv.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 5 votes |
def main(argv): # Set TF random seed to improve reproducibility tf.set_random_seed(1234) input_shape = [FLAGS.batch_size, 224, 224, 3] x_src = tf.abs(tf.random_uniform(input_shape, 0., 1.)) x_guide = tf.abs(tf.random_uniform(input_shape, 0., 1.)) print("Input shape:") print(input_shape) model = make_imagenet_cnn(input_shape) attack = FastFeatureAdversaries(model) attack_params = {'eps': 0.3, 'clip_min': 0., 'clip_max': 1., 'nb_iter': FLAGS.nb_iter, 'eps_iter': 0.01, 'layer': FLAGS.layer} x_adv = attack.generate(x_src, x_guide, **attack_params) h_adv = model.fprop(x_adv)[FLAGS.layer] h_src = model.fprop(x_src)[FLAGS.layer] h_guide = model.fprop(x_guide)[FLAGS.layer] with tf.Session() as sess: init = tf.global_variables_initializer() sess.run(init) ha, hs, hg, xa, xs, xg = sess.run( [h_adv, h_src, h_guide, x_adv, x_src, x_guide]) print("L2 distance between source and adversarial example `%s`: %.4f" % (FLAGS.layer, ((hs-ha)*(hs-ha)).sum())) print("L2 distance between guide and adversarial example `%s`: %.4f" % (FLAGS.layer, ((hg-ha)*(hg-ha)).sum())) print("L2 distance between source and guide `%s`: %.4f" % (FLAGS.layer, ((hg-hs)*(hg-hs)).sum())) print("Maximum perturbation: %.4f" % np.abs((xa-xs)).max()) print("Original features: ") print(hs[:10, :10]) print("Adversarial features: ") print(ha[:10, :10])
Example #30
Source File: audio.py From Griffin_lim with MIT License | 5 votes |
def save_wav(wav, path): wav *= 32767 / max(0.01, np.max(np.abs(wav))) wavfile.write(path, hparams.sample_rate, wav.astype(np.int16))