def test_start(monkeypatch, capsys):
monkeypatch.setattr(session, 'SESSIONS', 'sessions_location')
monkeypatch.setattr(MockContext, 'run', mock_run)
c = MockContext()
session.start(c, 'session_file')
assert capsys.readouterr(
).out == '/bin/sh sessions_location/session_file\n'
def testPauseValueError(self):
self.assertRaises(ValueError, session.pause)
session.start('sample task')
session.pause()
self.assertRaises(ValueError, session.pause)
session.stop()
self.assertRaises(ValueError, session.pause)
def auth_state(status): if status=='access': #need to start session session.start() session.session['logged'] #need to queue this for the webclient to get updated Queue. elif status=='deny':
def train(self, learning_rate, step_num, init_step=None, restoring_file=None):
print('\n%s: training...' % datetime.now())
sys.stdout.flush()
session = Session(self._graph, self.models_dir)
init_step = session.init(self._network, init_step, restoring_file)
session.start()
last_step = init_step+step_num
print('%s: training till: %d steps' %(datetime.now(), last_step))
print_loss = 0
train_loss = None
save_loss = 0
save_step = 0
total_loss = 0
feed_dict={self._lr_placeholder: learning_rate}
for step in range(init_step+1, last_step+1):
start_time = time.time()
_, total_loss_batch, loss_batch = session.run(
[self._train, self._total_loss, self._cross_entropy_losses], feed_dict=feed_dict
)
duration = time.time() - start_time
assert not np.isnan(total_loss_batch), 'Model diverged with loss = NaN'
cross_entropy_loss_value = np.mean(loss_batch)
print_loss += cross_entropy_loss_value
save_loss += cross_entropy_loss_value
total_loss += total_loss_batch
save_step += 1
if ((step - init_step) % Trainer.PRINT_FREQUENCY == 0):
examples_per_sec = Trainer.BATCH_SIZE / duration
format_str = ('%s: step %d, loss = %.2f, lr = %f, '
'(%.1f examples/sec; %.3f sec/batch)')
print_loss /= Trainer.PRINT_FREQUENCY
print(format_str % (datetime.now(), step, print_loss, learning_rate,
examples_per_sec, float(duration)))
print_loss = 0
# Save the model checkpoint and summaries periodically.
if (step == last_step or
(Trainer.SAVE_FREQUENCY is not None and (step - init_step) % Trainer.SAVE_FREQUENCY == 0)):
session.save(step)
total_loss /= save_step
train_loss = save_loss / save_step
print('%s: train_loss = %.3f' % (datetime.now(), train_loss))
if (self.writer):
summary_str = session.run(self._all_summaries, feed_dict=feed_dict)
self.writer.write_summaries(summary_str, step)
self.writer.write_scalars({'losses/training/cross_entropy_loss': train_loss,
'losses/training/total_loss': total_loss}, step)
total_loss = 0
save_loss = 0
save_step = 0
session.stop()
return step, train_loss
def test(self, step_num=None, init_step=None, restoring_file=None):
print('%s: testing...' %datetime.now())
sys.stdout.flush()
session = Session(self._graph, self.models_dir)
init_step = session.init(self._network, init_step, restoring_file)
session.start()
if (init_step == 0):
print('WARNING: testing an untrained model')
if (step_num is None):
step_num = np.int(np.ceil(np.float(self.fold_size) / Tester.BATCH_SIZE))
test_num = step_num * Tester.BATCH_SIZE
print('%s: test_num=%d' %(datetime.now(), test_num))
loss_value = 0
prob_values = np.zeros((test_num, Reader.CLASSES_NUM), dtype=np.float32)
label_values = np.zeros(test_num, dtype=np.int64)
filename_values = []
begin = 0
start_time = time.time()
for step in range(step_num):
#print('%s: eval_iter=%d' %(datetime.now(), i))
loss_batch, prob_batch, label_batch, filename_batch = session.run(
[self._loss, self._probs, self._labels, self._filenames]
)
loss_value += loss_batch
begin = step * Tester.BATCH_SIZE
prob_values[begin:begin+Tester.BATCH_SIZE, :] = prob_batch
label_values[begin:begin+Tester.BATCH_SIZE] = label_batch
filename_values.extend(filename_batch)
duration = time.time() - start_time
print('%s: duration = %.1f sec' %(datetime.now(), float(duration)))
sys.stdout.flush()
loss_value /= step_num
#return loss_value, probs_values, labels_values
print('%s: test_loss = %.3f' %(datetime.now(), loss_value))
mult_acc, bin_acc, auc, bin_sens = self.get_pred_stat(
prob_values, label_values, filename_values
)
if (self.writer):
summary_str = session.run(self._all_summaries)
self.writer.write_summaries(summary_str, init_step)
self.writer.write_scalars({'losses/testing/total_loss': loss_value,
'accuracy/multiclass': mult_acc,
'accuracy/binary': bin_acc,
'stats/AUC': auc,
'stats/sensitivity': bin_sens[0],
'stats/specificity': bin_sens[1]}, init_step)
session.stop()
return init_step, loss_value
def main(): #init session variable session.start() #init the webserver thread = Thread(target=init_web_server) thread.start() #init the fifo client thread = Thread(target=init_fifo_client) thread.start() while True: pass
def train(self, learning_rate, step_num, init_step=None, restoring_file=None):
print('%s: training...' % datetime.now())
sys.stdout.flush()
session = Session(self._graph, self.models_dir)
init_step = session.init(self._network, init_step, restoring_file)
session.start()
last_step = init_step+step_num
print('%s: training till: %d steps' %(datetime.now(), last_step))
print_loss = 0
train_loss = None
save_loss = 0
save_step = 0
feed_dict={self._lr_placeholder: learning_rate}
for step in range(init_step+1, last_step+1):
start_time = time.time()
_, loss_batch = session.run([self._train, self._loss],
feed_dict=feed_dict)
duration = time.time() - start_time
assert not np.isnan(loss_batch), 'Model diverged with loss = NaN'
print_loss += loss_batch
save_loss += loss_batch
save_step += 1
if ((step - init_step) % Trainer.PRINT_FREQUENCY == 0):
examples_per_sec = Trainer.BATCH_SIZE / duration
format_str = ('%s: step %d, loss = %.2f, lr = %f, '
'(%.1f examples/sec; %.3f sec/batch)')
print_loss /= Trainer.PRINT_FREQUENCY
print(format_str % (datetime.now(), step, print_loss, learning_rate,
examples_per_sec, float(duration)))
print_loss = 0
# Save the model checkpoint and summaries periodically.
if (step == last_step or
(Trainer.SAVE_FREQUENCY is not None and (step - init_step) % Trainer.SAVE_FREQUENCY == 0)):
session.save(step)
train_loss = save_loss / save_step
print('%s: train_loss = %.3f' % (datetime.now(), train_loss))
save_loss = 0
save_step = 0
if (self.writer):
summary_str = session.run(self._all_summaries, feed_dict=feed_dict)
self.writer.write_summaries(summary_str, step)
self.writer.write_scalars({'losses/training/total_loss': train_loss}, step)
session.stop()
return step, train_loss
def testPause(self):
event = session.start('sample task', user='******')
event = session.pause(user='******')
self.assertEqual(event.id, db.Events.pause)
self.assertEqual(session.isStarted('oy'), True)
self.assertEqual(session.isPaused('oy'), True)
def onReady(client_name):
try:
socket_id = request.sid
client_id = client_name
emit('ready', socket_id)
session_formed, room_id = matchmake.checkJoin(socket_id, client_id)
if session_formed:
session.start(room_id)
chat.roomChatInfo(socket_id, client_id)
chat.roomServerMessage(
'Client ' + misc.generateNameTag(
socket_id, matchmake.sid_cid_pairs[socket_id]) +
' has joined the room', room_id)
print((u'Client ready: ' + client_name).encode('utf-8'))
except Exception:
err_log = open('err_log', 'a', encoding='utf-8')
err_log.write(traceback.format_exc())
print(traceback.format_exc())
def test(self, step_num=None, init_step=None, restoring_file=None):
print('\n%s: testing...' %datetime.now())
sys.stdout.flush()
session = Session(self._graph, self.models_dir)
init_step = session.init(self._network, init_step, restoring_file)
session.start()
if (init_step == 0):
print('WARNING: testing an untrained model')
if (step_num is None):
step_num = np.int(np.ceil(np.float(self.fold_size) / Tester.BATCH_SIZE))
test_num = step_num * Tester.BATCH_SIZE
print('%s: test_num=%d' %(datetime.now(), test_num))
loss_values = np.zeros(test_num, dtype=np.float32)
prob_values = np.zeros((test_num, Reader.CLASSES_NUM), dtype=np.float32)
label_values = np.zeros(test_num, dtype=np.int64)
start_time = time.time()
for step in range(step_num):
#print('%s: eval_iter=%d' %(datetime.now(), i))
loss_batch, prob_batch, label_batch = session.run(
[self._cross_entropy_losses, self._probs, self._input['labels']]
)
begin = step * Tester.BATCH_SIZE
loss_values[begin:begin+Tester.BATCH_SIZE] = loss_batch
prob_values[begin:begin+Tester.BATCH_SIZE, :] = prob_batch
label_values[begin:begin+Tester.BATCH_SIZE] = label_batch
duration = time.time() - start_time
print('%s: duration = %.1f sec' %(datetime.now(), float(duration)))
sys.stdout.flush()
test_loss, mult_acc = self.get_all_stat(loss_values, prob_values, label_values)
if (self.writer):
summary_str = session.run(self._all_summaries)
self.writer.write_summaries(summary_str, init_step)
self.writer.write_scalars({'losses/testing/cross_entropy_loss': test_loss,
'accuracy/multiclass': mult_acc}, init_step)
session.stop()
return init_step, test_loss
def testStopValueError(self):
self.assertRaises(ValueError, session.stop)
session.start('sample task')
session.stop()
self.assertRaises(ValueError, session.stop)
def testStop(self):
event = session.start('sample task', user='******')
event = session.stop(user='******')
self.assertEqual(event.id, db.Events.stop)
self.assertEqual(session.isStarted('oy'), False)
self.assertEqual(session.isPaused('oy'), False)
def testResumeValueError(self):
self.assertRaises(ValueError, session.resume)
session.start('sample task')
self.assertRaises(ValueError, session.resume)
session.stop()
self.assertRaises(ValueError, session.resume)