def getReverseOneHotDict(dict):
inverted_dict = {str(value): key for key, value in dict.items()}
return inverted_dict
print("started")
model = p.load("vecTrained")
encoderDict = p.load("oneHotDict")
reverseEncoderDict = getReverseOneHotDict(encoderDict)
num_samples = p.load('numSamples')
targetLine = math.floor(random.random() * num_samples)
seed_line = 0
myfile = open('training_data.csv', 'r')
reader = csv.reader(myfile, delimiter=',')
row = []
for i in range(targetLine):
row = next(reader)
#print(i)
song = convertW2V(row[1:], window_size)
for i in range(500):
tempSong = song[-100:]
model.reset_states()
outputVec = model.predict(np.array(tempSong).reshape(1, 100, 20))
#print(outputHot)
song.append(closestVec(outputVec[0]))
p.save(song[99:], 'song')
import ezPickle as p
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
series_stats = pd.read_csv('../data/summary_stats.csv')
outputs = p.load('output_list')
for i in range(len(outputs)):
outputs[i] = outputs[i].index(1)
clf = RandomForestClassifier(n_estimators=500, max_depth=7, random_state=0)
clf.fit(series_stats.values[0:3000], outputs[0:3000])
p.save(clf, 'rf_clf')
print(clf.score(series_stats.values[3000:], outputs[3000:]))
import keras, math, os, glob
import pandas as pd
import numpy as np
import ezPickle as p
from scipy.misc import imread
train_curated = pd.read_csv('train_curated.csv')
files = train_curated['fname']
labels = train_curated['labels']
labels = [item for label_list in labels for item in label_list.split(',')]
le = preprocessing.LabelEncoder()
le.fit(labels)
print(len(le.classes_.tolist()))
p.save(le, 'le')
data = []
max_len = 0
os.environ["CUDA_VISIBLE_DEVICES"] = "1,2,3"
for file_name in files:
#print(file_name)
spectrogram = imread("mel_spec_curated/" + file_name + ".png")
#print("\t sampled")
#print('\t',spectrogram.shape)
if spectrogram.shape[1] > max_len:
max_len = spectrogram.shape[1]
max_shape = spectrogram.shape
print(max_len)
print(max_shape)
model.add(
LSTM(256, return_sequences=True, input_shape=p.load('inputShape')))
model.add(Dropout(.2))
model.add(LSTM(128, return_sequences=True))
model.add(Dropout(.2))
model.add(LSTM(128, return_sequences=False))
model.add(Dropout(.2))
model.add(Dense(size, activation='sigmoid'))
return model
with tf.device("/cpu:0"):
model = create_model()
# make the model parallel
p_model = multi_gpu_model(model, gpus=3)
rms = RMSprop()
p_model.compile(loss='mean_squared_error',
optimizer=rms,
metrics=['mean_squared_error'])
print("Fitting")
num_samples = p.load('numSamples')
p_model.fit_generator(songBatchGenerator(batch_size),
epochs=50,
verbose=1,
shuffle=False,
steps_per_epoch=math.ceil(num_samples / batch_size))
p.save(p_model, 'vecTrained')
print("Saved")
from scipy.misc import imsave
df = pd.DataFrame()
print("Please enter name of input folder")
in_folder = input()
print("Please enter name of output folder")
out_folder = input()
le = p.load('le')
data = []
lengths = []
count = 0
files = glob.glob(in_folder + "/*")
for file_name in files:
print(file_name)
rate, data = wavfile.read(file_name)
print("\t read")
print('\t', data.shape, " Frames at ", rate)
print('\t', count / len(files))
#new_data = resample(data, round(data.shape[0]/rate * new_rate))
spectrogram = librosa.feature.melspectrogram(y=data.astype(float), sr=rate)
print("\t Converted")
print('\t', spectrogram.shape)
imsave(out_folder + '/' + file_name[file_name.index('/'):] + ".png",
spectrogram)
print("\twrote")
lengths.append(spectrogram.shape[1])
count += 1
series = pd.Series(lengths)
p.save(series, 'series')
print(series.describe())
from gensim.models import Word2Vec
import ezPickle as p
size = 20
songs = p.load('songList')
w2v = Word2Vec(sg=1, seed=1, size=size, window=8, min_count=0, workers=2)
w2v.build_vocab(songs)
w2v.train(songs, total_examples=w2v.corpus_count, epochs=100)
p.save(w2v, 'w2v')
p.save(size, "size")
print(len(w2v.wv.vocab))
if len(song) > maxLen:
maxLen = len(song)
print(maxLen)
print(len(songList))
inputData = []
outputData = []
window_size = 100
print("Writing Data")
import csv
data_file = open('training_data.csv',mode='w')
file_writer = csv.writer(data_file, delimiter=',')
num_samples = 0
for song in [item for item in songList if len(item) > window_size]:
for i in range(0,len(song)-window_size):
file_writer.writerow([song[i+window_size]] + song[i:i+window_size])
num_samples+=1
print("done")
inputData = np.array(inputData).reshape(len(inputData), maxLen, 20)
inputShape = (window_size, size)
outputSize = len(encoderDict.keys())
print("Saving")
p.save(encoderDict,'oneHotDict')
p.save(inputShape, 'inputShape')
p.save(outputSize,'outputSize')
p.save(num_samples,'numSamples')
p.save(window_size,'window_size')
#split the training data into batches
import ezPickle as p
import math
print("loading data")
inputData = p.load('inputData')
outputData = p.load('outputData')
print('Size is : ', len(inputData))
#Split into Sets of 12 songs
numSongs = 12
sets = math.floor(len(inputData)/numSongs)
tempInput = []
tempOutput = []
#making output
numSongs = 12
for i in range(sets):
start = i*numSongs
end = (i+1)*numSongs
tempInput = inputData[start:end]
tempOutput = outputData[start:end]
p.save(tempInput, 'inputData'+str(i))
p.save(tempOutput, 'outputData'+str(i))
if end >= len(inputData):
tempInput = inputData[start:]
tempOutput = outputData[start:]
p.save(tempInput, 'inputData'+str(i))
p.save(tempOutput, 'outputData'+str(i))
print(inputData[0])
for row in reader:
if current_line >= end:
#print(np.array(o_d)[0])
yield (np.array(i_d), np.array(o_d))
start = end
end = start + batch_size
i_d = []
o_d = []
if end > num_samples:
end = num_samples - 1
i_d.append(convertW2V(row[1:], window_size))
o_d.append(np.array(encoderDict[row[0]].copy()))
current_line += 1
p_model = p.load('kerasTrained')
rms = RMSprop()
#p_model.compile(loss='categorical_crossentropy',optimizer=rms, metrics=['categorical_accuracy'])
print("Fitting")
num_samples = p.load('numSamples')
p_model.fit_generator(songBatchGenerator(batch_size),
epochs=100,
verbose=1,
shuffle=False,
steps_per_epoch=math.ceil(num_samples / batch_size))
p.save(p_model, 'kerasTrained')
print("Saved")
model.add(LSTM(128, return_sequences=True))
model.add(Dense(outputSize, activation='softmax'))
return model
#with tf.device("/cpu:0"):
model = create_model()
# make the model parallel
#p_model = multi_gpu_model(model, gpus=3)
rms = RMSprop()
try:
model.compile(loss='categorical_crossentropy',
optimizer=rms,
metrics=['categorical_accuracy'])
print("Fitting")
batch_size = 12
epochs = 100
songList = p.load('songList')
#model.fit_generator(songBatchGenerator(songList,batch_size), epochs=10, verbose=1, shuffle=False, steps_per_epoch=math.ceil(len(songList)/batch_size),max_queue_size=2)
for inp, out in songBatchGenerator(
songList, batch_size,
epochs * math.ceil(len(songList) / batch_size)):
model.train_on_batch(inp, out)
p.save(model, 'kerasTrainedNoDropout')
print("Saved")
except MemoryError:
print("Memory whyyyyyy")
parity = True
while True:
if parity:
yield next(g)
else:
yield next(ng)
parity = not parity
model = Sequential()
model.add(Conv2D(64, 3, strides=(3,3), activation='relu', input_shape = ( 128, max_len,1)))
model.add(Conv2D(128, 3, strides=(1,1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2), strides=None))
#model.add(Conv2D(16, 3, strides=(1,1), activation='relu'))
#model.add(Conv2D(16, 3, strides=(1,1), activation='relu'))
#model.add(MaxPooling2D(pool_size=(2,2), strides=None))
model.add(Flatten())
model.add(Dense(256, activation='sigmoid'))
model.add(Dense(len(le.classes_.tolist()), activation='sigmoid'))
opt = Adadelta()
p_model = multi_gpu_model(model, gpus=3)
p_model.compile(loss='mean_squared_error',optimizer=opt, metrics=['mean_squared_error'])
batch_size = 42
#p_model = p.load('conv_model2')
p_model.fit_generator(generator(batch_size), epochs=10, verbose=1, shuffle=False, steps_per_epoch=math.ceil((len(files))/batch_size),max_queue_size=1, callbacks = [cb])
p_model.save_weights("model.h5")
p.save(p_model, 'conv_model1')
import ezPickle as p
import pandas as pd
from sklearn import svm
series_stats = pd.read_csv('../data/summary_stats.csv')
test_stats = pd.read_csv('../data/test_summary_stats.csv')
outputs = p.load('output_list')
print('load data done..')
for i in range(len(outputs)):
outputs[i] = outputs[i].index(1)
clf = svm.SVC(gamma='scale', decision_function_shape='ovo')
print('train...')
clf.fit(series_stats.values, outputs)
p.save(clf,'clf')
print('train done...')
predictions = clf.predict(test_stats.values)
print('predict done...')
def getReverseOneHotDict(dict):
inverted_dict = {str(value): key for key, value in dict.items()}
return inverted_dict
encoder_dict = p.load('encoder_dict')
decoder_dict = getReverseOneHotDict(encoder_dict)
predictions = predictions.tolist()
for i in range(len(predictions)):
temp = [0]*9
temp[predictions[i]] = 1
predictions[i] = temp
l.append(np.zeros(20))
return l
def getReverseOneHotDict(dict):
inverted_dict = {str(value): key for key, value in dict.items()}
return inverted_dict
print("started")
model = p.load("kerasTrained")
encoderDict = p.load("oneHotDict")
reverseEncoderDict = getReverseOneHotDict(encoderDict)
num_samples= p.load('numSamples')
targetLine = math.floor(random.random() * num_samples)
seed_line = 0
myfile = open('training_data.csv', 'r')
reader = csv.reader(myfile, delimiter=',')
row = []
for i in range(targetLine):
row = next(reader)
#print(i)
song = convertW2V(row[1:],window_size)
for i in range(100):
tempSong = song[-100:]
model.reset_states()
outputHot = list(model.predict(np.array(tempSong).reshape(1,100,20)))
#print(max(outputHot))
song.append(w2v[reverseEncoderDict[str(outputHot)]])
p.save( song, 'song' )
model.add(LSTM(256, return_sequences=True))
model.add(Dropout(.2))
model.add(LSTM(128, return_sequences=True))
model.add(Dropout(.2))
model.add(LSTM(128, return_sequences=True))
model.add(Dropout(.2))
model.add(Dense(outputSize, activation='softmax'))
return model
#with tf.device("/cpu:0"):
model = create_model()
# make the model parallel
#p_model = multi_gpu_model(model, gpus=3)
rms = RMSprop()
try:
model.compile(loss='categorical_crossentropy',optimizer=rms, metrics=['categorical_accuracy'])
print("Fitting")
batch_size = 12
epochs = 100
songList = p.load('songList')
#model.fit_generator(songBatchGenerator(songList,batch_size), epochs=10, verbose=1, shuffle=False, steps_per_epoch=math.ceil(len(songList)/batch_size),max_queue_size=2)
for inp, out in songBatchGenerator(songList,batch_size,epochs*math.ceil(len(songList)/batch_size)):
model.train_on_batch(inp,out)
p.save(model, 'kerasTrained2')
print("Saved")
except MemoryError:
print("Memory whyyyyyy")
yield x , y data_list = [] label_list = [] #for x, y in audio_generator(10): # print(x, y) # os.sleep(5) batch_size = 9 model = Sequential() model.add(Masking(mask_value=0, input_shape=(max_len, 1))) model.add(LSTM(256, return_sequences=True)) model.add(Dropout(.2)) model.add(LSTM(128, return_sequences=True)) model.add(Dropout(.2)) model.add(LSTM(128, return_sequences=False)) model.add(Dropout(.2)) model.add(Dense(len(le.classes_.tolist()), activation='softmax')) rms = RMSprop() p_model = multi_gpu_model(model, gpus=3) p_model.compile(loss='categorical_crossentropy',optimizer=rms, metrics=['categorical_accuracy']) p_model.fit_generator(audio_generator(batch_size), epochs=10, verbose=1, shuffle=False, steps_per_epoch=math.ceil(len(files)/batch_size),max_queue_size=1) p.save(p_model, 'p_model') #sequence = pad_sequences(sequences, maxlen=max_len, dtype='int32', padding='pre', truncating='pre', value=-1)
import ezPickle as p
print("Number of Songs is: ", len(glob.glob("songs/*.mid")))
count = 0
songs = []
#This section is largely based on a web tutorial
for file in glob.glob("songs/*.mid"):
song = converter.parse(file)
parts = instrument.partitionByInstrument(song)
if parts:
notes = parts.parts[0].recurse()
else:
notes = song.flat.notes
currentSong = []
for item in notes:
if isinstance(item, note.Note):
if item.isNote:
currentSong.append(
str(item.pitch) + ":" + str(item.quarterLength)
) #For melody I am recording octave information
else:
currentSong.append('rest:' + str(item.quarterLength))
if isinstance(item, chord.Chord):
currentSong.append(
'.'.join(str(n) for n in item.normalOrder) + ":" +
str(item.quarterLength)
) #For harmony I am only recording the 12 tone values
songs.append(currentSong)
p.save(songs, 'songList')
#print(songs[0:3])