def get_timer_detail(request, timer_id):
if request.is_ajax():
try:
user_id = get_user_info(request).get('user').id
t = timer.get_timer(user_id, int(timer_id))
ret = format_timer_str(t)
return JsonResponse({'valid':True, 'data':ret})
except Timer.DoesNotExist, ValueError:
return JsonResponse({'ret':'index is wrong', 'valid':False})
def test(self):
now = get_utcnow()
from datetime import timedelta
time = now + timedelta(days=10)
time_range = {'start': parseStr2utc(time - timedelta(days=1), self.tz_name),
'end': parseStr2utc(time + timedelta(days=1), self.tz_name)}
# time = parseStr2utc('20110809T091606', self.tz_name)
t = timer.create(time=time, title='Timer title', desc='Timer desc', user=self.owner, tlid=self.timelist.id, tzname=self.tz_name)
# get_timer
self.assertEqual(timer.get_timer(self.owner.id, t.id) is None, False);
# get_timers
self.assertEqual(len(timer.get_timers({'user': self.owner}, time_range.get('start'), time_range.get('end'))), 1)
self.assertEqual(len(timer.get_timers({'user': self.owner, 'is_home': True}, time_range.get('start'), time_range.get('end'))), 1)
self.assertEqual(len(timer.get_timers({'user': self.owner, 'is_own': True}, time_range.get('start'), time_range.get('end'))), 1)
# error range
err_time_range = {'start': parseStr2utc(time + timedelta(days=1), self.tz_name),
'end': parseStr2utc(time + timedelta(days=2), self.tz_name)}
self.assertEqual(len(timer.get_timers({'user': self.owner}, err_time_range.get('start'), err_time_range.get('end'))), 0)
# get_timelist_timers
self.assertEqual(len(timer.get_timelist_timers(self.owner, self.timelist.id, time_range.get('start'), time_range.get('end'))), 1)
self.assertEqual(len(timer.get_timelist_timers(self.owner, self.timelist.id, err_time_range.get('start'), err_time_range.get('end'))), 0)
# get_crrent_timer
self.assertEqual(timer.get_current_timer({'user': self.owner, 'is_own': True}).id, t.id)
self.assertEqual(timer.get_current_timer({'user': self.owner, 'is_home': True}).id, t.id)
self.assertEqual(timer.get_current_timer({'user': self.owner}).id, t.id)
# get _timelist_current_timer
self.assertEqual(timer.get_timelist_current_timer(self.owner, self.timelist.id).id, t.id)
# edit
title = 'test title edit'
desc = 'test desc edit'
t = timer.edit(user=self.owner, tid=t.id, time=time, title=title, desc=desc, tlid=self.timelist.id, tzname=self.tz_name, reminders=None)
self.assertEqual(t.title, title)
self.assertEqual(t.desc, desc)
# delete
timer.delete(self.owner, t.id)
self.assertEqual(len(timer.get_timers({'user': self.owner}, time_range.get('start'), time_range.get('end'))), 0)
def test_performance(args):
if args.gpu >= 0:
cuda.init()
cuda.get_device(args.gpu).use()
xp = cuda.cupy if args.gpu >= 0 else np
test_obj = TestPerformance(xp, args)
dataset = test_obj.dataset
dataset_test = test_obj.dataset_test
nn = net.NStepLSTM(n_layer=args.n_layer,
n_vocab=args.n_vocab,
n_input=args.n_input,
n_units=args.n_units,
dropout=args.dropout,
cudnn=args.cudnn)
opt = optimizers.SGD()
opt.setup(nn)
if args.gpu >= 0:
nn.to_gpu()
avg_time_forward = []
avg_time_backward = []
avg_time_forward_test = []
# n epoch
for i in xrange(args.n_epoch):
sum_forward_time = 0.0
sum_backward_time = 0.0
for input_data in dataset:
hx = chainer.Variable(xp.zeros(
(args.n_layer, len(input_data), args.n_units),
dtype=xp.float32),
volatile="auto")
cx = chainer.Variable(xp.zeros(
(args.n_layer, len(input_data), args.n_units),
dtype=xp.float32),
volatile="auto")
if args.gpu >= 0:
chainer.cuda.to_cpu(cx.data)
# forward
# start_time = test_obj.start_time()
with timer.get_timer(xp) as t:
ys = nn(hx, cx, input_data)
time_forward = t.total_time()
# if args.gpu >= 0:
# chainer.cuda.to_cpu(ys[0].data)
# end_time = test_obj.end_time()
# time_forward = end_time - start_time
# loss
loss = sum([F.sum(_ys) for _ys in ys])
# update
nn.zerograds()
# start_time = test_obj.start_time()
# backward
with timer.get_timer(xp) as t:
loss.backward()
time_backward = t.total_time()
# if args.gpu >= 0:
# chainer.cuda.to_cpu(loss.data)
# end_time = test_obj.end_time()
# time_backward = end_time - start_time
opt.update()
sum_forward_time += time_forward
sum_backward_time += time_backward
# print "time_forward :", time_forward
# print "time_backward:", time_backward
sum_forward_time_test = 0.0
# test data
for input_data in dataset_test:
hx = chainer.Variable(xp.zeros(
(args.n_layer, len(input_data), args.n_units),
dtype=xp.float32),
volatile="auto")
cx = chainer.Variable(xp.zeros(
(args.n_layer, len(input_data), args.n_units),
dtype=xp.float32),
volatile="auto")
if args.gpu >= 0:
chainer.cuda.to_cpu(cx.data)
# forward
with timer.get_timer(xp) as t:
ys = nn(hx, cx, input_data)
time_forward = t.total_time()
# start_time = test_obj.start_time()
# ys = nn(hx, cx, input_data)
# if args.gpu >= 0:
# chainer.cuda.to_cpu(ys[0].data)
# end_time = test_obj.end_time()
# time_forward = end_time - start_time
sum_forward_time_test += time_forward
# print "time_forward (test) :", time_forward
# print ys[0].data.shape
avg_time_forward.append(sum_forward_time)
avg_time_forward_test.append(sum_forward_time_test)
avg_time_backward.append(sum_backward_time)
print i, " time_forward :", sum_forward_time
print i, " time_forward (test):", sum_forward_time_test
print i, " time_backward :", sum_backward_time
print '------------------------'
print "avg_time_forward:", float(
sum(avg_time_forward)) / len(avg_time_forward)
print "avg_time_forward_test:", float(
sum(avg_time_forward_test)) / len(avg_time_forward_test)
print "avg_time_backward:", float(
sum(avg_time_backward)) / len(avg_time_backward)
def test_info_level(self):
t = get_timer(logging.WARNING)
with t('warning test'):
pass
def test_performance(args):
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
xp = cuda.cupy if args.gpu >= 0 else np
# make data
def make_seq2seq_dataset():
dataset_s = make_random_dataset(xp, args.datasize, args.seq_length,
args.n_vocab, args.random_length,
args.batchsize)
dataset_t = make_random_dataset(xp, args.datasize, args.seq_length,
args.n_vocab, args.random_length,
args.batchsize)
dataset = [(s, t) for s, t in six.moves.zip(dataset_s, dataset_t)]
return dataset
dataset = make_seq2seq_dataset()
dataset_test = make_seq2seq_dataset()
if args.v5:
model = Seq2seq(args.n_layer, args.n_vocab, args.n_vocab,
args.n_units, args.dropout, args.rnn_algo, v5=True)
else:
model = Seq2seq(args.n_layer, args.n_vocab, args.n_vocab,
args.n_units, args.dropout, args.rnn_algo)
if args.gpu >= 0:
model.to_gpu(args.gpu)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
avg_time_forward = []
avg_time_backward = []
avg_time_forward_test = []
time_forward_first = 0.0
# n epoch
for i in range(args.n_epoch):
print('forward and backward')
hook = TimerHook()
with hook:
sum_forward_time = 0.0
sum_backward_time = 0.0
for input_data in dataset:
with cupy.prof.time_range('iteration', color_id=0, sync=True):
xs, ys = input_data
# forward
with timer.get_timer(xp) as t:
with cupy.prof.time_range('forward', color_id=1, sync=True):
loss = model(xs, ys)
time_forward = t.total_time()
if i == 0 and time_forward_first == 0.0:
time_forward_first = time_forward
# backward and update
with timer.get_timer(xp) as t:
with cupy.prof.time_range('backward', color_id=2, sync=True):
model.cleargrads()
loss.backward()
with cupy.prof.time_range('update', color_id=3, sync=True):
optimizer.update()
time_backward = t.total_time()
sum_forward_time += time_forward
sum_backward_time += time_backward
hook.print_report()
print( '------------------------' )
# print('test')
# hook = TimerHook()
# with hook:
# # test data
# sum_forward_time_test = 0.0
# for input_data in dataset_test:
# xs, _ = input_data
# # forward
# with timer.get_timer(xp) as t:
# result = model.translate(xs, max_length=10, no_cpu=True)
# time_forward = t.total_time()
# sum_forward_time_test += time_forward
#
# hook.print_report()
# print( '------------------------' )
avg_time_forward.append(sum_forward_time)
# avg_time_forward_test.append(sum_forward_time_test)
avg_time_backward.append(sum_backward_time)
print( i, " time_forward :", sum_forward_time )
# print( i, " time_forward (test):", sum_forward_time_test )
print( i, " time_backward :", sum_backward_time )
print( '------------------------' )
def mean_time(time_list):
return float(sum(time_list)) / len(time_list)
print( 'time_forward_first:', time_forward_first )
print( "avg_time_forward:", mean_time(avg_time_forward) )
# print( "avg_time_forward_test:", mean_time(avg_time_forward_test) )
print( "avg_time_backward:", mean_time(avg_time_backward) )
