### Run the graph! # Now it's time to start a session and run the graph! with tf.Session() as sess: #First, we train the model #initialize the variables of the model init = tf.initialize_all_variables() sess.run(init) #Run through all of the training data num_epochs times for epoch in tqdm(range(num_epochs)): for song in songs: #The songs are stored in a time x notes format. The size of each song is timesteps_in_song x 2*note_range #Here we reshape the songs so that each training example is a vector with num_timesteps x 2*note_range elements song = np.array(song) song = song[:np.floor(song.shape[0]/num_timesteps)*num_timesteps] song = np.reshape(song, [song.shape[0]/num_timesteps, song.shape[1]*num_timesteps]) #Train the RBM on batch_size examples at a time for i in range(1, len(song), batch_size): tr_x = song[i:i+batch_size] sess.run(updt, feed_dict={x: tr_x}) #Now the model is fully trained, so let's make some music! #Run a gibbs chain where the visible nodes are initialized to 0 sample = gibbs_sample(1).eval(session=sess, feed_dict={x: np.zeros((10, n_visible))}) for i in range(sample.shape[0]): if not any(sample[i,:]): continue #Here we reshape the vector to be time x notes, and then save the vector as a midi file S = np.reshape(sample[i,:], (num_timesteps, 2*note_range)) midi_manipulation.noteStateMatrixToMidi(S, "generated_chord_{}".format(i))
# author chinabluewu@github import numpy as np from tqdm import tqdm import glob #sudo pip install msgpack-python import msgpack import midi_manipulation #files = glob.glob('{}/*.mid*'.format(path)) try: files = glob.glob('generated*.mid*') except Exception as e: raise e songs = np.zeros((0,156)) for f in tqdm(files): try: song = np.array(midi_manipulation.midiToNoteStateMatrix(f)) if np.array(song).shape[0] > 10: #songs.append(song) songs = np.concatenate((songs,song)) except Exception as e: raise e print "samlpes merging ..." print np.shape(songs) midi_manipulation.noteStateMatrixToMidi(songs, "final")
# author chinabluewu@github import numpy as np from tqdm import tqdm import glob #sudo pip install msgpack-python import msgpack import midi_manipulation #files = glob.glob('{}/*.mid*'.format(path)) try: files = glob.glob('./generated/generated*.mid*') except Exception as e: raise e songs = np.zeros((0, 156)) for f in tqdm(files): try: song = np.array(midi_manipulation.midiToNoteStateMatrix(f)) #if np.array(song).shape[0] > 10: #songs.append(song) songs = np.concatenate((songs, song)) except Exception as e: raise e print("samlpes merging ...") print(np.shape(songs)) midi_manipulation.noteStateMatrixToMidi(songs, "final")
print(it, end=' ! ') plt.plot(losses) plt.savefig('plot_losses') if it % 1 == 0: samples = torch.randn(8, 300).to(device) samples = model.decode(X=samples, z=samples, sample_new=True).cpu() samples = samples.detach().numpy() samples[samples <= 0.5] = 0 samples[samples > 0.5] = 1 for i, sample in enumerate(samples): sample = sample.reshape(-1, 156) noteStateMatrixToMidi(sample, name=("samples/" + str(it) + "new_sample_" + str(i))) if it > 2 and it % 4 == 0: for param_group in optimizer.param_groups: param_group['lr'] *= 0.8 for ii, X in enumerate(dataloader): # X = Variable(torch.from_numpy(X)) optimizer.zero_grad() X = X.type(torch.FloatTensor) X = X.to(device) # Forward X_sample, z_mu, z_var = model(X)
def launch(): #TODO All the entry point ###################################### ### Hypermarameters ### ###################################### lowest_note = import_midi.lowerBound highest_note = import_midi.upperBound note_range = highest_note - lowest_note truncated_backprop_length = 15 n_inputs = 2 * note_range * truncated_backprop_length num_steps = 15 num_neurons = 150 num_outputs = n_inputs num_epochs = 100 batch_size = 10 state_size = 4 num_classes = 2 songs = import_midi.get_songs("../musics/") songs = np.array(songs) print(songs.shape) num_batches = len(songs) // batch_size learning_rate = tf.constant(0.005, tf.float32) ###################################### ### variables ### ###################################### x = tf.placeholder(tf.float32, [None, None, n_inputs]) y = tf.placeholder(tf.int32, [None, None]) seqlen = tf.placeholder W = tf.Variable(np.random.rand(batch_size, n_inputs, batch_size), dtype=tf.float32) b = tf.Variable(np.zeros((1, batch_size)), dtype=tf.float32) W2 = tf.Variable(np.random.rand(batch_size, n_inputs, batch_size), dtype=tf.float32) b2 = tf.Variable(np.zeros((1, batch_size)), dtype=tf.float32) cell = tf.contrib.rnn.BasicRNNCell(num_units=num_neurons) outputs, states = tf.nn.dynamic_rnn(cell, x, dtype=tf.float32) logits_series = tf.layers.dense(outputs, num_outputs) ###################################### ### fonction de perte ### ###################################### print(logits_series) print(y) losses = tf.nn.sparse_softmax_cross_entropy_with_logits( labels=y, logits=logits_series) total_loss = tf.reduce_mean(losses) ########################################### ### fonction d optimisation ### ########################################### optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) train_step = optimizer.minimize(total_loss) ########################################### ### fonction de descente de gradient ### ########################################### def sample(probs): return tf.floor(probs + tf.random_uniform(tf.shape(probs), 0, 1)) def gibbs_sample(k): def gibbs_step(count, k, xk): return count + 1, k, xk ct = tf.constant(0) [_, _, x_sample] = control_flow_ops.while_loop( lambda count, num_iter, *args: count < num_iter, gibbs_step, [ct, tf.constant(k), x]) x_sample = tf.stop_gradient(x_sample) return x_sample ###################################### ### Run ### ###################################### with tf.Session() as sess: sess.run(tf.initialize_all_variables()) updt = [total_loss, train_step, states] for epoch_idx in range(num_epochs): _states = np.zeros((batch_size, state_size)) print("New song, epoch :", epoch_idx) print(len(songs)) for song in songs: if len(song) > 1: song = np.array(song) song = song[:int( np.floor(song.shape[0] // num_steps) * num_steps)] print(song) print(song.shape) song = np.reshape(song, [ -1, song.shape[0] // num_steps, song.shape[1] * num_steps ]) for i in range(1, len(song), batch_size): tr_x = song[i:i + batch_size] print(x.shape) print(tr_x.shape) print(tr_x) _total_loss, _train_step, _states = sess.run( updt, feed_dict={x: tr_x}) sample = gibbs_sample(1).eval( session=sess, feed_dict={x: np.zeros((batch_size, num_steps, n_inputs))}) for i in range(sample.shape[0]): smpl = np.array(sample[i, :]) spml = smpl[:int( np.floor(smpl.shape[0] // num_steps) * num_steps)] print(smpl) S = np.reshape(smpl, [ -1, smpl.shape[0] // num_steps, smpl.shape[1] * num_steps ]) midi_manipulation.noteStateMatrixToMidi( S, "../out/generated_chord_{}".format(i))
for song in songs: # The songs are stored in a time x notes format. The size of each song is timesteps_in_song x 2*note_range # Here we reshape the songs so that each training example # is a vector with num_timesteps x 2*note_range elements song = np.array(song) song = song[:int( np.floor(song.shape[0] // num_timesteps) * num_timesteps)] song = np.reshape(song, [ song.shape[0] // num_timesteps, song.shape[1] * num_timesteps ]) # Train the RBM on batch_size examples at a time for i in range(1, len(song), batch_size): tr_x = song[i:i + batch_size] sess.run(updt, feed_dict={x: tr_x}) #-------------------------------------------------------------------------------------------------------------------------------------------- # Generating Music print("Generating Music...................") # Run a gibbs chain where the visible nodes are initialized to 0 sample = gibbs_sample(1).eval(session=sess, feed_dict={x: np.zeros((10, n_visible))}) for i in range(sample.shape[0]): if not any(sample[i, :]): continue # Here we reshape the vector to be time x notes, and then save the vector as a midi file S = np.reshape(sample[i, :], (num_timesteps, 2 * note_range)) if not os.path.exists("out"): os.mkdir('out') midi_manipulation.noteStateMatrixToMidi( S, "out/generated_chord_{}".format(i)) #--------------------------------------------------------------------------------------------------------------------------------------------
# When we do sess.run(updt), TensorFlow will run all 3 update steps updt = [W.assign_add(W_adder), bv.assign_add(bv_adder), bh.assign_add(bh_adder)] with tf.Session() as sess: # First, we train the model # initialize the variables of the model init = tf.global_variables_initializer() sess.run(init) # Run through all of the training data num_epochs times for epoch in tqdm(range(num_epochs)): for song in songs: # The songs are stored in a time x notes format. The size of each song is timesteps_in_song x 2*note_range # Here we reshape the songs so that each training example # is a vector with num_timesteps x 2*note_range elements song = np.array(song) song = song[:int(np.floor(song.shape[0] // num_timesteps) * num_timesteps)] song = np.reshape(song, [song.shape[0] // num_timesteps, song.shape[1] * num_timesteps]) # Train the RBM on batch_size examples at a time for i in range(1, len(song), batch_size): tr_x = song[i:i + batch_size] sess.run(updt, feed_dict={x: tr_x}) #make music # Run a gibbs chain where the visible nodes are initialized to 0 sample = gibbs_sample(1).eval(session=sess, feed_dict={x: np.zeros((10, n_visible))}) for i in range(sample.shape[0]): if not any(sample[i, :]): continue # Here we reshape the vector to be time x notes, and then save the vector as a midi file S = np.reshape(sample[i, :], (num_timesteps, 2 * note_range)) midi_manipulation.noteStateMatrixToMidi(S, "path_to_output_folder/generated_chord_{}".format(i))
init = tf.compat.v1.global_variables_initializer() sess.run(init) # Run through all of the training data epochs times for epoch in tqdm(range(epochs)): for song in songs: # The songs are stored in a time x notes format. The size of each song is timesteps_in_song x 2*note_range # Here we reshape the songs so that each training example # is a vector with num_timesteps x 2*note_range elements song = np.array(song) song = song[:int( np.floor(song.shape[0] // num_timesteps) * num_timesteps)] song = np.reshape(song, [ song.shape[0] // num_timesteps, song.shape[1] * num_timesteps ]) # Train the RBM on batch_size examples at a time for i in range(1, len(song), batch_size): tr_x = song[i:i + batch_size] sess.run(updt, feed_dict={x: tr_x}) # Now the model is fully trained, so let's make some music! # Run a gibbs chain where the visible nodes are initialized to 0 sample = gibbs_sample(1).eval(session=sess, feed_dict={x: np.zeros((10, n_visible))}) for i in range(sample.shape[0]): if not any(sample[i, :]): continue # Here we reshape the vector to be time x notes and then save the vector as a midi file S = np.reshape(sample[i, :], (num_timesteps, 2 * note_range)) midi_manipulation.noteStateMatrixToMidi(S, f"out/generated_chord_{i}") print("done training. outputs saved in the out folder")
def generate_midi_from_sequences(self, sequence, dir_path): for i in range(len(sequence)): print(sequence[i]) mm.noteStateMatrixToMidi(sequence[i], dir_path + 'generated_chord_{}'.format(i))
def generate(W, bv, bh): """ We initialize the variables l_note, h_note, music_note_range for creating new music chords from the distribution of the emperical data learnt """ l_note = midi_manipulation.lowerBound h_note = midi_manipulation.upperBound music_note_range = h_note - l_note # No of time steps number_of_timesteps = 10 # No of neurons in visible layer(input layer) number_of_visible = 2 * music_note_range * number_of_timesteps # No of music files to be generated number_of_chords = 50 ########----------------Helper Functions-----------------######## def sample(vector_probs): """ Sample function will return the uniform randomly sampled vector of zeroes and ones of the size of vector_probs """ return tf.floor(vector_probs + tf.random_uniform(tf.shape(vector_probs), 0, 1)) def single_gibbs_step(xk): """ this function will be used two times 1) while training to sample out the data from the network 2) while generating the output music by sampling from the network by giving random input vectors #Runs a single gibbs step. The visible values are initialized to xk """ hk = sample(tf.sigmoid( tf.matmul(xk, W) + bh)) #Propagate the visible values to sample the hidden values xk = sample(tf.sigmoid( tf.matmul(hk, tf.transpose(W)) + bv)) #Propagate the hidden values to sample the visible values return xk def get_gibbs_sample(k): #Runs a k-step gibbs chain to sample from the probability distribution of the RBM defined by W, bh, bv #Run gibbs steps for k iterations count = 0 x_sample = x while (count < k): x_sample = single_gibbs_step(x_sample) count += 1 x_sample = tf.stop_gradient(x_sample) return x_sample ##Declaring x tensor place holder to sample the vectors from the distribution learnt x = tf.placeholder(tf.float32, [None, number_of_visible], name="x") #The placeholder variable that holds our data #We need to generate music now......Finally :) #To do that we need to sample 50 vectors from the gibbs sample(the whole intelligence is now stored in the weights and the biases of the network.) with tf.Session() as sess: init = tf.global_variables_initializer() sess.run(init) print(sess.run(W)) samples = sample = get_gibbs_sample(1).eval( session=sess, feed_dict={x: np.zeros((number_of_chords, number_of_visible))}) for i in range(samples.shape[0]): if not any(samples[i, :]): continue #Here we reshape the vector to be time x notes, and then save the vector as a midi file S = np.reshape(sample[i, :], (number_of_timesteps, 2 * music_note_range)) midi_manipulation.noteStateMatrixToMidi( S, "generated_new_music/generated_chord_{}".format(i))
plt.plot(loss_test[11:60], label='test loss', c='xkcd:crimson') plt.xlabel('epochs') plt.ylabel('loss') plt.legend(prop={'size': 16}) plt.subplot(1, 2, 2) plt.plot(loss_train[11:60] - rec_loss_train[11:60], label='train KL divergence', c='xkcd:tomato') plt.plot(loss_test[11:60] - rec_loss_test[11:60], label='test KL divergence', c='xkcd:crimson') plt.xlabel('epochs') plt.ylabel('loss') plt.legend(prop={'size': 16}) # generate song # from test sample: sample = 5 x = model(test[5, :, :, :].reshape([1, timesteps * freqs]).astype('float32')) # or from randomly sampled z n_examples = 1 z = chainer.Variable( np.random.normal(0, 1, (n_examples, 20)).astype(np.float32)) # z=np.float32(np.reshape(song[160:260, :], [1, 15600])) x = model.decode(z) # convert to midi generated_song = np.reshape(x.data, [timesteps, freqs]) generated_song = (generated_song > 0.2) * 1 #save generated midi midi_manipulation.noteStateMatrixToMidi(generated_song)