Update app.py

app.py

@@ -11,74 +11,111 @@ from streamlit_lottie import st_lottie
 
 
 ####################### Music Generation Functions #######################
-def generate(seq_len, x):
+def generate(seq_len,x):
     """ Generate a piano midi file """
+    #load the notes used to train the model
     with open('final_notes', 'rb') as filepath:
         notes = pickle.load(filepath)
 
+    # Get all pitch names
     pitchnames = sorted(set(item for item in notes))
     n_vocab = len(set(notes))
 
-    network_input, normalized_input = prepare_sequences(notes, pitchnames, n_vocab, seq_length=seq_len)
+    network_input, normalized_input = prepare_sequences(notes, pitchnames, n_vocab , seq_length = seq_len)
     model = create_network(normalized_input, n_vocab)
     prediction_output = generate_notes(model, network_input, pitchnames, n_vocab, x)
     create_midi(prediction_output)
 
-def prepare_sequences(notes, pitchnames, n_vocab, seq_length):
+
+def prepare_sequences(notes, pitchnames, n_vocab , seq_length):
+    """ Prepare the sequences used by the Neural Network """
+    # map between notes and integers and back
     note_to_int = dict((note, number) for number, note in enumerate(pitchnames))
+
+    sequence_length = seq_length
     network_input = []
     normalized_input = []
     output = []
-    for i in range(0, len(notes) - seq_length, 1):
-        sequence_in = notes[i:i + seq_length]
+    for i in range(0, len(notes) - sequence_length, 1):
+        sequence_in = notes[i:i + sequence_length]
         sequence_out = notes[i + sequence_length]
         network_input.append([note_to_int[char] for char in sequence_in])
         output.append(note_to_int[sequence_out])
 
     n_patterns = len(network_input)
-    normalized_input = np.reshape(network_input, (n_patterns, seq_length, 1))
+
+    # reshape the input into a format compatible with LSTM layers
+    normalized_input = numpy.reshape(network_input, (n_patterns, sequence_length, 1))
+    # normalize input
     normalized_input = normalized_input / float(n_vocab)
 
     return (network_input, normalized_input)
 
-
 def create_network(network_input, n_vocab):
-    model = tf.keras.Sequential()
-    model.add(tf.keras.layers.LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), return_sequences=True, recurrent_dropout=0.3))
-    model.add(tf.keras.layers.LSTM(512, return_sequences=True, recurrent_dropout=0.3))
-    model.add(tf.keras.layers.LSTM(256))
-    model.add(tf.keras.layers.BatchNormalization())
-    model.add(tf.keras.layers.Dropout(0.2))
-    model.add(tf.keras.layers.Dense(256, activation='relu'))
-    model.add(tf.keras.layers.BatchNormalization())
-    model.add(tf.keras.layers.Dropout(0.2))
-    model.add(tf.keras.layers.Dense(n_vocab, activation='softmax'))
-    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+    """ create the structure of the neural network """
+    adam = tf.keras.optimizers.Adam(0.001)
+
+    model = Sequential()
+    model.add(LSTM(
+        512,
+        input_shape=(network_input.shape[1], network_input.shape[2]),
+        recurrent_dropout=0.3,
+        return_sequences=True
+    ))
+    model.add(LSTM(512, return_sequences=True, recurrent_dropout=0.3,))
+    model.add(LSTM(256))
+    model.add(BatchNorm())
+    model.add(Dropout(0.2))
+    model.add(Dense(256))
+    model.add(Activation('relu'))
+    model.add(BatchNorm())
+    model.add(Dropout(0.2))
+    model.add(Dense(n_vocab))
+    model.add(Activation('softmax'))
+     # 'rmsprop'
+    model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy'])
+
+    # Load the weights to each node
     model.load_weights('best2.h5')
+
     return model
 
-def generate_notes(model, network_input, pitchnames, n_vocab, x):
-    start = np.random.randint(0, len(network_input)-1)
+
+def generate_notes(model, network_input, pitchnames, n_vocab , x):
+    """ Generate notes from the neural network based on a sequence of notes """
+    # pick a random sequence from the input as a starting point for the prediction
+    start = numpy.random.randint(0, len(network_input)-1)
+
     int_to_note = dict((number, note) for number, note in enumerate(pitchnames))
+
     pattern = network_input[start]
     prediction_output = []
 
+    # generate x notes (x entered by user)
     for note_index in range(x):
-        prediction_input = np.reshape(pattern, (1, len(pattern), 1))
+        prediction_input = numpy.reshape(pattern, (1, len(pattern), 1))
         prediction_input = prediction_input / float(n_vocab)
+
         prediction = model.predict(prediction_input, verbose=0)
-        index = np.argmax(prediction)
+
+        index = numpy.argmax(prediction)
         result = int_to_note[index]
         prediction_output.append(result)
+
         pattern.append(index)
         pattern = pattern[1:len(pattern)]
 
     return prediction_output
 
+
 def create_midi(prediction_output):
+    """ convert the output from the prediction to notes and create a midi file from the notes """
     offset = 0
     output_notes = []
+
+    # create note and chord objects based on the values generated by the model
     for pattern in prediction_output:
+        # pattern is a chord
         if ('.' in pattern) or pattern.isdigit():
             notes_in_chord = pattern.split('.')
             notes = []
@@ -89,21 +126,32 @@ def create_midi(prediction_output):
             new_chord = chord.Chord(notes)
             new_chord.offset = offset
             output_notes.append(new_chord)
+            
+        # pattern is a rest
         elif pattern == 'r':
             new_note = note.Rest(pattern)
             new_note.offset = offset
             new_note.storedInstrument = instrument.Piano()
             output_notes.append(new_note)
+            
+        # pattern is a note
         else:
             new_note = note.Note(pattern)
             new_note.offset = offset
             new_note.storedInstrument = instrument.Piano()
             output_notes.append(new_note)
+
+        # increase offset each iteration so that notes do not stack
         offset += 0.5
 
     midi_stream = stream.Stream(output_notes)
+
     midi_stream.write('midi', fp='test_output2.mid')
 
+
+
+
+
     
 # Set page config
 st.set_page_config(page_title="Music Generation", page_icon=":tada:", layout="wide")