def perform_SER(self, input, target, device): LOAD_PATH = '/home/zhoukun/SER/Speech-Emotion-Recognition-main/checkpoint/best_model_esd.pth' model_SER = acrnn().to('cpu') model_SER.load_state_dict(torch.load(LOAD_PATH, map_location='cpu')) criterion = torch.nn.CrossEntropyLoss() best_valid_uw = 0 model_SER.eval() size = input.shape[0] with torch.no_grad(): inputs = torch.tensor(input).to('cpu') targets = torch.tensor(target, dtype=torch.long).to('cpu') outputs, emotion_embedding_low, emotion_embedding_high = model_SER( inputs) loss = criterion(outputs, targets).cpu().detach().numpy() cost_valid = np.sum(loss) / size valid_acc_uw = recall(target.cpu().detach().numpy(), np.argmax(outputs.cpu().detach().numpy(), 1), average='macro') valid_conf = confusion(target.cpu().detach().numpy(), np.argmax(outputs.cpu().detach().numpy(), 1)) if valid_acc_uw > best_valid_uw: best_valid_uw = valid_acc_uw best_valid_conf = valid_conf cost_valid = torch.tensor(cost_valid).to(device) emotion_embedding_high = torch.tensor(emotion_embedding_high).to( device) best_valid_uw = torch.tensor(best_valid_uw).to(device) return cost_valid, emotion_embedding_high, best_valid_uw
def main(): company_code = 'BBAS3.SA' # company_code = 'PETR4.SA' historical_data = ml_loader.get_historical_data_for_ml(company_code) # print(historical_data['label'].value_counts()) # sns.countplot(x='label', data=historical_data, palette='hls') # plt.show() # historical_data.groupby('label').mean() y = historical_data['label'] X = historical_data.drop(columns=['label', 'Next_Day_Close', 'Date', 'Datee', 'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume']) # X = historical_data.drop(columns=['label', 'Next_Day_Close', 'Date', 'Datee', 'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume']) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0) logreg = LogisticRegression() logreg.fit(X_train, y_train) y_pred = logreg.predict(X_test) print('Accuracy of logistic regression classifier on train set: {:.2f}'.format(logreg.score(X_train, y_train))) print('Accuracy of logistic regression classifier on test set: {:.2f}'.format(logreg.score(X_test, y_test))) confusion_matrix = confusion(y_test, y_pred) print(confusion_matrix) print('finished')
def cfmat(x, s): #Function to display Confusion Matrix columns = [ 'class %s' % (i) for i in list(ascii_uppercase)[0:len(np.unique(testTargets))] ] confm = confusion(testTargets, x) df_cm = DataFrame(confm, index=columns, columns=columns) ax = sns.heatmap(df_cm, cmap='Oranges', annot=True) ax.set_title('Confusion Matrix of %s' % (s), size=14) plt.show()
def evaluate(): with tf.Graph().as_default() as g: model = crnn.CRNN('test') model._build_model() #load training data test_data, test_label, valid_data, valid_label, Valid_label, Test_label, pernums_test, pernums_valid = load_data( ) # test, valid segment size test_size = test_data.shape[0] valid_size = valid_data.shape[0] # for hole sentence label test_label = dense_to_one_hot(test_label, 4) valid_label = dense_to_one_hot(valid_label, 4) # for segement label Test_label = dense_to_one_hot(Test_label, 4) Valid_label = dense_to_one_hot(Valid_label, 4) # for sgement type : 1 :for hole sentence, 2: for sgement sentecne tnum = pernums_test.shape[0] vnum = pernums_valid.shape[0] pred_test_uw = np.empty((tnum, 4), dtype=np.float32) pred_test_w = np.empty((tnum, 4), dtype=np.float32) valid_iter = divmod((valid_size), FLAGS.valid_batch_size)[0] test_iter = divmod((test_size), FLAGS.test_batch_size)[0] y_pred_valid = np.empty((valid_size, 4), dtype=np.float32) y_pred_test = np.empty((test_size, 4), dtype=np.float32) y_test = np.empty((tnum, 4), dtype=np.float32) y_valid = np.empty((vnum, 4), dtype=np.float32) cross_entropy = tf.nn.softmax_cross_entropy_with_logits( labels=model.labels, logits=model.logits) variable_averages = tf.train.ExponentialMovingAverage(FLAGS.momentum) variable_to_restore = variable_averages.variables_to_restore() saver = tf.train.Saver(variable_to_restore) #saver = tf.train.Saver() flag = False best_valid_uw = 0 best_valid_w = 0 for i in range(5): with tf.Session() as sess: ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) global_step = ckpt.model_checkpoint_path.split( '/')[-1].split('-')[-1] #for validation data index = 0 cost_valid = 0 if (valid_size < FLAGS.valid_batch_size): validate_feed = { model.inputs: valid_data, model.labels: Valid_label } y_pred_valid, loss = sess.run( [model.softmax, cross_entropy], feed_dict=validate_feed) cost_valid = cost_valid + np.sum(loss) else: for v in range(valid_iter): v_begin = v * FLAGS.valid_batch_size v_end = (v + 1) * FLAGS.valid_batch_size if (v == valid_iter - 1): if (v_end < valid_size): v_end = valid_size validate_feed = { model.inputs: valid_data[v_begin:v_end], model.labels: Valid_label[v_begin:v_end] } loss, y_pred_valid[v_begin:v_end, :] = sess.run( [cross_entropy, model.softmax], feed_dict=validate_feed) cost_valid = cost_valid + np.sum(loss) cost_valid = cost_valid / valid_size print(y_pred_valid) valid_acc_uw = recall(np.argmax(Valid_label, 1), np.argmax(y_pred_valid, 1), average='macro') valid_acc_w = recall(np.argmax(Valid_label, 1), np.argmax(y_pred_valid, 1), average='weighted') valid_conf = confusion(np.argmax(Valid_label, 1), np.argmax(y_pred_valid, 1)) print('----------segment metrics---------------') print("Best valid_UA: %3.4g" % best_valid_uw) print("Best valid_WA: %3.4g" % best_valid_w) print('Valid Confusion Matrix:["ang","sad","hap","neu"]') print(valid_conf) print('----------segment metrics---------------') for s in range(vnum): y_valid[s, :] = np.max( y_pred_valid[index:index + pernums_valid[s], :], 0) index += pernums_valid[s] valid_acc_uw = recall(np.argmax(valid_label, 1), np.argmax(y_valid, 1), average='macro') valid_acc_w = recall(np.argmax(valid_label, 1), np.argmax(y_valid, 1), average='weighted') valid_conf = confusion(np.argmax(valid_label, 1), np.argmax(y_valid, 1)) #for test set index = 0 for t in range(test_iter): t_begin = t * FLAGS.test_batch_size t_end = (t + 1) * FLAGS.test_batch_size if (t == test_iter - 1): if (t_end < test_size): t_end = test_size #print t_begin,t_end,t,test_iter test_feed = { model.inputs: test_data[t_begin:t_end], model.labels: Test_label[t_begin:t_end] } y_pred_test[t_begin:t_end, :] = sess.run( model.logits, feed_dict=test_feed) for s in range(tnum): y_test[s, :] = np.max( y_pred_test[index:index + pernums_test[s], :], 0) index = index + pernums_test[s] if valid_acc_uw > best_valid_uw: best_valid_uw = valid_acc_uw pred_test_uw = y_test test_acc_uw = recall(np.argmax(test_label, 1), np.argmax(y_test, 1), average='macro') test_conf = confusion(np.argmax(test_label, 1), np.argmax(y_test, 1)) confusion_uw = test_conf flag = True if valid_acc_w > best_valid_w: best_valid_w = valid_acc_w pred_test_w = y_test test_acc_w = recall(np.argmax(test_label, 1), np.argmax(y_test, 1), average='weighted') test_conf = confusion(np.argmax(test_label, 1), np.argmax(y_test, 1)) confusion_w = test_conf flag = True print( "*****************************************************************" ) print(global_step) print("Epoch: %s" % global_step) print("Valid cost: %2.3g" % cost_valid) print("Valid_UA: %3.4g" % valid_acc_uw) print("Valid_WA: %3.4g" % valid_acc_w) print("Best valid_UA: %3.4g" % best_valid_uw) print("Best valid_WA: %3.4g" % best_valid_w) print('Valid Confusion Matrix:["ang","sad","hap","neu"]') print(valid_conf) print("Test_UA: %3.4g" % test_acc_uw) print("Test_WA: %3.4g" % test_acc_w) print('Test Confusion Matrix:["ang","sad","hap","neu"]') print(confusion_uw) print( "*****************************************************************" ) if (flag): f = open(FLAGS.pred_name, 'wb') pickle.dump(( best_valid_uw, best_valid_w, pred_test_w, test_acc_w, confusion_w, pred_test_uw, test_acc_uw, confusion_uw, ), f) f.close() flag = False
def train(): #####load data########## train_data,train_label,test_data,test_label,valid_data,valid_label,Valid_label,Test_label,pernums_test,pernums_valid = load_data(FLAGS.traindata_path) train_label = dense_to_one_hot(train_label,FLAGS.num_classes) valid_label = dense_to_one_hot(valid_label,FLAGS.num_classes) Valid_label = dense_to_one_hot(Valid_label,FLAGS.num_classes) valid_size = valid_data.shape[0] dataset_size = train_data.shape[0] vnum = pernums_valid.shape[0] best_valid_uw = 0 ##########tarin model########### X = tf.placeholder(tf.float32, shape=[None, FLAGS.image_height,FLAGS.image_width,FLAGS.image_channel]) Y = tf.placeholder(tf.int32, shape=[None, FLAGS.num_classes]) is_training = tf.placeholder(tf.bool) lr = tf.placeholder(tf.float32) keep_prob = tf.placeholder(tf.float32) Ylogits = acrnn(X, is_training=is_training, dropout_keep_prob=keep_prob) tf.summary.histogram("predict y ", Ylogits) cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels = Y, logits = Ylogits) cost = tf.reduce_mean(cross_entropy) tf.summary.scalar("loss_function", cost) var_trainable_op = tf.trainable_variables() if FLAGS.is_adam: # not apply gradient clipping train_op = tf.train.AdamOptimizer(lr).minimize(cost) else: # apply gradient clipping grads, _ = tf.clip_by_global_norm(tf.gradients(cost, var_trainable_op), 5) opti = tf.train.AdamOptimizer(lr) train_op = opti.apply_gradients(zip(grads, var_trainable_op)) correct_pred = tf.equal(tf.argmax(Ylogits, 1), tf.argmax(Y,1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) saver=tf.train.Saver(tf.global_variables()) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) merged_summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.logdir, sess.graph) if FLAGS.restore: # Restore saved model if the user requested it, default = True try: checkpoint_state = tf.train.get_checkpoint_state(FLAGS.checkpoint) if (checkpoint_state and checkpoint_state.model_name): # log('Loading checkpoint {}'.format(checkpoint_state.model), slack=True) print('Loading checkpoint %s',checkpoint_state.model) saver.restore(sess, checkpoint_state.model_name) else: print('No model to load at %s',FLAGS.checkpoint) #log('No model to load at {}'.format(FLAGS.checkpoint), slack=True) #saver.save(sess, FLAGS.model_name) except tf.errors.OutOfRangeError as e: print('Cannot restore checkpoint:%s',e) #log('Cannot restore checkpoint: {}'.format(e), slack=True) else: print('Starting new training!') #log('Starting new training!', slack=True) saver.save(sess, FLAGS.model_name) for i in range(FLAGS.num_epoch): #learning_rate = FLAGS.learning_rate start = (i * FLAGS.batch_size) % dataset_size end = min(start+FLAGS.batch_size, dataset_size) [_,tcost,tracc] = sess.run([train_op,cost,accuracy], feed_dict={X:train_data[start:end,:,:,:], Y:train_label[start:end,:], is_training:True, keep_prob:FLAGS.dropout_keep_prob, lr:FLAGS.learning_rate}) tf.summary.scalar("train_loss", tcost) tf.summary.scalar("train_acc", tracc) if i % 5 == 0: #for valid data valid_iter = divmod((valid_size),FLAGS.batch_size)[0] y_pred_valid = np.empty((valid_size,FLAGS.num_classes),dtype=np.float32) y_valid = np.empty((vnum,4),dtype=np.float32) index = 0 cost_valid = 0 if(valid_size < FLAGS.batch_size): loss, y_pred_valid = sess.run([cross_entropy,Ylogits],feed_dict = {X:valid_data, Y:Valid_label,is_training:False, keep_prob:1}) cost_valid = cost_valid + np.sum(loss) for v in range(valid_iter): v_begin = v*FLAGS.batch_size v_end = (v+1)*FLAGS.batch_size if(v == valid_iter-1): if(v_end < valid_size): v_end = valid_size loss, y_pred_valid[v_begin:v_end,:] = sess.run([cross_entropy,Ylogits],feed_dict = {X:valid_data[v_begin:v_end],Y:Valid_label[v_begin:v_end],is_training:False, keep_prob:1}) cost_valid = cost_valid + np.sum(loss) cost_valid = cost_valid/valid_size tf.summary.scalar("valid cost", cost_valid) for s in range(vnum): y_valid[s,:] = np.max(y_pred_valid[index:index+pernums_valid[s],:],0) index = index + pernums_valid[s] valid_acc_uw = recall(np.argmax(valid_label,1),np.argmax(y_valid,1),average='macro') tf.summary.scalar("valid acc", valid_acc_uw) valid_conf = confusion(np.argmax(valid_label, 1),np.argmax(y_valid,1)) if valid_acc_uw > best_valid_uw: best_valid_uw = valid_acc_uw best_valid_conf = valid_conf saver.save(sess, os.path.join(FLAGS.checkpoint, FLAGS.model_name), global_step = i+1) print ("*****************************************************************") print ("Epoch: %05d" %(i+1)) print ("Training cost: %2.3g" %tcost) print ("Training accuracy: %3.4g" %tracc) print ("Valid cost: %2.3g" %cost_valid) print ("Valid_UA: %3.4g" %valid_acc_uw) print ("Best valid_UA: %3.4g" %best_valid_uw) print ('Valid Confusion Matrix:["ang","sad","hap","neu"]') print (valid_conf) print ('Best Valid Confusion Matrix:["ang","sad","hap","neu"]') print (best_valid_conf) print ("*****************************************************************" ) summary_str=sess.run(merged_summary_op, feed_dict = {X:train_data[start:end,:,:,:], Y:train_label[start:end,:], is_training:True, keep_prob:FLAGS.dropout_keep_prob, lr:FLAGS.learning_rate}) summary_writer.add_summary(summary_str, i)
order = dict() with open(path, 'r') as f: for line in f: filepath, cnt = line.split() if config.pos_class in filepath: label = 1 else: label = 0 order[filepath] = (int(cnt), label) pprint.pprint(order) y_true = [v[1] for k, v in order.items()] y_pred = [v[0] for k, v in order.items()] # pos_cnt > 0 then predict True y_pred = np.int_(np.array(y_pred) > 0) conf = confusion(y_true=y_true, y_pred=y_pred, labels=[0, 1]) tn, fp, fn, tp = conf.ravel() print('tp', tp, 'tn', tn, 'fp', fp, 'fn', fn) valid_recall = tp / (tp + fn) valid_prec = tp / (tp + fp) f1 = post_lib.f1_score(tn, fp, fn, tp) print("recall: {}".format(valid_recall)) print("precision: {}".format(valid_prec)) print("f1: {}".format(f1)) print('Confusion Matrix: {}'.format(config.class_vocab)) print(conf)
def train(): #####load data########## train_data, train_label, test_data, test_label, valid_data, valid_label, Valid_label, Test_label, pernums_test, pernums_valid = load_data( FLAGS.traindata_path) train_label = dense_to_one_hot(train_label, FLAGS.num_classes) valid_label = dense_to_one_hot(valid_label, FLAGS.num_classes) Valid_label = dense_to_one_hot(Valid_label, FLAGS.num_classes) valid_size = valid_data.shape[0] dataset_size = train_data.shape[0] vnum = pernums_valid.shape[0] best_valid_uw = 0 ##########tarin model########### X = tf.placeholder(tf.float32, shape=[ None, FLAGS.image_height, FLAGS.image_width, FLAGS.image_channel ]) Y = tf.placeholder(tf.int32, shape=[None, FLAGS.num_classes]) is_training = tf.placeholder(tf.bool) lr = tf.placeholder(tf.float32) keep_prob = tf.placeholder(tf.float32) Ylogits = acrnn(X, is_training=is_training, dropout_keep_prob=keep_prob) cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=Ylogits) cost = tf.reduce_mean(cross_entropy) var_trainable_op = tf.trainable_variables() if FLAGS.is_adam: # not apply gradient clipping train_op = tf.train.AdamOptimizer(lr).minimize(cost) else: # apply gradient clipping grads, _ = tf.clip_by_global_norm(tf.gradients(cost, var_trainable_op), 5) opti = tf.train.AdamOptimizer(lr) train_op = opti.apply_gradients(zip(grads, var_trainable_op)) correct_pred = tf.equal(tf.argmax(Ylogits, 1), tf.argmax(Y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) saver = tf.train.Saver(tf.global_variables()) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for i in range(FLAGS.num_epoch): #learning_rate = FLAGS.learning_rate start = (i * FLAGS.batch_size) % dataset_size end = min(start + FLAGS.batch_size, dataset_size) [_, tcost, tracc] = sess.run( [train_op, cost, accuracy], feed_dict={ X: train_data[start:end, :, :, :], Y: train_label[start:end, :], is_training: True, keep_prob: FLAGS.dropout_keep_prob, lr: FLAGS.learning_rate }) if i % 5 == 0: # for valid data valid_iter = divmod((valid_size), FLAGS.batch_size)[0] y_pred_valid = np.empty((valid_size, FLAGS.num_classes), dtype=np.float32) y_valid = np.empty((vnum, 4), dtype=np.float32) index = 0 cost_valid = 0 if (valid_size < FLAGS.batch_size): loss, y_pred_valid = sess.run( [cross_entropy, Ylogits], feed_dict={ X: valid_data, Y: Valid_label, is_training: False, keep_prob: 1 }) cost_valid = cost_valid + np.sum(loss) for v in range(valid_iter): v_begin = v * FLAGS.batch_size v_end = (v + 1) * FLAGS.batch_size if (v == valid_iter - 1): if (v_end < valid_size): v_end = valid_size loss, y_pred_valid[v_begin:v_end, :] = sess.run( [cross_entropy, Ylogits], feed_dict={ X: valid_data[v_begin:v_end], Y: Valid_label[v_begin:v_end], is_training: False, keep_prob: 1 }) cost_valid = cost_valid + np.sum(loss) cost_valid = cost_valid / valid_size for s in range(vnum): y_valid[s, :] = np.max( y_pred_valid[index:index + pernums_valid[s], :], 0) index = index + pernums_valid[s] valid_acc_uw = recall(np.argmax(valid_label, 1), np.argmax(y_valid, 1), average='macro') valid_conf = confusion(np.argmax(valid_label, 1), np.argmax(y_valid, 1)) if valid_acc_uw > best_valid_uw: best_valid_uw = valid_acc_uw best_valid_conf = valid_conf saver.save(sess, os.path.join(FLAGS.checkpoint, FLAGS.model_name), global_step=i + 1) print( "*****************************************************************" ) print("Epoch: %05d" % (i + 1)) print("Training cost: %2.3g" % tcost) print("Training accuracy: %3.4g" % tracc) print("Valid cost: %2.3g" % cost_valid) print("Valid_UA: %3.4g" % valid_acc_uw) print("Best valid_UA: %3.4g" % best_valid_uw) print('Valid Confusion Matrix:["ang","sad","hap","neu"]') print(valid_conf) print('Best Valid Confusion Matrix:["ang","sad","hap","neu"]') print(best_valid_conf) print( "*****************************************************************" )
# Logistic regression print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") print("Logistic Regression") print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") lr1 = LR(penalty='l1', dual=False, tol=0.0002, C=1) lr2 = lr1.fit(x_train, y_train) print(lr2) y_pred_reg = lr2.predict(x_test) print ('Accuracy is ', acc(y_test,y_pred_reg)) print("confusion matrix") print(confusion(y_test,y_pred_reg)) print(status(y_test,y_pred_reg)) #cross validation print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") print("Cross validation of the best method ") lr3 = cross_val_score(estimator=lr1, X=x_train, y=y_train, cv=10, n_jobs=4,scoring='accuracy') print(lr3) print("mean", lr3.mean()) print("variance", np.var(lr3))
def train(train_dir=None, model_dir=None, mode='train'): model = crnn.CRNN(mode) model._build_model() global_step = tf.Variable(0, trainable=False) #sess1 = tf.InteractiveSession() #load training data train_data, train_label, valid_data, Valid_label = load_data() train_label = dense_to_one_hot(train_label, 4) Valid_label = dense_to_one_hot(Valid_label, 4) training_size = train_data.shape[0] with tf.name_scope('cross_entropy'): cross_entropy = tf.nn.softmax_cross_entropy_with_logits( labels=model.labels, logits=model.logits) loss = tf.reduce_mean(cross_entropy) # print model.logits.get_shape() with tf.name_scope('accuracy'): correct_pred = tf.equal(tf.argmax(model.softmax, 1), tf.argmax(model.labels, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) with tf.name_scope("moving_average"): variable_averages = tf.train.ExponentialMovingAverage( FLAGS.momentum, global_step) variable_averages_op = variable_averages.apply( tf.trainable_variables()) with tf.name_scope("train_step"): lr = tf.train.exponential_decay(FLAGS.learning_rate, global_step, training_size / FLAGS.train_batch_size, FLAGS.decay_rate, staircase=True) #print (lr.eval()) train_step = tf.train.AdamOptimizer(lr).minimize( loss, global_step=global_step) with tf.control_dependencies([train_step, variable_averages_op]): train_op = tf.no_op(name='train') saver = tf.train.Saver() init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for e in range(FLAGS.num_epochs): print(type(train_label)) print(train_label.shape) index = np.arange(training_size) np.random.shuffle(index) train_data = train_data[index] train_label = train_label[index] for i in range(int(training_size / FLAGS.train_batch_size) + 1): start = (i * FLAGS.train_batch_size) % training_size end = min(start + FLAGS.train_batch_size, training_size) _, loss_value, step, acc, softmax = sess.run( [train_op, loss, global_step, accuracy, model.softmax], feed_dict={ model.inputs: train_data[start:end], model.labels: train_label[start:end] }) if i % 10 == 0: print( "After epoch:%d, step: %d, loss on training batch is %.2f, accuracy is %.3f." % (e, step, loss_value, acc)) saver.save(sess, os.path.join(FLAGS.checkpoint, FLAGS.model_name), global_step=global_step) train_acc_uw = recall(np.argmax(softmax, 1), np.argmax(train_label[start:end], 1), average='macro') train_acc_w = recall(np.argmax(softmax, 1), np.argmax(train_label[start:end], 1), average='weighted') train_conf = confusion( np.argmax(softmax, 1), np.argmax(train_label[start:end], 1)) print("train_UA: %3.4g" % train_acc_uw) print("train_WA: %3.4g" % train_acc_w) print('Confusion Matrix:["ang","sad","hap","neu"]') print(train_conf) if i % 20 == 0: #for validation data valid_size = len(valid_data) valid_iter = divmod((valid_size), FLAGS.valid_batch_size)[0] y_pred_valid = np.empty((valid_size, 4), dtype=np.float32) index = 0 cost_valid = 0 if (valid_size < FLAGS.valid_batch_size): validate_feed = { model.inputs: valid_data, model.labels: Valid_label } y_pred_valid, p_loss = sess.run( [model.softmax, cross_entropy], feed_dict=validate_feed) cost_valid = cost_valid + np.sum(p_loss) else: print(valid_data.shape) for v in range(valid_iter): v_begin = v * FLAGS.valid_batch_size v_end = (v + 1) * FLAGS.valid_batch_size if (v == valid_iter - 1): if (v_end < valid_size): v_end = valid_size validate_feed = { model.inputs: valid_data[v_begin:v_end], model.labels: Valid_label[v_begin:v_end] } p_loss, y_pred_valid[v_begin:v_end, :] = sess.run( [cross_entropy, model.softmax], feed_dict=validate_feed) cost_valid = cost_valid + np.sum(p_loss) cost_valid = cost_valid / valid_size print(np.argmax(y_pred_valid, 1)) print(np.argmax(Valid_label, 1)) valid_acc_uw = recall(np.argmax(Valid_label, 1), np.argmax(y_pred_valid, 1), average='macro') valid_acc_w = recall(np.argmax(Valid_label, 1), np.argmax(y_pred_valid, 1), average='weighted') valid_conf = confusion(np.argmax(Valid_label, 1), np.argmax(y_pred_valid, 1)) print('----------segment metrics---------------') print("valid_UA: %3.4g" % valid_acc_uw) print("valid_WA: %3.4g" % valid_acc_w) print('Valid Confusion Matrix:["ang","sad","hap","neu"]') print(valid_conf) print('----------segment metrics---------------')
import matlab.engine import numpy as np import matplotlib.pyplot as plt # from sklearn.metrics import confusion_matrix from sklearn.metrics import confusion_matrix as confusion # 导入matlab引擎,实现python、matlab混合编程的第一步 eng = matlab.engine.start_matlab() [train_acc, test_acc, Rate, Error, y_pre, y_true] = eng.eval('BallMill_Classification_SCN()', nargout=6) y_pre = np.array(y_pre) y_pre = y_pre.reshape(-1, 1) # print(y_pre) y_true = np.array(y_true) y_true = y_true.reshape(-1, 1) # print(y_true) Y = confusion(y_true, y_pre) print(Y) # eng.plotconfusion(Y) plt.plot(Y) plt.show()
def decsion(): dir0 = './model_max0.pkl' dir1 = './model_max1.pkl' dir2 = './model_max2.pkl' dir3 = './model_max3.pkl' dir4 = './model_max4.pkl' dir5 = './model_max5.pkl' dir6 = './model_max6.pkl' dir7 = './model_max7.pkl' test_label = load_data() best_valid_uw0, best_valid_w0, pred_test_w0, test_acc_w0, confusion_w0, pred_test_uw0, test_acc_uw0, confusion_uw0 = read_data( dir0) best_valid_uw1, best_valid_w1, pred_test_w1, test_acc_w1, confusion_w1, pred_test_uw1, test_acc_uw1, confusion_uw1 = read_data( dir1) best_valid_uw2, best_valid_w2, pred_test_w2, test_acc_w2, confusion_w2, pred_test_uw2, test_acc_uw2, confusion_uw2 = read_data( dir2) best_valid_uw3, best_valid_w3, pred_test_w3, test_acc_w3, confusion_w3, pred_test_uw3, test_acc_uw3, confusion_uw3 = read_data( dir3) best_valid_uw4, best_valid_w4, pred_test_w4, test_acc_w4, confusion_w4, pred_test_uw4, test_acc_uw4, confusion_uw4 = read_data( dir4) best_valid_uw5, best_valid_w5, pred_test_w5, test_acc_w5, confusion_w5, pred_test_uw5, test_acc_uw5, confusion_uw5 = read_data( dir5) best_valid_uw6, best_valid_w6, pred_test_w6, test_acc_w6, confusion_w6, pred_test_uw6, test_acc_uw6, confusion_uw6 = read_data( dir6) best_valid_uw7, best_valid_w7, pred_test_w7, test_acc_w7, confusion_w7, pred_test_uw7, test_acc_uw7, confusion_uw7 = read_data( dir7) print(test_acc_uw0, test_acc_w0) print(test_acc_uw1, test_acc_w1) print(test_acc_uw2, test_acc_w2) print(test_acc_uw3, test_acc_w3) print(test_acc_uw4, test_acc_w4) print(test_acc_uw7, test_acc_w7) print(test_acc_uw6, test_acc_w6) print(test_acc_uw5, test_acc_w5) # voting size = pred_test_uw0[0] Pred_w_vote = np.empty((size, 8), dtype=np.int8) Pred_w_vote[:, 0] = np.argmax(pred_test_w0, 1) Pred_w_vote[:, 1] = np.argmax(pred_test_w1, 1) Pred_w_vote[:, 2] = np.argmax(pred_test_w2, 1) Pred_w_vote[:, 3] = np.argmax(pred_test_w3, 1) Pred_w_vote[:, 4] = np.argmax(pred_test_w4, 1) Pred_w_vote[:, 5] = np.argmax(pred_test_w5, 1) Pred_w_vote[:, 6] = np.argmax(pred_test_w6, 1) Pred_w_vote[:, 7] = np.argmax(pred_test_w7, 1) # print Pred_w0.shape, Pred_w1.shape, Pred_w2.shape, Pred_w3.shape # Pred_w_vote = np.concatenate((Pred_w0,Pred_w1,Pred_w2,Pred_w3),axis=1) pred_w_vote = np.empty((Pred_w_vote.shape[0], 1), dtype=np.int8) for l in range(Pred_w_vote.shape[0]): pred_w_vote[l] = np.argmax(np.bincount(Pred_w_vote[l])) Pred_uw_vote = np.empty((size, 8), dtype=np.int8) Pred_uw_vote[:, 0] = np.argmax(pred_test_uw0, 1) Pred_uw_vote[:, 1] = np.argmax(pred_test_uw1, 1) Pred_uw_vote[:, 2] = np.argmax(pred_test_uw2, 1) Pred_uw_vote[:, 3] = np.argmax(pred_test_uw3, 1) Pred_uw_vote[:, 4] = np.argmax(pred_test_uw4, 1) Pred_uw_vote[:, 5] = np.argmax(pred_test_uw5, 1) Pred_uw_vote[:, 6] = np.argmax(pred_test_uw6, 1) Pred_uw_vote[:, 7] = np.argmax(pred_test_uw7, 1) # print Pred_uw0.shape, Pred_uw1.shape, Pred_uw2.shape, Pred_uw3.shape # Pred_uw_vote = np.concatenate((Pred_uw0,Pred_uw1,Pred_uw2,Pred_uw3),axis=1) pred_uw_vote = np.empty((Pred_uw_vote.shape[0], 1), dtype=np.int8) for l in range(Pred_uw_vote.shape[0]): pred_uw_vote[l] = np.argmax(np.bincount(Pred_uw_vote[l])) acc_uw_vote = recall(np.argmax(test_label, 1), pred_uw_vote, average='macro') acc_w_vote = recall(np.argmax(test_label, 1), pred_w_vote, average='weighted') conf_uw_vote = confusion(np.argmax(test_label, 1), pred_uw_vote) conf_w_vote = confusion(np.argmax(test_label, 1), pred_w_vote) print('*' * 30) print("Voting UW Accuracy: %3.4g" % acc_uw_vote) print('Confusion Matrix(UA):["ang","sad","hap","neu"]') print(conf_uw_vote) print("Voting W Accuracy: %3.4g" % acc_w_vote) print('Confusion Matrix(A):["ang","sad","hap","neu"]') print(conf_w_vote)
def train(): #####load data########## train_data, train_label, test_data, test_label, valid_data, valid_label, Valid_label, Test_label, pernums_test, pernums_valid = load_data( './IEMOCAP.pkl') train_label = train_label.reshape(-1) valid_label = valid_label.reshape(-1) Valid_label = Valid_label.reshape(-1) valid_size = valid_data.shape[0] dataset_size = train_data.shape[0] vnum = pernums_valid.shape[0] best_valid_uw = 0 device = 'cuda' ##########tarin model########### def init_weights(m): if type(m) == torch.nn.Linear: m.weight.data.normal_(0.0, 0.1) m.bias.data.fill_(0.1) elif type(m) == torch.nn.Conv2d: m.weight.data.normal_(0.0, 0.1) m.bias.data.fill_(0.1) model = acrnn() model.apply(init_weights) model = model.to(device) optimizer = optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999), weight_decay=5e-4) criterion = torch.nn.CrossEntropyLoss() # print(train_data.shape) # (1200, 300, 40, 3) # (B, H, W, C) train_data = train_data.transpose((0, 3, 1, 2)) test_data = test_data.transpose((0, 3, 1, 2)) valid_data = valid_data.transpose((0, 3, 1, 2)) # print(train_data.shape) # (1200, 3, 300, 40) # (B, C, H, W) num_epoch = 250 train_iter = divmod(dataset_size, batch_size)[0] for epoch in range(num_epoch): # training model.train() shuffle_index = list(range(len(train_data))) np.random.shuffle(shuffle_index) for i in range(train_iter): start = (i * batch_size) % dataset_size end = min(start + batch_size, dataset_size) if i == (train_iter - 1) and end < dataset_size: end = dataset_size inputs = torch.tensor( train_data[shuffle_index[start:end]]).to(device) targets = torch.tensor(train_label[shuffle_index[start:end]], dtype=torch.long).to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() if clip: # torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip) torch.nn.utils.clip_grad_norm_(model.parameters(), clip) optimizer.step() if epoch % 1 == 0: # validation model.eval() valid_iter = divmod(valid_size, batch_size)[0] y_pred_valid = np.empty((valid_size, num_classes), dtype=np.float32) y_valid = np.empty((vnum, 4), dtype=np.float32) index = 0 cost_valid = 0 if (valid_size < batch_size): # inference with torch.no_grad(): inputs = torch.tensor(valid_data[v_begin:v_end]).to(device) targets = torch.tensor(Valid_label[v_begin:v_end], dtype=torch.long).to(device) outputs = model(inputs) y_pred_valid[ v_begin:v_end, :] = outputs.cpu().detach().numpy() loss = criterion(outputs, targets).cpu().detach().numpy() cost_valid = cost_valid + np.sum(loss) for v in range(valid_iter): v_begin, v_end = v * batch_size, (v + 1) * batch_size if v == (valid_iter - 1) and v_end < valid_size: v_end = valid_size # inference with torch.no_grad(): inputs = torch.tensor(valid_data[v_begin:v_end]).to(device) targets = torch.tensor(Valid_label[v_begin:v_end], dtype=torch.long).to(device) outputs = model(inputs) y_pred_valid[ v_begin:v_end, :] = outputs.cpu().detach().numpy() loss = criterion(outputs, targets).cpu().detach().numpy() cost_valid = cost_valid + np.sum(loss) cost_valid = cost_valid / valid_size for s in range(vnum): y_valid[s, :] = np.max( y_pred_valid[index:index + pernums_valid[s], :], 0) index = index + pernums_valid[s] # compute evaluated results valid_acc_uw = recall(valid_label, np.argmax(y_valid, 1), average='macro') valid_conf = confusion(valid_label, np.argmax(y_valid, 1)) # save the best val result if valid_acc_uw > best_valid_uw: best_valid_uw = valid_acc_uw best_valid_conf = valid_conf if not os.path.isdir(checkpoint): os.mkdir(checkpoint) torch.save(model.state_dict(), os.path.join(checkpoint, model_name)) # print results print( "*****************************************************************" ) print("Epoch: %05d" % (epoch + 1)) # print ("Training cost: %2.3g" %tcost) # print ("Training accuracy: %3.4g" %tracc) print("Valid cost: %2.3g" % cost_valid) print("Valid_UA: %3.4g" % valid_acc_uw) print("Best valid_UA: %3.4g" % best_valid_uw) print('Valid Confusion Matrix:["ang","sad","hap","neu"]') print(valid_conf) print('Best Valid Confusion Matrix:["ang","sad","hap","neu"]') print(best_valid_conf) print( "*****************************************************************" )
print fraud_count print "\n The number of non_frauds are:-\n" print non_count #RANDOM FOREST rf = RandomForestClassifier(n_estimators=10, max_depth=7, random_state=42) rf.fit(trainX, trainTargets) #training the model using the training set predictions = rf.predict( testX ) #making predictions on the test data based on what it learned from training phase probs = rf.predict_proba(testX) print "Confusion Matrix of Random Forest \n" print confusion(testTargets, predictions) cfmat(predictions, 'Random Forest') #Display Confusion Matrix print "\nAUPRC score of Random Forest is:-\n" print average_precision_score(testTargets, probs[:, 1]) #Display the AUPRC score skplt.metrics.plot_precision_recall(testTargets, probs) #Plot AUPRC Graph plt.show() tree = rf.estimators_[ 5] #arbitrarily taking the 5th of the 10 trees that were generated # Export the image to a dot file export_graphviz(tree, out_file='branch.dot', feature_names=feature_list)
vectorizador = CountVectorizer(ss) sX = vectorizador.fit_transform(ss) sX = sX.toarray() X_train, X_test, Y_train, Y_test = tts(sX, Y, stratify=Y, test_size=0.2, random_state=101) regresion = LogisticRegression() regresion.fit(X_train, Y_train) prediccion = regresion.predict(X_test) print(confusion(Y_test, prediccion), precision(Y_test, prediccion)) ###red neuronal keras # Se elige la catidad de neuronas nresults = [0, 0] for i in range(1, 21): ## Crea un modelo vacio model = keras.Sequential() ## Adiciona las capas model.add( keras.layers.Dense(units=i, activation=tf.nn.relu, input_dim=X_train.shape[1])) model.add(keras.layers.Dense(units=1, activation=tf.nn.sigmoid)) model.summary()