def classify(self): storage = store(os.path.join(settings.BRAIN_DIR, 'nn')) save_path = storage['save.path'] meta_path = save_path + '.meta' saver = tf.train.import_meta_graph(meta_path) data = self.get_features() n_f = data.shape[0] data = data.reshape((1, n_f)) prediction = None with tf.Session() as sess: saver.restore(sess, save_path) graph = tf.get_default_graph() x = graph.get_tensor_by_name('x:0') y_ = graph.get_tensor_by_name('y_:0') keep_prob = graph.get_tensor_by_name('keep_prob:0') result = sess.run(y_, feed_dict={x: data, keep_prob: 1})[0] idx = np.argmax(result) dataset = musicset.MusicSet() dataset.one_hot_encode_genres() for genre in dataset.genres: if dataset.encoded_genres[genre][idx] == 1: prediction = genre if self.prediction is not None: self.prediction.destroy() self.prediction = tk.Label(self.root, text=prediction) self.prediction.config(font=("Courier", 36)) self.prediction.grid(row=0, column=1)
def test_pca_mdb(self): featureset = musicset.MusicSet(dirname='features2') train = featureset.load_train_data() new_features = reduce.pca(train.music) storage = store(featureset.results_dir) storage['reduced_mdb.dat'] = new_features self.assertGreater(train.music.shape[1], new_features.shape[1])
def train(self, display_step=100, num_feat=20, path=None): storage = store(path) if storage['features.dat'] is not None: return storage['features.dat'] n_input = settings.CNN['INPUT_SHAPE'][0]*settings.CNN['INPUT_SHAPE'][1] n_classes = len(settings.GENRES) new_shape = [-1, settings.CNN['INPUT_SHAPE'][0], settings.CNN['INPUT_SHAPE'][1], 1] x = self.x = tf.placeholder("float", [None, n_input]) new_x = self.new_x = tf.reshape(self.x, new_shape) y = self.y = tf.placeholder("float", [None, n_classes]) cw, dw = self.get_weights(n_classes) cb, db = self.get_bias(n_classes) y_ = self.y_ = self.prepare_layers() cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=self.y_, labels=self.y)) optimizer = tf.train.AdamOptimizer(learning_rate=settings.NN['LEARNING_RATE']).minimize(cost) init = tf.global_variables_initializer() new_ds = DataSet() with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)) as sess: sess.run(init) step = 1 for genre in self.data.genres: for file in self.data.files[genre]: data, sr = librosa.load(file) options = {} options['frame_length'] = int(settings.FRAME_LENGTH) options['hop_length'] = int(settings.HOP_LENGTH) frames = librosa.util.frame(data, **options) frames = frames.T[:settings.KEEP_FRAMES, :] #print(frames.shape, type(frames)) #return labels = np.tile(self.data.encoded_genres[genre], (settings.KEEP_FRAMES, 1)) for i in range(settings.CNN['TRAINING_CYCLES']): sess.run(optimizer, feed_dict={x: frames, y: labels}) features = np.array(sess.run(self.dense_layers[-2], feed_dict={x: frames})[0]) true_label = np.array(self.data.encoded_genres[genre]) if new_ds.music is None: new_ds.music = features new_ds.labels = true_label else: new_ds.music = np.vstack((new_ds.music, features,)) new_ds.labels = np.vstack((new_ds.labels, true_label,)) print("File Processed: %s" % file) print("Genre Processed: %s" % genre) storage['features.dat'] = new_ds return new_ds
def __init__(self, force_load=False, genres=None, dirname=RESULT_DIR): self.results_dir = os.path.join(settings.BRAIN_DIR, dirname) if not os.path.isdir(self.results_dir): os.mkdir(self.results_dir) self.genres = genres or settings.GENRES self.storage = store(self.results_dir, force_load) self.files = {} self.train = None self.test = None self.validation = None self.encoded_genres = None self.load_files()
def test_nn(self): p = os.path.join(settings.BRAIN_DIR, "specfeat") dataset = musicset.MusicSet(dirname='special') dataset.load_files() dataset.one_hot_encode_genres() storage = store(p) ds = storage['features.dat'] all_data = np.hstack(tuple(np.split(ds.music, 10, axis=0))) all_labels = np.hstack(tuple(np.split(ds.labels, 10, axis=0))) dataset.train = musicset.DataSet() dataset.test = musicset.DataSet() dataset.train.music = np.vstack( tuple(np.split(all_data[:70, :], 10, axis=-1))) dataset.train.labels = np.vstack( tuple(np.split(all_labels[:70, :], 10, axis=-1))) dataset.test.music = np.vstack( tuple(np.split(all_data[70:, :], 10, axis=-1))) dataset.test.labels = np.vstack( tuple(np.split(all_labels[70:, :], 10, axis=-1))) nn_t = nn.NN(dataset, n_input=256) step = 100 tr, te, trc, tec = nn_t.train(display_step=step, out=True, path='special.final') epochs = np.arange(int(settings.NN['TRAINING_CYCLES'] / step)) f, ax = plt.subplots(2) ax[0].plot(epochs, tr, color='#FF2D00', label='Training Accuracy') #ax[0].plot(epochs, vl, color='#1DFF00', label='Validation Accuracy') ax[0].plot(epochs, te, color='#0014FF', label='Testing Accuracy') ax[0].legend(loc="lower right") ax[0].set_xlabel('Epoch') ax[0].set_ylabel('Accuracy') ax[0].set_title('Accuracy vs Number of epochs') ax[1].plot(epochs, trc, color='#FF2D00', label='Training Lost') ax[1].plot(epochs, tec, color='#1DFF00', label='Test Lost') ax[1].legend(loc="lower right") ax[1].set_xlabel('Epoch') ax[1].set_ylabel('Loss') ax[1].set_title('Loss vs Number of Epochs') f.suptitle('Network with %s layers' % settings.NN['NUM_HIDDEN_LAYERS']) plt.show()
def __init__(self, force=False): self.storage = store('/tmp', force)
def train(self, display_step=100, out=False, path='model.final'): n_classes = len(settings.GENRES) n_input = self.n_input x = self.x = tf.placeholder("float", [None, n_input], name='x') y = self.y = tf.placeholder("float", [None, n_classes], name='y') keep_prob = self.keep_prob = tf.placeholder(tf.float32, name='keep_prob') w = self.get_weights(n_input, n_classes) b = self.get_bias(n_classes) y_ = self.y_ = self.prepare_layers() cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=self.y_, labels=self.y)) optimizer = tf.train.AdamOptimizer( learning_rate=settings.NN['LEARNING_RATE']).minimize(cost) init = tf.global_variables_initializer() saver = tf.train.Saver() self.correct_pred = correct_pred = tf.equal(tf.argmax(self.y_, 1), tf.argmax(self.y, 1)) self.accuracy = accuracy = tf.reduce_mean( tf.cast(correct_pred, tf.float32)) train_acc = [] #val_acc = [] test_acc = [] train_cost = [] test_cost = [] with tf.Session(config=tf.ConfigProto( allow_soft_placement=True, log_device_placement=True)) as sess: sess.run(init) step = 1 for i in range(settings.NN['TRAINING_CYCLES']): bx, by = self.data.train.next_batch(settings.NN['BATCH_SIZE']) sess.run(optimizer, feed_dict={ x: bx, y: by, keep_prob: settings.NN['DROPOUT_PROB'] }) if step % display_step == 0: # Calculate batch accuracy acc = sess.run(accuracy, feed_dict={ x: bx, y: by, keep_prob: 1. }) # Calculate batch loss loss = sess.run(cost, feed_dict={ x: bx, y: by, keep_prob: 1. }) train_acc.append(acc) #vac = sess.run(accuracy, # feed_dict={x: self.data.validation.music, y: self.data.validation.labels, keep_prob: 1.}) tac = sess.run(accuracy, feed_dict={ x: self.data.test.music, y: self.data.test.labels, keep_prob: 1. }) te_loss = sess.run(cost, feed_dict={ x: self.data.test.music, y: self.data.test.labels, keep_prob: 1. }) train_cost.append(loss) test_cost.append(te_loss) #val_acc.append(vac) test_acc.append(tac) save_path = saver.save( sess, os.path.join(self.results_dir, "model.ckpt")) if out: print("Iter " + str(step * settings.NN['BATCH_SIZE']) + ", Minibatch Loss= " + \ "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)) #print("Validation Accuracy:", vac) print("Testing Accuracy:", tac) print("Model saved in file: %s" % save_path) step += 1 save_path = saver.save(sess, os.path.join(self.results_dir, path)) storage = store(self.results_dir) storage['save.path'] = save_path print("Model saved in file: %s" % save_path) print( "Testing Accuracy:", sess.run(self.accuracy, feed_dict={ x: self.data.test.music, y: self.data.test.labels, keep_prob: 1. })) return train_acc, test_acc, train_cost, test_cost