def function_wrapper(x, b, axis=0, **kwargs):
# add the padding to the array
xsize = x.shape[axis]
if 'pad' in kwargs and kwargs['pad']:
npad = b.shape[axis] // 2
padd = cp.take(x, cp.arange(npad), axis=axis) * 0
if kwargs['pad'] == 'zeros':
x = cp.concatenate((padd, x, padd), axis=axis)
if kwargs['pad'] == 'constant':
x = cp.concatenate((padd * 0 + cp.mean(x[:npad]), x,
padd + cp.mean(x[-npad:])),
axis=axis)
if kwargs['pad'] == 'flip':
pad_in = cp.flip(cp.take(x, cp.arange(1, npad + 1), axis=axis),
axis=axis)
pad_out = cp.flip(cp.take(x,
cp.arange(xsize - npad - 1,
xsize - 1),
axis=axis),
axis=axis)
x = cp.concatenate((pad_in, x, pad_out), axis=axis)
# run the convolution
y = fcn_convolve(x, b, **kwargs)
# remove padding from both arrays (necessary for x ?)
if 'pad' in kwargs and kwargs['pad']:
# remove the padding
y = cp.take(y, cp.arange(npad, x.shape[axis] - npad), axis=axis)
x = cp.take(x, cp.arange(npad, x.shape[axis] - npad), axis=axis)
assert xsize == x.shape[axis]
assert xsize == y.shape[axis]
return y
def __get_streaked_spectra(self, streakspeed):
if self.is_low_res == True:
return None
else:
from cupy.fft import fft
def fs_in_au(t):
return 41.3414 * t # from fs to a.u.
# def eV_in_au(e): return 0.271106*np.sqrt(e) # from eV to a.u.
# in V/m; shape of Vectorpotential determines: 232000 V/m = 1 meV/fs max streakspeed
E0 = 232000 * streakspeed
ff1 = cp.flip(
fft(self.__temp * cp.exp(-1j * fs_in_au(self.__tAxis) *
(1 / (2) *
(self.p0 * E0 * p_times_A_vals_up +
1 * E0**2 * A_square_vals_up)))))
ff2 = cp.flip(
fft(self.__temp * cp.exp(-1j * fs_in_au(self.__tAxis) *
(1 / (2) *
(self.p0 * E0 * p_times_A_vals_down +
1 * E0**2 * A_square_vals_down)))))
spectrum1 = cp.square(cp.abs(ff1))
spectrum2 = cp.square(cp.abs(ff2))
# ff1=ff1/(cp.sum(cp.square(cp.abs(ff1))))
# ff1=ff2/(cp.sum(cp.square(cp.abs(ff2))))
return spectrum1, spectrum2
def backward(self, w, grad):
# 这部分的推导可以看 /resource下的cnn_bp.md
if w != -1:
grad = grad @ w
self.dz = grad * self.activation.backward()
self.dw = np.tensordot(
self.dz, self.input_split, axes=[(0, 2, 3), (0, 2, 3)]) / self.m
self.db = np.mean(self.dz, axis=(0, 2, 3))
pad_diff = 2 * (self.shape[2] - self.dz.shape[2]) * self.strides
self.padding_layer_bp = ZeroPadding2d(pad_diff // 2, pad_diff // 2)
self.dz = self.padding_layer_bp.forward(self.dz)
self.dz = self.split_by_strides(self.dz,
kh=self.kernel_size[0],
kw=self.kernel_size[1],
s=self.strides)
# 翻转180度
self.dz = np.flip(self.dz, axis=4)
self.dz = np.flip(self.dz, axis=4)
# 这里炫个技，其实和算dw的tensor dot一样的，但是cupy不支持einsum
# grad = np.einsum('mcab,nmwhab->ncwh', self.w, self.dz)
grad = np.tensordot(self.w, self.dz,
axes=[(0, 2, 3),
(1, 4, 5)]).transpose([1, 0, 2, 3])
if self.padding_layer is not None:
return self.padding_layer.backward(w=-1, grad=grad)
return -1, grad
def reverse(tensor, axis):
"""Reverses specific dimensions of a tensor.
Args:
tensor (tensor): tensor to reverse
axis (tensor): axis or tuple of axis
"""
if isinstance(axis, int):
return cp.flip(tensor, axis)
else:
for ax in axis:
tensor = cp.flip(tensor, axis=ax)
return tensor
def compute_all_results(experiment):
global seq_uid_map, frame_no_map, seq_uid_count_map
cuda_embeddings = cp.asarray(experiment.embeddings)
embeddings = experiment.embeddings
chunk_size = 500
chunks = []
results = []
chunk_size = 100
for i in tqdm(range(0, int(len(embeddings) / chunk_size) + 1)):
start = i * chunk_size
end = i * chunk_size + chunk_size
if end > len(embeddings):
end = len(embeddings)
#start = chunk_size
#end = chunk_size+chunk_size
chunk_similarity = cp.dot(cuda_embeddings[start:end],
cuda_embeddings.T)
chunk_similarity[np.arange(chunk_size),
np.arange(chunk_size) + start] = 0
chunk_matches = cp.argsort(chunk_similarity, axis=1)
chunk_matches = cp.flip(chunk_matches, axis=1)
chunk_matches = chunk_matches.get()
chunk_results = get_results_for_chunk(chunk_matches, start, end)
results.append(chunk_results)
compiled_results = {}
for result in results:
compiled_results.update(result)
#compiled_results
df = pd.DataFrame.from_dict(compiled_results).T
df = df.rename(columns={0: "reid", 1: "jitter", 2: "AUC", 3: "seq_uid"})
return df
def gpu_rot4D_flat(data4Df, rotangle, flip=True, return_numpy=False):
warnings.filterwarnings('ignore')
data4Df = cp.asarray(data4Df, dtype=data4D.dtype)
if flip:
data4Df = cp.flip(data4Df, axis=-1)
data4Df = csnd.rotate(data4Df, rotangle, axes=(1, 2), reshape=False)
return data4Df
def match_fuzzy(q, tms, tmt, opt):
tms_score = cdist(q, tms)
if not opt.include_perfect_match:
tms_score[tms_score > 0.99] = -float('inf')
tmt_score = cdist(q, tmt)
if not opt.include_perfect_match:
tmt_score[tms_score == -float('inf')] = -float('inf')
tmt_score[tmt_score > 0.99] = -float('inf')
tms_top_v, tms_top_i = topk(tms_score, opt.topk)
tmt_top_v, tmt_top_i = topk(tmt_score, opt.topk)
tms_top_i += opt.shard_i * opt.shard_max_len
tmt_top_i += opt.shard_i * opt.shard_max_len
top_v = cp.hstack([tms_top_v, tmt_top_v])
top_i = cp.hstack([tms_top_i, tmt_top_i])
arg_i = cp.flip(top_v.astype('float32').argsort(axis=1), axis=1)
top_v = top_v[cp.arange(top_v.shape[0]).reshape(-1, 1),
arg_i][:, :opt.topk]
top_i = top_i[cp.arange(top_i.shape[0]).reshape(-1, 1),
arg_i][:, :opt.topk]
return top_v, top_i
def topk(array, k):
assert array.ndim == 2
top_i = array.astype('float32').argpartition(
-k
)[:, -k:] # cupy.argpartition do whole sorting for implementation reason
top_i = cp.flip(top_i, axis=1)
top_v = cp.vstack([array[r, top_i[r]] for r in range(array.shape[0])])
return top_v, top_i
def mass2_gpu(ts, query):
"""
Compute the distance profile for the given query over the given time
series. This require cupy to be installed.
Parameters
----------
ts : array_like
The array to create a rolling window on.
query : array_like
The query.
Returns
-------
An array of distances.
Raises
------
ValueError
If ts is not a list or np.array.
If query is not a list or np.array.
If ts or query is not one dimensional.
"""
def moving_mean_std_gpu(a, w):
s = cp.concatenate([cp.array([0]), cp.cumsum(a)])
sSq = cp.concatenate([cp.array([0]), cp.cumsum(a**2)])
segSum = s[w:] - s[:-w]
segSumSq = sSq[w:] - sSq[:-w]
movmean = segSum / w
movstd = cp.sqrt(segSumSq / w - (segSum / w)**2)
return (movmean, movstd)
x = cp.asarray(ts)
y = cp.asarray(query)
n = x.size
m = y.size
meany = cp.mean(y)
sigmay = cp.std(y)
meanx, sigmax = moving_mean_std_gpu(x, m)
meanx = cp.concatenate([cp.ones(n - meanx.size), meanx])
sigmax = cp.concatenate([cp.zeros(n - sigmax.size), sigmax])
y = cp.concatenate((cp.flip(y, axis=0), cp.zeros(n - m)))
X = cp.fft.fft(x)
Y = cp.fft.fft(y)
Z = X * Y
z = cp.fft.ifft(Z)
dist = 2 * (m - (z[m - 1:n] - m * meanx[m - 1:n] * meany) /
(sigmax[m - 1:n] * sigmay))
dist = cp.sqrt(dist)
return cp.asnumpy(dist)
def acc_gate(t, ext):
s = []
for i in range(num_gates):
s.append(F.sum(t[i]).data)
# オッズを元にリターンベースで評価
v = cp.argsort(cp.array(s, dtype=cp.float32))
v = cp.flip(v, axis=0)
tansho = 0
if v[0] == 0:
tansho = ext[0][0] # 単勝
fukusho1 = 0
if v[0] == 0:
fukusho1 = ext[0][1] # 複勝（1枚買ったとき）
if v[0] == 1:
fukusho1 = ext[0][2] # 複勝（1枚買ったとき）
if v[0] == 2:
fukusho1 = ext[0][3] # 複勝（1枚買ったとき）
fukusho2 = 0
if v[0] == 0 or v[1] == 0:
fukusho2 += ext[0][1] # 複勝（2枚買ったとき）
if v[0] == 1 or v[1] == 1:
fukusho2 += ext[0][2] # 複勝（2枚買ったとき）
fukusho2 = fukusho2 / 2
fukusho3 = 0
if v[0] == 0 or v[1] == 0 or v[2] == 0:
fukusho3 += ext[0][1] # 複勝（3枚買ったとき）
if v[0] == 1 or v[1] == 1 or v[2] == 1:
fukusho3 += ext[0][2] # 複勝（3枚買ったとき）
if v[0] == 2 or v[1] == 2 or v[2] == 2:
fukusho3 += ext[0][3] # 複勝（3枚買ったとき）
fukusho3 = fukusho3 / 3
umaren = 0
if v[0] == 0 and v[1] == 1:
umaren = ext[0][5]
elif v[0] == 1 and v[1] == 0:
umaren = ext[0][5] # 馬連
wide = 0
if (v[0] == 0 and v[1] == 1) or (v[0] == 1 and v[1] == 0):
wide = ext[0][6] # ワイド
elif (v[0] == 0 and v[1] == 2) or (v[0] == 2 and v[1] == 0):
wide = ext[0][7] # ワイド
elif (v[0] == 1 and v[1] == 2) or (v[0] == 2 and v[1] == 1):
wide = ext[0][8] # ワイド
umatan = 0
if v[0] == 0 and v[1] == 1:
umatan = ext[0][9] # 馬単
triren = 0
if v[0] <= 2 and v[1] <= 2 and v[2] <= 2:
triren = ext[0][10] # 3連複
tritan = 0
if v[0] == 0 and v[1] == 1 and v[2] == 2:
tritan = ext[0][11] # 3単連
return (tansho, fukusho1, fukusho2, fukusho3, umaren, wide, umatan,
triren, tritan)
def get_image_init_positions(image, shape: Tuple[int], n: int, flip=False):
init_image = IMG.open(image).convert("L")
init_image = init_image.resize(tuple(np.flip(shape)))
init_image = np.array(init_image) / 255
if flip:
init_image = 1 - init_image
linear_idx = np.random.choice(init_image.size,
size=n,
p=init_image.ravel() /
float(init_image.sum()))
x, y = np.unravel_index(linear_idx, shape)
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)
return np.hstack([x, y])
def gpu_rot4D(data4D, rotangle, flip=True, return_numpy=False):
warnings.filterwarnings('ignore')
data4D = cp.asarray(data4D, dtype=data4D.dtype)
if flip:
data4D = cp.flip(data4D, axis=-1)
data_shape = data4D.shape
data4D = csnd.rotate(data4D.reshape(-1, data_shape[-2], data_shape[-1]),
rotangle,
axes=(1, 2),
reshape=False)
data4D = cp.reshape(data4D, data_shape)
if return_numpy:
data4D = cp.asnumpy(data4D)
return data4D
def __init__(self):
self.bias = config.fargs['bias']
all_patches, idxs = utils.grab_patches(
X_train,
patch_size=config.fargs['patch_size'],
max_threads=16,
tot_patches=100000)
all_patches = utils.normalize_patches(all_patches, zca_bias=1e-3)
filters = all_patches[np.random.choice(all_patches.shape[0],
config.fargs['num_filters'],
replace=False)].astype(
np.float32)
self.filters = cp.asarray(filters)
if config.flip:
self.filters = cp.concatenate(
(self.filters, cp.flip(self.filters, 3)), axis=0)
with mrcfile.open(obs_projection, permissive=True) as mrc:
cp_obs_projection = cp.asarray(mrc.data, dtype="float32")
mrc.close
with mrcfile.open(obs_projection_150_temp, permissive=True) as mrc:
cp_obs_projection_150_temp = cp.asarray(mrc.data, dtype="float32")
mrc.close
if (index_rot[n] == 0):
cp_obs_projection = cp_obs_projection
elif (index_rot[n] == 1):
cp_obs_projection = cp.rot90(cp_obs_projection, axes=(1, 2))
cp_obs_projection = cp.rot90(cp_obs_projection, axes=(1, 2))
elif (index_rot[n] == 2):
cp_obs_projection = cp.flip(cp_obs_projection, axis=1)
elif (index_rot[n] == 3):
cp_obs_projection = cp.rot90(cp_obs_projection, axes=(1, 2))
cp_obs_projection = cp.rot90(cp_obs_projection, axes=(1, 2))
cp_obs_projection = cp.flip(cp_obs_projection, axis=1)
if (index_rot[n] == 0):
cp_obs_projection_150_temp = cp_obs_projection_150_temp
elif (index_rot[n] == 1):
cp_obs_projection_150_temp = cp.rot90(cp_obs_projection_150_temp,
axes=(1, 2))
cp_obs_projection_150_temp = cp.rot90(cp_obs_projection_150_temp,
axes=(1, 2))
elif (index_rot[n] == 2):
cp_obs_projection_150_temp = cp.flip(cp_obs_projection_150_temp,
axis=1)
def precision_recall_curve(
y_true, probs_pred) -> typing.Tuple[CumlArray, CumlArray, CumlArray]:
"""
Compute precision-recall pairs for different probability thresholds
.. note:: this implementation is restricted to the binary classification
task. The precision is the ratio ``tp / (tp + fp)`` where ``tp`` is the
number of true positives and ``fp`` the number of false positives. The
precision is intuitively the ability of the classifier not to label as
positive a sample that is negative.
The recall is the ratio ``tp / (tp + fn)`` where ``tp`` is the number
of true positives and ``fn`` the number of false negatives. The recall
is intuitively the ability of the classifier to find all the positive
samples. The last precision and recall values are 1. and 0.
respectively and do not have a corresponding threshold. This ensures
that the graph starts on the y axis.
Read more in the scikit-learn's `User Guide
<https://scikit-learn.org/stable/modules/model_evaluation.html#precision-recall-f-measure-metrics>`_.
Parameters
----------
y_true : array, shape = [n_samples]
True binary labels, {0, 1}.
probas_pred : array, shape = [n_samples]
Estimated probabilities or decision function.
Returns
-------
precision : array, shape = [n_thresholds + 1]
Precision values such that element i is the precision of
predictions with score >= thresholds[i] and the last element is 1.
recall : array, shape = [n_thresholds + 1]
Decreasing recall values such that element i is the recall of
predictions with score >= thresholds[i] and the last element is 0.
thresholds : array, shape = [n_thresholds <= len(np.unique(probas_pred))]
Increasing thresholds on the decision function used to compute
precision and recall.
Examples
--------
.. code-block:: python
>>> import cupy as cp
>>> from cuml.metrics import precision_recall_curve
>>> y_true = cp.array([0, 0, 1, 1])
>>> y_scores = cp.array([0.1, 0.4, 0.35, 0.8])
>>> precision, recall, thresholds = precision_recall_curve(
... y_true, y_scores)
>>> print(precision)
[0.666... 0.5 1. 1. ]
>>> print(recall)
[1. 0.5 0.5 0. ]
>>> print(thresholds)
[0.35 0.4 0.8 ]
"""
y_true, n_rows, n_cols, ytype = \
input_to_cupy_array(y_true, check_dtype=[np.int32, np.int64,
np.float32, np.float64])
y_score, _, _, _ = \
input_to_cupy_array(probs_pred, check_dtype=[np.int32, np.int64,
np.float32, np.float64],
check_rows=n_rows, check_cols=n_cols)
if cp.any(y_true) == 0:
raise ValueError("precision_recall_curve cannot be used when "
"y_true is all zero.")
fps, tps, thresholds = _binary_clf_curve(y_true, y_score)
precision = cp.flip(tps / (tps + fps), axis=0)
recall = cp.flip(tps / tps[-1], axis=0)
n = (recall == 1).sum()
if n > 1:
precision = precision[n - 1:]
recall = recall[n - 1:]
thresholds = thresholds[n - 1:]
precision = cp.concatenate([precision, cp.ones(1)])
recall = cp.concatenate([recall, cp.zeros(1)])
return precision, recall, thresholds
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))
x - i_shift,
axis=1)
ave_sub_density_stack_shift = cp.roll(
ave_sub_density_stack_shift, y - i_shift, axis=2)
ave_sub_density_stack_rot_shift = cp.roll(
ave_sub_density_stack_rot_shift, y - i_shift, axis=2)
AB_presum = ave_sub_density_stack_shift[:, :, :] * ave_sub_calc_dens[:, :, :]
AB = cp.sum(AB_presum, axis=(1, 2))
correlation[0, :, x, y] = AB / C
AB_presum = ave_sub_density_stack_rot_shift[:, :, :] * ave_sub_calc_dens[:, :, :]
AB = cp.sum(AB_presum, axis=(1, 2))
correlation[1, :, x, y] = AB / C
ave_sub_density_stack_shift = cp.flip(ave_sub_density_stack_shift,
axis=1)
ave_sub_density_stack_rot_shift = cp.flip(
ave_sub_density_stack_rot_shift, axis=1)
AB_presum = ave_sub_density_stack_shift[:, :, :] * ave_sub_calc_dens[:, :, :]
AB = cp.sum(AB_presum, axis=(1, 2))
correlation[2, :, x, y] = AB / C
AB_presum = ave_sub_density_stack_rot_shift[:, :, :] * ave_sub_calc_dens[:, :, :]
AB = cp.sum(AB_presum, axis=(1, 2))
correlation[3, :, x, y] = AB / C
index = cp.argmax(correlation, axis=(0, 2, 3))
index_rot = index[:] / (2 * i_shift * 2 * i_shift)
index_rot = index_rot.astype(cp.int)
stable: bool = True) -> Array:
"""
Array API compatible wrapper for :py:func:`np.argsort <numpy.argsort>`.
See its docstring for more information.
"""
# Note: this keyword argument is different, and the default is different.
kind = "stable" if stable else "quicksort"
if not descending:
res = np.argsort(x._array, axis=axis, kind=kind)
else:
# As NumPy has no native descending sort, we imitate it here. Note that
# simply flipping the results of np.argsort(x._array, ...) would not
# respect the relative order like it would in native descending sorts.
res = np.flip(
np.argsort(np.flip(x._array, axis=axis), axis=axis, kind=kind),
axis=axis,
)
# Rely on flip()/argsort() to validate axis
normalised_axis = axis if axis >= 0 else x.ndim + axis
max_i = x.shape[normalised_axis] - 1
res = max_i - res
return Array._new(res)
# Note: the descending keyword argument is new in this function
def sort(x: Array,
/,
*,
axis: int = -1,
descending: bool = False,
stable: bool = True) -> Array:
def sort(tensor, axis, descending=False):
if descending:
return cp.flip(cp.sort(tensor, axis=axis), axis=axis)
else:
return cp.sort(tensor, axis=axis)
#m_data=Image.open(multiply_2D_data)
#cp_m_data=cp.asarray(m_data,dtype="float32")
t1 = time.time()
multi_pattern = [cp_diff] * int(n_diff)
t2 = time.time()
print("make array : " + str(t2 - t1))
multi_pattern = cp.asarray(multi_pattern, dtype="float32")
t3 = time.time()
print("cupy convert : " + str(t3 - t2))
multi_pattern = cp.flip(multi_pattern, axis=1)
print("2D_multi shape = " + str(multi_pattern.shape))
#multi_pattern=multi_pattern*cp_m_data #全ての階層に適用される。
multi_pattern = cp.asnumpy(multi_pattern) #cupy配列 ⇒ numpy配列に変換
foname = finame[finame.rfind("/") + 1:len(finame) -
4] + "_n_" + n_diff + ".mrc"
with mrcfile.new(foname, overwrite=True) as mrc:
mrc.set_data(multi_pattern)
mrc.close
t5 = time.time()
print("total time : " + str(t5 - t1))
def display(a):
surf = pygame.surfarray.make_surface(
cp.asnumpy(
upsample((cp.flip(cp.flip(cp.swapaxes(a, 0, 1), 1), 0) * 255))))
disp.blit(surf, (0, 0))
import cupy as np
def argsort(
x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True
) -> Array:
"""
Array API compatible wrapper for :py:func:`np.argsort <numpy.argsort>`.
See its docstring for more information.
"""
# Note: this keyword argument is different, and the default is different.
kind = "stable" if stable else "quicksort"
res = np.argsort(x._array, axis=axis, kind=kind)
if descending:
res = np.flip(res, axis=axis)
return Array._new(res)
def sort(
x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True
) -> Array:
"""
Array API compatible wrapper for :py:func:`np.sort <numpy.sort>`.
See its docstring for more information.
"""
# Note: this keyword argument is different, and the default is different.
kind = "stable" if stable else "quicksort"
res = np.sort(x._array, axis=axis, kind=kind)
if descending:
def flip(arr, axis=None):
return cp.flip(arr, axis)
def get_image_init_array(image, shape: Tuple[int]):
init_image = IMG.open(image).convert("L")
init_image = init_image.resize(tuple(np.flip(shape)))
init_image = np.array(init_image) / 255
return init_image
ft1[0,2*intv:3*intv]=tri_wave.reshape(-1,)
ft1[0,6*intv:7*intv]=tri_wave.reshape(-1,)
ft1[0,9*intv:10*intv]=tri_wave.reshape(-1,)
ft1[0,14*intv:15*intv]=tri_wave.reshape(-1,)
ft1[0,21*intv:22*intv]=tri_wave.reshape(-1,)
ft[0] = ft0
ft[1] = ft1[0]
ft = cp.hstack([ft,ft,ft,ft,ft])
inputs0 = (1/flt -1 )/9
inputs1 = (1-inputs0)*2
# inputs = cp.vstack([inputs0,inputs1])
inputs = cp.ones((1,2000))*0.1
inputs = cp.hstack([inputs,inputs,inputs,inputs,inputs])
test_inputs = cp.flip(inputs,axis=1)
np.savez('./embed_data/longtime_train.npz',cp.asnumpy(ft),cp.asnumpy(inputs))
# np.savez('longtime_test.npz',ft,inpu)
# %%
while True:
nt = 3
N = 500
alpha = 1+ float(np.random.randn(1))
fb =1.0 + float(np.random.rand(1))
g = 1.6
gin = 1.0 + float(np.random.rand(1))
Pz = 0.2
# Pgg = float(cp.random.rand(1))*0.75
Pgg = 0.1
nn = Force_multi_out_gpu.Reservoir(N=N,p=Pgg,g=g)
def detect_particles(self, kltpicker):
"""
Construct the scoring matrix and then use the picking_from_scoring_mat function to pick particles and noise
images.
"""
eig_func_stat = self.eig_func[0:self.num_of_func, :]
eig_val_stat = self.eig_val[0:self.num_of_func]
for i in range(self.num_of_func):
tmp_func = np.reshape(
eig_func_stat[i, :],
(kltpicker.patch_size_func, kltpicker.patch_size_func))
tmp_func[kltpicker.rad_mat > np.floor(
(kltpicker.patch_size_func - 1) / 2)] = 0
eig_func_stat[i, :] = tmp_func.flatten()
[q, r] = np.linalg.qr(eig_func_stat.transpose(), 'complete')
r = r[0:self.num_of_func, 0:self.num_of_func]
kappa = np.linalg.multi_dot([
r, np.diag(eig_val_stat), r.transpose()
]) + (self.approx_noise_var * np.eye(self.num_of_func))
kappa_inv = np.linalg.inv(kappa)
t_mat = (1 / self.approx_noise_var) * np.eye(
self.num_of_func) - kappa_inv
[D, P] = np.linalg.eigh(t_mat)
D = D[::-1]
P = P[:, ::-1]
p_full = np.zeros(q.shape)
p_full[0:t_mat.shape[0], 0:t_mat.shape[1]] = P
mu = np.linalg.slogdet((1 / self.approx_noise_var) * kappa)[1]
num_of_patch_row = self.mc_size[0] - kltpicker.patch_size_func + 1
num_of_patch_col = self.mc_size[1] - kltpicker.patch_size_func + 1
qp = q @ p_full
qp = qp.transpose().copy()
if not kltpicker.no_gpu:
qp = cp.asarray(qp)
noise_mc = cp.asarray(self.noise_mc)
log_test_mat = cp.zeros((num_of_patch_row, num_of_patch_col))
D = cp.asarray(D)
for i in range(self.num_of_func):
qp_tmp = cp.reshape(qp[i, :],
(kltpicker.patch_size_func,
kltpicker.patch_size_func)).transpose()
qp_tmp = cp.flip(cp.flip(qp_tmp, 0), 1)
scoreTmp = fftconvolve2d_gpu(noise_mc, qp_tmp)
log_test_mat = log_test_mat + D[i] * abs(scoreTmp**2)
log_test_mat = log_test_mat.transpose() - mu
neigh = cp.ones(
(kltpicker.patch_size_func, kltpicker.patch_size_func))
log_test_n = cp.asnumpy(fftconvolve2d_gpu(log_test_mat, neigh))
else:
log_test_mat = np.zeros((num_of_patch_row, num_of_patch_col))
for i in range(self.num_of_func):
qp_tmp = np.reshape(qp[i, :],
(kltpicker.patch_size_func,
kltpicker.patch_size_func)).transpose()
qp_tmp = np.flip(np.flip(qp_tmp, 0), 1)
scoreTmp = signal.fftconvolve(self.noise_mc, qp_tmp, 'valid')
log_test_mat = log_test_mat + D[i] * abs(scoreTmp**2)
log_test_mat = log_test_mat.transpose() - mu
neigh = np.ones(
(kltpicker.patch_size_func, kltpicker.patch_size_func))
log_test_n = signal.fftconvolve(log_test_mat, neigh, 'valid')
[num_picked_particles,
num_picked_noise] = picking_from_scoring_mat(log_test_n.transpose(),
self.mrc_name, kltpicker,
self.mg_big_size)
return num_picked_particles, num_picked_noise
test_acc_array = []
train_acc_array = []
while train_iter.epoch < max_epoch:
train_accuracies = []
# ----------------- training loop 한 주기 설정----------------------
train_batch = train_iter.next()
image_train, target_train = concat_examples(train_batch, gpu_id)
# image_train = (image_train - Train_mean)
image_train = (image_train - Train_mean) / Train_std
Iarray_pad = cp.pad(image_train, ((0, 0), (0, 0), (4, 4), (4, 4)),
mode='constant')
Iarray_flip = cp.flip(Iarray_pad, 1)
a = [0, 1]
filp_flag = cp.random.choice(a, 128)
b = [0, 1, 2, 3, 4, 5, 6, 7]
c = [0, 1, 2, 3, 4, 5, 6, 7]
height_rand = cp.random.choice(b, 128)
width_rand = cp.random.choice(c, 128)
image_train_dataAug = cp.zeros([Iarray.shape[0], 3, 32, 32], 'float32')
for i in range(0, image_train.shape[0] - 1):
height = height_rand[i]
width = width_rand[i]
if filp_flag[i] == 0:
image_train_dataAug[i, :, :, :] = Iarray_pad[i, :,
height:height + 32,
width:width + 32]
def _project_cupy(reference_sources, estimated_source, flen, nsrc):
"""Least-squares projection of estimated source on the subspace spanned by
delayed versions of reference sources, with delays between 0 and flen-1
"""
# nsrc = tf.shape(reference_sources)[0]
nsampl = reference_sources.shape[1]
typ = reference_sources.dtype
# computing coefficients of least squares problem via FFT ##
# zero padding and FFT of input data
reference_sources = cp.concatenate(
(reference_sources, cp.zeros([nsrc, flen - 1], dtype=typ)), 1)
estimated_source = cp.concatenate(
(estimated_source, cp.zeros([flen - 1], dtype=typ)), 0)
n_fft = cp.power(2., cp.ceil(cp.log2(nsampl + flen - 1))).astype('i')
sf = cp.fft.fft(reference_sources, n=int(n_fft), axis=1)
sef = cp.fft.fft(estimated_source, n=int(n_fft))
# inner products between delayed versions of reference_sources
G = cp.empty([nsrc * flen, nsrc * flen])
for i in range(nsrc):
for j in range(nsrc):
ssf = sf[i] * cp.conj(sf[j])
ssf = cp.real(cp.fft.ifft(ssf))
ss = toeplitz_cupy(
cp.concatenate((cp.reshape(ssf[0], [1]), ssf[-1:-flen:-1]), 0),
ssf[:flen])
G[i * flen:(i + 1) * flen, j * flen:(j + 1) * flen] = ss
G[j * flen:(j + 1) * flen,
i * flen:(i + 1) * flen] = cp.transpose(ss)
# inner products between estimated_source and delayed versions of
# reference_sources
D = cp.empty([nsrc * flen])
for i in range(nsrc):
ssef = sf[i] * cp.conj(sef)
ssef = cp.real(cp.fft.ifft(ssef))
conc = cp.concatenate(
[cp.reshape(ssef[0], [1]),
cp.flip(ssef[-flen + 1:], 0)], 0)
D[i * flen:(i + 1) * flen] = conc
# Computing projection
# Distortion filters
s = cp.linalg.solve(G, cp.expand_dims(D, 1))
if nsrc == 2:
C = cp.concatenate((s[:flen], s[flen:]), 1)
else:
C = cp.reshape(s, (flen, nsrc))
# Filtering
sproj = cp.zeros([nsampl + flen - 1], dtype=cp.float64)
for i in range(nsrc):
fshape = C[:, i].shape[0] + reference_sources[i].shape[0] - 1
fft1 = cp.fft.rfftn(C[:, i], (fshape, ))
fft2 = cp.fft.rfftn(reference_sources[i], (fshape, ))
ifft = cp.fft.irfftn(fft1 * fft2, (fshape, ))
sproj += ifft[:nsampl + flen - 1]
return sproj
else:
print("OSS mode")
print("")
# open mrc file
with mrcfile.open(initial_dens, permissive=True) as mrc:
cp_dens = cp.asarray(mrc.data, dtype="float32")
mrc.close
if (support.find("tif") != 0):
sup = Image.open(support)
np_sup = np.asarray(sup, dtype="float32")
cp_sup = [np_sup] * int(cp_dens.shape[0])
cp_sup = cp.asarray(cp_sup, dtype="float32")
cp_sup = cp.flip(cp_sup, axis=1)
print("np_sup dtype = " + str(np_sup.dtype))
print("np_sup shape = " + str(np_sup.shape))
else:
with mrcfile.open(support, permissive=True) as mrc:
cp_sup = cp.asarray(mrc.data, dtype="float32")
mrc.close
print("cp_sup dtype = " + str(cp_sup.dtype))
print("cp_sup shape = " + str(cp_sup.shape))
print("cp_initial_dens dtype = " + str(cp_dens.dtype))
print("cp_initial_dens shape = " + str(cp_dens.shape))
print("")
if (cp_sup.shape != cp_dens.shape):
def flip(im):
return np.flip(im, random.choice([x for x in range(len(im.shape))]))
