def main():
parser = argparse.ArgumentParser(
description="Converts the LPD 5 dataset to midi files")
parser.add_argument("--input_dir", help="dataset directory")
parser.add_argument("--output_dir", help="output directory")
args = parser.parse_args()
assert (args.input_dir and args.output_dir)
input_dir = Path(args.input_dir)
mask = str(input_dir / "**/*.npz")
ouput_dir = Path(args.output_dir)
filenames = glob(mask, recursive=True)
for filename in filenames:
print(f"Converting {filename}...")
filename = Path(filename)
file_output_dir = ouput_dir / Path(os.path.relpath(
filename, input_dir)).parent
if not file_output_dir.is_dir():
file_output_dir.mkdir(parents=True)
sample = pp.load(str(filename))
pp.write(sample, str(file_output_dir / (filename.stem + ".mid")))
def create_batch(self, i, source, meta_link, pianorolls_path, batch_path):
dest = []
labels = []
# for each pianoroll, store it and the corresponding labels
for sample in source:
multitrack = pproll.load(os.path.join(pianorolls_path, sample))
proll = multitrack.get_stacked_pianoroll()
dest.append(proll)
# retrieve corresponding s factors
sample_id = sample.split(".")[0]
song_id = meta_link[sample_id]
label = np.load(
os.path.join(self.dataset_path, "labels",
str(song_id) + ".npy"))
labels.append(label)
dest = np.array(dest)
labels = np.array(labels)
# preprocess batch, get X and Y
X, Y = self.preprocess(dest)
# store everything
np.save(os.path.join(batch_path, "X", str(i) + ".npy"), X)
np.save(os.path.join(batch_path, "Y", str(i) + ".npy"), Y)
np.save(os.path.join(batch_path, "labels", str(i) + ".npy"), labels)
print("batch - end: " + str(i))
def main():
args = parser()
pypianoroll_file = abspath(args.input_file)
loaded = pypianoroll.load(pypianoroll_file)
if args.savepath is None:
savepath = os.getcwd()
else:
savepath = args.savepath
os.makedirs(savepath, exist_ok=True)
#Save to plot
if args.output is None:
output_filename = os.path.basename(pypianoroll_file).split(".")[0]
output_filename = join(savepath, output_filename)
else:
output_filename = ags.output
output_filename = join(savepath, output_filename)
print(output_filename)
plot_multitrack(loaded, filename=output_filename + ".svg", preset="frame")
#Save to WAV
pypianoroll.write(loaded, (output_filename + ".mid"))
fs = FluidSynth('FluidR3_GM.sf2')
fs.midi_to_audio((output_filename + ".mid"), (output_filename + ".wav"))
def generate_batches(self, path, filenames, batch_size):
print("Generating batches from data...")
dataset_len = len(filenames)
# shuffle samples
random.shuffle(filenames)
# discard filenames
remainder = dataset_len % batch_size
dataset = np.array(filenames[:-remainder])
dataset_len = dataset.shape[0]
assert (dataset_len % batch_size == 0)
dataset = dataset.reshape((-1, batch_size))
n_of_batches = dataset.shape[0]
for i in range(n_of_batches):
source = dataset[i, :]
dest = []
for sample in source:
multitrack = pproll.load(os.path.join(path, sample))
proll = multitrack.get_stacked_pianoroll()
dest.append(proll)
dest = np.array(dest)
yield dest
def pooled_tensor_batches(self, args):
idx, source = args
dest = []
labels = []
batch_path = os.path.join(self.data_path, "batches/")
pianorolls_path = os.path.join(self.data_path, "pianorolls/")
metadata_path = os.path.join(self.data_path, "metadata/")
# for each pianoroll, store it and the corresponding labels
for sample in source:
multitrack = pproll.load(os.path.join(pianorolls_path, sample))
proll = multitrack.get_stacked_pianoroll()
dest.append(proll)
# retrieve corresponding s factors
sample_id = sample.split(".")[0]
labels.append(sample_id)
# song_id = meta_link[sample_id]
# label = np.load(os.path.join(self.dataset_path, "labels", str(song_id) + ".npy"))
# labels.append(label)
dest = np.array(dest)
labels = np.array(labels)
# preprocess batch, get X and Y
X, _ = self.preprocess(dest)
# store everything
with open(os.path.join(batch_path, f'tensors-{idx}.pkl'), 'wb') as f:
pickle.dump((torch.from_numpy(X), labels), f,
pickle.HIGHEST_PROTOCOL)
def load_data():
data = []
# Iterate over all the songs in the ID list
for msd_id in tqdm(id_list):
# Load the multitrack as a Multitrack
song_dir = dataset_root / msd_id_to_dirs(msd_id)
multitrack = pypianoroll.load(song_dir / os.listdir(song_dir)[0])
multitrack.binarize()
multitrack.set_resolution(beat)
pianoroll = (multitrack.stack() > 0)
pianoroll = pianoroll[:, :, lowest_pitch:lowest_pitch + number_of_pitches]
n_total_measures = multitrack.get_max_length() // measure_resolution
candidate = n_total_measures - number_of_measures
target_number_of_samples = min(n_total_measures // number_of_measures, samples_per_song)
for selected in np.random.choice(candidate, target_number_of_samples, False):
start = selected * measure_resolution
end = (selected + number_of_measures) * measure_resolution
if (pianoroll.sum(axis=(1, 2)) < 10).any():
continue
data.append(pianoroll[:, start:end])
random.shuffle(data)
data = np.stack(data)
print(f"Successfully collect {len(data)} samples from {len(id_list)} songs")
print(f"Data shape : {data.shape}")
data = torch.as_tensor(data, dtype=torch.float32)
dataset = torch.utils.data.TensorDataset(data)
return torch.utils.data.DataLoader(
dataset, batch_size=batch_size, drop_last=True, shuffle=True)
def convert_midi_to_state(
f_name,
scale_num=None,
scale_type="maj",
twelve_tone_normalize=True,
save_midi=False,
save_json=False,
):
is_midi = f_name.endswith(".mid") or f_name.endswith(".midi")
sc_num = scale_num
sc_type = scale_type
scale = get_scale(scale_num, scale_type)
if is_midi:
mt = load(f_name)
# convert to binary representation
mt.binarize()
# ensure that the vector is 0,1 only
track = mt.get_merged_pianoroll(mode="any").astype(int)
# NOTE: these are the dimensions
states = []
for s in track:
# compress to scale
states.append(s)
if twelve_tone_normalize:
states = squash_piano_roll_to_chromatic_frames(states)
if sc_num != None:
# Squash to scale
states = [
squash_state_to_scale(s, CHROMATIC_SCALE[0:12]) for s in states
]
states = list(filter(lambda x: np.sum(x) > 0, states))
deduped_states = []
for i, state in enumerate(states):
if i == 0:
deduped_states.append(state)
else:
# filter out silence
s = np.sum(state)
if s > 0 and not np.all(np.equal(state, states[i - 1])):
deduped_states.append(state)
states = deduped_states
else:
print("Not midi file: {}".format(f_name))
exit(1)
json_states_file = "{f_name}.{ext}".format(f_name=(f_name +
".training_states"),
ext="json")
if save_json:
write_states_to_file(states, f_name=json_states_file)
return states
def piano_track(data_file):
data = pp.load(data_file)
index = [track.name for track in data.tracks].index("Piano")
raw_track = data.tracks[index].pianoroll
step = 4
track = np.array([ [ np.sign(np.sum(raw_track[i:i+step, j])) for j in range(128) ] for i in range(0, raw_track.shape[0]-1, step) ])
return track
def __load_data_into_memory__(self):
# check if path exists
path = os.path.join(self.data_dir)
assert(os.path.exists(path))
print('Loading data into memory...')
# get all npz files, and check if there is at least one
files = [x for x in glob.glob(path + '/**/*.npz', recursive=True)]
assert(len(files) > 0)
print('{} files found.'.format(len(files)))
downsample_factor = self.__class__.DEFAULT_BEAT_RESOLUTION // self.beat_resolution
n_sequences = []
# load files
for f in tqdm(files):
multitrack_roll = pp.load(str(f))
# not sure what role downbeats play, but all samples in the lpd5 cleansed dataset
# contain only one downbeat at the beginning, so I check for that, just in case.
assert(np.all(multitrack_roll.get_downbeat_steps() == [0]))
# all samples from the lpd5 cleansed dataset should have a beat resolution of 24
assert(multitrack_roll.beat_resolution == self.__class__.DEFAULT_BEAT_RESOLUTION)
multitrack_roll.downsample(downsample_factor)
assert(multitrack_roll.beat_resolution == self.beat_resolution)
# transpose to get (timesteps, n_instruments, pitch_range)
stacked = multitrack_roll.get_stacked_pianoroll().transpose(0, 2, 1)
# all samples from the lpd5 cleansed dataset should have 5 instruments
assert(stacked.shape[1] == self.__class__.N_INSTRUMENTS)
stacked = stacked[:, [inst.value for inst in self.instruments], self.lowest_pitch:self.lowest_pitch + self.n_pitches]
# only add samples if not empty
if not np.all(stacked == 0):
i = np.where(stacked > 0)
# map values from [0, 127] to [0, 1]
v = stacked[i] / 127
self.names.append(multitrack_roll.name)
self.samples.append((stacked.shape, i, v))
sample_length = multitrack_roll.get_max_length()
n_sequences.append(self.calc_num_sequences(sample_length))
self.cum_n_sequences = np.cumsum(n_sequences)
self.total_n_sequences = self.cum_n_sequences[-1]
print('Loaded {} samples with a total of {} sequences!'
.format(len(self.samples), self.total_n_sequences))
def midi2pianoroll(filename):
### Create a `pypianoroll.Multitrack` instance
multitrack = Multitrack(filepath=filename + '.mid',
tempo=120.0,
beat_resolution=12)
### save pypianoroll
pypianoroll.save(filename + '.npz', multitrack, compressed=True)
data = pypianoroll.load(filename + '.npz')
data_tracks = data.get_stacked_pianorolls()
data_bool = data_tracks.astype(bool)
np.save(filename + '.npy', data_bool)
def load_data_from_MIDI(opt):
data = pypianoroll.load('training_data/%s/%s' % (opt.input_dir, opt.input_phrase))
Data = []
for i in range(opt.ntrack):
track_data = data.tracks[i].pianoroll
Data.append(track_data)
#列表转数组
Data = np.array(Data)
Data = Data.reshape(-1, opt.nbar, opt.ntime, opt.npitch, opt.ntrack)
Data = Data[0:1, :, :, :, :]
return Data
def select_song(self, idx, metadata=True):
_metadata_ = None
multitrack = pproll.load(
os.path.join(self.dataset_path + "songs/" + str(idx) + ".npz"))
if metadata:
_metadata_ = self.retrieve_metadata(
os.path.join(self.dataset_path, "metadata/",
str(idx) + ".json"))
return _metadata_, multitrack
def __init__(self, filename=None):
self.debug = False
if not self.debug:
# off debug msg
self.chan = open(os.devnull, 'w')
else:
self.chan = sys.stderr
if filename is not None:
ext = os.path.split(filename)[-1].split('.')[-1]
if ext == 'npz':
import pypianoroll
mido.MidiFile.__init__(self)
data = pypianoroll.load(filename)
track_len = len(data.tracks)
self.tracks = [
self._get_events_from_roll(
data.tracks[i].get_pianoroll_copy().transpose(), i)
for i in range(track_len)
]
self.instrument = [track.program for track in data.tracks]
self.ticks_per_beat = data.beat_resolution
# assume we follow only 1 bpm in a song
bpm = data.tempo[0]
self.set_tempo_bpm(bpm)
elif ext == 'mid':
mido.MidiFile.__init__(self, filename)
self.meta = {}
# assume only 0 or 1 program change event in each channel
# default instrument is Piano in ch.0
for idx, track in enumerate(self.tracks):
# remove mido.UnknownMetaMessage in track (which would cause error)
self.tracks[idx] = [
msg for msg in track
if not isinstance(msg, mido.UnknownMetaMessage)
]
self.instrument = [-1 for _ in range(16)]
self.get_instrument()
else:
mido.MidiFile.__init__(self, filename)
self.meta = {}
self.instrument = [-1 for _ in range(16)]
def load_phrase_from_single_npz(opt):
"""Load and return the training data from a npz file (sparse format)."""
#with np.load(filename) as f:
# data = np.zeros(f['shape'], np.bool_)
# data[[x for x in f['nonzero']]] = True
data = pypianoroll.load('training_data/%s/%s' % (opt.input_dir, opt.input_phrase))
Data = []
for i in range(opt.ntrack):
track_data = data.tracks[i].pianoroll
Data.append(track_data)
#列表转数组
Data = np.array(Data)
Data = Data.reshape(-1, opt.nbar, opt.ntime, opt.npitch, opt.ntrack)
Data = Data[0:1, :, :, :, :]
return np2torch(Data)
def _convert_to_tfrecords(self, mode, filename_list):
filename = self.DATA_PATH + "/" + mode + ".tfrecords"
if check_path_exists(filename):
return
logging.info("Writing {}".format(filename))
with tf.python_io.TFRecordWriter(filename) as writer:
for filename in tqdm(filename_list):
if filename.endswith(".mid") or filename.endswith(".midi"):
multi_track = ppr.parse(filename)
else:
multi_track = ppr.load(filename)
TOTAL_STEPS = self._choose_total_steps(multi_track)
if TOTAL_STEPS == 1e8:
continue
RANGE = self.INPUT_SIZE
FINAL_STEPS = math.ceil(TOTAL_STEPS / 24)
multi_data = np.zeros((FINAL_STEPS, RANGE))
for track in multi_track.tracks:
if not self._is_valid_track(track):
continue
data = track.pianoroll.astype(int)
data = self._sampling(data)
multi_data = np.add(multi_data, data)
multi_data = np.clip(multi_data, 0, 1).astype(int)
RANGE = self._split_into_segments(multi_data, 1)
length = self.MAX_LEN
for start in RANGE:
end = start + length
if end >= FINAL_STEPS:
break
example = tf.train.Example(
features=tf.train.Features(
feature={
"pianoroll":
self._int64_list_feature(
multi_data[start:end + 1].flatten())
}))
writer.write(example.SerializeToString())
def parse_data(genres_directory, parsed_directory):
save_directory_name = "NT-" + str(NUM_TRACKS) + "-NB-" + str(NUM_BARS) + "-BPB-" + str(BEATS_PER_BAR) + "-NN-" + str(NUM_NOTES)
save_directory_path = join(parsed_directory, save_directory_name)
os.makedirs(save_directory_path, exist_ok=True)
for genre in os.listdir(genres_directory):
if genre in GENRE_LIST:
print("\n\n\n\n")
print(genre)
print("\n\n\n\n")
genre_directory = join(genres_directory, genre)
for song in os.listdir(genre_directory):
print(song)
song_multitrack = pypianoroll.load(join(genre_directory, song))
song_multitrack.pad_to_same()
song_multitrack.pad_to_multiple(BEATS_PER_SET)
song_divisions = int(((song_multitrack.tracks[0].pianoroll.size)/128)/(BEATS_PER_SET))
for division in range(0, song_divisions):
track_list = []
for track in song_multitrack.tracks:
current_beat = division*(BEATS_PER_SET)
bar_list = []
for bar in range(0, 4):
beat_list = []
for beat in range(current_beat, current_beat+BEATS_PER_BAR):
beat_list.append(np.asarray(track.pianoroll[beat][LOWEST_NOTE:LOWEST_NOTE+NUM_NOTES]))
bar_list.append(np.asarray(beat_list))
current_beat += BEATS_PER_BAR
track_list.append(np.asarray(bar_list))
filename = genre + "-" + song.split(".")[0] + "-" + str(division)
filepath = join(save_directory_path, filename)
reshaped_track_list = np.reshape(np.asarray(track_list), (4, 96, 84, 5))
np.savez_compressed(filepath, data=np.asarray([reshaped_track_list, genre]))
def _compute_all_features(self):
"""Computes all the features (beatsync, framesync) from the audio."""
# Read multitrack
self._audio = pypianoroll.load(self.file_struct.audio_file)
# Get duration (in time step) of the multitrack
num_timestep = self._audio.tracks[0].pianoroll.shape[0]
self.tempo = self._audio.tempo[0]
self.dur = (60. / self.tempo) * num_timestep
# Compute times
self._framesync_times = (60. / self.tempo) * np.arange(0, num_timestep)
self._ann_beats_times = (60. / self.tempo) * np.arange(
0, num_timestep, self._audio.beat_resolution)
self._ann_beatsync_times = self._ann_beats_times
self._est_beats_times = self._ann_beats_times
self._est_beatsync_times = self._ann_beats_times
# Compute features
self._framesync_features = self.compute_features()
self.compute_beat_sync_features()
def gbs_piano_roll(filepath):
pm = pypianoroll.load(filepath).to_pretty_midi()
instruments = pm.instruments
# g = Guitar; b = Bass; s = String.
gbs = []
for instrument in instruments[2:]:
if len(instrument.notes) == 0:
return None
else:
gbs.append(instrument.notes)
piano_roll_length = pm.time_to_tick(pm.get_end_time()) * 4 // pm.resolution
piano_roll = np.zeros((128 * 3, piano_roll_length), dtype=np.int8)
for i, instrument in enumerate(gbs):
for note in instrument:
start = pm.time_to_tick(note.start) * 4 // pm.resolution
end = pm.time_to_tick(note.end) * 4 // pm.resolution
for tick in range(end - start):
piano_roll[(i * 128) + note.pitch][start + tick] = 1
# plt.imshow(piano_roll, cmap='gray')
# plt.show()
return piano_roll
def load_npz(filepath):
multi_tracks = []
pm = pypianoroll.load(filepath).to_pretty_midi()
resolution = pm.resolution
time = pm.get_end_time()
tick = pm.time_to_tick(time * 8 / resolution)
tracks = pm.instruments
for track in tracks:
piano_roll = track.get_piano_roll(fs=tick / time)
if tick < 640:
padded_pr = np.pad(piano_roll,
((0, 0), (0, 640 - len(piano_roll[0]))),
'constant').T
else:
padded_pr = np.pad(piano_roll,
((0, 0), (0, tick - len(piano_roll[0]))),
'constant').T
multi_tracks.append(padded_pr[:640])
concat_pr = multi_tracks[0]
for i in multi_tracks[1:]:
concat_pr = np.concatenate((concat_pr, i), axis=1)
return concat_pr
def main():
args = parser()
pypianoroll_directory = abspath(args.input_directory)
if args.savepath is None:
savepath = os.getcwd()
else:
savepath = args.savepath
os.makedirs(savepath, exist_ok=True)
for pypianoroll_file in os.listdir(pypianoroll_directory):
if os.path.basename(pypianoroll_file).split(".")[1] == "npz":
loaded = pypianoroll.load(
join(pypianoroll_directory, pypianoroll_file))
#Save to plot
if args.output is None:
output_filename = os.path.basename(pypianoroll_file).split(
".")[0]
output_filename = join(savepath, output_filename)
else:
output_filename = ags.output + os.path.basename(
pypianoroll_file).split(".")[0]
output_filename = join(savepath, output_filename)
fig, axs = plot_multitrack(loaded,
filename=output_filename + ".svg",
preset="frame")
plt.close(fig)
#Save to WAV
pypianoroll.write(loaded, (output_filename + ".mid"))
fs = FluidSynth('FluidR3_GM.sf2')
fs.midi_to_audio((output_filename + ".mid"),
(output_filename + ".wav"))
def load_npz(path):
try:
return pypianoroll.load(path)
except Exception as e:
return None
import pypianoroll
import os
from tqdm import tqdm
def get_all_file_from_directory(path):
all_files_with_full_path = []
for path, subdirs, files in os.walk(path):
for name in files:
xx = os.path.join(path, name)
all_files_with_full_path.append((name, xx))
return all_files_with_full_path
all_files = get_all_file_from_directory("../data/lpd/")
out_dir_name = "../data/lakhdataset_midi/"
for sign, each in tqdm(all_files):
filep = pypianoroll.load(filepath=each)
filep.write("{path}{sign}.mid".format(path=out_dir_name, sign=sign))
def create_batches(self, batch_size=128):
print("Building batches from data...")
batch_path = os.path.join(self.data_path, "batches/")
if not os.path.exists(batch_path):
os.makedirs(os.path.join(batch_path, "X"))
os.makedirs(os.path.join(batch_path, "Y"))
os.makedirs(os.path.join(batch_path, "labels"))
pianorolls_path = os.path.join(self.dataset_path, "pianorolls/")
metadata_path = os.path.join(self.dataset_path, "metadata/")
_, _, files = next(os.walk(pianorolls_path))
dataset_len = len(files)
random.shuffle(files)
remainder = dataset_len % batch_size
dataset = np.array(files[:-remainder])
dataset_len = dataset.shape[0]
print("dataset_length:", dataset_len)
print("batch_size:", batch_size)
print("number of batches:", dataset_len // batch_size)
print("remainder:", remainder)
assert (dataset_len % batch_size == 0)
dataset = dataset.reshape((-1, batch_size))
n_of_batches = dataset.shape[0]
# store each batch in a file toghether
# bar = progressbar.ProgressBar(max_value=n_of_batches)
meta_link = json.load(
open(os.path.join(self.dataset_path, "meta_link.json")))
for i in track(range(n_of_batches), description="Batching data..."):
# bar.update(i)
source = dataset[i, :]
dest = []
labels = []
# for each pianoroll, store it and the corresponding labels
for sample in source:
multitrack = pproll.load(os.path.join(pianorolls_path, sample))
proll = multitrack.get_stacked_pianoroll()
dest.append(proll)
# retrieve corresponding s factors
sample_id = sample.split(".")[0]
song_id = meta_link[sample_id]
label = np.load(
os.path.join(self.dataset_path, "labels",
str(song_id) + ".npy"))
labels.append(label)
dest = np.array(dest)
labels = np.array(labels)
# preprocess batch, get X and Y
X, Y = self.preprocess(dest)
# store everything
np.save(os.path.join(batch_path, "X", str(i) + ".npy"), X)
np.save(os.path.join(batch_path, "Y", str(i) + ".npy"), Y)
np.save(os.path.join(batch_path, "labels",
str(i) + ".npy"), labels)
print(os.path.join(root, file))
file_list.append(os.path.join(root, file))
return file_list
###########################################
# From lpd_5_cleansed to lpd_4dbar_12_npy #
###########################################
root_dir = './lpd_5_cleansed/'
file_list = traverse_dir(root_dir)
tensor_file = np.zeros((0,768,128,5))
i = 0
for file in file_list:
i += 1
print(i)
multitrack = pr.load(file)
track_list = [3,0,2,1,4]
file_len = max(multitrack.tracks[0].pianoroll.shape[0],
multitrack.tracks[1].pianoroll.shape[0],
multitrack.tracks[2].pianoroll.shape[0],
multitrack.tracks[3].pianoroll.shape[0],
multitrack.tracks[4].pianoroll.shape[0])
dbar_len = int(np.floor(file_len/768.0))
if dbar_len > 0:
tensor_new = []
for track_idx in track_list:
track = multitrack.tracks[track_idx].pianoroll
if (track.shape[0]==0):
track_re = np.zeros((dbar_len,768,128))
tensor_new.append(track_re)
def select_pianoroll(self, idx):
pianoroll = pproll.load(
os.path.join(self.dataset_path + "pianorolls/" + str(idx) +
".npz"))
return pianoroll
import glob
import pypianoroll
for file in glob.glob("flattened/*.npz"):
print(file)
new_obj = pypianoroll.load(file) #loads npz into a pypianoroll multitrack matrix
new_obj.write(file) #converts to a midi
def main():
pre_melody = pypianoroll.load(args.input)
pre = []
step = pre_melody.beat_resolution // 4 # 16 beat minimum
pianoroll = np.zeros((pre_melody.get_max_length(),128,len(programs)))
for track in pre_melody.tracks:
if track.is_drum:
dst_index = 0
else:
dst_index = 1
for i in range(1,len(programs),1):
if track.program >= programs[i] and (len(programs) == i+1 or track.program < programs[i+1]):
dst_index = i
break
pianoroll[0:track.pianoroll.shape[0],:,dst_index] += track.pianoroll
pianoroll = pianoroll[:,note_offset:note_offset+note_size,trc_idx]
p = np.where(pianoroll != 0)
current_seq = []
def _current(cur_seq):
cur = []
for c in sorted(cur_seq):
if not (c >= note_size and c < note_size*2):
cur.append(c)
for c in sorted(cur_seq):
if (c >= note_size and c < note_size*2):
cur.append(c)
return cur # Bass, Piano, etc..., Drums
pos = 0
for i in np.argsort(p[0]):
if p[0][i] % step != 0:
continue
if pos < p[0][i]:
for _ in range(pos,p[0][i],step):
pre.extend(_current(current_seq))
pre.append(time_note)
current_seq = []
pos = p[0][i]
j = p[1][i]
t = p[2][i]
note = t*note_size + j
current_seq.append(note)
pre.extend(_current(current_seq))
if len(pre) == 0 or pre[-1] != time_note:
pre.append(time_note)
if len(pre) > 512:
pre = pre[-512:]
cur_top = (0,top_p)
with tf.Session(graph=tf.Graph()) as sess:
context = tf.placeholder(tf.int32, [1, None])
output = model.model(hparams=hparams, X=context)
vars = [v for v in tf.trainable_variables() if 'model' in v.name]
saver = tf.train.Saver(var_list=vars)
ckpt = tf.train.latest_checkpoint(args.model)
saver.restore(sess, ckpt)
pianoroll = np.zeros((trc_len, args.num_bars*16, 128))
seq = get_sequence(sess, context, pre, cur_top)
pos = 0
firstnote = False
print('Generating Melody...')
progress = tqdm(total=pianoroll.shape[1])
while pos < pianoroll.shape[1]:
for note in seq:
if (not firstnote) and note >= time_note:
continue
else:
firstnote = True
pre.append(note)
if note == time_note:
pos += 1
progress.update(1)
if pos >= pianoroll.shape[1]:
break
elif note < time_note:
trc = trc_idx.index(note // note_size)
mid = note % note_size + note_offset
if mid < 128:
pianoroll[trc,pos,mid] = 100
seq = get_sequence(sess, context, pre[-512:], cur_top)
pr = []
for i,(t,p) in enumerate(zip(tracks,programs)):
pr.append(pypianoroll.Track(pianoroll=pianoroll[i], program=p, is_drum=(t=='Drums')))
mt = pypianoroll.Multitrack(tracks=pr, tempo=args.tempo, beat_resolution=4)
mt.write(args.output)
def plot_loss(self):
plt.plot(self.disc_loss, c='red')
plt.plot(self.gen_loss, c='blue')
plt.title("GAN Loss per Epoch")
plt.legend(['Discriminator', 'Generator'])
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.savefig('GAN_Loss_per_Epoch_final_1000.png', transparent=True)
plt.close()
if __name__ == '__main__':
path = "C:\\Users\\10413\\Desktop\\deep_learning\\project\\midi-lstm-gan-master\\lpd_5\\lpd_5_cleansed" # 文件夹目录
listOfFiles = getListOfFiles(path)
data_train = np.empty([len(listOfFiles), 4 * 96, 128])
i = 0
for files in listOfFiles:
piano_roll = pypianoroll.load(files)
data = piano_roll.tracks[1].pianoroll
data2 = piano_roll.tracks[1]
pypianoroll.plot(data2) # 打开文件
if data.shape[0] > (4 * 96 - 1):
data_train[i, 0:4 * 96 - 1, 0:127] = data[0:4 * 96 - 1, 0:127]
i = i + 1
if i > 10:
break
gan = GAN(rows=4 * 96)
gan.train(epochs=2,
batch_size=32,
train_data=data_train,
sample_interval=1)
import copy
from madmom.audio.chroma import DeepChromaProcessor
from madmom.features.chords import DeepChromaChordRecognitionProcessor
##################################
# .mid to .npy . #
##################################
# Create a `pypianoroll.Multitrack` instance
print('----------------Start data preprocessing !!-------------------')
multitrack = Multitrack(filepath='./data/preprocessing/mysong_mid_C/test.mid', tempo=120.0, beat_resolution=12)
# save pypianoroll
pr.save('./data/preprocessing/mysong_npy_C/test.npz', multitrack, compressed=True)
data = pr.load('./data/preprocessing/mysong_npy_C/test.npz')
data_tracks = data.get_stacked_pianorolls()
data_bool = data_tracks.astype(bool)
np.save('./data/preprocessing/mysong_npy_C/test.npy',data_bool)
data_npy_C = np.load('./data/preprocessing/mysong_npy_C/test.npy')
# print(np.shape(data_npy_C)) #(3072, 128, 2)
##################################
# .mid to .wav . #
##################################
# from music21 import *
# from midi2audio import FluidSynth
# from IPython.display import display, Image, Audio
fs = FluidSynth('/usr/share/sounds/sf2/FluidR3_GM.sf2') # arch
def load(npz):
return pypianoroll.load(npz)
