def main():
if not os.path.exists('./result'):
os.makedirs('./result')
question_vocab, answer_vocab = {}, {}
if os.path.exists('./result/vdict.json') and os.path.exists('./result/adict.json'):
write_log('restoring vocab', 'log.txt')
with open('./result/vdict.json','r') as f:
question_vocab = json.load(f)
with open('./result/adict.json','r') as f:
answer_vocab = json.load(f)
else:
question_vocab, answer_vocab = make_vocab_files()
with open('./result/vdict.json','w') as f:
json.dump(question_vocab, f)
with open('./result/adict.json','w') as f:
json.dump(answer_vocab, f)
write_log('question vocab size: '+ str(len(question_vocab)), 'log.txt')
write_log('answer vocab size: '+ str(len(answer_vocab)), 'log.txt')
with open('./result/proto_train.prototxt', 'w') as f:
f.write(str(qlstm(config.TRAIN_DATA_SPLITS, config.BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
with open('./result/proto_test.prototxt', 'w') as f:
f.write(str(qlstm('val', config.VAL_BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
caffe.set_device(config.GPU_ID)
caffe.set_mode_gpu()
solver = caffe.get_solver('./qlstm_solver.prototxt')
train_loss = np.zeros(config.MAX_ITERATIONS)
# results = []
for it in range(config.MAX_ITERATIONS):
solver.step(1)
# store the train loss
train_loss[it] = solver.net.blobs['loss'].data
if it != 0 and it % config.PRINT_INTERVAL == 0:
write_log('------------------------------------', 'log.txt')
write_log('Iteration: ' + str(it), 'log.txt')
c_mean_loss = train_loss[it-config.PRINT_INTERVAL:it].mean()
write_log('Train loss: ' + str(c_mean_loss), 'log.txt')
if it != 0 and it % config.VALIDATE_INTERVAL == 0: # acutually test
solver.test_nets[0].save('./result/tmp.caffemodel')
write_log('Validating...', 'log.txt')
test_loss, acc_overall, acc_per_ques, acc_per_ans = exec_validation(config.GPU_ID, 'val', it=it)
write_log('Iteration: ' + str(it), 'log.txt')
write_log('Test loss: ' + str(test_loss), 'log.txt')
write_log('Overall Accuracy: ' + str(acc_overall), 'log.txt')
write_log('Per Question Type Accuracy is the following:', 'log.txt')
for quesType in acc_per_ques:
write_log("%s : %.02f" % (quesType, acc_per_ques[quesType]), 'log.txt')
write_log('Per Answer Type Accuracy is the following:', 'log.txt')
for ansType in acc_per_ans:
write_log("%s : %.02f" % (ansType, acc_per_ans[ansType]), 'log.txt')
def main():
if not os.path.exists('./result'):
os.makedirs('./result')
question_vocab, answer_vocab = {}, {}
if os.path.exists('./result/vdict.json') and os.path.exists('./result/adict.json'):
print 'restoring vocab'
with open('./result/vdict.json','r') as f:
question_vocab = json.load(f)
with open('./result/adict.json','r') as f:
answer_vocab = json.load(f)
else:
question_vocab, answer_vocab = make_vocab_files()
with open('./result/vdict.json','w') as f:
json.dump(question_vocab, f)
with open('./result/adict.json','w') as f:
json.dump(answer_vocab, f)
print 'question vocab size:', len(question_vocab)
print 'answer vocab size:', len(answer_vocab)
with open('./result/proto_train.prototxt', 'w') as f:
f.write(str(qlstm(config.TRAIN_DATA_SPLITS, config.BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
with open('./result/proto_test.prototxt', 'w') as f:
f.write(str(qlstm('val', config.VAL_BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
raise
caffe.set_device(config.GPU_ID)
caffe.set_mode_gpu()
solver = caffe.get_solver('./qlstm_solver.prototxt')
train_loss = np.zeros(config.MAX_ITERATIONS)
results = []
for it in range(config.MAX_ITERATIONS):
solver.step(1)
# store the train loss
train_loss[it] = solver.net.blobs['loss'].data
if it % config.PRINT_INTERVAL == 0:
print 'Iteration:', it
c_mean_loss = train_loss[it-config.PRINT_INTERVAL:it].mean()
print 'Train loss:', c_mean_loss
if it != 0 and it % config.VALIDATE_INTERVAL == 0:
solver.test_nets[0].save('./result/tmp.caffemodel')
print 'Validating...'
test_loss, acc_overall, acc_per_ques, acc_per_ans = exec_validation(config.GPU_ID, 'val', it=it)
print 'Test loss:', test_loss
print 'Accuracy:', acc_overall
results.append([it, c_mean_loss, test_loss, acc_overall, acc_per_ques, acc_per_ans])
best_result_idx = np.array([x[3] for x in results]).argmax()
print 'Best accuracy of', results[best_result_idx][3], 'was at iteration', results[best_result_idx][0]
drawgraph(results)
def main():
if not os.path.exists('./result'):
os.makedirs('./result')
question_vocab, answer_vocab = {}, {}
if os.path.exists('./result/vdict.json') and os.path.exists('./result/adict.json'):
print 'restoring vocab'
with open('./result/vdict.json','r') as f:
question_vocab = json.load(f)
with open('./result/adict.json','r') as f:
answer_vocab = json.load(f)
else:
question_vocab, answer_vocab = make_vocab_files()
with open('./result/vdict.json','w') as f:
json.dump(question_vocab, f)
with open('./result/adict.json','w') as f:
json.dump(answer_vocab, f)
print 'question vocab size:', len(question_vocab)
print 'answer vocab size:', len(answer_vocab)
with open('./result/proto_train.prototxt', 'w') as f:
f.write(str(qlstm(config.TRAIN_DATA_SPLITS, config.BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
with open('./result/proto_test.prototxt', 'w') as f:
f.write(str(qlstm('val', config.BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
caffe.set_device(config.GPU_ID)
caffe.set_mode_gpu()
solver = caffe.get_solver('./qlstm_solver.prototxt')
train_loss = np.zeros(config.MAX_ITERATIONS)
results = []
for it in range(config.MAX_ITERATIONS):
solver.step(1)
# store the train loss
train_loss[it] = solver.net.blobs['loss'].data
if it % config.PRINT_INTERVAL == 0:
print 'Iteration:', it
c_mean_loss = train_loss[it-config.PRINT_INTERVAL:it].mean()
print 'Train loss:', c_mean_loss
if it % config.VALIDATE_INTERVAL == 0:
print 'Validating...'
solver.test_nets[0].save('./result/tmp.caffemodel')
test_loss, acc_overall, acc_per_ques, acc_per_ans = exec_validation(config.GPU_ID, 'val', it=it)
print 'Test loss:', test_loss
print 'Accuracy:', acc_overall
results.append([it, c_mean_loss, test_loss, acc_overall, acc_per_ques, acc_per_ans])
best_result_idx = np.array([x[3] for x in results]).argmax()
print 'Best accuracy of', results[best_result_idx][3], 'was at iteration', results[best_result_idx][0]
drawgraph(results)
def main():
#Make Result Fold
if not os.path.exists('./result'):
os.makedirs('./result')
#Make Empty Dict Variable
question_vocab, answer_vocab = {}, {}
if os.path.exists('./result/vdict.json') and os.path.exists(
'./result/adict.json'):
print 'restoring vocab'
with open('./result/vdict.json', 'r') as f:
question_vocab = json.load(f)
with open('./result/adict.json', 'r') as f:
answer_vocab = json.load(f)
else:
#Load TrainData
question_vocab, answer_vocab = make_vocab_files()
with open('./result/vdict.json', 'w') as f:
json.dump(question_vocab, f)
with open('./result/adict.json', 'w') as f:
json.dump(answer_vocab, f)
#json.dump Encoding to string object
print 'question vocab size:', len(question_vocab)
print 'answer vocab size:', len(answer_vocab)
#################Read ConfigFile + Make Network##############################
with open('./result/proto_train.prototxt', 'w') as f:
f.write(str(qlstm(config.TRAIN_DATA_SPLITS, config.BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
with open('./result/proto_test.prototxt', 'w') as f:
f.write(str(qlstm('val', config.VAL_BATCH_SIZE, \
config.MAX_WORDS_IN_QUESTION, len(question_vocab))))
#######################################################################
#당시 caffe -python 버전은 multi gpu지원하지않음 c++interface only
#현재는 python도 지원
caffe.set_device(config.GPU_ID)
caffe.set_mode_gpu()
solver = caffe.get_solver('./qlstm_solver.prototxt')
#solver.prototxt 학습 config를 Load할때 사용.
train_loss = np.zeros(config.MAX_ITERATIONS)
results = []
for it in range(config.MAX_ITERATIONS):
solver.step(1)
#step : forward backward update 3가지를 실시한다.
# store the train loss
train_loss[it] = solver.net.blobs['loss'].data
if it % config.PRINT_INTERVAL == 0:
print 'Iteration:', it
c_mean_loss = train_loss[it - config.PRINT_INTERVAL:it].mean()
print 'Train loss:', c_mean_loss
if it != 0 and it % config.VALIDATE_INTERVAL == 0:
solver.test_nets[0].save('./result/tmp.caffemodel')
print 'Validating...'
test_loss, acc_overall, acc_per_ques, acc_per_ans = exec_validation(
config.GPU_ID, 'val', it=it)
print 'Test loss:', test_loss
print 'Accuracy:', acc_overall
results.append([
it, c_mean_loss, test_loss, acc_overall, acc_per_ques,
acc_per_ans
])
best_result_idx = np.array([x[3] for x in results]).argmax()
print 'Best accuracy of', results[best_result_idx][
3], 'was at iteration', results[best_result_idx][0]
drawgraph(results)
