def _build(det_dropout):
all_out_probs = []
for encoding, lstmstack, encoded_melody, relative_pos in zip(self.encodings, self.lstmstacks, encoded_melodies, relative_posns):
activations = lstmstack.do_preprocess_scan( timestep=T.tile(T.arange(n_time), (n_batch,1)) ,
relative_position=relative_pos,
cur_chord_type=chord_types,
cur_chord_root=chord_roots,
last_output=T.concatenate([T.tile(encoding.initial_encoded_form(), (n_batch,1,1)),
encoded_melody[:,:-1,:] ], 1),
deterministic_dropout=det_dropout)
out_probs = encoding.decode_to_probs(activations, relative_pos, self.bounds.lowbound, self.bounds.highbound)
all_out_probs.append(out_probs)
reduced_out_probs = functools.reduce((lambda x,y: x*y), all_out_probs)
if self.normalize_artic_only:
non_artic_probs = reduced_out_probs[:,:,:2]
artic_probs = reduced_out_probs[:,:,2:]
non_artic_sum = T.sum(non_artic_probs, 2, keepdims=True)
artic_sum = T.sum(artic_probs, 2, keepdims=True)
norm_artic_probs = artic_probs*(1-non_artic_sum)/artic_sum
norm_out_probs = T.concatenate([non_artic_probs, norm_artic_probs], 2)
else:
normsum = T.sum(reduced_out_probs, 2, keepdims=True)
normsum = T.maximum(normsum, constants.EPSILON)
norm_out_probs = reduced_out_probs/normsum
return Encoding.compute_loss(norm_out_probs, correct_notes, True)
def _build(det_dropout):
activations = self.lstmstack.do_preprocess_scan( timestep=T.tile(T.arange(n_time), (n_batch,1)) ,
relative_position=relative_pos,
cur_chord_type=chord_types,
cur_chord_root=chord_roots,
last_output=T.concatenate([T.tile(self.encoding.initial_encoded_form(), (n_batch,1,1)),
encoded_melody[:,:-1,:] ], 1),
deterministic_dropout=det_dropout)
out_probs = self.encoding.decode_to_probs(activations, relative_pos, self.bounds.lowbound, self.bounds.highbound)
return Encoding.compute_loss(out_probs, correct_notes, True)
def _build(det_dropout):
all_activations = []
for encoding, enc_lstmstack, encoded_melody, relative_pos in zip(self.encodings, self.enc_lstmstacks, encoded_melodies, relative_posns):
activations = enc_lstmstack.do_preprocess_scan( timestep=T.tile(T.arange(n_time), (n_batch,1)) ,
relative_position=relative_pos,
cur_chord_type=chord_types,
cur_chord_root=chord_roots,
cur_input=encoded_melody,
deterministic_dropout=det_dropout)
all_activations.append(activations)
reduced_activations = functools.reduce((lambda x,y: x+y), all_activations)
queue_loss, feat_strengths, feat_vects, queue_info = self.qman.process(reduced_activations, extra_info=True)
features = QueueManager.queue_transform(feat_strengths, feat_vects)
all_out_probs = []
for encoding, dec_lstmstack, encoded_melody, relative_pos in zip(self.encodings, self.dec_lstmstacks, encoded_melodies, relative_posns):
activations = dec_lstmstack.do_preprocess_scan( timestep=T.tile(T.arange(n_time), (n_batch,1)) ,
relative_position=relative_pos,
cur_chord_type=chord_types,
cur_chord_root=chord_roots,
cur_feature=features,
last_output=T.concatenate([T.tile(encoding.initial_encoded_form(), (n_batch,1,1)),
encoded_melody[:,:-1,:] ], 1),
deterministic_dropout=det_dropout)
out_probs = encoding.decode_to_probs(activations, relative_pos, self.bounds.lowbound, self.bounds.highbound)
all_out_probs.append(out_probs)
reduced_out_probs = functools.reduce((lambda x,y: x*y), all_out_probs)
normsum = T.sum(reduced_out_probs, 2, keepdims=True)
normsum = T.maximum(normsum, constants.EPSILON)
norm_out_probs = reduced_out_probs/normsum
reconstruction_loss, reconstruction_info = Encoding.compute_loss(norm_out_probs, correct_notes, extra_info=True)
queue_surrogate_loss_parts = self.qman.surrogate_loss(reconstruction_loss, queue_info)
updates = []
full_info = queue_info.copy()
full_info.update(reconstruction_info)
full_info["queue_loss"] = queue_loss
full_info["reconstruction_loss"] = reconstruction_loss
float_n_batch = T.cast(n_batch,'float32')
if self.loss_mode is "add":
full_loss = queue_loss + reconstruction_loss
elif self.loss_mode is "priority":
curviness = np.array(self.loss_mode_params[0], np.float32)*float_n_batch
# ln( e^x + e^y - 1 )
# ln( C(e^x + e^y - 1) ) - ln(C)
# ln( e^c(e^x + e^y - 1) ) - c
# ln( e^(x+c) + e^(y+c) - e^c ) - c
# ln( e^(x-c) + e^(y-c) - e^(-c) ) + c
# Now let c = maximum(x,y), d = minimum(x,y). WOLOG replace x=c, y=d
# ln( e^(c-c) + e^(d-c) - e^(-c) ) + c
# ln( 1 + e^(d-c) - e^(-c) ) + c
x = reconstruction_loss/curviness
y = queue_loss/curviness
c = T.maximum(x,y)
d = T.minimum(x,y)
full_loss = (T.log( 1 + T.exp(d-c) - T.exp(-c)) + c)*curviness
elif self.loss_mode is "cutoff":
cutoff_val = np.array(self.loss_mode_params[0], np.float32)
full_loss = T.switch(reconstruction_loss<cutoff_val*float_n_batch, reconstruction_loss+queue_loss, reconstruction_loss)
elif self.loss_mode is "trigger":
trigger_val = np.array(self.loss_mode_params[0], np.float32)
trigger_speed = np.array(1.0/self.loss_mode_params[1], np.float32)
trigger_is_on = theano.shared(np.array(0, np.int8))
trigger_scale = theano.shared(np.array(0.0, np.float32))
full_loss = reconstruction_loss + trigger_scale * queue_loss
updates.append((trigger_is_on, T.or_(trigger_is_on, reconstruction_loss<trigger_val*float_n_batch)))
updates.append((trigger_scale, T.switch(trigger_is_on, T.minimum(trigger_scale + trigger_speed, np.array(1.0,np.float32)), np.array(0.0,np.float32))))
full_info["trigger_scale"] = trigger_scale
if queue_surrogate_loss_parts is not None:
surrogate_loss, addtl_updates = queue_surrogate_loss_parts
full_loss = full_loss + surrogate_loss
updates.extend(addtl_updates)
full_info["surrogate_loss"] = surrogate_loss
return full_loss, full_info, updates
def _build(det_dropout):
all_activations = []
for encoding, enc_lstmstack, encoded_melody, relative_pos in zip(
self.encodings, self.enc_lstmstacks, encoded_melodies,
relative_posns):
activations = enc_lstmstack.do_preprocess_scan(
timestep=T.tile(T.arange(n_time), (n_batch, 1)),
relative_position=relative_pos,
cur_chord_type=chord_types,
cur_chord_root=chord_roots,
cur_input=encoded_melody,
deterministic_dropout=det_dropout)
all_activations.append(activations)
reduced_activations = functools.reduce((lambda x, y: x + y),
all_activations)
queue_loss, feat_strengths, feat_vects, queue_info = self.qman.process(
reduced_activations, extra_info=True)
features = QueueManager.queue_transform(feat_strengths, feat_vects)
all_out_probs = []
for encoding, dec_lstmstack, encoded_melody, relative_pos in zip(
self.encodings, self.dec_lstmstacks, encoded_melodies,
relative_posns):
activations = dec_lstmstack.do_preprocess_scan(
timestep=T.tile(T.arange(n_time), (n_batch, 1)),
relative_position=relative_pos,
cur_chord_type=chord_types,
cur_chord_root=chord_roots,
cur_feature=features,
last_output=T.concatenate([
T.tile(encoding.initial_encoded_form(),
(n_batch, 1, 1)), encoded_melody[:, :-1, :]
], 1),
deterministic_dropout=det_dropout)
out_probs = encoding.decode_to_probs(activations, relative_pos,
self.bounds.lowbound,
self.bounds.highbound)
all_out_probs.append(out_probs)
reduced_out_probs = functools.reduce((lambda x, y: x * y),
all_out_probs)
normsum = T.sum(reduced_out_probs, 2, keepdims=True)
normsum = T.maximum(normsum, constants.EPSILON)
norm_out_probs = reduced_out_probs / normsum
reconstruction_loss, reconstruction_info = Encoding.compute_loss(
norm_out_probs, correct_notes, extra_info=True)
queue_surrogate_loss_parts = self.qman.surrogate_loss(
reconstruction_loss, queue_info)
updates = []
full_info = queue_info.copy()
full_info.update(reconstruction_info)
full_info["queue_loss"] = queue_loss
full_info["reconstruction_loss"] = reconstruction_loss
float_n_batch = T.cast(n_batch, 'float32')
if self.loss_mode is "add":
full_loss = queue_loss + reconstruction_loss
elif self.loss_mode is "priority":
curviness = np.array(self.loss_mode_params[0],
np.float32) * float_n_batch
# ln( e^x + e^y - 1 )
# ln( C(e^x + e^y - 1) ) - ln(C)
# ln( e^c(e^x + e^y - 1) ) - c
# ln( e^(x+c) + e^(y+c) - e^c ) - c
# ln( e^(x-c) + e^(y-c) - e^(-c) ) + c
# Now let c = maximum(x,y), d = minimum(x,y). WOLOG replace x=c, y=d
# ln( e^(c-c) + e^(d-c) - e^(-c) ) + c
# ln( 1 + e^(d-c) - e^(-c) ) + c
x = reconstruction_loss / curviness
y = queue_loss / curviness
c = T.maximum(x, y)
d = T.minimum(x, y)
full_loss = (T.log(1 + T.exp(d - c) - T.exp(-c)) +
c) * curviness
elif self.loss_mode is "cutoff":
cutoff_val = np.array(self.loss_mode_params[0], np.float32)
full_loss = T.switch(
reconstruction_loss < cutoff_val * float_n_batch,
reconstruction_loss + queue_loss, reconstruction_loss)
elif self.loss_mode is "trigger":
trigger_val = np.array(self.loss_mode_params[0], np.float32)
trigger_speed = np.array(1.0 / self.loss_mode_params[1],
np.float32)
trigger_is_on = theano.shared(np.array(0, np.int8))
trigger_scale = theano.shared(np.array(0.0, np.float32))
full_loss = reconstruction_loss + trigger_scale * queue_loss
updates.append(
(trigger_is_on,
T.or_(trigger_is_on,
reconstruction_loss < trigger_val * float_n_batch)))
updates.append((trigger_scale,
T.switch(
trigger_is_on,
T.minimum(trigger_scale + trigger_speed,
np.array(1.0, np.float32)),
np.array(0.0, np.float32))))
full_info["trigger_scale"] = trigger_scale
if queue_surrogate_loss_parts is not None:
surrogate_loss, addtl_updates = queue_surrogate_loss_parts
full_loss = full_loss + surrogate_loss
updates.extend(addtl_updates)
full_info["surrogate_loss"] = surrogate_loss
return full_loss, full_info, updates