def iterate(self, inputs, targets):
assert len(inputs) == len(targets)
seg_size = self.config.getint('pairwise_kldiv', 'seg_size')
spectrogram_height = self.config.getint('pairwise_kldiv',
'spectrogram_height')
for i in range(0, self.batches_per_epoch):
Xb = np.zeros((self.batchsize, 1, spectrogram_height, seg_size),
dtype=np.float32)
yb = np.zeros(self.batchsize, dtype=np.int32)
# here one batch is generated
for j in range(
0, self.batchsize,
self.speaker_offset_limit * self.segments_per_sentence):
speaker_idx = randint(0, len(inputs) - 1)
for speaker_offset in range(self.speaker_offset_limit):
speaker_idx_offset = speaker_idx + speaker_offset
if speaker_idx_offset >= len(inputs):
speaker_idx_offset = speaker_idx - speaker_offset
spect = extract_spectrogram(inputs[speaker_idx, 0],
seg_size, spectrogram_height)
self._extract_segments(Xb, yb, targets,
j + speaker_offset * 2,
speaker_idx_offset, spect,
self.segments_per_sentence)
yield Xb, yb
def generate_cluster_data(X, y, overlapping=False):
seg_size = config.getint('pairwise_cosface', 'seg_size')
spectrogram_height = config.getint('pairwise_cosface',
'spectrogram_height')
X_cluster = np.zeros((10000, 1, spectrogram_height, seg_size),
dtype=np.float32)
y_cluster = []
step = seg_size
if overlapping:
step = seg_size / 2
pos = 0
for i in range(len(X)):
spect = extract_spectrogram(X[i, 0], seg_size, spectrogram_height)
for j in range(int(spect.shape[1] / step)):
y_cluster.append(y[i])
seg_idx = j * step
try:
X_cluster[pos, 0] = spect[:, seg_idx:seg_idx + seg_size]
except ValueError:
# if the last segment doesn't match ignore it
pass
pos += 1
return X_cluster[0:len(y_cluster)], np.asarray(y_cluster, dtype=np.int32)
def iterate(self, inputs, targets):
assert len(inputs) == len(targets)
seg_size = self.config.getint('pairwise_kldiv', 'seg_size')
spectrogram_height = self.config.getint('pairwise_kldiv',
'spectrogram_height')
seg_count = 0
for input in inputs:
seg_count += extract_spectrogram(
input[0], seg_size, spectrogram_height
).shape[
1] / seg_size + 1 # todo: make the segments overlapping by half a second
speaker_idx = 0
segment_pos = 0
iterations = seg_count - self.batchsize + 1
if seg_count < self.batchsize:
iterations = seg_count
for start_idx in range(0, iterations, self.batchsize):
Xb = np.zeros((self.batchsize, 1, spectrogram_height, seg_size),
dtype=np.float32)
yb = []
spect = extract_spectrogram(inputs[speaker_idx, 0], seg_size,
spectrogram_height)
for batch_pos in range(0, self.batchsize):
if targets is not None:
yb.append(targets[speaker_idx])
if segment_pos == spect.shape[1] / seg_size:
# add the last segment backwards to ensure nothing is left out
Xb[batch_pos,
0] = spect[:, spect.shape[1] - seg_size:spect.shape[1]]
else:
seg_idx = segment_pos * seg_size
Xb[batch_pos, 0] = spect[:, seg_idx:seg_idx + seg_size]
segment_pos += 1
if segment_pos == spect.shape[
1] / seg_size + 1 and speaker_idx + 1 < len(inputs):
speaker_idx += 1
spect = extract_spectrogram(inputs[speaker_idx, 0],
seg_size, spectrogram_height)
segment_pos = 0
elif segment_pos == spect.shape[
1] / seg_size + 1 and speaker_idx + 1 == len(inputs):
break
yield Xb[0:len(yb)], np.asarray(yb, dtype=np.int32)
def __iter__(self):
bs = self.batch_size
seg_size = self.config.getint('luvo', 'seg_size')
spectrogram_height = self.config.getint('luvo', 'spectrogram_height')
# build as much batches as fit into the training set
for i in range((self.n_samples + bs - 1) // bs):
Xb = np.zeros((bs, 1, spectrogram_height, seg_size),
dtype=np.float32)
yb = np.zeros(bs, dtype=np.int32)
# here one batch is generated
for j in range(0, bs):
speaker_idx = randint(0, len(self.X) - 1)
if self.y is not None:
yb[j] = self.y[speaker_idx]
spectrogramm = extract_spectrogram(self.X[speaker_idx,
0], seg_size,
spectrogram_height)
seg_idx = randint(0, spectrogramm.shape[1] - seg_size)
Xb[j, 0] = spectrogramm[:, seg_idx:seg_idx + seg_size]
yield Xb, yb
def _extract(self, spectrogram):
return extract_spectrogram(spectrogram, self.segment_size,
self.spectrogram_height)
def extract(spectrogram, segment_size):
return extract_spectrogram(spectrogram, segment_size,
settings.FREQ_ELEMENTS)
def extract_spectrogram(self, spectrogram):
return extract_spectrogram(spectrogram, self.duration, self.frequency_elements)
def extract(spectrogram, segment_size):
return extract_spectrogram(spectrogram, segment_size, spectrogram_height)
