def train_loop(model, train_iter, test_iter, optimizer, gpu_id, epochs):
while train_iter.epoch < epochs:
# ---------- One iteration of the training loop ----------
train_batch = train_iter.next()
image_train, target_train = concat_examples(train_batch, gpu_id)
# Calculate the prediction of the network
prediction_train = model(image_train)
# Calculate the loss with mean squared error
loss = F.mean_squared_error(prediction_train, target_train)
# Calculate the gradients in the network
model.cleargrads()
loss.backward()
# Update all the trainable parameters
optimizer.update()
# --------------------- until here ---------------------
# Check the validation accuracy of prediction after every epoch
if train_iter.is_new_epoch: # If this iteration is the final iteration of the current epoch
# Display the training loss
print('Epoch:{:02d} train_loss:{:.04f} '.format(
train_iter.epoch, float(to_cpu(loss.array))),
end='')
test_losses = []
test_accuracies = []
while True:
test_batch = test_iter.next()
image_test, target_test = concat_examples(test_batch, gpu_id)
# Forward the test data
prediction_test = model(image_test)
# Calculate the loss
loss_test = F.mean_squared_error(prediction_test, target_test)
test_losses.append(to_cpu(loss_test.array))
# Calculate the R2
accuracy = F.r2_score(prediction_test, target_test)
accuracy.to_cpu()
test_accuracies.append(accuracy.array)
if test_iter.is_new_epoch:
test_iter.reset()
break
print('val_loss:{:.04f} '.format(np.mean(test_losses)))
def forward(self, inputs, device):
x, t = inputs
y = functions.r2_score(x, t, self.sample_weight, self.multioutput)
return y,
def __call__(self, x, t):
y = self.predictor(x)
loss = F.mean_squared_error(y, t)
r2_score = F.r2_score(y, t)
chainer.report({'loss': loss, 'r2_score': r2_score}, self)
return loss
def train_nn(nn,
env,
test_env,
optimizer,
batch_size,
lr_decay_period,
train_epochs,
test_interval,
test_epochs,
target_type,
save_dir,
name,
prev_score=None):
## Training loop
t0 = 1e-8
if prev_score:
assert isinstance(prev_score, float) or isinstance(
prev_score, int), 'prev_score must be int or float.'
best_score = prev_score
else:
best_score = -np.inf
train_r2_log = []
train_loss_log = []
test_r2_log = []
test_loss_log = []
for epoch in range(train_epochs):
try:
t1 = time()
if epoch % lr_decay_period == 0:
optimizer.hyperparam.alpha /= 2
obs_batch, target_train = make_train_batch(env, batch_size,
target_type)
prediction_train = nn(obs_batch)
loss = F.mean_squared_error(prediction_train, target_train)
nn.cleargrads()
loss.backward()
optimizer.update()
train_r2 = F.r2_score(prediction_train, target_train)
train_loss_log.append(loss.data)
train_r2_log.append(train_r2.data)
t0 += time() - t1
print(
"Training epoch %d/%d, loss: %.08f, r2: %f, mean r2: %f, samples/sec: %f "
% (epoch + 1, train_epochs, loss.data, train_r2.data,
float(np.mean(train_r2_log[-100:])),
(epoch + 1) * batch_size / t0),
end='\r')
if epoch % test_interval == 0 and epoch != 0:
test_losses = []
test_scores = []
print()
for j in range(test_epochs):
test_batch, target_test = make_train_batch(
test_env, batch_size, target_type)
# Forward the test data
prediction_test = nn(test_batch)
# Calculate the loss
loss_test = F.mean_squared_error(prediction_test,
target_test)
loss_test.to_cpu()
test_losses.append(loss_test.data)
# Calculate the accuracy
test_r2 = F.r2_score(prediction_test, target_test)
test_r2.to_cpu()
test_scores.append(test_r2.data)
test_loss_log.append(np.mean(test_losses))
test_r2_log.append(np.mean(test_scores))
print(
"Test epoch: %d, loss: %.08f, r2: %.08f "
% (j + 1, loss_test.data, test_r2.data),
end='\r')
if np.mean(test_scores) > best_score:
best_score = np.mean(test_scores)
print("\nNew best score:", best_score, end='\r')
chainer.serializers.save_npz(save_dir + name + '>' +
str(float(best_score)) +
'.npz',
nn,
compression=True)
print('\nval loss: {:.08f}, val r2 score: {:.08f}'.format(
np.mean(test_losses), np.mean(test_scores)))
except KeyboardInterrupt:
print("\nInterrupted by the user. Best score:", best_score)
break
'''
predict_ro = predict_1[:,0] + f0[:,0]
predict_e = predict_1[:,1] + f0[:,1]
predict_vx = predict_1[:,2] + f0[:,2]
predict_vy = predict_1[:,3] + f0[:,3]
predict_vz = predict_1[:,4] + f0[:,4]
predict_By = predict_1[:,5] + f0[:,5]
predict_Bz = predict_1[:,6] + f0[:,6]
'''
R2 = [F.r2_score(predict_ro,ro), F.r2_score(predict_e,e), F.r2_score(predict_vx,vx), F.r2_score(predict_vy,vy),F.r2_score(predict_vz,vz),F.r2_score(predict_By,By),F.r2_score(predict_Bz,Bz)]
R2_df = [F.r2_score(predict_1[:,0],data_f[:,0]), F.r2_score(predict_1[:,1],data_f[:,1]), F.r2_score(predict_1[:,2],data_f[:,2]),\
F.r2_score(predict_1[:,3],data_f[:,3]),F.r2_score(predict_1[:,4],data_f[:,4]),F.r2_score(predict_1[:,5],data_f[:,5]),F.r2_score(predict_1[:,6],data_f[:,6])]
for i in range(len(R2)):
print(flux[i],' R2 score :',R2[i])
print(flux_1[i],' R2 score :',R2_df[i])
print(T_flux[i])
print(P_flux[i])
kwargs = dict(c='deeppink',s=4, alpha=0.5,zorder=1, label='Predict')
kwargs1 = dict(c='deepskyblue', label='True', zorder=10)
plt.style.use('seaborn-colorblind')
plt.style.use('seaborn-whitegrid')
fig, ax = plt.subplots(2, 4, figsize=(15,6))
with chainer.using_config('enable_backprop', False):
print('Exp:',it,' Itry:',itry,' Epoch:',i)
for j in range(3):
#predict model1(ro,e,vx)
predict_train_1 = model_1(train_1[:,0:n_in])
predict_valid_1 = model_1(valid_1[:,0:n_in])
if LOSS == 'RMSE':
loss_train_tmp = to_cpu(F.mean_squared_error(predict_train_1[:,j],train_1_label[:,j]).data)
loss_valid_tmp = to_cpu(F.mean_squared_error(predict_valid_1[:,j],valid_1_label[:,j]).data)
elif LOSS == 'MAE':
loss_train_tmp = to_cpu(F.mean_absolute_error(predict_train_1[:,j],train_1_label[:,j]).data)
loss_valid_tmp = to_cpu(F.mean_absolute_error(predict_valid_1[:,j],valid_1_label[:,j]).data)
it_train_loss.append(loss_train_tmp)
it_valid_loss.append(loss_valid_tmp)
r2_train_tmp = to_cpu(F.r2_score(predict_train_1[:,j],train_1_label[:,j]).data)
it_train_r2.append(r2_train_tmp)
r2_valid_tmp = to_cpu(F.r2_score(predict_valid_1[:,j],valid_1_label[:,j]).data)
it_valid_r2.append(r2_valid_tmp)
print(flux_1[j],' R2 score (train):',r2_train_tmp,' R2 score (valid):',r2_valid_tmp)
print('loss(train):',loss_train_tmp,'loss(valid):',loss_valid_tmp)
for j in range(2):
#predict model1(vy, vz)
predict_train_2 = model_2(train_2[:,0:37])
predict_valid_2 = model_2(valid_2[:,0:37])
if LOSS == 'RMSE':
loss_train_tmp = to_cpu(F.mean_squared_error(predict_train_2[:,j],train_2_label[:,j]).data)
loss_valid_tmp = to_cpu(F.mean_squared_error(predict_valid_2[:,j],valid_2_label[:,j]).data)
def score(self, X, Y, step=100):
predicted = self.predict(X, step)
score = F.r2_score(predicted, Y).data
return score
F.mean_squared_error(
predict_valid_1[:, j],
valid_1_label[:, j]).data)
elif LOSS == 'MAE':
loss_train_tmp = to_cpu(
F.mean_absolute_error(
predict_train_1[:, j],
train_1_label[:, j]).data)
loss_valid_tmp = to_cpu(
F.mean_absolute_error(
predict_valid_1[:, j],
valid_1_label[:, j]).data)
it_train_loss.append(loss_train_tmp)
it_valid_loss.append(loss_valid_tmp)
r2_train_tmp = to_cpu(
F.r2_score(predict_train_1[:, j],
train_1_label[:, j]).data)
it_train_r2.append(r2_train_tmp)
r2_valid_tmp = to_cpu(
F.r2_score(predict_valid_1[:, j],
valid_1_label[:, j]).data)
it_valid_r2.append(r2_valid_tmp)
print(flux_1[j], ' R2 score (train):',
r2_train_tmp, ' R2 score (valid):',
r2_valid_tmp)
print('loss(train):', loss_train_tmp,
'loss(valid):', loss_valid_tmp)
for j in range(2):
predict_train_2 = model_2(train_2[:, 0:25])
predict_valid_2 = model_2(valid_2[:, 0:25])
if LOSS == 'RMSE':
print('Exp:',it,' Itry:',itry,' Epoch:',i)
for j in range(7):
#predict model1(ro,e,vx,By,Bz)
predict_train_1 = model_1(train_1[:,0:n_in])
predict_valid_1 = model_1(valid_1[:,0:n_in])
#define loss function
if LOSS == 'RMSE':
loss_train_tmp = to_cpu(F.mean_squared_error(predict_train_1[:,j],train_1[:,n_in + j]).data)
loss_valid_tmp = to_cpu(F.mean_squared_error(predict_valid_1[:,j],valid_1[:,n_in + j]).data)
elif LOSS == 'MAE':
loss_train_tmp = to_cpu(F.mean_absolute_error(predict_train_1[:,j],train_1[:,n_in + j]).data)
loss_valid_tmp = to_cpu(F.mean_absolute_error(predict_valid_1[:,j],valid_1[:,n_in + j]).data)
it_train_loss.append(loss_train_tmp)
it_valid_loss.append(loss_valid_tmp)
r2_train_tmp = to_cpu(F.r2_score(predict_train_1[:,j],train_1[:,n_in + j]).data)
it_train_r2.append(r2_train_tmp)
r2_valid_tmp = to_cpu(F.r2_score(predict_valid_1[:,j],valid_1[:,n_in + j]).data)
it_valid_r2.append(r2_valid_tmp)
print(flux[j],' R2 score (train):',r2_train_tmp,' R2 score (valid):',r2_valid_tmp)
print('loss(train):',loss_train_tmp,'loss(valid):',loss_valid_tmp)
with chainer.using_config('enable_backprop', False):
loss_train.append(it_train_loss)
loss_valid.append(it_valid_loss)
R2_train.append(it_train_r2)
R2_valid.append(it_valid_r2)
model_1.to_cpu()
y_1_p = model_1(to_cpu(valid_1[:,0:n_in]))
print(y_1_p.shape)
# Evaluate training set
y_train = []
for s in range(0, train_size, batch_size):
x_batch = chainer.cuda.to_gpu(x_train[s:s + batch_size])
y_train.extend(chainer.cuda.to_cpu(model(x_batch).data).tolist())
# Evaluate test set
y_test = []
for s in range(0, test_size, batch_size):
x_batch = chainer.cuda.to_gpu(x_test[s:s + batch_size])
y_test.extend(chainer.cuda.to_cpu(model(x_batch).data).tolist())
train_loss = F.mean_squared_error(cp.asarray(y_train, dtype=np.float32), cp.asarray(t_train,dtype=np.float32))
train_R2 = F.r2_score(cp.asarray(y_train, dtype=np.float32),cp.asarray(t_train,dtype=np.float32))
train_losses.append(to_cpu(train_loss.data))
train_r2.append(to_cpu(train_R2.data))
train_loss = cp.asnumpy(train_loss.data)
train_R2 = cp.asnumpy(train_R2.data)
test_loss = F.mean_squared_error(cp.asarray(y_test, dtype=np.float32), cp.asarray(t_test, dtype=np.float32))
test_R2 = F.r2_score(cp.asarray(y_test, dtype=np.float32),cp.asarray(t_test,dtype=np.float32))
test_losses.append(to_cpu(test_loss.data))
test_r2.append(to_cpu(test_R2.data))
test_loss = cp.asnumpy(test_loss.data)
test_R2 = cp.asnumpy(test_R2.data)
elapsed_time2 = time.time() - start2
epoch = i / per_epoch
epoch_predict = y_train + y_test
print('epoch:{:.0f} \ntrain_loss:{:.04f} test_loss:{:0.4f} time:{:02f} '.format(epoch, train_loss, test_loss, elapsed_time2))
print('train_R2:{:.04f} test_R2:{:0.4f} '.format(train_R2, test_R2))
def r2_score(ys, ts):
cys = F.concat(ys, axis=0)
cts = F.concat(ts, axis=0)
return F.r2_score(cys, cts)
def forward(self, inputs, device):
x, t = inputs
y = functions.r2_score(x, t, self.sample_weight, self.multioutput)
return y,
