def main(file_path):
# Validate raw data path
if not os.path.exists(file_path):
LOG_ERROR('Could not find file: {}'.format(file_path))
return
# Validate raw data file type
if not file_path.endswith('.json'):
LOG_ERROR('File path must be a json file')
return
# Parse JSON
with open(file_path, encoding='utf-8') as f:
LOG_INFO('Parsing JSON file: {}'.format(file_path))
json_archive = json.load(f)
if not 'conversation_state' in json_archive.keys():
LOG_ERROR('Could not find `conversation_state` in file {}'.format(
file_path))
return
# Parse each conversation
for state in json_archive['conversation_state']:
conv = Conversation(state)
conv.parse()
conv.print_summary()
conv.serialize()
LOG_INFO('Finished parsing conversations!')
def compile(self, input_placeholder, label_placeholder, loss, optimizer):
x = input_placeholder
for k in range(self.num_layers):
x = self.layer_list[k].forward(x)
self.loss = loss.forward(x, label_placeholder)
self.updates = optimizer.get_updates(self.loss, self.params)
self.accuracy = T.mean(T.eq(T.argmax(x, axis=-1),
T.argmax(label_placeholder, axis=-1)))
LOG_INFO('start compiling model...')
self.train = theano.function(
inputs=[input_placeholder, label_placeholder],
outputs=[self.loss, self.accuracy],
updates=self.updates,
allow_input_downcast=True)
self.test = theano.function(
inputs=[input_placeholder, label_placeholder],
outputs=[self.accuracy, self.loss],
allow_input_downcast=True)
self.predict = theano.function(
inputs=[input_placeholder],
outputs=[x],
allow_input_downcast=True)
LOG_INFO('model compilation done!')
def main():
test_loss_list = []
test_acc_list = []
train_loss_list = []
train_acc_list = []
args = get_parser()
model, config, loss = get_model(args)
starttime = datetime.datetime.now()
for epoch in range(args.max_epoch):
LOG_INFO('Training @ %d epoch...' % (epoch))
train_loss, train_acc = train_net(model, loss, config, train_data, train_label, config['batch_size'], config['disp_freq'])
train_loss_list.extend(train_loss)
train_acc_list.extend(train_acc)
if epoch > 5:
config['learning_rate'] = config['learning_rate'] * args.learning_rate_decay
if epoch % config['test_epoch'] == 0:
LOG_INFO('Testing @ %d epoch...' % (epoch))
test_loss, test_acc = test_net(model, loss, test_data, test_label, config['batch_size'])
test_loss_list.append(test_loss)
test_acc_list.append(test_acc)
endtime = datetime.datetime.now()
print ("total training time:",(endtime - starttime).seconds)
save(args, train_loss_list, train_acc_list, test_loss_list, test_acc_list)
def compile(self, input_placeholder, label_placeholder, label_active_size_placeholder, loss, optimizer):
x = input_placeholder
for k in range(self.num_layers):
x = self.layer_list[k].forward(x)
self.loss = loss.forward(x, label_placeholder)
self.updates = optimizer.get_updates(self.loss, self.params)
nhot_acc = NHotAcc()
self.accuracy = nhot_acc(label_placeholder, x, label_active_size_placeholder)
LOG_INFO('start compiling model...')
self.train = theano.function(
inputs=[input_placeholder, label_placeholder, label_active_size_placeholder],
outputs=[self.loss, self.accuracy, x],
updates=self.updates,
allow_input_downcast=True)
self.test = theano.function(
inputs=[input_placeholder, label_placeholder, label_active_size_placeholder],
outputs=[self.accuracy, self.loss],
allow_input_downcast=True)
self.predict = theano.function(
inputs=[input_placeholder],
outputs=[x],
allow_input_downcast=True)
LOG_INFO('model compilation done!')
def train_model(part_name, criterion, epochs):
LOSS = 100
epoch_min = 1
LOG_INFO('\n\nTraining model for %s ...' % part_name)
model = models[part_name]
optimizer = optimizers[part_name]
scheduler = schedulers[part_name]
if args.load_model == True:
model = pickle.load(open('res/saved-model-%s.pth'%part_name, 'rb'))
train_loader = DataLoader(train_datasets[part_name], batch_size=args.batch_size, shuffle=True, num_workers=4)
valid_loader = DataLoader(valid_datasets[part_name], batch_size=args.batch_size, shuffle=True, num_workers=4)
test_loader = DataLoader(test_datasets[part_name], batch_size=args.batch_size, shuffle=True, num_workers=4)
for epoch in range(1, epochs + 1):
train(epoch, model, train_loader, optimizer, criterion)
valid_loss = evaluate(model, valid_loader, criterion)
if valid_loss < LOSS:
LOSS = valid_loss
epoch_min = epoch
pickle.dump(model, open('res/saved-model-%s.pth'%part_name, 'wb'))
#scheduler.step()
msg = '...Epoch %02d, val loss (%s) = %.4f' % (epoch, part_name, valid_loss)
LOG_INFO(msg)
model = pickle.load(open('res/saved-model-%s.pth'%part_name, 'rb'))
msg = 'Min @ Epoch %02d, val loss (%s) = %.4f' % (epoch_min, part_name, LOSS)
LOG_INFO(msg)
test_loss = evaluate(model, test_loader, criterion)
LOG_INFO('Finally, test loss (%s) = %.4f' % (part_name, test_loss))
def main(file_path):
# Validate raw data path
if not os.path.exists(file_path):
LOG_ERROR('Could not find file: {}'.format(file_path))
return
# Validate raw data file type
if not file_path.endswith('.pkl'):
LOG_ERROR('File path must be a pickle file')
return
with open(file_path, 'rb') as f:
LOG_INFO('Parsing pickle file: {}'.format(file_path))
conversation = pickle.load(f)
LOG_INFO('Found conversation: {}'.format(conversation['conversation_name']))
df = pd.DataFrame(conversation['messages'])
df.columns = ['Timestamp', 'Type', 'Participant']
# df['Datetime'] = pd.to_datetime(df['Timestamp'])
df['Datetime'] = df['Timestamp'].apply(lambda x:
datetime.datetime.fromtimestamp(float(x)).toordinal())
histogram = ggplot.ggplot(df, ggplot.aes(x='Datetime', fill='Participant')) \
+ ggplot.geom_histogram(alpha=0.6, binwidth=2) \
+ ggplot.scale_x_date(labels='%b %Y') \
+ ggplot.ggtitle(conversation['conversation_name']) \
+ ggplot.ylab('Number of messages') \
+ ggplot.xlab('Date')
print(histogram)
def train(adj, input_feats, target_labels, config, weights=None):
num_vertices = adj.shape[0]
label_kind = np.max(target_labels) + 1
feat_dim = input_feats.shape[-1]
layer_config = (feat_dim, config['hidden_dim'], label_kind)
model, loss = GCN("GCN", adj, weights, layer_config)
# model, loss = MLP("MLP", weights, layer_config)
# Construct masks for training and testing
train_size = int(num_vertices * config['train_portion'])
train_mask = np.zeros(target_labels.shape, dtype=bool)
train_mask[:train_size] = True
np.random.shuffle(train_mask)
test_mask = ~train_mask
for epoch in range(config['max_epoch']):
LOG_INFO('Training @ %d epoch...' % (epoch))
train_net(model, loss, config, input_feats,
target_labels, train_mask, label_kind)
if (epoch + 1) % config['test_epoch'] == 0:
LOG_INFO('Testing @ %d epoch...' % (epoch))
test_net(model, loss, input_feats,
target_labels, test_mask, label_kind)
if (epoch + 1) % 50 == 0:
config['learning_rate'] *= 0.5
def train_and_save(model, loss, train_data, test_data, train_label,
test_label):
best_test_loss = -1
update_round_before = 0
train_loss_list = []
train_acc_list = []
test_loss_list = []
test_acc_list = []
epoch_final = 0
for epoch in range(config['max_epoch']):
LOG_INFO('Training @ %d epoch...' % (epoch))
train_loss_now, train_acc_now = train_net(model, loss, config,
train_data, train_label,
config['batch_size'],
config['disp_freq'])
train_loss_list.append(train_loss_now)
train_acc_list.append(train_acc_now)
if epoch % config['test_epoch'] == 0:
LOG_INFO('Testing @ %d epoch...' % (epoch))
test_loss_now, test_acc_now = test_net(model, loss, test_data,
test_label,
config['batch_size'])
test_loss_list.append(test_loss_now)
test_acc_list.append(test_acc_now)
if best_test_loss == -1:
update_round_before = 0
best_test_loss = test_loss_now
elif test_loss_now <= best_test_loss:
update_round_before = 0
best_test_loss = test_loss_now
else:
update_round_before += 1
if update_round_before >= 5:
epoch_final = epoch + 1
break
save_dir = os.path.join('result', config['name'])
if not os.path.exists(save_dir):
os.makedirs(save_dir)
result_dict = {
"train_loss": train_loss_list,
"train_acc": train_acc_list,
"test_loss": test_loss_list,
"test_acc": test_acc_list
}
with open(os.path.join(save_dir, "result.json"), 'w') as f:
json.dump(result_dict, f)
x = range(epoch_final)
plt.cla()
plt.plot(x, train_loss_list, label="train loss")
plt.plot(x, test_loss_list, label="test loss")
plt.legend()
plt.savefig(os.path.join(save_dir, "loss.png"))
plt.cla()
plt.plot(x, train_acc_list, label="train acc")
plt.plot(x, test_acc_list, label="test acc")
plt.legend()
plt.savefig(os.path.join(save_dir, "acc.png"))
def solve_net(model, dataset, max_epoch, disp_freq, test_freq):
iter_counter = 0
loss_list = []
accuracy_list = []
test_acc = []
test_loss = []
total_loss_list = []
for k in range(max_epoch):
for train_sample in dataset.train_iterator():
iter_counter += 1
train_input = train_sample.vec_input()
train_label = train_sample.label()
loss, accuracy, outs = \
model.train(train_input, train_label, train_sample.label_key_count())
loss_list.append(loss)
accuracy_list.append(accuracy)
if iter_counter % disp_freq == 0:
msg = 'Training iter %d, mean loss %.5f (batch loss %.5f), mean acc %.5f' % (
iter_counter, np.mean(loss_list), loss_list[-1],
np.mean(accuracy_list))
LOG_INFO(msg)
loss_list = []
accuracy_list = []
# i = 0
# epsilon = 1e-5
# to_max = np.reshape(np.append(outs[i] - epsilon, np.zeros(len(outs[i]))), [2, len(outs[i])])
# v = np.max(to_max, axis=0) * (1 / (1 - epsilon))
# print("out %s" % (str(v)))
if iter_counter % test_freq == 0:
LOG_INFO(' Testing...')
for test_sample in dataset.test_iterator():
test_input = test_sample.vec_input()
test_label = test_sample.label()
t_accuracy, t_loss = model.test(
test_input, test_label, train_sample.label_key_count())
test_acc.append(t_accuracy)
test_loss.append(t_loss)
msg = ' Testing iter %d, mean loss %.5f, mean acc %.5f' % (
iter_counter, np.mean(test_loss), np.mean(test_acc))
LOG_INFO(msg)
test_acc = []
test_loss = []
if iter_counter % 100 == 0:
total_loss_list.append(loss)
def serialize(self, filename=None, prefix='output'):
# Assemble all data from conversation
hangouts_data = {
'conversation_id': self.conversation_id,
'conversation_name': self.conversation_name,
'other_conversation_names': self.conversation_names,
'message_count': self.get_total_message_count(),
'video_duration': self.get_hangout_duration_h(),
'participant_ids': [p.id for p in self.participants],
'participant_names':
[p.get_name_or_id() for p in self.participants],
'messages': self.message_data
}
# Create output directory if it doesn't exist
output_dir = os.path.join(os.getcwd(), prefix)
if not os.path.isdir(output_dir):
os.mkdir(output_dir)
# Set default filename
if filename is None:
filename = '{}-parsed.pkl'.format(self.conversation_id)
output_filename = os.path.join(output_dir, filename)
LOG_INFO(
'Serializing conversation data to "{}"'.format(output_filename))
# Serialize the conversation and dump it to file
with open(output_filename, 'wb') as f:
pickle.dump(hangouts_data, f)
def train(epoch, model, iterator, optimizer, criterion):
loss_list = []
acc_list = []
loss_ = []
model.train()
for i, batch in enumerate(iterator):
optimizer.zero_grad()
predictions = model(batch.text)
loss = criterion(predictions, batch.label.long())
loss.backward()
optimizer.step()
acc = (predictions.max(1)[1] == batch.label.long()).float().mean()
loss_list.append(loss.item())
loss_.append(loss.item())
acc_list.append(acc.item())
if i % args.display_freq == 0:
msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f, train acc = %.4f" % (
epoch, i, len(iterator), np.mean(loss_list), np.mean(acc_list))
LOG_INFO(msg)
loss_list.clear()
acc_list.clear()
return np.mean(loss_)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq):
iter_counter = 0
loss_list = []
acc_list = []
for input, label in data_iterator(inputs, labels, batch_size):
target = onehot_encoding(label, 10)
iter_counter += 1
# forward net
output = model.forward(input)
# calculate loss
loss_value = loss.forward(output, target)
# generate gradient w.r.t loss
grad = loss.backward(output, target)
# backward gradient
model.backward(grad)
# update layers' weights
model.update(config)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
if iter_counter % disp_freq == 0:
msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (
iter_counter, np.mean(loss_list), np.mean(acc_list))
loss_list = []
acc_list = []
LOG_INFO(msg)
def train(model, device, train_loader, optimizer, epoch):
model.train()
loss_list = []
loss_ = []
acc_list = []
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
data = data.view(data.shape[0], -1) # flatten
optimizer.zero_grad()
output = model(data)
loss = F.cross_entropy(output, target)
loss.backward()
optimizer.step()
loss_list.append(loss.item())
pred = output.argmax(
dim=1, keepdim=True) # get the index of the max log-probability
acc = pred.eq(target.view_as(pred)).float().mean()
acc_list.append(acc.item())
if batch_idx % LOG_INTERVAL == 0:
msg = 'Train Epoch: {} [{}/{} ({:.0f}%)]\tAvg Loss: {:.4f}\tAvg Acc: {:.4f}'.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), np.mean(loss_list),
np.mean(acc_list))
LOG_INFO(msg)
loss_.append(np.mean(loss_list))
loss_list.clear()
acc_list.clear()
return loss_
def train(model, optimizer, epoch, sentences, labels, verbosity=True):
model.train()
loss_list = []
acc_list = []
batch_idx = 0
for data, target in batching.iterate_data(sentences, labels, embeddings,
TRAIN_BATCH_SIZE):
optimizer.zero_grad()
output = model(data)
loss = F.cross_entropy(output, target)
loss.backward()
optimizer.step()
loss_list.append(loss.item())
pred = output.argmax(
dim=1, keepdim=True) # get the index of the max log-probability
acc = pred.eq(target.view_as(pred)).float().mean()
acc_list.append(acc.item())
if batch_idx % LOG_INTERVAL == 0:
if verbosity:
msg = 'Train Epoch: {} [{}/{} ({:.0f}%)]\tAvg Loss: {:.4f}\tAvg Acc: {:.4f}'.format(
epoch, batch_idx * len(data), len(sentences),
100. * batch_idx / len(sentences), np.mean(loss_list),
np.mean(acc_list))
LOG_INFO(msg)
loss_list.clear()
acc_list.clear()
batch_idx += 1
return loss_list, acc_list
def test_net(model, loss, inputs, labels, batch_size, epoch, layer_name):
loss_list = []
acc_list = []
for input, label in data_iterator(inputs,
labels,
batch_size,
shuffle=False):
target = onehot_encoding(label, 10)
output, output_visualize = model.forward(input,
visualize=True,
layer_name=layer_name)
# collapse output_visualize into 1 channel
output_visualize = np.sum(output_visualize, axis=(1))
loss_value = loss.forward(output, target)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
msg = ' Testing, total mean loss %.5f, total acc %.5f' % (
np.mean(loss_list), np.mean(acc_list))
LOG_INFO(msg)
# save weights and biases
model.save_weights(loss.name, epoch)
return np.mean(loss_list), np.mean(
acc_list
), output_visualize # output_visualize: batch_size x height x width
def train2(epoch, model, train_loader, optimizer):
loss_list3 = []
model.train()
for j, batch in enumerate(train_loader):
optimizer.zero_grad()
image, labels, rects = batch['image'].to(device), batch['labels'].to(
device), batch['rects'].to(device)
full = model(F.interpolate(image, size=[128, 128], mode='bilinear'))
#full = model(image)
## Loss3
full_l = F.interpolate(labels.float(),
size=[128, 128],
mode='bilinear').argmax(dim=1)
#full_l = labels.argmax(dim=1)
loss3 = criterion3(full, full_l)
## Total loss
loss3.backward()
optimizer.step()
loss_list3.append(loss3.item())
if j % args.display_freq == 0:
msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f" % (
epoch, j, len(train_loader), np.mean(loss_list3))
LOG_INFO(msg)
loss_list3.clear()
def parse(self):
LOG_INFO('Parsing conversation with ID: {}'.format(
self.conversation_id))
self.parse_initial_participants()
for e in self.event:
self.parse_message(e)
def solve_rnn(model, train_x, train_y, test_x, test_y,
max_epoch, disp_freq, test_freq):
iter_counter = 0
loss_list = []
accuracy_list = []
test_acc = []
test_loss = []
test_equation_acc = []
for k in range(max_epoch):
for x, y in one_sample_iterator(train_x, train_y):
iter_counter += 1
loss, accuracy = model.train(x, y)
loss_list.append(loss)
accuracy_list.append(accuracy)
if iter_counter % disp_freq == 0:
msg = 'Training iter %d, mean loss %.5f (sample loss %.5f), mean acc %.5f' % (iter_counter,
np.mean(loss_list),
loss_list[-1],
np.mean(accuracy_list))
LOG_INFO(msg)
loss_list = []
accuracy_list = []
if iter_counter % test_freq == 0:
LOG_INFO(' Testing...')
for tx, ty in one_sample_iterator(test_x, test_y, shuffle=False):
t_accuracy, t_equ_acc, t_loss = model.test(tx, ty)
test_acc.append(t_accuracy)
test_loss.append(t_loss)
test_equation_acc.append(t_equ_acc)
msg = ' Testing iter %d, mean loss %.5f, mean acc %.5f, equation acc %.5f' % (iter_counter,
np.mean(test_loss),
np.mean(test_acc),
np.mean(test_equation_acc))
LOG_INFO(msg)
test_acc = []
test_loss = []
test_equation_acc = []
def run(net_func, save_loss_path, save_acc_path, result_dir="result/"):
model, config = net_func()
loss_, acc_ = [], []
for epoch in range(config['max_epoch']):
LOG_INFO('Training @ %d epoch...' % (epoch))
a, b = train_net(model, loss, config, train_data, train_label,
config['batch_size'], config['disp_freq'])
loss_ += a
acc_ += b
if epoch % config['test_epoch'] == 0:
LOG_INFO('Testing @ %d epoch...' % (epoch))
test_net(model, loss, test_data, test_label, config['batch_size'])
test_net(model, loss, test_data, test_label, config['batch_size'])
if not os.path.exists(result_dir):
os.mkdir(result_dir)
np.save(result_dir + save_loss_path, loss_)
np.save(result_dir + save_acc_path, acc_)
def solve_net(model, train_x, train_y, test_x, test_y, batch_size, max_epoch,
disp_freq, test_freq):
tic = time.time()
iter_counter = 0
loss_list = []
accuracy_list = []
test_acc = []
test_loss = []
for k in range(max_epoch):
for x, y in data_iterator(train_x, train_y, batch_size):
iter_counter += 1
loss, accuracy = model.train(x, y)
loss_list.append(loss)
accuracy_list.append(accuracy)
if iter_counter % disp_freq == 0:
msg = 'Training iter %d, mean loss %.5f (batch loss %.5f), mean acc %.5f' % (
iter_counter, np.mean(loss_list), loss_list[-1],
np.mean(accuracy_list))
LOG_INFO(msg)
loss_list = []
accuracy_list = []
if iter_counter % test_freq == 0:
LOG_INFO(' Testing...')
for tx, ty in data_iterator(test_x,
test_y,
batch_size,
shuffle=False):
t_accuracy, t_loss = model.test(tx, ty)
test_acc.append(t_accuracy)
test_loss.append(t_loss)
msg = ' Testing iter %d, mean loss %.5f, mean acc %.5f' % (
iter_counter, np.mean(test_loss), np.mean(test_acc))
LOG_INFO(msg)
test_acc = []
test_loss = []
toc = time.time()
print "Elapsed Time:%ds" % (toc - tic)
def test_net(model, loss, input_feats, labels, test_mask, label_kind):
target = onehot_encoding(labels, label_kind)
output = model.forward(input_feats)
# set mask
output[~test_mask] = target[~test_mask]
loss_value = loss.forward(output, target)
acc_value = calculate_acc(output, labels, np.sum(test_mask))
msg = ' Testing, total mean loss %.5f, total acc %.5f' % (loss_value,
acc_value)
LOG_INFO(msg)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq, Loss,
Acur):
iter_counter = 0
loss_list = []
acc_list = []
ll = []
ac = []
for input, label in data_iterator(inputs, labels, batch_size):
target = onehot_encoding(label, 10)
iter_counter += 1
# forward net
output = model.forward(input)
# calculate loss
loss_value = loss.forward(output, target)
# generate gradient w.r.t loss
grad = loss.backward(output, target)
# backward gradient
model.backward(grad)
if loss_value > 1:
config['learning_rate'] = 0.2
elif loss_value > 0.5:
config['learning_rate'] = 0.1
elif loss_value > 0.2:
config['learning_rate'] = 0.05
else:
config['learning_rate'] = max(loss_value / 5.0, 0.005)
# update layers' weights
model.update(config)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
ll.append(loss_value)
ac.append(acc_value)
if iter_counter % disp_freq == 0:
msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (
iter_counter, np.mean(loss_list), np.mean(acc_list))
Loss.append(np.mean(loss_list))
Acur.append(np.mean(acc_list))
loss_list = []
acc_list = []
LOG_INFO(msg)
Loss.append(np.mean(ll))
Acur.append(np.mean(ac))
def test_net(model, loss, inputs, labels, batch_size):
loss_list = []
acc_list = []
for input, label in data_iterator(inputs, labels, batch_size, shuffle=False):
target = onehot_encoding(label, 10)
output = model.forward(input)
loss_value = loss.forward(output, target)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
msg = ' Testing, total mean loss %.5f, total acc %.5f' % (np.mean(loss_list), np.mean(acc_list))
LOG_INFO(msg)
def train(model, loss, train_data, test_data, train_label, test_label):
best_test_loss = -1
update_round_before = 0
for epoch in range(config['max_epoch']):
LOG_INFO('Training @ %d epoch...' % (epoch))
train_loss_now, train_acc_now = train_net(model, loss, config,
train_data, train_label,
config['batch_size'],
config['disp_freq'])
if epoch % config['test_epoch'] == 0:
LOG_INFO('Testing @ %d epoch...' % (epoch))
test_loss_now, test_acc_now = test_net(model, loss, test_data,
test_label,
config['batch_size'])
if best_test_loss == -1:
update_round_before = 0
best_test_loss = test_loss_now
elif test_loss_now <= best_test_loss:
update_round_before = 0
best_test_loss = test_loss_now
else:
update_round_before += 1
if update_round_before >= 5:
break
def test_net(model, loss, inputs, labels, batch_size):
loss_list = []
acc_list = []
# test model with all the test data
for input, label in data_iterator(inputs, labels, batch_size, shuffle=False):
# get the expected value of this batch of input
target = onehot_encoding(label, 10)
output = model.forward(input)
# calculate loss of this batch
loss_value = loss.forward(output, target)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
# use the mean of all batch's loss and accuracy as the final result
msg = ' Testing, total mean loss %.5f, total acc %.5f' % (np.mean(loss_list), np.mean(acc_list))
LOG_INFO(msg)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq, loss_file):
iter_counter = 0
loss_list = []
acc_list = []
for input, label in data_iterator(inputs, labels, batch_size):
target = onehot_encoding(label, 10)
iter_counter += 1
# print "Debug: ", "input=", input.shape, " target=", target.shape
# forward net
output = model.forward(input)
# calculate loss
loss_value = loss.forward(output, target)
# generate gradient w.r.t loss
grad = loss.backward(output, target)
# backward gradient
model.backward(grad)
# update layers' weights
model.update(config)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
acc_list.append(acc_value)
'''
outf = file(loss_file, "a")
outf.write(str(loss_value) + ' ' + str(acc_value) + '\n')
outf.close()
'''
if iter_counter % disp_freq == 0:
msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (iter_counter, np.mean(loss_list), np.mean(acc_list))
outf = file(loss_file, "a")
outf.write(str(np.mean(loss_list)) + ' ' + str(np.mean(acc_list)) + '\n')
outf.close()
loss_list = []
acc_list = []
LOG_INFO(msg)
def train1(epoch, model, train_loader, optimizer):
loss_list = []
model.train()
for i, batch in enumerate(train_loader):
optimizer.zero_grad()
image, rects = batch['image'].to(device), batch['rects'].to(device)
pred_rects = model(image, rects_only=True)
loss = criterion1(pred_rects, rects)
loss.backward()
optimizer.step()
loss_list.append(loss.item())
if i % args.display_freq == 0:
msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f" % (
epoch, i, len(train_loader), np.mean(loss_list))
LOG_INFO(msg)
loss_list.clear()
def train(epoch, model, train_loader, optimizer, criterion):
loss_list = []
model.train()
for i, batch in enumerate(train_loader):
optimizer.zero_grad()
image, labels = batch['image'].to(device), batch['labels'].to(device)
predictions = model(image)
loss = criterion(predictions, labels.argmax(dim=1, keepdim=False))
loss.backward()
optimizer.step()
loss_list.append(loss.item())
if i % args.display_freq == 0:
msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f" % (
epoch, i, len(train_loader), np.mean(loss_list))
LOG_INFO(msg)
loss_list.clear()
def train_net(model, loss, config, input_feats, labels, train_mask,
label_kind):
target = onehot_encoding(labels, label_kind)
# forward net
output = model.forward(input_feats)
# set mask
output[~train_mask] = target[~train_mask]
# calculate loss
loss_value = loss.forward(output, target)
# generate gradient w.r.t loss
grad = loss.backward(output, target)
# backward gradient
model.backward(grad)
# update layers' weights
model.update(config)
acc_value = calculate_acc(output, labels, np.sum(train_mask))
msg = ' Training batch loss %.4f, batch acc %.4f' % (loss_value,
acc_value)
LOG_INFO(msg)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq, Loss, Acur):
iter_counter = 0
loss_list = []
acc_list = []
ll = []
ac = []
# train model with
for input, label in data_iterator(inputs, labels, batch_size):
target = onehot_encoding(label, 10)
iter_counter += 1
# forward net
output = model.forward(input)
# calculate loss value of the whole batch
loss_value = loss.forward(output, target)
# generate gradient w.r.t loss, this is actually the local gradient contribution of the output layer
grad = loss.backward(output, target)
# backward gradient
model.backward(grad)
# update layers' weights: recount after the whole backward procedure
model.update(config)
acc_value = calculate_acc(output, label)
loss_list.append(loss_value)
ll.append(loss_value)
acc_list.append(acc_value)
ac.append(acc_value)
if iter_counter % disp_freq == 0:
msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (iter_counter, np.mean(loss_list), np.mean(acc_list))
loss_list = []
acc_list = []
LOG_INFO(msg)
Loss.append(np.mean(ll))
Acur.append(np.mean(ac))
