def _reconstruct():
log.info("Choosing a random sample and autoencoding it...")
samples = glob(cfg.Paths.samples + "/*sample*.npz")
sample = np.random.choice(samples)
sample = np.load(sample)
sample = sample['sample']
tracks = []
for track in range(sample.shape[0]):
t = pproll.Track(pianoroll=sample[track, :, :], program=0)
t = t.binarize()
tracks.append(t)
song = pproll.Multitrack(tracks=tracks, resolution=midi_cfg.resolution)
song = song.set_nonzeros(1)
pproll.write(multitrack=song,
path=os.path.join(cfg.Paths.generated, "original.mid"))
sample = dataset.preprocess_single(sample)
e = best_encoder.predict(sample)
d = best_decoder.predict(e)
d = d.reshape((1, 1, midi_cfg.phrase_size, 130))
reconstructed = dataset.postprocess(d)
tracks = []
for sample in range(reconstructed.shape[0]):
for track in range(reconstructed.shape[1]):
t = pproll.Track(pianoroll=reconstructed[sample, track, :, :],
program=0)
t = t.binarize()
tracks.append(t)
song = pproll.Multitrack(tracks=tracks, resolution=midi_cfg.resolution)
song = song.set_nonzeros(1)
pproll.write(multitrack=song,
path=os.path.join(cfg.Paths.generated,
f"reconstructed{sample}.mid"))
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 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 main():
data = np.load("output_{}_songs_augmented_19.npy".format(MODEL_NAME),
allow_pickle=True)
chord = np.load("output_{}_chords_augmented_19.npy".format(MODEL_NAME),
allow_pickle=True)
instrument = int(
input(
'which instrument you want to play? from 0 to 128, default = 0: '))
volume = int(
input('how loud you want to play? from 1 to 127, default = 40: '))
for i in random.sample(range(data.shape[0]), 4):
one_song = data[i]
song = []
for item in one_song:
item = item.detach().numpy()
item = item.reshape(16, 128)
song.append(item)
eight_bar = reshape_bar(song)
eight_bar_binarized = find_pitch(eight_bar, volume)
track = make_a_track(eight_bar_binarized, instrument)
song_chord = chord_list(chord, i)
chord_player = get_chord(song_chord)
chord_track = make_chord_track(chord_player, instrument, volume)
a = make_a_demo(track, chord_track, i)
pypiano.write(a, "{}_augmented_19epoch_{}.mid".format(MODEL_NAME, i))
print('saved')
def numpy2midi(m, c, theta, filename): resolution = 12 ratio = int(resolution/4) # 3 bar = int(m.shape[0]/4) mr = m[:,-4:].flatten() m = np.argmax(m[:,:-4].reshape(m.shape[0]*4, 49), 1) midi_m = np.zeros((resolution*bar*4, 128)) for i in range(len(m)): if m[i] == 48: # stop continue if i+1 != len(m): if mr[i+1] > theta: midi_m[i*ratio:(i+1)*ratio - 1, m[i]+48] = 100 else: midi_m[i*ratio:(i+1)*ratio, m[i]+48] = 100 else: #i+1 != len(m) and mr[i+1] == 0: midi_m[i*ratio:(i+1)*ratio - 1, m[i]+48] = 100 # else: #i+1 == len(m): # midi_m[i*ratio:(i+1)*ratio - 1, m[i]+48] = 100 midi_c = np.zeros((resolution*bar*4, 128)) nextchord = -1 for i in range(len(c)): # round # midi_c[i*resolution:(i+1)*resolution-1, np.where(np.round(c[i])==1)[0]+48] = 100 # dot if np.sum(c[i]) == 0: chord = len(chord_composition)-1 else: chord = np.argmax( np.dot(chord_composition, c[i])/(np.linalg.norm(chord_composition, axis=1)+1e-5)/(np.linalg.norm(c)+1e-5) ) if i < len(c)-1 and i%4!=3: nextchord = np.argmax( np.dot(chord_composition, c[i+1])/(np.linalg.norm(chord_composition, axis=1)+1e-5)/(np.linalg.norm(c)+1e-5) ) else: nextchord = -1 main = int(chord/7) for j in np.where(chord_composition[chord]==1)[0]: if j < main: if chord == nextchord: midi_c[i*resolution:(i+1)*resolution, j+60] = 100 else: midi_c[i*resolution:(i+1)*resolution-1, j+60] = 100 else: if chord == nextchord: midi_c[i*resolution:(i+1)*resolution, j+48] = 100 else: midi_c[i*resolution:(i+1)*resolution-1, j+48] = 100 track_m = Track(pianoroll=midi_m, program=0, is_drum=False) track_c = Track(pianoroll=midi_c, program=0, is_drum=False) multitrack = Multitrack(tracks=[track_m, track_c], tempo=80.0, beat_resolution=resolution) pypianoroll.write(multitrack, filename)
def train(self, epochs, train_data, batch_size=128, sample_interval=50):
# Load and convert the data
#notes = get_notes()
#n_vocab = len(set(notes))
#X_train, y_train = prepare_sequences(notes, n_vocab)
X_train = train_data
# Adversarial ground truths
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Training the model
for epoch in range(epochs):
# Training the discriminator
# Select a random batch of note sequences
idx = np.random.randint(0, X_train.shape[0], batch_size)
real_seqs = X_train[idx]
# noise = np.random.choice(range(484), (batch_size, self.latent_dim))
# noise = (noise-242)/242
noise = np.random.normal(
0, 1, (batch_size, self.seq_length, self.latent_dim))
# Generate a batch of new note sequences
gen_seqs = self.generator.predict(noise)
# Train the discriminator
d_loss_real = self.discriminator.train_on_batch(real_seqs, real)
d_loss_fake = self.discriminator.train_on_batch(gen_seqs, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Training the Generator
noise = np.random.normal(
0, 1, (batch_size, self.seq_length, self.latent_dim))
# Train the generator (to have the discriminator label samples as real)
g_loss = self.combined.train_on_batch(noise, real)
# Print the progress and save into loss lists
if epoch % sample_interval == 0:
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[1], g_loss))
self.disc_loss.append(d_loss[0])
self.gen_loss.append(g_loss)
noise = np.random.normal(0, 1, (1, self.seq_length, self.latent_dim))
predictions = self.generator.predict(noise)
track = pypianoroll.Track(pianoroll=predictions,
program=0,
is_drum=False,
name='my awesome piano')
pypianoroll.write(
track,
"C:\\Users\\10413\\Desktop\\deep_learning\\project\\midi-lstm-gan-master\\output"
)
def _generate_samples(decoder: k.Model):
z = np.random.randn(1, 512)
predicted = decoder.predict(z)
x = dataset.postprocess(predicted)
guitar = pproll.Track(pianoroll=predicted[0, :, :], program=0)
guitar = guitar.binarize()
song = pproll.Multitrack(tracks=[guitar], resolution=midi_cfg.resolution)
song = song.set_nonzeros(1)
song.validate()
pproll.write(multitrack=song,
path=os.path.join(cfg.Paths.generated, f"{0}.mid"))
def sample2midi(path, sample, resolution):
music = sample.reshape(512, 72)
all_notes = np.zeros((512, 128), dtype=np.uint8)
all_notes[:, 24:96] = music
pypianoroll.write(path=path,
multitrack=pypianoroll.Multitrack(
resolution=resolution,
tracks=[
pypianoroll.BinaryTrack(program=0,
is_drum=False,
pianoroll=all_notes)
]))
def create_midi_from_piano_roll(
roll: np.ndarray, midi_path: str, lowest_note: str, tempo: int,
instrument: int, velocity: float
) -> None:
"""
Create MIDI file from array with piano roll.
:param roll:
piano roll
:param midi_path:
path where resulting MIDI file is going to be saved
:param lowest_note:
note that corresponds to the lowest row of piano roll
:param tempo:
number of piano roll's time steps per minute
:param instrument:
ID (number) of instrument according to General MIDI specification
:param velocity:
one common velocity for all notes
:return:
None
"""
notes_order = {
'C': 0, 'C#': 1, 'D': 2, 'D#': 3, 'E': 4, 'F': 5, 'F#': 6,
'G': 7, 'G#': 8, 'A': 9, 'A#': 10, 'B': 11
}
n_semitones_per_octave = 12
n_rows_below = (
n_semitones_per_octave * int(lowest_note[-1])
+ notes_order[lowest_note[:-1]]
)
n_pypianoroll_pitches = 128
n_rows_above = n_pypianoroll_pitches - n_rows_below - roll.shape[0]
resized_roll = np.hstack((
np.zeros((roll.shape[1], n_rows_below)),
roll.T,
np.zeros((roll.shape[1], n_rows_above))
))
track = pypianoroll.Track(velocity * resized_roll, instrument)
multitrack = pypianoroll.Multitrack(
tracks=[track],
tempo=tempo,
beat_resolution=1
)
pypianoroll.write(multitrack, midi_path)
def save_midi_pypiano(m, midi_path, filename):
# velocity = 100
# zero1 = np.zeros((m.shape[0],47))
# zero2 = np.zeros((m.shape[0],128 - 95))
# m1 = np.concatenate((zero1,m[:,:-1],zero2),axis=1)
m1 = np.zeros((m.shape[0], 128))
m1[:, 48:96] = m[:, :-1]
velocity_matrix = get_velocity_matrix(m1)
m1 = m1 * velocity_matrix
# m1 = m1 * velocity
resolution = DATA_CONFIG['data_tpb']
track_m = Track(pianoroll=m1, program=0, is_drum=False, name='Melody')
multitrack = Multitrack(tracks=[track_m],
tempo=80.0,
beat_resolution=resolution)
pypiano.write(multitrack, midi_path + filename + ".mid")
def pianoroll_to_midi(snippet, filename="Sampled/sample.midi"):
snippet = np.asarray(snippet, dtype=np.uint8)
snippet = snippet * 127 # sets velocity of notes from 1 to 127 (max MIDI velocity)
if snippet.shape[1] == 89:
snippet = one_hot_pianoroll_to_small_pianoroll(snippet)
snippet = small_to_full_pianoroll(snippet)
elif snippet.shape[1] == 88:
snippet = small_to_full_pianoroll(snippet)
else:
if not snippet.shape[1] == 128:
raise ValueError(
"input shape does not have 128 pitches (or 88, then it will be converted automatically) and cannot be converted to MIDI!"
)
snippet = ppr.Track(pianoroll=snippet)
snippet = ppr.Multitrack(tracks=[snippet], tempo=120, beat_resolution=4)
ppr.write(snippet, path_to_root + filename)
def write_pianoroll(result_dir, melody_data, accompany_pianoroll_frame,
chord_groundtruth_frame, length, tempos, downbeats):
print('write pianoroll...')
if not os.path.exists(result_dir):
os.makedirs(result_dir)
counter = 0
for melody_roll, chord_roll, truth_roll, l, tempo, downbeat in tqdm(
zip(melody_data, accompany_pianoroll_frame,
chord_groundtruth_frame, length, tempos, downbeats),
total=len(melody_data)):
melody_roll, chord_roll, truth_roll = melody_roll[:
l], chord_roll[:
l], truth_roll[:
l]
track1 = Track(pianoroll=melody_roll)
track2 = Track(pianoroll=chord_roll)
track3 = Track(pianoroll=truth_roll)
generate = Multitrack(tracks=[track1, track2],
tempo=tempo,
downbeat=downbeat,
beat_resolution=Constants.BEAT_RESOLUTION)
truth = Multitrack(tracks=[track1, track3],
tempo=tempo,
downbeat=downbeat,
beat_resolution=Constants.BEAT_RESOLUTION)
pr.write(generate, result_dir + '/generate_' + str(counter) + '.mid')
pr.write(truth, result_dir + '/groundtruth_' + str(counter) + '.mid')
fig, axs = generate.plot()
plt.savefig(result_dir + '/generate_' + str(counter) + '.png')
plt.close()
fig, axs = truth.plot()
plt.savefig(result_dir + '/groundtruth_' + str(counter) + '.png')
plt.close()
counter += 1
print('Finished!')
def numpy_to_pianoroll(folder):
#Bass Drums Guitar Piano Strings
programs = [34,0,30,1,51]
names = ['Bass' ,'Drums' ,'Guitar' ,'Piano' ,'Strings']
tempo = np.full((96), 105)
for filename in os.listdir(folder):
multisample = np.load(os.path.join(folder,filename))
for sample,i in zip(multisample,range(multisample.shape[0])):
tracks = []
classes = []
for instrument,program,name in zip(sample,programs,names):
print(instrument.shape)
track = np.vstack(instrument)
print(track.shape)
track[track > 0.5] = 100
track[track < 0.5] = 0
print(track.shape)
track = np.pad(track.astype(int),((0,0),(0,44)),mode='constant')
if name !='Guitar':
print(ppr.metrics.qualified_note_rate((track),2))
print(ppr.metrics.n_pitches_used((track)))
classes.append(ppr.metrics.n_pitches_used((track)))
print(track.shape)
isdrum = False
if program == 0:
isdrum = True
ppr_track = ppr.Track(track,program,isdrum,name)
tracks.append(ppr_track)
ppr_song = ppr.Multitrack(tracks=tracks, tempo=tempo, beat_resolution=24)
for instrument, clasnum in zip(names,classes):
print(instrument+':'+str(clasnum))
print(123)
plot = ppr.plot_multitrack(ppr_song,mode='separate',ytick='off')
plt.savefig('gen_samples/'+filename+str(i)+".png",dpi=400)
ppr.write(ppr_song, 'gen_samples/'+filename+"song")
def write_one_pianoroll(result_dir, filename, melody_data,
accompany_pianoroll_frame, chord_groundtruth_frame,
length, tempo, downbeat):
print('write pianoroll...')
if not os.path.exists(result_dir):
os.makedirs(result_dir)
l = length
melody_roll, chord_roll, truth_roll = melody_data[
0][:l], accompany_pianoroll_frame[0][:l], chord_groundtruth_frame[
0][:l]
track1 = Track(pianoroll=melody_roll)
track2 = Track(pianoroll=chord_roll)
track3 = Track(pianoroll=truth_roll)
generate = Multitrack(tracks=[track1, track2],
tempo=tempo[0],
downbeat=downbeat[0],
beat_resolution=Constants.BEAT_RESOLUTION)
truth = Multitrack(tracks=[track1, track3],
tempo=tempo[0],
downbeat=downbeat[0],
beat_resolution=Constants.BEAT_RESOLUTION)
pr.write(generate, result_dir + '/generate-' + filename + '.mid')
pr.write(truth, result_dir + '/groundtruth-' + filename + '.mid')
fig, axs = generate.plot()
plt.savefig(result_dir + '/generate-' + filename + '.png')
plt.close()
fig, axs = truth.plot()
plt.savefig(result_dir + '/groundtruth-' + filename + '.png')
plt.close()
print('Finished!')
def write_midi(sequence, output_path):
"""
Transform the given sequence into MIDI format and store it in the given path
sequence (List(num_bars): torch.Tensor(1 x 1 x 128 x 96)): sequence of bar encodings
output_path (str): path to store the transformed MIDI
"""
# get number of bars
num_bars = len(sequence)
# squeeze into List(num_bars): numpy.ndarray(128 x 96)
melody = [sequence[i][0][0].detach().cpu().numpy() for i in range(num_bars)]
# transform into MIDI track format (num_bars*RESOLUTION x 128)
melody = np.concatenate(melody, axis=1).transpose()
# pack into binary track
melody_track = pypianoroll.BinaryTrack(pianoroll = melody > 0)
# pack into multi-track
multi_track = pypianoroll.Multitrack(resolution=RESOLUTION, tracks=[melody_track])
# write to output path
pypianoroll.write(output_path, multi_track)
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 train(self, epochs, train_data, batch_size=128, sample_interval=50):
# Load and convert the data
#notes = get_notes()
#n_vocab = len(set(notes))
#X_train, y_train = prepare_sequences(notes, n_vocab)
X_train = train_data
# Adversarial ground truths
real = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Training the model
for epoch in range(epochs):
# Training the discriminator
# Select a random batch of note sequences
idx = np.random.randint(0, X_train.shape[0], batch_size)
real_seqs = X_train[idx]
# noise = np.random.choice(range(484), (batch_size, self.latent_dim))
# noise = (noise-242)/242
noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
# Generate a batch of new note sequences
gen_seqs = self.generator.predict(noise)
# Train the discriminator
if epoch > 99 or epoch == 0:
if epoch % 5 == 0:
d_loss_real = self.discriminator.train_on_batch(
real_seqs, real)
d_loss_fake = self.discriminator.train_on_batch(
gen_seqs, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Training the Generator
noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
# Train the generator (to have the discriminator label samples as real)
g_loss = self.combined.train_on_batch(noise, real)
# Print the progress and save into loss lists
if epoch % sample_interval == 0:
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[1], g_loss))
self.disc_loss.append(d_loss[0])
self.gen_loss.append(g_loss)
noise = np.random.normal(0, 1, (1, self.seq_length, self.latent_dim))
predictions = self.generator.predict(noise)
predictions[predictions > 0.5] = 1
predictions[predictions <= 0.5] = 0
a = predictions[predictions == 1]
b = a.shape
track = pypianoroll.Track(pianoroll=np.squeeze(predictions),
program=0,
is_drum=False,
name='Piano')
emp0 = np.zeros(self.seq_shape)
track0 = pypianoroll.Track(pianoroll=emp0,
program=0,
is_drum=True,
name='Drums')
emp2 = np.zeros(self.seq_shape)
track2 = pypianoroll.Track(pianoroll=emp2,
program=0,
is_drum=False,
name='Guitar')
emp3 = np.zeros(self.seq_shape)
track3 = pypianoroll.Track(pianoroll=emp2,
program=0,
is_drum=False,
name='Bass')
emp4 = np.zeros(self.seq_shape)
track4 = pypianoroll.Track(pianoroll=emp2,
program=0,
is_drum=False,
name='Strings')
track_list = [track0, track, track2, track3, track4]
Multrack = pypianoroll.Multitrack(filename=None,
tracks=track_list,
tempo=120.0,
downbeat=None,
beat_resolution=24,
name='Piano')
pypianoroll.write(
Multrack,
"C:\\Users\\10413\\Desktop\\deep_learning\\project\\midi-lstm-gan-master\\output\\output1.midi"
)
print(j)
xo = np.expand_dims(x_con[j], axis=1)
yo = np.expand_dims(y_con[j], axis=1)
for k in range(len(x_con[j])):
print(model.train_on_batch(xo[k], xo[k]), end=' ')
model.reset_states()
print('\n')
print('\n')
print('Testing')
print('\n')
kolo = []
for j in range(5):
print(j)
bolo = []
xo = np.expand_dims(x_ton[j], axis=1)
for k in range(len(x_ton[j])):
bolo.extend(model.predict_on_batch(xo[k]))
model.reset_states()
bolo = np.concatenate(np.array(bolo))
kolo.append(bolo)
jojo = np.array(kolo)
for j in range(5):
r2 = pn.Track(pianoroll=jojo[j] * 300,
program=0,
is_drum=False,
name='my awesome piano')
multitrack2 = pn.Multitrack(tracks=[r2])
os.system('mkdir ./results/' + str(i))
pn.write(multitrack2, './results/' + str(i) + '/' + str(j) + '.mid')
model.save('stacked.h5')
for j in range(len(x_train)):
temp_x = np.array(
np.array_split(pad_along_axis(x_train[j], seq_len),
np.ceil(len(x_train[j]) / seq_len)))
windows.append(temp_x)
return np.array(windows)
x = []
for i in range(1, len(sys.argv)):
a = pn.parse(sys.argv[i])
x.append(1 * np.sign(a.tracks[0].pianoroll))
x_final = np.array(x)
x_con = trunc_sequences(x_final)
for j in range(len(x_con)):
bolo = []
xo = np.expand_dims(x_con[j], axis=1)
for k in range(len(x_con[j])):
bolo.extend(model.predict_on_batch(xo[k]))
model.reset_states()
bolo = np.concatenate(np.array(bolo))
result = pn.binarize(pn.Track(pianoroll=bolo * 100,
program=0,
is_drum=False,
name='my awesome piano'),
threshold=0.05)
multitracksam11 = pn.Multitrack(tracks=[result])
pn.write(multitracksam11,
'./result/10_' + sys.argv[j + 1].split('_')[0] + '.mid')
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)
piano_roll = pypianoroll.load(listOfFiles[1])
piano_roll.tracks[2].pianoroll = piano_roll.tracks[2].pianoroll > 2
piano_roll.tracks[0].pianoroll = piano_roll.tracks[0].pianoroll > 2
piano_roll.tracks[3].pianoroll = piano_roll.tracks[3].pianoroll > 3
piano_roll.tracks[4].pianoroll = piano_roll.tracks[4].pianoroll > 3
data = piano_roll.tracks[2].pianoroll
b = np.sum(data)
pypianoroll.write(piano_roll, path)
print(listOfFiles[1])
data_train = np.empty([300, 20 * 96, 128])
i = 0
for files in listOfFiles:
piano_roll = pypianoroll.load(files)
data = piano_roll.tracks[1].pianoroll
if data.shape[0] > (20 * 96 - 1):
data_train[i, 0:20 * 96 - 1, 0:127] = data[0:20 * 96 - 1, 0:127]
i = i + 1
if i > 299:
break
gan = GAN(rows=20 * 96)
gan.train(epochs=200,
batch_size=32,
train_data=data_train,
