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()
