def minibatches(data, batch_size): x = np.array([d[0] for d in data]) y = np.array([d[2] for d in data]) one_hot = np.zeros((y.size, 3)) one_hot[np.arange(y.size), y] = 1 return get_minibatches([x, one_hot], batch_size)
def run_valid_epoch(self, sess, dataset, valid_writer, merged): print "\nEvaluating on dev set", total_correct = 0 total_loss = [] predicted_ids = [] target_ids = [] for i, (valid_x, valid_y) in enumerate( get_minibatches([dataset.valid_inputs, dataset.valid_targets], self.config.test_batch_size, is_multi_feature_input=True)): batch_feed = self.create_feed_dict(valid_x, labels_batch=valid_y, is_training=False) batch_predictions, batch_loss, batch_accuracy = sess.run( [self.pred, self.loss, self.accuracy], feed_dict=batch_feed) total_correct += (batch_accuracy * len(valid_y)) total_loss.append(batch_loss) predicted_ids.extend(list(np.argmax(batch_predictions, axis=1))) target_ids.extend(list(np.argmax(valid_y, axis=1))) valid_loss = sum(total_loss) / float(len(total_loss)) valid_accuracy = float(total_correct) / len(dataset.valid_targets) valid_f1_score = get_weighted_f1_score(predicted_ids, target_ids) return valid_loss, valid_accuracy, valid_f1_score
def run_epoch(self, sess, inputs, labels, input_masks, label_masks, train_writer, step_i): """Runs an epoch of training. Args: sess: tf.Session() object inputs: np.ndarray of shape (n_samples, n_features) labels: np.ndarray of shape (n_samples, n_classes) input_masks: boolean np.ndarray of shape (max_num_frames,) label_masks: boolean np.ndarray of shape (max_num_frames,) train_writer: a tf.summary.FileWriter object step_i: The global number of steps taken so far (i.e., batches we've done a full forward and backward pass on) Returns: average_loss: scalar. Average minibatch loss of model on epoch. """ n_minibatches, total_loss = 0, 0 for input_batch, labels_batch, input_masks_batch, label_masks_batch in \ get_minibatches([inputs, labels, input_masks, label_masks], self.config.batch_size): n_minibatches += 1 batch_loss, summary, feed = self.train_on_batch( sess, input_batch, input_masks_batch, labels_batch, label_masks_batch) total_loss += batch_loss train_writer.add_summary(summary, step_i) #print "step_i: ", step_i step_i += 1 return total_loss / n_minibatches, step_i, feed
def run_epoch(self, sess, inputs, labels, train_writer, step_i): """Runs an epoch of training. Args: sess: tf.Session() object inputs: A list of length num_examples with float np.ndarray entries of shape (max_num_frames, num_mfcc_coeffs) labels: A list of length num_examples with float np.ndarray entries of shape (max_num_frames, num_mfcc_coeffs) train_writer: a tf.summary.FileWriter object step_i: The global number of steps taken so far (i.e., batches we've done a full forward and backward pass on) Returns: average_loss: scalar. Average minibatch loss of model on epoch. step_i: The global number of steps taken so far (i.e., batches we've done a full forward and backward pass on) """ n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches( [inputs, labels], self.config.batch_size): batch_loss, summary = self.train_on_batch(sess, input_batch, labels_batch) total_loss += batch_loss n_minibatches += 1 train_writer.add_summary(summary, step_i) step_i += 1 return total_loss / n_minibatches, step_i
def predict(self, sess, inputs, ids): labels = [] for inputs_batch in get_minibatches(inputs, self.config.batch_size): raw_preds = self.predict_on_batch(sess, inputs_batch) masks = self.convert_to_mask(raw_preds, 0.0) labels += masks return ids, labels
def run_epoch(self, inputs, labels): """Runs an epoch of training. Args: inputs: np.ndarray of shape (n_samples, n_features) labels: np.ndarray of shape (n_samples, n_classes) Returns: average_loss: scalar. Average minibatch loss of model on epoch. """ config = self.config n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches([inputs, labels], config.batch_size): n_minibatches += 1 dy.renew_cg() '''Compute the loss of a batch''' # loss = [] # for i in xrange(config.batch_size): # input_t, labels_t = input_batch[i].reshape(1, config.n_features), labels_batch[i].reshape(1, config.n_classes) # loss_t = self.train_on_batch(input_t, labels_t) # loss.append(loss_t) # loss = dy.esum(loss) / config.batch_size loss = self.train_on_batch(input_batch, labels_batch) / config.batch_size loss.forward() loss.backward() self.trainer.update() total_loss += loss.value() return total_loss / n_minibatches
def run_epoch(self, sess, train_examples, dev_set): """Runs an epoch of training. train_examples: a list of np.arrays of the form [inputs, labels]. dev_sets: a list of np.arrays of the form [inputs, labels]. """ n_minibatches, total_loss = 0, 0 mask_batch = np.full((self.config.batch_size, self.config.max_length), fill_value=True) for inputs_batch, labels_batch in get_minibatches( train_examples, self.config.batch_size): #train_examples is a list of (sentence, label, mask) tuples. #Each setence/label/mask is itself a list of integers or boolean(in case of mask). assert mask_batch.shape == inputs_batch.shape, "mask_batch size doesn't match with inputs_batch." n_minibatches += 1 total_loss += self.train_on_batch(sess, inputs_batch, labels_batch, mask_batch) ''' preds= self.predict_on_batch(sess, *batches) for pred in preds: print [self.helper.id2tok.get(np.argmax(t)) for t in pred] ''' # batches is a list of input_batch, labels_batch, mask_batch. # That is, batches = [input_batch, labels_batch, mask_batch]. train_loss = total_loss / n_minibatches dev_loss = self.evaluate(sess, dev_set) return train_loss, dev_loss
def evaluate(self, sess, examples): n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches( examples, self.config.batch_size): n_minibatches += 1 total_loss += self.loss_on_batch(sess, input_batch, labels_batch) return total_loss / n_minibatches
def minibatches(data, batch_size, pad_instance, config): data_dict = {"features": []} sent = [] ch = [] ch_len = [] n_gram = [] n_gram_len = [] sent_len = [] seq_len = [] arc_pair_x = [] arc_y = [] pos_y = [] dep_y = [] for d in data: instances = d["instances"][:config.seq_len] ex = d["ex"] word_list = ex["word"][:config.sent_len] pos_list = ex["pos"][:config.sent_len] ch_list = ex["ch"][:config.sent_len] n_gram_list = ex["n_gram"][:config.sent_len] n_words = min(len(ex["word"]), config.sent_len) data_dict["features"].append([i[0] for i in instances]) sent += [word_list + [config.pad_id] * (config.sent_len - n_words)] ch += [[ i[:config.n_char] + [config.pad_id] * (config.n_char - len(i)) for i in ch_list ] + [[config.pad_id] * config.n_char] * (config.sent_len - n_words)] n_gram += [[ i[:config.n_char] + [config.pad_id] * (config.n_char - len(i)) for i in n_gram_list ] + [[config.pad_id] * config.n_char] * (config.sent_len - n_words)] arc_y.append([int(i[2] / config.n_dep_classes) for i in instances]) dep_y.append([int(i[2] % config.n_dep_classes) for i in instances]) pos_y.append([i - config.pos_offset for i in pos_list] + [0] * (config.sent_len - n_words)) seq_len += [n_words * 2] sent_len += [n_words] ch_len += [[min(len(i), config.n_char) for i in ch_list] + [0] * (config.sent_len - n_words)] n_gram_len += [[min(len(i), config.n_char) for i in n_gram_list] + [0] * (config.sent_len - n_words)] data_dict["sent"] = sent data_dict["char"] = ch data_dict["n_gram"] = n_gram data_dict["char_len"] = ch_len data_dict["n_gram_len"] = n_gram_len data_dict["seq_len"] = seq_len data_dict["sent_len"] = sent_len data_dict["arc_y"] = arc_y data_dict["dep_y"] = dep_y data_dict["pos_y"] = pos_y return get_minibatches(data_dict, batch_size, pad_instance, config)
def run_train_epoch(self, sess, train_inputs, train_labels): # Iterate through the train inputs, and train the weights prog = Progbar(target=1 + len(train_labels) / self.config.batch_size) iterator = get_minibatches([train_inputs, train_labels], self.config.batch_size) for i, (train_x, train_y) in enumerate(iterator): loss = self.train_on_batch(sess, train_x, train_y) prog.update(i + 1, [("train loss", loss)])
def run_epoch(self, sess, inputs, labels): """Runs an epoch of training. """ n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches([inputs, labels], self.config.batch_size): #For my own benefit: get_minibatches randomly selects as many as batch_size from the total training samples. This implements SGD. n_minibatches += 1 total_loss += self.train_on_batch(sess, input_batch, labels_batch) return total_loss / n_minibatches
def dev_model(self, sess, inputs, labels, seqs, mask): n_minibatches, total_loss = 0.0, 0.0 for input_batch, labels_batch, seq_batch, mask_batch in get_minibatches( [inputs, labels, seqs, mask], self.config.batch_size): n_minibatches += 1 batchloss = self.loss_on_batch(sess, input_batch, labels_batch, seq_batch, mask_batch) total_loss += batchloss return total_loss / n_minibatches
def run_epoch(self, sess, config, dataset, train_writer, merged):#按批次运行 prog = Progbar(target=1 + len(dataset.train_inputs[0]) / config.batch_size) for i, (train_x, train_y) in enumerate(get_minibatches([dataset.train_inputs, dataset.train_targets], config.batch_size, is_multi_feature_input=True)): # print "input, outout: {}, {}".format(np.array(train_x).shape, np.array(train_y).shape) summary, loss = self.train_on_batch(sess, train_x, train_y, merged)#训练主函数 prog.update(i + 1, [("train loss", loss)]) # train_writer.add_summary(summary, global_step=i) return summary, loss # Last batch
def test_model(self, sess, inputs, labels, seqs, mask): n_minibatches, total_loss, total_correct = 0.0, 0.0, 0.0 pred = None lbls = None for input_batch, labels_batch, seq_batch, mask_batch in get_minibatches( [inputs, labels, seqs, mask], self.config.batch_size): n_minibatches += 1 lbls, pred, batchloss, batchcorrect = self.test_on_batch( sess, input_batch, labels_batch, seq_batch, mask_batch) total_loss += batchloss total_correct += batchcorrect return lbls, pred, total_loss / n_minibatches, total_correct / n_minibatches
def evaluate_answer(self, session, dataset, sample=100, log=False): """ Evaluate the model's performance using the harmonic mean of F1 and Exact Match (EM) with the set of true answer labels This step actually takes quite some time. So we can only sample 100 examples from either training or testing set. :param session: session should always be centrally managed in train.py :param dataset: a representation of our data, in some implementations, you can pass in multiple components (arguments) of one dataset to this function here the signature is [vq,vc,va] :param sample: how many examples in dataset we look at :param log: whether we print to std out stream :return: """ for dataset_minix in get_minibatches(dataset, sample): dataset_feed = self.prepare_feed_input(dataset_minix) ind_out = self.answer_indices(session, dataset_feed) #batch, 2 answers = dataset_minix[2] gold = np.array(answers) #batch, 2 preds = np.array(ind_out).T #batch, 2 gold_lengths = gold[:, 1] - gold[:, 0] + 1 #batch preds_lengths = preds[:, 1] - preds[:, 0] + 1 #batch correct_mask = preds[:, 1] >= preds[:, 0] #batch correct_end_indices = np.where(gold[:, 1] < preds[:, 1], gold[:, 1], preds[:, 1]) correct_start_indices = np.where(gold[:, 0] > preds[:, 0], gold[:, 0], preds[:, 0]) correct_lengths = np.clip( correct_end_indices - correct_start_indices + 1, 0, None) correct_lengths = correct_mask * correct_lengths preds_lengths = preds_lengths * correct_mask gl = np.sum(gold_lengths) pl = np.sum(preds_lengths) exact_preds = np.logical_and((correct_lengths == gold_lengths), (correct_lengths == preds_lengths)) cl = np.sum(correct_lengths) p = 0. if pl != 0: p = cl / pl r = cl / gl f1 = 0. if (p + r) != 0.: f1 = 2 * p * r / (p + r) em = np.sum(exact_preds) if log: logging.info("F1: {}, EM: {}, for {} samples".format( f1, em, sample)) break return f1, em
def run_dev_epoch(self, sess, dev_inputs, dev_labels): # Iterate through the dev inputs and print the accuracy prf = [] print "Evaluating on dev set" prog = Progbar(target=1 + len(dev_labels) / self.config.batch_size) iterator = get_minibatches([dev_inputs, dev_labels], self.config.batch_size) for i, (train_x, train_y) in enumerate(iterator): prf.append(self.evaluate_on_batch(sess, train_x, train_y)) prog.update(i + 1) prf = np.mean(np.array(prf), axis=0) print "Precision={:.2f}, Recall={:.2f}, F1={:.2f}".format( prf[0], prf[1], prf[2]) return prf[2]
def run_epoch(self, sess, inputs, labels): """Runs an epoch of training. Args: sess: tf.Session() object inputs: np.ndarray of shape (n_samples, n_features) labels: np.ndarray of shape (n_samples, n_classes) Returns: average_loss: scalar. Average minibatch loss of model on epoch. """ n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches([inputs, labels], self.config.batch_size): n_minibatches += 1 total_loss += self.train_on_batch(sess, input_batch, labels_batch) return total_loss / n_minibatches
def run_test_epoch(self, sess, dataset): print "\nEvaluating on Test set", total_correct = 0 total_loss = [] predicted_ids = [] target_ids = [] incorrect_predictions_path = os.path.join( DataConfig.data_dir_path, DataConfig.model_dir, DataConfig.test_incorrect_predictions_file) predictions_path = os.path.join(DataConfig.data_dir_path, DataConfig.model_dir, DataConfig.test_predictions_file) if os.path.exists(predictions_path): os.remove(predictions_path) if os.path.exists(incorrect_predictions_path): os.remove(incorrect_predictions_path) offset = 0 for i, (test_x, test_y) in enumerate( get_minibatches([dataset.test_inputs, dataset.test_targets], self.config.test_batch_size, shuffle=False, is_multi_feature_input=True)): batch_feed = self.create_feed_dict(test_x, labels_batch=test_y, is_training=False) batch_predictions, batch_loss, batch_accuracy = sess.run( [self.pred, self.loss, self.accuracy], feed_dict=batch_feed) total_correct += (batch_accuracy * len(test_y)) total_loss.append(batch_loss) predicted_ids.extend(list(np.argmax(batch_predictions, axis=1))) target_ids.extend(list(np.argmax(test_y, axis=1))) self.dump_incorrect_predictions(batch_predictions, test_y, offset, incorrect_predictions_path, predictions_path) offset += len(test_y) test_loss = sum(total_loss) / float(len(total_loss)) test_accuracy = float(total_correct) / len(dataset.test_targets) test_f1_score = get_weighted_f1_score(predicted_ids, target_ids) return test_loss, test_accuracy, test_f1_score
def run_epoch(self, inputs, labels): config = self.config n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches([inputs, labels], config.batch_size): n_minibatches += 1 dy.renew_cg() loss = self.train_on_batch(input_batch, labels_batch) / config.batch_size loss.forward() loss.backward() self.trainer.update() total_loss += loss.value() return total_loss / n_minibatches
def run_epoch(self, sess, examples): """Runs an epoch of training. Args: sess: tf.Session() object inputs: np.ndarray of shape (n_samples, n_features) labels: np.ndarray of shape (n_samples, n_classes) Returns: average_loss: scalar. Average minibatch loss of model on epoch. """ n_minibatches, total_loss = 0, 0 for input_batch, labels_batch in get_minibatches( examples, self.config.batch_size ): #For my own benefit: get_minibatches randomly selects as many as batch_size of the total training samples. This implements SGD. n_minibatches += 1 total_loss += self.train_on_batch(sess, input_batch, labels_batch) return total_loss / n_minibatches
def run_epoch(self, dataset, sess): '''dataset is a list [q,c,a, c_sent_masks]''' n_minibatches = 0. total_loss = 0. for dataset_mini in get_minibatches(dataset, self.minibatch_size): n_minibatches += 1 dataset_feed = self.prepare_feed_input(dataset_mini) feed_dict = self.feed_dict(dataset_feed) output = [self.optimizer_op, self.loss, self.global_norm] _, loss, global_norm = sess.run(output, feed_dict) if not n_minibatches % 100: print("n_minibatch = {}".format(n_minibatches), "loss: {}".format(loss), "global_norm{}".format(global_norm)) total_loss += loss return total_loss / n_minibatches
def run_epoch(self, dataset, sess): '''dataset is a list [q,c,a]''' n_minibatches = 0. total_loss = 0. for dataset_mini in get_minibatches(dataset, self.minibatch_size): dat_pad, dat_pad_masks = self.pad(dataset_mini) dat_pad_masks = dat_pad_masks[:-1] n_minibatches += 1 dataset_i = [dat_pad, dat_pad_masks] feed_dict = self.feed_dict(dataset_i) output = [self.optimizer_op , self.loss, self.global_norm] _, loss, global_norm = sess.run(output, feed_dict) if not n_minibatches % 100: print("n_minibatch = {}".format(n_minibatches), "loss: {}".format(loss), "global_norm{}".format(global_norm)) total_loss += loss return total_loss/n_minibatches
def evaluate_answer(self, session, dataset, sample=100, log=False): """ Evaluate the model's performance using the harmonic mean of F1 and Exact Match (EM) with the set of true answer labels This step actually takes quite some time. So we can only sample 100 examples from either training or testing set. :param session: session should always be centrally managed in train.py :param dataset: a representation of our data, in some implementations, you can pass in multiple components (arguments) of one dataset to this function here the signature is [vq,vc,va] :param sample: how many examples in dataset we look at :param log: whether we print to std out stream :return: """ for dataset_s in get_minibatches(dataset, sample): data_pad, data_pad_masks = self.pad(dataset_s) q, c, a = data_pad q_masks, c_masks = data_pad_masks[:2] dataset_a = [[q, c, a], [q_masks, c_masks]] ind_out, answers = np.array(self.answer_indices(session, dataset_a)) #batch, max_length gold = np.array(answers) #batch, max_lengt pp = np.sum(ind_out) gp = np.sum(gold) correct_predictions = np.logical_and(ind_out, gold) exact_preds = ind_out == gold cp = np.sum(correct_predictions) p = 0. if pp != 0.: p = cp/pp r = cp/gp f1 = 0. if (p + r) != 0.: f1 = 2*p*r/(p+r) em = np.sum(np.all(exact_preds, axis = 1))/sample if log: logging.info("F1: {}, EM: {}, for {} samples".format(f1, em, sample)) break return f1, em
def run_epoch(self, sess, inputs, labels): """Runs an epoch of training. Args: sess: tf.Session() object inputs: np.ndarray of shape (n_samples, n_features) labels: np.ndarray of shape (n_samples, n_classes) Returns: average_loss: scalar. Average minibatch loss of model on epoch. """ n_minibatches, total_loss = 0, 0 inputs_shape = inputs.shape prog = Progbar(target=1 + inputs_shape[0] / self.config.batch_size) for input_batch, labels_batch in get_minibatches( [inputs, labels], self.config.batch_size): n_minibatches += 1 loss = self.train_on_batch(sess, input_batch, labels_batch) total_loss += loss prog.update(n_minibatches, [("train loss", loss)]) return total_loss / n_minibatches
def evaluate(self, sess, inputs, labels, metric=None): from utils.data_utils import Precision from utils.data_utils import get_iou_vector IoUs = [] IoUs2 = [] Precisions = [] for input_batch, labels_batch in get_minibatches( [inputs, labels], self.config.batch_size): loss = self.train_on_batch(sess, input_batch, labels_batch) raw_preds = self.predict_on_batch(sess, input_batch) #IoUbatch = get_iou_vector(labels_batch.astype(int), (raw_preds>0.5).astype(int)) #IoUs = IoUs + IoUbatch pBatch, IoUbatch = Precision((raw_preds > 0.5).astype(int), labels_batch) Precisions = Precisions + pBatch.tolist() IoUs = IoUs + IoUbatch.tolist() IoUs2 = IoUs2 + get_iou_vector(labels_batch, (raw_preds > 0.5).astype(int)) return np.mean(IoUs), np.mean(np.asarray(IoUs2)), np.mean( np.mean(Precisions))
def run_epoch(self, sess, config, dataset, train_writer, merged): prog = Progbar(target=1 + len(dataset.train_inputs[0]) / config.batch_size) for i, (train_x, train_y) in enumerate( get_minibatches([dataset.train_inputs, dataset.train_targets], config.batch_size, is_multi_feature_input=True)): print "word input, char input, outout: {}, {}, {}".format( np.array(train_x[0]).shape, np.array(train_x[1]).shape, np.array(train_y).shape) summary, loss = self.train_on_batch(sess, train_x, train_y, merged) prog.update(i + 1, [("train loss", loss)]) # feed = self.create_feed_dict(dataset.train_inputs, labels_batch=dataset.train_targets, # keep_prob_word=self.config.keep_prob, keep_prob_fc=self.config.keep_prob_fc, # is_training=False) # train_accuracy = sess.run(self.accuracy, feed_dict=feed) # print "- train Accuracy: {:.2f}".format(train_accuracy * 100.0) return summary, loss # returns for Last batch
def run_epoch(self, sess, inputs, input_masks, labels, label_masks, train_writer, step_i, should_output_wavefiles): """Runs an epoch of training. Args: sess: tf.Session() object inputs: A list of length num_examples with float np.ndarray entries of shape (max_num_frames, num_mfcc_coeffs) input_masks: A list of length num_examples with boolean np.darray entries of shape (max_num_frames,) labels: A list of length num_examples with float np.ndarray entries of shape (max_num_frames, num_mfcc_coeffs) label_masks: A list of length num_examples with boolean np.darray entries of shape (max_num_frames,) train_writer: a tf.summary.FileWriter object step_i: The global number of steps taken so far (i.e., batches we've done a full forward and backward pass on) Returns: average_loss: scalar. Average minibatch loss of model on epoch. step_i: The global number of steps taken so far (i.e., batches we've done a full forward and backward pass on) """ n_minibatches, total_loss = 0, 0 for input_batch, input_masks_batch, labels_batch, label_masks_batch in \ get_minibatches([inputs, input_masks, labels, label_masks], self.config.batch_size): # We only evaluate and output wavefiles on the first batch of the epoch should_output_wavefiles_batch = False if n_minibatches == 0: should_output_wavefiles_batch = True batch_loss, summary = self.train_on_batch( sess, input_batch, input_masks_batch, labels_batch, label_masks_batch, should_output_wavefiles and should_output_wavefiles_batch) total_loss += batch_loss n_minibatches += 1 train_writer.add_summary(summary, step_i) step_i += 1 return total_loss / n_minibatches, step_i
def predict(self, sess, inputs, ids): labels = {} for ix, inputs_batch in enumerate( get_minibatches(inputs, self.config.batch_size, shuffle=False)): raw_preds = self.predict_on_batch(sess, inputs_batch) masks = self.convert_to_mask(raw_preds, 0.5) from utils.data_utils import rle_encode from PIL import Image import sys import numpy as np for kx, mask in enumerate(masks): #im = Image.fromarray(np.uint8(mask*255)) #im.save("/results/preds/"+str(ids[ix+kx])+".png", "PNG") labels[ids[ix * self.config.batch_size + kx]] = rle_encode(mask) import pandas as pd df = pd.DataFrame.from_dict(labels, orient="index") df.index.names = ['id'] df.columns = ['rle_mask'] df.to_csv("../submission/results.csv") return ids, labels
with tf.Session() as sess: init = tf.global_variables_initializer() sess.run(init) #new_saver = tf.train.Saver() #new_saver.restore(sess, './models/regularized_RNN_100d-1-29') saver = tf.train.Saver() for epoch in range(n_epochs): print("Epoch: ", epoch) #n_minibatches = 1 + len(train_embeddings) / batch_size #prog = tf.keras.utils.Progbar(target=n_minibatches) for i, (s1, s2, l, m1, m2) in enumerate( get_minibatches([[ex[0] for ex in train_input], [ex[1] for ex in train_input], [ex[2] for ex in train_input], [ex[3] for ex in train_input], [ex[4] for ex in train_input]], batch_size)): feed_dict = { input_placeholder_s1: s1, input_placeholder_s2: s2, mask_placeholder_s1: m1, mask_placeholder_s2: m2, labels_placeholder: l, dropout_placeholder: dropout } sess.run(train_op, feed_dict=feed_dict) _, batch_loss = sess.run([train_op, loss], feed_dict=feed_dict) #print "Gradient: ", global_norm.eval() #_, batch_loss = sess.run([train_op(loss), loss], feed_dict=feed_dict) #print pred, labels_placeholder, loss, losses
def main(): print "Starting matlab ... type in your password if prompted" eng = matlab.engine.start_matlab() eng.addpath('../invMFCCs_new') print "Done starting matlab" batch_size = 32 n_epochs = 50 lr = 1e-3 max_num_frames = 706 num_mfcc_coeffs = 25 sample_rate = 16000.0 num_features = max_num_frames * num_mfcc_coeffs state_size_1 = 25 state_size_2 = 50 state_size_3 = 50 state_size_4 = 25 inputs, labels = preprocess_data(num_mfcc_coeffs, max_num_frames) logs_path = "tensorboard/" + strftime("%Y_%m_%d_%H_%M_%S", gmtime()) input_placeholder = tf.placeholder(tf.float32, (None, max_num_frames, num_mfcc_coeffs)) labels_placeholder = tf.placeholder( tf.float32, (None, max_num_frames, num_mfcc_coeffs)) xavier = tf.contrib.layers.xavier_initializer() W1 = tf.get_variable("W1", shape=(num_features, state_size_1), initializer=xavier) b1 = tf.get_variable("b1", shape=(1, state_size_1)) W2 = tf.get_variable("W2", shape=(state_size_1, state_size_2), initializer=xavier) b2 = tf.get_variable("b2", shape=(1, state_size_2)) W3 = tf.get_variable("W3", shape=(state_size_2, state_size_3), initializer=xavier) b3 = tf.get_variable("b3", shape=(1, state_size_3)) W4 = tf.get_variable("W4", shape=(state_size_3, state_size_4), initializer=xavier) b4 = tf.get_variable("b4", shape=(1, state_size_4)) W5 = tf.get_variable("W5", shape=(state_size_4, num_features), initializer=xavier) b5 = tf.get_variable("b5", shape=(1, num_features)) # forward propagation mfcc_preds = forward_prop(W1, W2, W3, W4, W5, b1, b2, b3, b4, b5, input_placeholder, max_num_frames, num_mfcc_coeffs) # backward propagation loss = tf.reduce_mean(tf.squared_difference(mfcc_preds, labels_placeholder)) updates = tf.train.GradientDescentOptimizer(lr).minimize(loss) # run SGD sess = tf.Session() init = tf.global_variables_initializer() sess.run(init) train_writer = tf.summary.FileWriter(logs_path + '/train', sess.graph) for epoch in range(n_epochs): start_time = time() # train with each batch n_minibatches = 0 for input_batch, labels_batch in get_minibatches([inputs, labels], batch_size): n_minibatches += 1 feed = { input_placeholder: input_batch, labels_placeholder: labels_batch } sess.run(updates, feed_dict=feed) #train_writer.add_summary(summary, epoch_count) duration = time() - start_time print 'Epoch ' + str(epoch) + ' : loss = ' + str( loss.eval(session=sess, feed_dict=feed)) + ' (' + str(duration) + ' sec)' predicted_mfccs_batch = mfcc_preds.eval(session=sess, feed_dict=feed) for i in range(predicted_mfccs_batch.shape[0]): predicted_mfccs_transposed = np.transpose( predicted_mfccs_batch[i, :, :]) # MFCC features need to be a numpy array of shape (num_coefficients x num_frames) in order to be passed to the invmelfcc function inverted_wav_data = eng.invmelfcc( matlab.double(predicted_mfccs_transposed.tolist()), sample_rate, num_mfcc_coeffs) # eng.soundsc(inverted_wav_data, sample_rate, nargout=0) inverted_wav_data = np.squeeze(np.array(inverted_wav_data)) # Scales the waveform to be between -1 and 1 maxVec = np.max(inverted_wav_data) minVec = np.min(inverted_wav_data) inverted_wav_data = ((inverted_wav_data - minVec) / (maxVec - minVec) - 0.5) * 2 wav.write('learned_wav' + str(i) + '.wav', sample_rate, inverted_wav_data) sess.close()