def compute_psnr(diff_img):
"""takes diff Image as inout and returns PSNR and Minimum SNR for each color channel"""
diff = np.asarray(diff_img)
diff = diff.reshape(3, diff_img.width * diff_img.height)
mse_rgb = np.mean(diff**2, axis = 1)
psnr_rgb = 10 * np.log10(255**2 / mse_rgb)
min_mse_rgb = np.amax(diff, axis = 1)
min_snr_rgb = 10 * np.log10(255**2 / min_mse_rgb)
return psnr_rgb[0], psnr_rgb[1], psnr_rgb[2], min_snr_rgb[0], min_snr_rgb[1], min_snr_rgb[2]
def __init__(self, Nx, Ny, gamma):
"""
Parameters
----------
Nx : int
Number of segment for x-axis
Ny : int
Number of segment for y-axis
gamma : ndarray
Gain factor distribution
"""
self.Nx = Nx
self.Ny = Ny
self.Lb = 3.5
self.L = 0.1
self.W = 0.1
self.H = 0.1
self.b = 0.4
self.rho = 1.0
self.dx = self.Lb/self.Nx
self.x = cp.arange(0,self.Lb,self.dx, dtype=cp.float32)
By = 1e-3
Ay = -1/self.H*cp.log10(By)
m = cp.linspace(0,1,Ny,dtype=cp.float32)
self.y = -1/Ay*cp.log10(1-m*(1-By))
self.dy = self.y[1:]-self.y[0:-1]
ch_damp = 2.8 * cp.exp(-0.2 * self.x)
self.k1 = 2.2e8*cp.exp(-3*self.x)
self.m1 = 3e-3
self.c1 = 6 + 670*cp.exp(-1.5*self.x) * ch_damp
self.k2 = 1.4e6*cp.exp(-3.3*self.x)
self.c2 = 4.4*cp.exp(-1.65*self.x) * ch_damp
self.m2 = 0.5e-3
self.k3 = 2.0e6*cp.exp(-3*self.x)
self.c3 = 0.8*cp.exp(-0.6*self.x) * ch_damp
self.k4 = 1.15e8*cp.exp(-3*self.x)
self.c4 = 440.0*cp.exp(-1.5*self.x) * ch_damp
self.c1c3 = self.c1 + self.c3
self.k1k3 = self.k1 + self.k3
self.c2c3 = self.c2 + self.c3
self.k2k3 = self.k2 + self.k3
self.gamma = gamma
self.dt = 10e-6
self.beta = 50e-7
def _gpu_snr(power, noise, block_size=200):
shp = power.shape
power_array = cp.array(power)
gpu_noise = cp.array(noise)
power_array = 10 * cp.log10(power_array / gpu_noise)
snr = power_array.get()
return snr
def compute_gain(sound, fs, min_db=-80.0, mode='A_weighting'):
if fs == 16000:
n_fft = 2048
elif fs == 44100:
n_fft = 4096
else:
raise Exception('Invalid fs {}'.format(fs))
stride = n_fft // 2
gain = None
for i in range(0, len(sound[0]) - n_fft + 1, stride):
if mode == 'RMSE':
g = cupy.mean(sound[i:i + n_fft]**2, axis=1)
elif mode == 'A_weighting':
spec = cupy.fft.rfft(
cupy.hanning(n_fft + 1)[:-1] * sound[:, i:i + n_fft])
power_spec = cupy.abs(spec)**2
a_weighted_spec = power_spec * cupy.power(10,
a_weight(fs, n_fft) / 10)
g = cupy.sum(a_weighted_spec, axis=1)
else:
raise Exception('Invalid mode {}'.format(mode))
if i == 0:
gain = g.reshape([-1, 1])
else:
gain = cupy.concatenate((gain, g.reshape([-1, 1])), axis=1)
gain = cupy.maximum(gain, cupy.power(10, min_db / 10))
gain_db = 10 * cupy.log10(gain)
return gain_db
def calc_antennas_vector(phase_diff):
# 送信アンテナのインスタンス作成
# txはx,yのgridに対してとりうる点をすべて保持する．（30x30)
# アンテナの高さと方向は固定
# TM波（水平偏波）
tx_ant1 = rt.TX(const.x1_grid, const.y1_grid, const.tx_antenna_hight,
const.freq, const.tx_power, const.tx_orientation,
const.phase_of_origin)
tx_ant2 = rt.TX(const.x2_grid, const.y2_grid, const.tx_antenna_hight,
const.freq, const.tx_power, const.tx_orientation,
(phase_diff / 180) * 2 * cp.pi)
# 受信アンテナのインスタンス作成
# rxもx,yのgridに対して取りうる点をすべて保持する（今回は7点のみx:0,50...,y:100）
# アンテナの高さと方向は固定
rx_ants = rt.RX(const.rx_ants_x_position, const.rx_ants_y_position,
const.rx_antenna_hight, const.freq, const.gain,
const.rx_orientation, const.phase_of_origin)
# 2波モデルを使って受信点でのパワーを計算
# power_rxs.shape = (30, 30, 7)
power_rx1 = rx_ants.receive_power(tx_ant1)
power_rx2 = rx_ants.receive_power(tx_ant2)
power_rxs = power_rx1[:, :, cp.newaxis, cp.newaxis, :] + \
power_rx2[cp.newaxis, cp.newaxis, :, :, :]
# unit[dBm]
power_rxs = 10 * cp.log10(cp.abs(power_rxs**2))
return power_rxs
def show_qq_plot(df, x_axis, y_axis):
x_values = cupy.fromDlpack(df[x_axis].to_dlpack())
y_values = cupy.fromDlpack(df[y_axis].to_dlpack())
x_max = cupy.max(x_values).tolist()
y_max = cupy.max(y_values).tolist()
qq_fig = figure(x_range=(0, x_max), y_range=(0, y_max))
qq_fig.circle(-cupy.log10(x_values + 1e-10).get(),
-cupy.log10(y_values).get())
qq_fig.line([0, x_max], [0, y_max])
qq_handle = show(qq_fig, notebook_handle=True)
push_notebook(handle=qq_handle)
return qq_fig
def log10(x: Array, /) -> Array:
"""
Array API compatible wrapper for :py:func:`np.log10 <numpy.log10>`.
See its docstring for more information.
"""
if x.dtype not in _floating_dtypes:
raise TypeError("Only floating-point dtypes are allowed in log10")
return Array._new(np.log10(x._array))
def peak_signal_noise_ratio(image_true, image_test, *, data_range=None):
"""
Compute the peak signal to noise ratio (PSNR) for an image.
Parameters
----------
image_true : ndarray
Ground-truth image, same shape as im_test.
image_test : ndarray
Test image.
data_range : int, optional
The data range of the input image (distance between minimum and
maximum possible values). By default, this is estimated from the image
data-type.
Returns
-------
psnr : float
The PSNR metric.
Notes
-----
.. versionchanged:: 0.16
This function was renamed from ``skimage.measure.compare_psnr`` to
``skimage.metrics.peak_signal_noise_ratio``.
References
----------
.. [1] https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
"""
check_shape_equality(image_true, image_test)
if data_range is None:
if image_true.dtype != image_test.dtype:
warn(
"Inputs have mismatched dtype. Setting data_range based on "
"im_true.",
stacklevel=2,
)
dmin, dmax = dtype_range[image_true.dtype.type]
true_min, true_max = cp.min(image_true), cp.max(image_true)
if true_max > dmax or true_min < dmin:
raise ValueError(
"im_true has intensity values outside the range expected for "
"its data type. Please manually specify the data_range")
if true_min >= 0:
# most common case (255 for uint8, 1 for float)
data_range = dmax
else:
data_range = dmax - dmin
image_true, image_test = _as_floats(image_true, image_test)
err = mean_squared_error(image_true, image_test)
return 10 * cp.log10((data_range * data_range) / err)
def show_qq_plot(df,
x_axis,
y_axis,
title="QQ",
save_to=None,
x_max=None,
y_max=None):
x_values = cupy.fromDlpack(df[x_axis].to_dlpack())
y_values = cupy.fromDlpack(df[y_axis].to_dlpack())
x_values = -cupy.log10(x_values)
y_values = -cupy.log10(y_values)
if x_max is None:
x_max = cupy.max(x_values).tolist()
if y_max is None:
y_max = cupy.max(y_values).tolist()
if y_max == cupy.inf:
print("Please pass y_max. Input contains inf.")
return
if x_max == cupy.inf:
print("Please pass x_max. Input contains inf.")
return
qq_fig = figure(x_range=(0, x_max), y_range=(0, y_max), title=title)
qq_fig.circle(x_values.get(), y_values.get(), size=1)
qq_fig.line([0, x_max], [0, y_max], line_color='orange', line_width=2)
if save_to:
export_png(qq_fig, filename=save_to)
else:
qq_handle = show(qq_fig, notebook_handle=True)
push_notebook(handle=qq_handle)
return qq_fig
def a_weight(fs, n_fft, min_db=-80.0):
freq = cupy.linspace(0, fs // 2, n_fft // 2 + 1)
freq_sq = cupy.power(freq, 2)
freq_sq[0] = 1.0
weight = 2.0 + 20.0 * (
2 * cupy.log10(12194) + 2 * cupy.log10(freq_sq) -
cupy.log10(freq_sq + 12194**2) - cupy.log10(freq_sq + 20.6**2) - 0.5 *
cupy.log10(freq_sq + 107.7**2) - 0.5 * cupy.log10(freq_sq + 737.9**2))
weight = cupy.maximum(weight, min_db)
return weight
def show_manhattan_plot(df,
group_by,
x_axis,
y_axis,
title='Manhattan Plot',
save_to=None):
chroms = df[group_by].unique().to_array()
plot_width = len(chroms) * 50
manhattan_fig = figure(title=title)
manhattan_fig.xaxis.axis_label = 'Chromosomes'
manhattan_fig.yaxis.axis_label = '-log10(p)'
manhattan_fig.xaxis.ticker = FixedTicker(ticks=[t for t in chroms])
start_position = 0.5
for chrom in chroms:
query = '%s == %s' % (group_by, chrom)
cdf = df.query(query)
x_array = cupy.fromDlpack(cdf[x_axis].to_dlpack()) + start_position
y_array = -cupy.log10(cupy.fromDlpack(cdf[y_axis].to_dlpack()))
manhattan_fig.circle(x_array.get(),
y_array.get(),
size=2,
color='orange' if
(start_position - 0.5) % 2 == 0 else 'gray',
alpha=0.5)
start_position += 1
if save_to:
export_png(manhattan_fig, filename=save_to)
else:
manhattan_handle = show(manhattan_fig, notebook_handle=True)
push_notebook(handle=manhattan_handle)
return manhattan_fig
def mat_mwu_gpu(a_mat, b_mat, melt: bool, effect: str, use_continuity=True):
"""
Compute rank-biserial correlations and Mann-Whitney statistics
between every column-column pair of a_mat (continuous) and b_mat (binary).
In the case that a_mat or b_mat has a single column, the results are
re-formatted with the multiple hypothesis-adjusted q-value also returned.
Parameters
----------
a_mat: Pandas DataFrame
Continuous set of observations, with rows as samples and columns
as labels.
b_mat: Pandas DataFrame
Binary set of observations, with rows as samples and columns as labels.
Required to be castable to boolean datatype.
melt: boolean
Whether or not to melt the outputs into columns.
use_continuity: bool
Whether or not to use a continuity correction. True by default.
effect: "mean", "median", or "rank_biserial"
The effect statistic.
Returns
-------
effects: rank-biserial correlations
pvals: -log10 p-values of correlations
"""
if effect not in ["rank_biserial"]:
raise ValueError("effect must be 'rank_biserial'")
a_nan = a_mat.isna().sum().sum() == 0
b_nan = b_mat.isna().sum().sum() == 0
if not a_nan and not b_nan:
raise ValueError("a_mat and b_mat cannot have missing values")
a_mat, b_mat = precheck_align(a_mat, b_mat, np.float64, np.bool)
a_names = a_mat.columns
b_names = b_mat.columns
a_ranks = a_mat.apply(rankdata)
a_ties = a_ranks.apply(tiecorrect)
a_ranks = cp.array(a_ranks)
a_mat, b_mat = cp.array(a_mat), cp.array(b_mat)
b_mat = b_mat.astype(cp.bool)
a_num_cols = a_mat.shape[1] # number of variables in A
b_num_cols = b_mat.shape[1] # number of variables in B
a_mat = cp.array(a_mat).astype(cp.float64)
b_pos = b_mat.astype(cp.float64)
b_neg = (~b_mat).astype(cp.float64)
pos_ns = b_pos.sum(axis=0)
neg_ns = b_neg.sum(axis=0)
pos_ns = cp.vstack([pos_ns] * a_num_cols)
neg_ns = cp.vstack([neg_ns] * a_num_cols)
pos_ranks = cp.dot(a_ranks.T, b_pos)
u1 = pos_ns * neg_ns + (pos_ns * (pos_ns + 1)) / 2.0 - pos_ranks
u2 = pos_ns * neg_ns - u1
# temporarily mask zeros
n_prod = pos_ns * neg_ns
zero_prod = n_prod == 0
n_prod[zero_prod] = 1
effects = 2 * u2 / (pos_ns * neg_ns) - 1
# set zeros to nan
effects[zero_prod] = 0
a_ties = cp.vstack([cp.array(a_ties)] * b_num_cols).T
# if T == 0:
# raise ValueError('All numbers are identical in mannwhitneyu')
sd = cp.sqrt(a_ties * pos_ns * neg_ns * (pos_ns + neg_ns + 1) / 12.0)
meanrank = pos_ns * neg_ns / 2.0 + 0.5 * use_continuity
bigu = cp.maximum(u1, u2)
# temporarily mask zeros
sd_0 = sd == 0
sd[sd_0] = 1
z = (bigu - meanrank) / sd
z[sd_0] = 0
# compute p values
pvals = 2 * (1 - ndtr(cp.abs(z)))
# account for small p-values rounding to 0
pvals[pvals == 0] = cp.finfo(cp.float64).tiny
pvals = -cp.log10(pvals)
pvals = pd.DataFrame(pvals, columns=b_names, index=a_names)
effects = pd.DataFrame(effects, columns=b_names, index=a_names)
pos_ns = pd.DataFrame(pos_ns, columns=b_names, index=a_names)
neg_ns = pd.DataFrame(neg_ns, columns=b_names, index=a_names)
effects = effects.fillna(0)
pvals = pvals.fillna(1)
if melt:
return melt_mwu(effects, pvals, pos_ns, neg_ns, effect)
return effects, pvals
def run_gpu_spectrum_int(num_samp, nbins, gain, rate, fc, t_int):
'''
Inputs:
num_samp: Number of elements to sample from the SDR IQ per call;
use powers of 2
nbins: Number of frequency bins in the resulting power spectrum; powers
of 2 are most efficient, and smaller numbers are faster on CPU.
gain: Requested SDR gain (dB)
rate: SDR sample rate, intrinsically tied to bandwidth in SDRs (Hz)
fc: Base center frequency (Hz)
t_int: Total effective integration time (s)
Returns:
freqs: Frequencies of the resulting spectrum, centered at fc (Hz),
numpy array
p_avg_db_hz: Power spectral density (dB/Hz) numpy array
'''
import cupy as cp
import cusignal
# Force a choice of window to allow converting to PSD after averaging
# power spectra
WINDOW = 'hann'
# Force a default nperseg for welch() because we need to get a window
# of this size later. Use the scipy default 256, but enforce scipy
# conditions on nbins vs. nperseg when nbins gets small.
if nbins < 256:
nperseg = nbins
else:
nperseg = 256
print('Initializing rtl-sdr with pyrtlsdr:')
sdr = RtlSdr()
try:
sdr.rs = rate # Rate of Sampling (intrinsically tied to bandwidth with SDR dongles)
sdr.fc = fc
sdr.gain = gain
print(' sample rate: %0.6f MHz' % (sdr.rs / 1e6))
print(' center frequency %0.6f MHz' % (sdr.fc / 1e6))
print(' gain: %d dB' % sdr.gain)
print(' num samples per call: {}'.format(num_samp))
print(' PSD binning: {} bins'.format(nbins))
print(' requested integration time: {}s'.format(t_int))
N = int(sdr.rs * t_int)
num_loops = int(N / num_samp) + 1
print(' => num samples to collect: {}'.format(N))
print(' => est. num of calls: {}'.format(num_loops - 1))
# Set up arrays to store power spectrum calculated from I-Q samples
freqs = cp.zeros(nbins)
p_xx_tot = cp.zeros(nbins, dtype=complex)
# Create mapped, pinned memory for zero copy between CPU and GPU
gpu_iq = cusignal.get_shared_mem(num_samp, dtype=np.complex128)
cnt = 0
# Set the baseline time
start_time = time.time()
print('Integration began at {}'.format(
time.strftime('%a, %d %b %Y %H:%M:%S',
time.localtime(start_time))))
# Time integration loop
for cnt in range(num_loops):
# Move USB-collected samples off CPU and onto GPU for calc
gpu_iq[:] = sdr.read_samples(num_samp)
freqs, p_xx = cusignal.welch(gpu_iq,
fs=rate,
nperseg=nperseg,
nfft=nbins,
noverlap=0,
scaling='spectrum',
window=WINDOW,
detrend=False,
return_onesided=False)
p_xx_tot += p_xx
end_time = time.time()
print('Integration ended at {} after {} seconds.'.format(
time.strftime('%a, %d %b %Y %H:%M:%S'), end_time - start_time))
print('{} spectra were measured at {}.'.format(cnt, fc))
print('for an effective integration time of {:.2f}s'.format(
num_samp * cnt / rate))
half_len = len(freqs) // 2
# Swap frequencies:
tmp_first = freqs[:half_len].copy()
tmp_last = freqs[half_len:].copy()
freqs[:half_len] = tmp_last
freqs[half_len:] = tmp_first
# Swap powers:
tmp_first = p_xx_tot[:half_len].copy()
tmp_last = p_xx_tot[half_len:].copy()
p_xx_tot[:half_len] = tmp_last
p_xx_tot[half_len:] = tmp_first
# Compute the average power spectrum based on the number of spectra read
p_avg = p_xx_tot / cnt
# Convert to power spectral density
# See the scipy docs for _spectral_helper().
win = get_window(WINDOW, nperseg)
p_avg_hz = p_avg * ((win.sum()**2) / (win * win).sum()) / rate
p_avg_db_hz = 10. * cp.log10(p_avg_hz)
# Shift frequency spectra back to the intended range
freqs = freqs + fc
# nice and tidy
sdr.close()
except OSError as err:
print("OS error: {0}".format(err))
raise (err)
except:
print('Unexpected error:', sys.exc_info()[0])
raise
finally:
sdr.close()
return cp.asnumpy(freqs), cp.asnumpy(p_avg_db_hz)
def __init__(self, bin_size=0.1, random_select=False):
self.bins = cp.array([])
self.weights = cp.array([], dtype=cp.int)
self.bin_size = bin_size
self._empty = True
self._rd = int(cp.log10(1. / bin_size).item())
def directivity(self, theta):
# ダイポールの長さがλ/2であることを前提の計算->測定時には周波数を合わせること
# Unit[倍]
deg_gain = const.gain + 10 * \
cp.log10(cp.abs(cp.cos(2*cp.pi / 2*cp.cos(theta)) * cp.sin(theta)))
return 10**(deg_gain/10)
def _safe_db_cupy(num, den):
"""Properly handle the potential +Inf db SIR, instead of raising a
RuntimeWarning. Only denominator is checked because the numerator can never
be 0.
"""
return 10.0 * cp.log10(num / (den + 1e-12))
def generate_spectrograms(
NSAMP=1000, # Number of created spectrograms per class (vowel, non-vowel)
N=512, # Window width in samples
fbefore=250, # Number of windows before the center window
fafter=250, # Number of windows after the center window
ds=2, # Step between the windows in samples
windows=None, # Matrix of window functions, 3 rows, N columns.
dynRange=60, # Dynamic range
signalLevel=10, # SNR
sourceDir="", # TIMIT dataset audio folder
sourceDirNoise="", # Noise dataset audio folder
targetDir="", # Output directory
noiseType="MAVD", # Type of the noise used {"MAVD", "ESC50"}
batchSize=50, # Batch size when computing fft and creating spectrograms
debug=False
):
start_time = timer()
if windows is None:
windows = cp.ones(shape=(3, N))
else:
windows = cp.array(windows)
eps = 1e-10
phones = []
wavfiles = []
minstart = N // 2 + fbefore * ds
for path, subdirs, files in os.walk(sourceDir):
for name in files:
basename, ext = os.path.splitext(name)
fname = os.path.join(path, name)
if ext != ".PHN":
continue
with open(fname, newline='') as phnfile:
rdr = list(csv.reader(phnfile, delimiter=' '))
wname = os.path.join(path, "{0}.WAV".format(basename))
file_phones = []
last_sampl = int(rdr[-1][1])
maxstart = last_sampl - ds * fafter - N // 2 + 1
for row in rdr:
start = int(row[0])
end = int(row[1])
if start < minstart:
continue
if end > maxstart:
continue
data = (wname, start, end, row[2].strip())
file_phones.append(data)
phones += file_phones
wavfiles.append(wname)
print("Total {0} phones in {1} files".format(len(phones), len(wavfiles)))
vowels = ["iy", "ih", "eh", "ey", "ae", "aa", "aw", "ay", "ah",
"ao", "oy", "ow", "uh", "uw", "ux", "er", "ax", "ix", "axr",
"ax-h"]
# do not take samples from the very edges
margin = int((fbefore + fafter) * ds * 0.1)
phn_len = lambda x: max(x[2] - x[1] - margin, 1)
class PhonePos:
def __init__(self, phone, kind):
self.file = phone[0]
self.start = phone[1]
self.end = phone[2]
self.phone = phone[3]
self.kind = kind
def random_pos(kind="vowel"):
if kind == "vowel":
subset_iter = (filter(lambda x: x[3] in vowels, phones))
else:
subset_iter = (filter(lambda x: x[3] not in vowels, phones))
subset_phones = list(subset_iter)
subset_cs = np.cumsum(np.array(list(map(phn_len, subset_phones))))
subset_max = subset_cs[-1]
print(kind + " phonemes combined length: " + str(subset_max))
subset_pos0 = np.sort(np.random.choice(subset_max, size=NSAMP, replace=False))
subset_idx = np.searchsorted(subset_cs, subset_pos0, side='right')
subset_pos = []
for i in range(len(subset_idx)):
j = subset_idx[i]
assert (j >= 0)
assert (j < len(subset_cs))
phone = subset_phones[j]
pp = PhonePos(phone, kind)
# position within file
file_pos = subset_pos0[i] + phone[1] + margin // 2
if j > 0:
file_pos -= subset_cs[j - 1]
assert (file_pos <= phone[2] - margin // 2)
assert (file_pos >= phone[1] + margin // 2)
pp.file_pos = file_pos
subset_pos.append(pp)
# returns a list of PhonePos objects
return subset_pos
def list_noise_files(sound_ext=".wav"):
noise_path_list = []
for path, subdirs, files in os.walk(sourceDirNoise):
for name in files:
# print("Processing folder: {}".format(path))
basename, ext = os.path.splitext(name)
if ext != sound_ext:
continue
fname = os.path.join(path, name)
noise_path_list.append(fname)
print(str(len(noise_path_list)) + " noise files found")
return noise_path_list
def load_noises(ns_pl, tar_rate):
print("Loading noise")
noises = []
for ni, nois_p in enumerate(ns_pl):
print("Loading noise " + str(int(ni / len(ns_pl) * 100)) + "%", end="\r")
nois, rate = librosa.load(nois_p, sr=None, mono=True)
nois_rs = librosa.resample(nois, rate, tar_rate)
noises.append(nois_rs)
return np.concatenate(noises)
def tile_noise(noise, tar_len):
multiple = tar_len / len(noise)
repeat_c = int(np.floor(multiple))
rest = tar_len - repeat_c * len(noise)
return np.concatenate([np.repeat(noise, repeat_c), noise[:rest]], 0)
def combine_with_noise(sig, nois, snr):
# snr = 10*log10(sum(s**2)/sum(n**2))
if len(nois) != len(sig):
nois = tile_noise(nois, len(sig))
E_sig = sum(sig ** 2)
E_nois = sum(nois ** 2)
if E_nois == 0:
print("Warning: zero energy noise")
return sig
if type(snr) == list:
snr = np.random.uniform(snr[0], snr[1])
coef = 10 ** ((snr - 10 * np.log10(E_sig / E_nois)) / (-20))
return (sig + coef * nois) / (1 + coef)
vp = random_pos("vowel")
up = random_pos("nonvowel")
v_tarDir = os.path.join(targetDir, "vowel")
u_tarDir = os.path.join(targetDir, "nonvowel")
if not os.path.exists(v_tarDir):
os.makedirs(v_tarDir)
if not os.path.exists(u_tarDir):
os.makedirs(u_tarDir)
# timit sample rate is 16 kHz
t_rate = 16000
if signalLevel is not None:
if noiseType == "MAVD":
noise_files = list_noise_files(".flac")
noises = load_noises(noise_files, t_rate)
elif noiseType == "ESC50":
nf = list_noise_files()
complete_count = 0
for wavFile in wavfiles:
curList = []
while len(vp) > 0 and vp[0].file == wavFile:
pp = vp.pop(0)
curList.append(pp)
while len(up) > 0 and up[0].file == wavFile:
pp = up.pop(0)
curList.append(pp)
if len(curList) == 0:
continue
complete_count += len(curList)
print("Creating spectrograms " + str(int(complete_count / (2 * NSAMP) * 100)) + "%", end="\r")
with open(wavFile, "rb") as fp:
fp.read(1024) # need to jump over 1024 bytes
wa = fp.read()
snd = np.frombuffer(wa, dtype=np.int16)
snd = snd.astype(np.float32) / 2 ** 15
if signalLevel is not None:
if noiseType == "MAVD":
noise_start = np.random.randint(0, len(noises) - len(snd))
nois = noises[noise_start:noise_start + len(snd)]
elif noiseType == "ESC50":
noise_ind = np.random.randint(len(nf))
nois, nois_rate = librosa.load(nf[noise_ind], sr=None, mono=False)
nois = librosa.resample(nois, nois_rate, t_rate, res_type='kaiser_fast')
snd = combine_with_noise(snd, nois, signalLevel)
ftotal = 1 + fbefore + fafter
dat = np.zeros(shape=(len(curList), 3, ftotal, N), dtype=cp.float32)
if debug:
sound_fn = os.path.join(targetDir, reg + "_" + speaker + "_" + fname + ".wav")
sf.write(sound_fn, snd, samplerate=t_rate)
for i, pp in enumerate(curList):
p = pp.file_pos
start = p - ds * fbefore - N // 2
end = p + ds * fafter + N // 2
stride_bytes = snd.strides[0]
matrix = np.lib.stride_tricks.as_strided(snd[start:end],
shape=(ftotal, N),
strides=(stride_bytes * ds, stride_bytes),
writeable=False)
dat[i, :, :, :] = matrix
for bstart in range(0, dat.shape[0], batchSize):
dat_batch = cp.transpose(cp.array(dat[bstart:bstart + batchSize]), (0, 2, 1, 3))
spect_abs = cp.abs(cp.fft.rfft(cp.multiply(dat_batch, windows), axis=3))
spect_abs[spect_abs == 0] = eps
spectra = 20 * cp.log10(spect_abs)
maxs = cp.max(spectra, axis=(1, 2, 3), keepdims=True)
mins = cp.max(cp.concatenate((maxs - dynRange, cp.min(spectra, axis=(1, 2, 3), keepdims=True)), 3), 3,
keepdims=True)
M_sp = spectra > mins
spectra[~M_sp] = 0
spectra[M_sp] = (((spectra - mins) / (maxs - mins)) * 255)[M_sp]
spec_tr = cp.flip(cp.transpose(spectra, (0, 3, 1, 2)), 1).astype(dtype=cp.byte)
fname = os.path.splitext(os.path.basename(wavFile))[0]
reg, speaker = os.path.split(os.path.split(wavFile)[0])
reg = os.path.split(reg)[1]
for i, pp in enumerate(curList[bstart:bstart + batchSize]):
pos = pp.file_pos
img_name = reg + "_" + speaker + "_" + fname + "_" + str(pos) + "_" + str(pp.phone) + ".png"
if pp.kind == "vowel":
img_path = os.path.join(v_tarDir, img_name)
else:
img_path = os.path.join(u_tarDir, img_name)
img = Image.fromarray(spec_tr[i].get(), mode="RGB")
img.save(img_path)
print("Finished in: {}s".format(timer() - start_time))
def General_n_Balance_n_Collision_Eff(self,
_new_path,
length_only = True,
GPU_accelerating = False,
GPU_accelerating_data = None,
matrix_data = None):
ITC = {}
max_ITC = 1
min_ITC = sys.maxsize
total_cost = 0
max_order = 0
total_order = 0
standard_index = self.tools.GetWidth()**2 + self.tools.GetHeight()**2
# Parallelization
if GPU_accelerating and length_only:
n_AGV, population_size = GPU_accelerating_data
T_matrix, S_matrix = matrix_data
T_matrix = cp.array(T_matrix)
S_matrix = cp.array(np.array(S_matrix).astype(float))
ITC_matrix = cp.reshape(cp.dot(T_matrix, cp.array([[1],[1]])), (population_size, n_AGV))
O_matrix = cp.reshape(cp.dot(T_matrix, cp.array([[0],[1]])), (population_size, n_AGV))
TC_matrix = cp.reshape(cp.dot(ITC_matrix, cp.ones((n_AGV, 1))), (population_size))
TO_matrix = cp.reshape(cp.dot(O_matrix, cp.ones((n_AGV, 1))), (population_size))
max_ITC_matrix = cp.amax(ITC_matrix, axis=1)
min_ITC_matrix = cp.amin(ITC_matrix, axis=1)
max_order_matrix = cp.amax(O_matrix, axis=1)
_, n_order_points, _ = S_matrix.shape
t_m = cp.reshape(cp.dot(S_matrix, cp.array([[[1],[0],[0],[0],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
x_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[1],[0],[0],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
y_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[0],[1],[0],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
l_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[0],[0],[1],[0]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
o_m = cp.reshape(cp.dot(S_matrix, cp.array([[[0],[0],[0],[0],[1]]]*n_order_points)),
(population_size, n_order_points, n_order_points))
t_m_l = cp.reshape(cp.dot(S_matrix, cp.array([[[1],[0],[0],[0],[0]]])),
(population_size, n_order_points))
t_m_diff = t_m - cp.transpose(t_m, (0, 2, 1))
x_m_diff = x_m - cp.transpose(x_m, (0, 2, 1))
y_m_diff = y_m - cp.transpose(y_m, (0, 2, 1))
m_xy_diff = cp.absolute(x_m_diff) + cp.absolute(y_m_diff)
m_diff = cp.absolute(t_m_diff) + m_xy_diff
m_diff_l = m_diff - l_m * 2
m_diff_l_sign = (cp.logical_xor(cp.sign(m_diff_l) + 1, True))
m_diff_l_eff = cp.multiply(m_diff, m_diff_l_sign)
m_diff_l_sign = cp.sign(m_diff_l_eff)
m_diff_l_H = cp.multiply(cp.multiply(cp.reciprocal(m_diff_l_eff + m_diff_l_sign - 1), m_diff_l_sign),
cp.log10(m_diff_l_eff + cp.absolute(m_diff_l_sign - 1)))
d_m = cp.reciprocal(cp.sum(m_diff_l_H,
(1,2)))
# Occupancy test
"""
t_m_o = t_m + o_m - 1
m_diff_o = cp.absolute(t_m_o - cp.transpose(t_m_o, (0, 2, 1))) - o_m - 1
m_occupancy = (cp.logical_xor(cp.sign(m_diff_o) + 1, True))
m_idn = cp.identity(n_order_points)
OT = cp.prod(cp.logical_or(m_xy_diff,
cp.logical_not(m_occupancy - m_idn)),
(1,2))
"""
G1 = max_order_matrix/max_ITC_matrix
G2 = TO_matrix/TC_matrix
BU = min_ITC_matrix/max_ITC_matrix
CI = cp.multiply(d_m, BU) # d_m * 0.1
E_matrix = G1 + G2 + BU + CI
cp.cuda.Stream.null.synchronize()
return (list(E_matrix), (list(max_ITC_matrix), list(TC_matrix), list(BU), list(CI)))
# Non-Paralleization
else:
print("[Scheduling] Must be use GPU to calculate")
for each_AGV_ID in _new_path.keys():
each_AGV_len_schedule = 0
each_AGV_num_orders = 0
if length_only:
each_AGV_len_schedule, each_num_order, each_order_list = _new_path[each_AGV_ID]
each_AGV_num_orders = each_num_order
else:
each_path = _new_path[each_AGV_ID]
for each_pos_path in each_path:
if len(each_pos_path) == 3:
each_AGV_num_orders += 1
each_AGV_len_schedule += 1
cost = each_AGV_len_schedule + each_AGV_num_orders
ITC[each_AGV_ID] = cost
if each_AGV_num_orders > max_order:
max_order = each_AGV_num_orders
total_order += each_AGV_num_orders
for _, each_value in ITC.items():
if each_value > max_ITC:
max_ITC = each_value
if each_value < min_ITC:
min_ITC = each_value
total_cost += each_value
TT = max_ITC
TTC = total_cost
BU = min_ITC / max_ITC
CI = 0
G1 = max_order/TT
G2 = total_order/TTC
value = G1 + G2 + BU + CI
return (value, (TT, TTC, BU, CI))
np_img = transform.resize(np_img, (4096, 4096)) # 4096*4096にリサイズ
np_img = color.rgb2gray(np_img) # グレースケール化
np_img = np_img.astype('f')
io.imshow(np_img) # 表示
io.show()
# フーリエ変換
cp_img = cp.asarray(np_img) # numpy配列 ⇒ cupy配列に変換
cp_fimg = cp.fft.fft2(cp_img) # 【フーリエ変換】
cp_fimg = cp.fft.fftshift(cp_fimg) # fftshiftを使ってシフト
# パワースペクトルで表示
cp_fabs = cp.absolute(cp_fimg) # 絶対値をとる
cp_fabs[cp_fabs < 1] = 1 # スケール調整用に1以下を1にする
cp_fpow = cp.log10(cp_fabs) # logをとってパワースペクトル化
np_fpow = cp.asnumpy(cp_fpow) # cupy配列 ⇒ numpy配列に変換
io.imshow(np_fpow) # 表示
io.show()
# フーリエ逆変換
cp_ffimg = cp.fft.ifftshift(cp_fimg) # シフトを戻す
cp_ffimg = cp.fft.ifft2(cp_ffimg) # 【フーリエ逆変換】
cp_ffimg = cp.absolute(cp_ffimg) # 絶対値をとって虚数をなくす
np_ffimg = cp.asnumpy(cp_ffimg) # cupy配列 ⇒ numpy配列に変換
io.imshow(cp.asnumpy(np_ffimg)) # 表示
io.show()
# Loop over all anisotropic Henyey-Greenly parameters.
for hg in g:
momentum_transfer = momentum_i * cp.ones_like(tau_atm)
for atm_i, atm in enumerate(tau_atm):
tau = cp.zeros(N_photons)
mu = cp.zeros_like(tau)
momentum_transfer = WalkLikeAPhoton(tau, mu, hg, atm,
momentum_transfer)
# if flag:
# break
# if flag:
# break
plt.plot(cp.asnumpy(cp.log10(tau_atm)),
cp.asnumpy(momentum_transfer) / N_photons,
label=hg)
b = time.time()
print('time taken: ' + str(b - a))
plt.figure(1)
plt.xlabel(r'$log_{10}(\tau_{atm})$')
plt.ylabel('Momentum transferred per photon')
plt.title('CUpy with reflecting boundary')
plt.legend(title="anisotropic weighting")
plt.savefig('cupy_test.png', dpi=200)
plt.figure(2)