def train_sentiment():
#load data
samples, labels, ID2label = load_training_data_sentiment(
'./data/manually_labeled_data_sentiment.txt')
samples_val, labels_val = load_val_data_sentiment(
'./data/sentiment_test_data.txt')
dict = tools.build_dict(samples, tools.MAX_NB_WORDS) #bulid dict
tools.save_dict(dict) #save the dict to local
#calculate weight for different to improve balance
sentiment_weight = {}
for i in range(2):
sentiment_weight[i] = len(labels) / labels.count(i)
print(len(dict))
embedding_matrix, nb_words, EMBEDDING_DIM = tools.load_embedding(
dict) #load embedding
N_label = len(ID2label)
X, y = tools.normalize_training_data(samples, labels, N_label, dict,
100) #normalize the input data
X_val, y_val = tools.normalize_training_data(samples_val, labels_val,
N_label, dict, 100)
print(len(X))
print(len(y))
NUM = len(X)
indices = np.arange(NUM)
np.random.shuffle(indices)
X = X[indices]
y = y[indices]
samples = np.asarray(samples)
samples = samples[indices]
labels = np.asarray(labels)
labels = labels[indices]
training_ratio = 1 #setting the training data percentage
N_train = int(NUM * training_ratio)
X_train = X[:N_train]
y_train = y[:N_train]
#X_val = X[N_train:]
#y_val = y[N_train:]
#samples_val = samples[N_train:]
#labels_val = labels[N_train:]
sample_weights = np.ones(
len(y_train)) #initialize the sample weight as all 1
model = tools.define_model(tools.MAX_SEQUENCE_LENGTH, embedding_matrix,
nb_words, EMBEDDING_DIM, N_label)
model_save_path = 'code\model_sentiment' #save the best model
model = tools.train_model(model, X_train, y_train, X_val, y_val,
sample_weights, model_save_path,
sentiment_weight)
score, acc = model.evaluate(
X_val, y_val, batch_size=2000) #get the score and acc for the model
print('Test score:', score)
print('Test accuracy:', acc)
pred = model.predict(
X_val,
batch_size=2000) #get the concrete predicted value for each text
labels_pred = tools.probs2label(
pred) #change the predicted value to labels
#save the wrong result
writer_sentiment = codecs.open(
'./data/wrong_analysis/sentiment_wrong_result.txt',
"w",
encoding='utf-8',
errors='ignore')
for i in range(len(labels_val)):
if labels_val[i] != labels_pred[i]:
writer_sentiment.write(samples_val[i] + '\t' +
ID2label[labels_val[i]] + '\t' +
ID2label[labels_pred[i]] + '\n')
writer_sentiment.flush()
writer_sentiment.close()
return acc
train_input = train_data[:trainDataSize, 0:3*totalJoints]
train_target = train_data[:trainDataSize, 3*totalJoints:]
test_input = test_data[:testDataSize, 0:3*totalJoints]
test_target = test_data[:testDataSize, 3*totalJoints:]
debug = True
# Train network
model = custom_models.InverseDynamicModel(nb_hidden_layers, nb_hidden_neurons).to(device)
print("training the model")
tools.train_model(model, train_input, train_target, nb_epochs,
batch_size, eta, s, len(seeds), f, nb_folds,
debug, device)
# Saving
if learnErrorModel:
torch.save(model, 'errorModel.pt')
else:
torch.save(model, 'torqueModel.pt')
train_error = tools.compute_loss(model, train_input, train_target, batch_size, device)
test_error = tools.compute_loss(model, test_input, test_target, batch_size, device)
result_train = torch.empty(len(seeds), nb_folds).to(device)
result_test = torch.empty(len(seeds), nb_folds).to(device)
result_train[s, f] = train_error
def train_class():
samples, labels, ID2label = load_training_data_class2(
tools.PATH + '/data/class2_labels.txt', tools.PATH +
'/data/manually_labeled_data_class2.txt') #load class data
dict = tools.build_dict(samples, tools.MAX_NB_WORDS) #bulid dict
print(len(dict))
tools.save_dict(dict) #save the dict to local
embedding_matrix, nb_words, EMBEDDING_DIM = tools.load_embedding(
dict) #load embedding
N_label = len(ID2label)
X, y = tools.normalize_training_data(samples, labels, N_label, dict,
100) #normalize the input data
print(len(X))
print(len(y))
NUM = len(X)
indices = np.arange(NUM)
np.random.shuffle(indices)
X = X[indices]
y = y[indices]
samples = np.asarray(samples)
samples = samples[indices]
labels = np.asarray(labels)
labels = labels[indices]
training_ratio = 0.9 #setting the training data percentage
N_train = int(NUM * training_ratio)
X_train = X[:N_train]
y_train = y[:N_train]
X_val = X[N_train:]
y_val = y[N_train:]
samples_val = samples[N_train:]
labels_val = labels[N_train:]
sample_weights = np.ones(
len(y_train)) #initialize the sample weight as all 1
model = tools.define_model(tools.MAX_SEQUENCE_LENGTH, embedding_matrix,
nb_words, EMBEDDING_DIM, N_label)
model_save_path = 'code\model_class2' #save the best model
model = tools.train_model(model, X_train, y_train, X_val, y_val,
sample_weights, model_save_path)
score, accuracy_class2 = model.evaluate(
X_val, y_val, batch_size=2000) #get the score and acc for the model
print('Test score:', score)
print('Test accuracy:', accuracy_class2)
pred = model.predict(
X_val,
batch_size=2000) #get the concrete predicted value for each text
labels_pred = tools.probs2label(
pred) #change the predicted value to labels
#save the wrong result for class2
writer_class2 = codecs.open(tools.PATH +
'/data/wrong_analysis/class2_wrong_result.txt',
"w",
encoding='utf-8',
errors='ignore')
for i in range(len(labels_val)):
if labels_val[i] != labels_pred[i]:
writer_class2.write(samples_val[i] + '\t' +
ID2label[labels_val[i]] + '\t' +
ID2label[labels_pred[i]] + '\n')
writer_class2.flush()
writer_class2.close()
class2_class1 = load_class2_to_class1(
tools.PATH + '/data/class2_class1.txt') #merge the class2 to class1
N_class1_true = 0
worng_class = []
for i in range(len(labels_val)):
if class2_class1[ID2label[labels_val[i]]] == class2_class1[ID2label[
labels_pred[i]]]:
N_class1_true += 1
else:
worng_class.append(class2_class1[ID2label[labels_val[i]]] + "\t" +
class2_class1[ID2label[labels_pred[i]]] + "\t" +
samples_val[i])
#save the wrong result for class1
writer = codecs.open(tools.PATH +
'/data/wrong_analysis/class1_wrong_result.txt',
"w",
encoding='utf-8',
errors='ignore')
writer.write("original_label" + "\t" + "predict_label" + "\t" + "sample" +
"\n")
for item in worng_class:
writer.write(item + '\n')
writer.flush()
writer.close()
accuracy_class1 = N_class1_true / len(labels_val)
print(accuracy_class1)
return accuracy_class2, accuracy_class1
def train():
with tf.Graph().as_default():
with tf.name_scope('input'):
tra_image_batch, tra_label_batch = get_batch(image_list, label_list)
x = tf.placeholder(tf.float32, shape=[32, 224, 224, 3])
y_gt = tf.placeholder(tf.int16, shape=[32, 5])
logits,_ =vgg.vgg_16(x,num_classes=5,is_training=True)
loss = slim.losses.softmax_cross_entropy(logits,y_gt)
accuracy = tools.accuracy(logits,y_gt)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
# update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
# with tf.control_dependencies([tf.group(*update_ops)]):
# my_global_step = tf.Variable(0, name='global_step', trainable=False)
# train_op = optimizer.minimize(loss,my_global_step)
# update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
# my_global_step = tf.Variable(0, name='global_step', trainable=False)
# with tf.control_dependencies(update_ops):
# train_op = optimizer.minimize(loss,my_global_step)
# var_list = tf.trainable_variables()
# g_list = tf.global_variables()
# bn_moving_vars = [g for g in g_list if 'moving_mean' in g.name]
# bn_moving_vars += [g for g in g_list if 'moving_variance' in g.name]
# var_list += bn_moving_vars
# saver = tf.train.Saver(var_list,max_to_keep=5)
train_op = tools.train_model(loss)
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
MAX_STEP = 6000
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
tra_images, tra_labels = sess.run([tra_image_batch, tra_label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
feed_dict={x: tra_images, y_gt: tra_labels})
if step % 50 == 0 or (step + 1) == MAX_STEP:
print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc))
# tf.summary.scalar('loss', tra_loss)
# tf.summary.scalar('accuracy', tra_acc)
summary_str = sess.run(summary_op)
tra_summary_writer.add_summary(summary_str, step)
if step % 1000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(model_path, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
tra_summary_writer.close()
coord.join(threads)
sess.close()
pa = ap.parse_args()
where = pa.data_dir
path = pa.save_dir
lr = pa.learning_rate
save_dir = pa.save_dir
dropout = pa.dropout
power = pa.gpu
epochs = pa.epochs
architecture = pa.pretrained_model
hiddenl = pa.hidden_units
trainloader, validloader, testloader, train_data, valid_data, test_data = load_data(where)
pretr_model = pa.pretrained_model
model = getattr(models, pretr_model)(pretrained = True)
build_classifier(model)
build_classifier(model)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(),lr=0.0001)
model, optimizer = train_model(model, epochs, trainloader, validloader, criterion, optimizer, power, lr, hiddenl, dropout)
test_model(model, testloader)
save_model(model, train_data, optimizer, save_dir, epochs, lr, architecture, hiddenl, dropout)
print("The Model is trained")
seed=SEED)
train_loader, valid_loader, _ = loaders
print(f"{len(train_loader)} train batches of size {BATCH_SIZE}")
print(classes)
for model_name, model in MODELS.items():
print(f"\n\n{model_name.upper()}\n\n")
# Two-stage Transfer Learning
# 1) Replace last layer, freeze all feature layers, train FC layers
tl.replace_last_layer(model=model, n_outputs=len(classes))
tl.adapt_first_fc_layer(model=model)
tl.freeze_feature_extractor(model=model)
print(f"\nTraining FC layers (warm-up), freezing feature extractor\n")
model = train_model(model=model,
train_loader=train_loader,
valid_loader=valid_loader,
lr=LR["warmup"],
n_epochs=EPOCHS["warmup"])
# 2) Fine-tune the whole model
model.requires_grad_(True)
print(f"\nTraining the whole model (fine-tuning)\n")
model = train_model(model=model,
train_loader=train_loader,
valid_loader=valid_loader,
lr=LR["fine-tune"],
n_epochs=EPOCHS["fine-tune"])