def fetch_train_thoughts(m,pcs,batches,name="trainthoughts"):
all_thoughts = []
for i in range(batches):
ipt, opt = multi_training.getPieceBatch(pcs)
thoughts = m.update_thought_fun(ipt,opt)
all_thoughts.append((ipt,opt,thoughts))
pickle.dump(all_thoughts, open('output/'+name+'.p','wb'))
def fetch_train_thoughts(m,pcs,batches,name="trainthoughts"):
all_thoughts = []
for i in range(batches):
ipt, opt = multi_training.getPieceBatch(pcs)
thoughts = m.update_thought_fun(ipt,opt)
all_thoughts.append((ipt,opt,thoughts))
pickle.dump(all_thoughts, open('output/'+name+'.p','wb'))
def test_training_model():
pcs = multi_training.loadPieces("Train_data")
data = multi_training.getPieceBatch(pcs)
model = m.BiaxialRNNModel([300, 300], [100, 50])
print(model)
out = model(data, training=True)
print(out.shape)
def train(music_folder, out_model_name, just_this_midi=None):
Working_Directory = os.getcwd()
Music_Directory = "../proyecto-beatles/midis_por_instrumento/"
print(Working_Directory)
Midi_Directories = [music_folder]
max_time_steps = 256 # only files atleast this many 16th note steps are saved
num_validation_pieces = 2
practice_batch_size = 15
practice_num_timesteps = 128
num_t_units = [200, 200]
start_time = time.time()
max_iteration = 15000 #50000
iter_midi = 3000
loss_hist = []
loss_valid_hist = []
restore_model_name = None #'Long_Train'
save_model_name = out_model_name
batch_size = 5
num_timesteps = 256
keep_prob = .3
num_n_units = [60, 60]
limit_train = None
# Gather the training pieces from the specified directories
training_pieces = {}
if just_this_midi:
training_pieces = {
just_this_midi:
midi_musical_matrix.midiToNoteStateMatrix(just_this_midi)
}
else:
for f in range(len(Midi_Directories)):
Training_Midi_Folder = Music_Directory + Midi_Directories[f]
training_pieces = {
**training_pieces,
**multi_training.loadPieces(Training_Midi_Folder,
max_time_steps,
max_elements=limit_train)
}
# Set aside a random set of pieces for validation purposes
validation_pieces = {}
if just_this_midi:
for f in range(1):
Training_Midi_Folder = Music_Directory + Midi_Directories[f]
validation_pieces = {
**validation_pieces,
**multi_training.loadPieces(Training_Midi_Folder,
max_time_steps,
max_elements=1)
}
else:
for v in range(num_validation_pieces):
index = random.choice(list(training_pieces.keys()))
validation_pieces[index] = training_pieces.pop(index)
print('')
print('Number of training pieces = ', len(training_pieces))
print('Number of validation pieces = ', len(validation_pieces))
# Generate sample Note State Matrix for dimension measurement and numerical checking purposes
# (Using external code to generate the Note State Matrix but using our own NoteInputForm (as defined in author's code) function
_, sample_state = multi_training.getPieceBatch(training_pieces,
practice_batch_size,
practice_num_timesteps)
sample_state = np.array(sample_state)
sample_state = np.swapaxes(sample_state, axis1=1, axis2=2)
print('Sample of State Input Batch: shape = ', sample_state.shape)
# Build the Model Graph:
tf.reset_default_graph()
print('Building Graph...')
#Capture number of notes from sample
num_notes = sample_state.shape[1]
# Graph Input Placeholders
Note_State_Batch = tf.placeholder(dtype=tf.float32,
shape=[None, num_notes, None, 2],
name='node_state_batch')
time_init = tf.placeholder(dtype=tf.int32, shape=(), name='time_init')
#Generate expanded tensor from batch of note state matrices
# Essential the CNN 'window' of this network
Note_State_Expand = Input_Kernel(Note_State_Batch,
Midi_low=24,
Midi_high=101,
time_init=time_init)
print('Note_State_Expand shape = ', Note_State_Expand.get_shape())
# lSTM Time Wise Training Graph
output_keep_prob = tf.placeholder(dtype=tf.float32,
shape=(),
name="output_keep_prob")
# Generate initial state (at t=0) placeholder
timewise_state = []
for i in range(len(num_t_units)):
timewise_c = tf.placeholder(
dtype=tf.float32,
shape=[None, num_t_units[i]],
name='timewise_c{0}'.format(i)) #None = batch_size * num_notes
timewise_h = tf.placeholder(dtype=tf.float32,
shape=[None, num_t_units[i]],
name='timewise_h{0}'.format(i))
timewise_state.append(LSTMStateTuple(timewise_h, timewise_c))
timewise_state = tuple(timewise_state)
timewise_out, timewise_state_out = LSTM_TimeWise_Training_Layer(
input_data=Note_State_Expand,
state_init=timewise_state,
output_keep_prob=output_keep_prob)
print('Time-wise output shape = ', timewise_out.get_shape())
#LSTM Note Wise Graph
# Generate initial state (at n=0) placeholder
notewise_state = []
for i in range(len(num_n_units)):
notewise_c = tf.placeholder(
dtype=tf.float32,
shape=[None, num_n_units[i]],
name='notewise_c{0}'.format(i)) #None = batch_size * num_timesteps
notewise_h = tf.placeholder(dtype=tf.float32,
shape=[None, num_n_units[i]],
name='notewise_h{0}'.format(i))
notewise_state.append(LSTMStateTuple(notewise_h, notewise_c))
notewise_state = tuple(notewise_state)
y_out, note_gen_out = LSTM_NoteWise_Layer(
timewise_out,
state_init=notewise_state,
output_keep_prob=output_keep_prob)
note_gen_out = tf.identity(note_gen_out, name="note_gen_out")
p_out = tf.sigmoid(y_out)
print('y_out shape = ', y_out.get_shape())
print('generated samples shape = ', note_gen_out.get_shape())
# Loss Function and Optimizer
loss, log_likelihood = Loss_Function(Note_State_Batch, y_out)
optimizer = tf.train.AdadeltaOptimizer(learning_rate=1).minimize(loss)
#optimizer = tf.train.RMSPropOptimizer
print('Graph Building Complete')
# Training
# Save Model
Output_Directory = Working_Directory + "/Output/" + save_model_name
directory = os.path.dirname(Output_Directory)
try:
print('creating new destination folder')
os.mkdir(directory)
except:
print('destination folder exists')
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
# try to restore the pre_trained
if restore_model_name is not None:
Load_Directory = Working_Directory + "/Output/" + restore_model_name
print("Load the model from: {}".format(restore_model_name))
saver.restore(sess,
Load_Directory + '/{}'.format(restore_model_name))
# Training Loop
for iteration in range(max_iteration + 1):
# Generate random batch of training data
if (iteration % 100 == 0):
print('Obtaining new batch of pieces')
_, batch_input_state = multi_training.getPieceBatch(
training_pieces, batch_size,
num_timesteps) # not using their 'convolution' filter
batch_input_state = np.array(batch_input_state)
batch_input_state = np.swapaxes(batch_input_state,
axis1=1,
axis2=2)
feed_dict = get_feed_dict(batch_input_state, 0, keep_prob)
feed_initial_st = get_feed_initil_state(batch_size, num_notes,
num_timesteps, num_t_units,
num_n_units)
feed_dict = {**feed_dict, **feed_initial_st}
# Run Session
loss_run, log_likelihood_run, _, note_gen_out_run = sess.run(
[loss, log_likelihood, optimizer, note_gen_out],
feed_dict=feed_dict)
# Periodically save model and loss histories
if (iteration % 1000 == 0) & (iteration > 0):
save_path = saver.save(
sess, Output_Directory + '/{}'.format(save_model_name))
print("Model saved in file: %s" % save_path)
np.save(Output_Directory + "/ training_loss.npy", loss_hist)
np.save(Output_Directory + "/ valid_loss.npy", loss_valid)
# Regularly Calculate Validation loss and store both training and validation losses
if (iteration % 100) == 0 & (iteration > 0):
# Calculation Validation loss
_, batch_input_state_valid = multi_training.getPieceBatch(
validation_pieces, batch_size,
num_timesteps) # not using their 'convolution' filter
batch_input_state_valid = np.array(batch_input_state_valid)
batch_input_state_valid = np.swapaxes(batch_input_state_valid,
axis1=1,
axis2=2)
feed_dict = get_feed_dict(batch_input_state_valid, 0,
keep_prob)
feed_initial_st = get_feed_initil_state(
batch_size, num_notes, num_timesteps, num_t_units,
num_n_units)
feed_dict = {**feed_dict, **feed_initial_st}
loss_valid, log_likelihood_valid = sess.run(
[loss, log_likelihood], feed_dict=feed_dict)
print('epoch = ', iteration, ' / ', max_iteration, ':')
print('Training loss = ', loss_run,
'; Training log likelihood = ', log_likelihood_run)
print('Validation loss = ', loss_valid,
'; Validation log likelihood = ', log_likelihood_valid)
loss_hist.append(loss_run)
loss_valid_hist.append(loss_valid)
# Periodically generate Sample of music
if (iteration % iter_midi) == 0 and (iteration > 0):
generate_midi(
sess, num_notes, num_t_units, num_n_units,
"midi_{1}_iteracion{0}".format(iteration, out_model_name))
end_time = time.time()
print('Training time = ', end_time - start_time, ' seconds')
# Plot the loss histories
os.makedirs(Output_Directory, exist_ok=True)
plt.switch_backend("agg")
plt.plot(loss_hist, label="Training Loss")
plt.plot(loss_valid_hist, label="Validation Loss")
plt.legend()
plt.savefig(
os.path.join(Output_Directory,
"train-val_loss_{0}.png".format(out_model_name)))