def fit(self,
xs,
ts,
max_epoch=10,
batch_size=20,
time_size=35,
max_grad=None,
eval_interval=20):
data_size = len(xs)
max_iters = data_size // (batch_size * time_size)
self.time_idx = 0
self.ppl_list = []
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
for epoch in range(max_epoch):
for iters in range(max_iters):
batch_x, batch_t = self.get_batch(xs, ts, batch_size,
time_size)
# 기울기를 구해 매개변수 갱신
loss = model.forward(batch_x, batch_t)
model.backward()
params, grads = remove_duplicate(
model.params, model.grads) # 공유된 가중치를 하나로 모음
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
# 퍼플렉서티 평가
if (eval_interval
is not None) and (iters % eval_interval) == 0:
ppl = np.exp(total_loss / loss_count)
elapsed_time = time.time() - start_time
print('| 에폭 %d | 반복 %d / %d | 시간 %d[s] | 퍼플렉서티 %.2f' %
(self.current_epoch + 1, iters + 1, max_iters,
elapsed_time, ppl))
self.ppl_list.append(float(ppl))
total_loss, loss_count = 0, 0
self.current_epoch += 1
def fit(self,
x,
t,
max_epoch=10,
batch_size=32,
max_grad=None,
eval_interval=20):
data_size = len(x)
max_iters = data_size // batch_size
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
for epoch in range(max_epoch):
idx = numpy.random.permutation(numpy.arange(data_size))
x = x[idx]
t = t[idx]
for iters in range(max_iters):
batch_x = x[iters * batch_size:(iters + 1) * batch_size]
batch_t = t[iters * batch_size:(iters + 1) * batch_size]
# 勾配を計算する
loss = model.forward(batch_x, batch_t)
model.backward()
params, grads = remove_duplicate(model.params, model.grads)
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
# 評価
if (eval_interval
is not None) and (iters % eval_interval) == 0:
avg_loss = total_loss / loss_count
elapsed_time = time.time() - start_time
print("epoch %d : iter %d / %d : loss %.2f" %
(epoch + 1, iters + 1, max_iters, avg_loss))
self.loss_list.append(float(avg_loss))
total_loss, loss_count = 0, 0
self.current_epoch += 1
def fit(self, x, t, max_epoch=10, batch_size=32, max_grad=None, eval_interval=20):
data_size = len(x)
max_iters = data_size // batch_size
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
for epoch in range(max_epoch):
# 뒤섞기
idx = numpy.random.permutation(numpy.arange(data_size)) # data_size만큼 random으로 순서를 섞어줌.
# contexts, targets
x = x[idx]
t = t[idx]
for iters in range(max_iters):
# batch_size 만큼 contexts, targest 추출.
batch_x = x[iters*batch_size:(iters+1)*batch_size]
batch_t = t[iters*batch_size:(iters+1)*batch_size]
# 기울기 구해 매개변수 갱신
loss = model.forward(batch_x, batch_t)
model.backward()
params, grads = remove_duplicate(model.params, model.grads) # 공유된 가중치를 하나로 모음
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
# 평가
if (eval_interval is not None) and ((iters+1) % eval_interval) == 0:
avg_loss = total_loss / loss_count
elapsed_time = time.time() - start_time
print('| 에폭 %d | 반복 %d / %d | 시간 %d[s] | 손실 %.2f'
% (self.current_epoch + 1, iters + 1, max_iters, elapsed_time, avg_loss))
self.loss_list.append(float(avg_loss))
total_loss, loss_count = 0, 0
self.current_epoch += 1
def fit(self, xs, ts, max_epoch=10, batch_size=20, time_size=35,
max_grad=None, eval_interval=20):
data_size = len(xs)
max_iters = data_size // (batch_size * time_size)
self.time_idx = 0
self.ppl_list = []
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
for epoch in range(max_epoch):
for iters in range(max_iters):
batch_x, batch_t = self.get_batch(xs, ts, batch_size, time_size)
# calculate grads and update parameters
loss = model.forward(batch_x, batch_t)
model.backward()
params, grads = remove_duplicate(model.params, model.grads) # remote duplicate one
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
# evaluate perplexity
if (eval_interval is not None) and (iters % eval_interval) == 0:
ppl = np.exp(total_loss / loss_count)
elaspd_time = time.time() - start_time
print('| epoch %d | iter %d / %d | time %d[s] | perplexity %.2f'
% (self.current_epoch + 1, iters + 1, max_iters, elaspd_time, ppl))
self.ppl_list.append(float(ppl))
total_loss, loss_count = 0, 0
self.current_epoch += 1
def fit(self,
x_train,
t_train,
x_test,
t_test,
max_epoch=10,
batch_size=32,
max_grad=None,
eval_interval=10):
data_size = len(x_train)
batch_size = min(batch_size, data_size)
max_iters = data_size // batch_size
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
print(
"Start training:\nmodel = {}\noptimizer = {}\nbatch size = {}\ntrain epochs = {}"
.format(self.model.__class__.__name__,
self.optimizer.__class__.__name__, batch_size, max_epoch))
for epoch in range(max_epoch):
epoch_start_time = time.time()
# シャッフル
idx = numpy.random.permutation(numpy.arange(data_size))
x = x_train[idx]
t = t_train[idx]
for iters in range(max_iters):
batch_x = x[iters * batch_size:(iters + 1) * batch_size]
batch_t = t[iters * batch_size:(iters + 1) * batch_size]
# 勾配を求め、パラメータを更新
loss = model.forward(batch_x, batch_t)
model.backward()
params, grads = remove_duplicate(model.params,
model.grads) # 共有された重みを1つに集約
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
def get_error_rate(xs, ts):
data_size = xs.shape[0]
max_iter = -(-data_size // batch_size) # 切り上げ整数
acc_count = 0 # 正答数
for iters in range(max_iter):
batch_x = xs[iters * batch_size:(iters + 1) * batch_size]
batch_t = ts[iters * batch_size:(iters + 1) * batch_size]
acc_count += self.model.validate(batch_x, batch_t)
return 1 - acc_count / data_size
# loss, accuracyの算出と表示
display_epoch = self.current_epoch + 1
self.loss_list.append(total_loss / loss_count)
total_loss, loss_count = 0, 0
elapsed_time = time.time() - epoch_start_time
total_time = time.time() - start_time
print(
'| epoch %d | time/total %d/%d[s] | loss = %.5f' %
(display_epoch, elapsed_time, total_time, self.loss_list[-1]))
# errorの算出は5epochまではepoch毎、以降はeval_interval毎に行う
if (display_epoch <= 5)\
or (display_epoch == max_epoch)\
or (eval_interval is not None) and (display_epoch % eval_interval) == 0:
self.err_epoch.append(display_epoch)
# 訓練誤差の算出と記録
self.err_train.append(get_error_rate(x_train, t_train))
elapsed_time = time.time() - epoch_start_time
total_time = time.time() - start_time
print('| epoch %d | time/total %d/%d[s] | train error = %.5f' %
(display_epoch, elapsed_time, total_time,
self.err_train[-1]))
# テスト誤差の算出と記録
self.err_test.append(get_error_rate(x_test, t_test))
elapsed_time = time.time() - epoch_start_time
total_time = time.time() - start_time
print('| epoch %d | time/total %d/%d[s] | test error = %.5f' %
(display_epoch, elapsed_time, total_time,
self.err_test[-1]))
self.current_epoch += 1
def fit(self, x, t, max_epoch=10, batch_size=32, max_grad=None, eval_interval=20):
data_size = len(x)
max_iters = data_size // batch_size
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
for epoch in range(max_epoch):
# シャッフル
idx = numpy.random.permutation(numpy.arange(data_size))
x = x[idx]
t = t[idx]
for iters in range(max_iters):
batch_x = x[iters*batch_size:(iters+1)*batch_size]
batch_t = t[iters*batch_size:(iters+1)*batch_size]
#print(batch_t.shape)
# 勾配を求め、パラメータを更新
loss = model.forward(batch_x, batch_t)
model.backward()
params, grads = remove_duplicate(model.params, model.grads) # 共有された重みを1つに集約
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
# 評価
if (eval_interval is not None) and (iters % eval_interval) == 0:
avg_loss = total_loss / loss_count
ppl = np.exp(total_loss / loss_count)#
values.append(ppl)#
elapsed_time = time.time() - start_time
print('| epoch %d | iter %d / %d | time %d[s] | loss %.2f'
% (self.current_epoch + 1, iters + 1, max_iters, elapsed_time, avg_loss))
file_name = "test.txt"#
with open(file_name,"a") as f:#
f.write(str(ppl)+"\n")#
self.loss_list.append(float(avg_loss))
total_loss, loss_count = 0, 0
while len(values) == max_iters:#
plas_minus = 0#
for i in range(len(values) - 1):#
sub.append(values[i] - values[i+1])#
plas_minus += np.sign(sub[i])#
if (abs(plas_minus) < 6):#
print("before_lr = %f" %(optimizer.lr))#
lr = lr / 4.0#
optimizer.lr = lr#
print("after_lr = %f" %(optimizer.lr))#
values = []#
for j in range(len(sub)):#
sum_res += abs(sub[j])#
d_ave = sum_res / max_iters#
print("="*50)#
print('ppl_delta_ave = %f' % (ave))#
print("="*50)#
if(d_ave <= 0.5):#
print("learning finish")#
#break#
self.flag = 1#
#print('flag1 = %d' % (self.flag))#
self.current_epoch += 1#
if(self.flag == 1):#
break#
if(self.flag==1):#
return self.flag#
def fit(self,
xs,
ts,
mode,
max_epoch=1,
batch_size=20,
time_size=35,
max_grad=None,
eval_interval=2):
data_size = len(xs)
max_iters = data_size // (batch_size * time_size)
self.time_idx = 0
self.ppl_list = []
self.eval_interval = eval_interval
model, optimizer = self.model, self.optimizer
total_loss = 0
loss_count = 0
start_time = time.time()
self.flag = 0
values = []
while self.flag == 0:
for epoch in range(max_epoch):
#print('flag2 = %d' % (self.flag))
sub = []
sum_res = 0
ave = 0
for iters in range(max_iters):
self.batch_x, self.batch_t = self.get_batch(
xs, ts, batch_size, time_size)
# 勾配を求め、パラメータを更新
loss = model.forward(self.batch_x, self.batch_t)
model.backward()
params, grads = remove_duplicate(
model.params, model.grads) # 共有された重みを1つに集約
if max_grad is not None:
clip_grads(grads, max_grad)
optimizer.update(params, grads)
total_loss += loss
loss_count += 1
# パープレキシティの評価
if (eval_interval
is not None) and (iters % eval_interval) == 0:
ppl = np.exp(total_loss / loss_count)
values.append(ppl)
elapsed_time = time.time() - start_time
print(
'| epoch %d | iter %d / %d | time %d[s] | perplexity %.2f'
% (self.current_epoch + 1, iters + 1, max_iters,
elapsed_time, ppl))
file_name = "test1.txt"
with open(file_name, "a") as f:
f.write(str(ppl) + "\n")
self.ppl_list.append(float(ppl))
total_loss, loss_count = 0, 0
print(len(values))
if mode == 1:
while len(values) == int(
(max_iters / eval_interval)) + 1: #
for i in range(len(values) - 1): #
sub.append(values[i] - values[i + 1]) #
for j in range(len(sub)): #
sum_res += abs(sub[j]) #
d_ave = sum_res / max_iters #
print("=" * 50) #
print('ppl_delta_ave = %f' % (d_ave)) #
print("=" * 50) #
if (d_ave <= 25): #
print("learning finish") #
self.flag = 1 #
break
break
if (self.flag == 1): #
break #
if (self.flag == 1): #
return self.flag #
self.current_epoch += 1 #
break
return self.flag
