Naive attempt using Markov chains

markov_chain.py

@@ -1,5 +1,12 @@
+
 import os
-from mido import MidiFile
+# from mido import MidiFile
+import mido
+import music21
+import numpy as np
+import pandas as pd
+from music21 import *
+from mido import Message, MidiFile, MidiTrack
 #number of notes to be used for prediction
 window = 3
 
@@ -18,18 +25,228 @@ def abs_paths(dir):
     for dir_path,_,filenames in os.walk(dir):
         for f in filenames:
             yield os.path.abspath(os.path.join(dir_path, f))
-def pitch_to_int():
-    #TODO: look at this later
-    pass
-if not os.path.exists('tracks'):
-    # os.mkdir('tracks')
-    i = 0
-    #Parse midi files into tracks folder
-    for path in abs_paths('data'):
-        print(path)
-        mid = MidiFile(path)
-        for i, track in enumerate(mid.tracks):
-            print('Track {}: {}'.format(i, track.name))
-            for message in track:
-                print(message)
-        break
+def pitch_to_int(nameWithOctave):
+    # letter names with corresponding values
+    letter_dict = {'C':0,'D':2,'E':4,'F':5,'G':7,'A':9,'B':11}
+    # parse characters from strings
+    chars = list(nameWithOctave)
+    # convert octave number to corresponding midi value
+    octave = 12*(int(chars[-1])+1)
+    # select value from letter_dict using first character
+    note = letter_dict[chars[0]]
+    # set accidental value
+    accidental = 0
+    # does accidental exist?
+    if not len(chars)==2:
+        # increase (sharp) or decrease (flat) value by one
+        accidental = 1 if chars[1]=='#' else -1
+    # return sum of these numbers, middle C(4) == 60
+    return octave + note + accidental
+def generate_notes():
+    df_notes = pd.read_csv('prepared.csv')
+    print(df_notes.shape)
+    # define arrays for generated notes and durations
+    gen_notes = []
+    gen_durations = []
+    # define note and duration feature columns based on names
+    features = df_notes.columns[:-2]
+    note_features = [s for s in features if "note" in s]
+    duration_features = [s for s in features if "duration" in s]
+    # define target columns
+    note_target = df_notes.columns[-2]
+    duration_target = df_notes.columns[-1]
+
+    # sample random row from dataframe and define start notes and durations
+    initial_sample = df_notes.sample()
+    start_notes = list(initial_sample[note_features].values[0])
+    start_durations = list(initial_sample[duration_features].values[0])
+    # append starting notes and durations to gen arrays
+    for note in start_notes:
+        gen_notes.append(int(note))
+    for duration in start_durations:
+        gen_durations.append(duration)
+
+    for i in range(num_notes) :
+        rows = df_notes
+        for i in range(window-1):
+            rows = rows.loc[df_notes[note_features[i]] == start_notes[i]]
+            rows = rows.loc[df_notes[duration_features[i]]== start_durations[i]]
+    
+        #This gives the same effect as probability.
+        # We effectively sample from a list which might have more than 1 C note, Hence increasing its probability
+        #Sometime, The start_notes and durations could be selected in such a way that we cannot generate any further notes uptill num_notes,
+        #This means there maybe some combinations of notes such as 76,68 which are not there in the dataset and hence cannot be sampled.
+        #In such cases, the only way about it would be to reset the start notes, because we cannot sample from an empty row 
+        #So here we check if any rows which we ta
+        if len(rows):
+            next_sample = rows.sample()
+            next_note = next_sample[note_target].values[0]
+            next_duration = next_sample[duration_target].values[0]
+            gen_notes.append(int(next_note))
+            gen_durations.append(next_duration)
+
+            start_notes.pop()
+            start_durations.pop()
+
+            start_notes.append(next_note)
+            start_durations.append(next_duration)
+        else:
+            #Received empty row
+            # print("Exiting!!!!!!")
+            #restarting again to get new start notes
+            return [],[]
+           
+        # print(rows[note_target].value_counts(normalize=True))
+        # print(rows[duration_target].value_counts(normalize=True))
+
+    return gen_notes, gen_durations
+
+#MAIN FUNCTION
+if __name__=="__main__":
+    # https://stackoverflow.com/questions/49462107/how-can-i-get-all-piano-parts-from-a-music21-score
+    if not os.path.exists('tracks'):
+        os.mkdir('tracks')
+        i = 0
+        #Parse midi files into tracks folder
+        for path in abs_paths('data'):
+            print(path)
+            # mid = MidiFile(path)
+            piece = converter.parse(path)
+            print(list(piece.parts))
+            for part in piece.parts:
+                part_notes = []
+                #get all note messages from all tracks
+                for event in part:
+                    if getattr(event, 'isNote', None) and event.isNote:
+                        print('note in {}'.format(part))
+
+                        #check if note is in accepted length
+                        #convert string to numerical value 
+                        if event.quarterLength in accepeted_lengths:
+                            part_notes.append([pitch_to_int(event.nameWithOctave), event.quarterLength])
+                if not len(part_notes) == 0:
+                    np.save('tracks/{}.npy'.format(i), np.array(part_notes))
+                    i+=1
+        print('Number of tracks parsed: {}'.format(i))
+    if not os.path.exists('prepared.csv'):
+        columns = []
+        for i in range(window):
+            columns.append('note' + str(i))
+            columns.append('duration' + str(i))
+        df_notes = pd.DataFrame(columns=columns)
+        # append segments from each track as rows to dataframe
+        for path in abs_paths('tracks'):
+            notes = np.load(path)
+            for i in range(len(notes)-window):
+                # take every x notes and durations
+                segment = notes[i:i+window].flatten()
+                # make into pd.Series row
+                row = pd.Series(segment, index=df_notes.columns)
+                # append row to dataframe
+                df_notes = df_notes.append(row, ignore_index=True)
+        # export
+        df_notes.to_csv('prepared.csv', index=False)
+    success = False
+    gen_notes =[]
+    gen_durations =[]
+
+    #Retry mechanism
+    while len(gen_notes)<num_notes:
+            gen_notes,gen_durations = generate_notes()
+
+# import
+# df_notes = pd.read_csv('prepared.csv')
+# print(df_notes.shape)
+# # define arrays for generated notes and durations
+# gen_notes = []
+# gen_durations = []
+# # define note and duration feature columns based on names
+# features = df_notes.columns[:-2]
+# note_features = [s for s in features if "note" in s]
+# duration_features = [s for s in features if "duration" in s]
+# # define target columns
+# note_target = df_notes.columns[-2]
+# duration_target = df_notes.columns[-1]
+
+# # sample random row from dataframe and define start notes and durations
+# initial_sample = df_notes.sample()
+# start_notes = list(initial_sample[note_features].values[0])
+# start_durations = list(initial_sample[duration_features].values[0])
+# # append starting notes and durations to gen arrays
+# for note in start_notes:
+#     gen_notes.append(int(note))
+# for duration in start_durations:
+#     gen_durations.append(duration)
+
+
+# for i in range(num_notes) :
+#     rows = df_notes
+#     for i in range(window-1):
+#         rows = rows.loc[df_notes[note_features[i]] == start_notes[i]]
+#         rows = rows.loc[df_notes[duration_features[i]]== start_durations[i]]
+    
+#     #This gives the same effect as probability.
+#     # We effectively sample from a list which might have more than 1 C note, Hence increasing its probability
+#     #Sometime, The start_notes and durations could be selected in such a way that we cannot generate any further notes uptill num_notes,
+#     #This means there maybe some combinations of notes such as 76,68 which are not there in the dataset and hence cannot be sampled.
+#     #In such cases, the only way about it would be to reset the start notes, because we cannot sample from an empty row 
+#     #So here we check if any rows which we ta
+#     if len(rows):
+#         next_sample = rows.sample()
+#         next_note = next_sample[note_target].values[0]
+#         next_duration = next_sample[duration_target].values[0]
+#         gen_notes.append(int(next_note))
+#         gen_durations.append(next_duration)
+
+#         start_notes.pop()
+#         start_durations.pop()
+
+#         start_notes.append(next_note)
+#         start_durations.append(next_duration)
+#     else:
+#         #Received empty row
+#         print("Exiting!!!!!!")
+# print(rows[note_target].value_counts(normalize=True))
+# print(rows[duration_target].value_counts(normalize=True))
+
+    print('Generated  notes/durations'.format(num_notes))
+    print(gen_notes)
+    print(gen_durations)
+
+    mid = MidiFile()
+    track = MidiTrack()
+    mid.tracks.append(track)
+    for i in range(num_notes):
+        track.append(Message('note_on', channel=0, note=gen_notes[i], velocity=60, time=0))
+        track.append(Message('note_on', channel=0, note=gen_notes[i], velocity=0,time=int(gen_durations[i]*quarter_note_ticks)))
+    mid.save('new_song.mid')
+#create new midi file which can be engraved
+#https://mido.readthedocs.io/en/latest/midi_files.html , crreating a New file sectoin
+# mid = MidiFile()
+# track = MidiTrack
+# mid.tracks.append(track)
+
+# for i in range(num_notes):
+#     track.append(Message('note_on', channel=0, note=gen_notes[i], velocity=60, time=0))
+#     track.append(Message('note_on', channel=0, note=gen_notes[i], velocity=0,time=int(gen_durations[i]*quarter_note_ticks)))
+# mid.save('output.mid')
+# def inspect_midi():
+#     #Just inspecting midi file 1.
+#     for path in abs_paths('data'):
+#         # print(path)
+#         mid = MidiFile(path)
+#         for i, track in enumerate(mid.tracks):
+#             print('Track {}: {}'.format(i, track.name))
+#             for message in track:
+#                 print(message)
+#         break
+# inspect_midi()
+# def isolate_note_on_msgs():
+#     #round each note duration to 250ms
+#     #Build adjaceny matrix
+
+
+# LILYPOND COMMANDS : To be used for generating music scores
+# Installation : sudo apt-get install -y lilypond
+# !midi2ly "new_song.ly"
+# !lilypond -fpng "new_song-midi.ly"