def train_model(num_epochs=1):
best_val_accu = 0.0
best_model_wts = copy.deepcopy(model.state_dict())
for epoch in range(num_epochs):
model.train()
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
running_loss = 0.0
running_corrects = 0.0
since = time.time()
trainloaders, train_size, _ = data_loader('train', data_dir)
for inputs, labels in trainloaders:
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad()
outputs = model.forward(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
time_elapsed = time.time() - since
model.eval()
val_loss = 0.0
val_correct = 0.0
validloaders, valid_size, _ = data_loader('valid', data_dir)
for inputs, labels in validloaders:
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
val_loss += loss.item() * inputs.size(0)
val_correct += torch.sum(preds == labels.data)
if val_correct.item() / valid_size > best_val_accu:
best_val_accu = val_correct.item() / valid_size
best_model_wts = copy.deepcopy(model.state_dict())
print('training took:{}'.format(time_elapsed))
print('train loss:{:.4f}'.format(running_loss / train_size))
print('train accuracy:{:.4f}\n'.format(
(running_corrects.item() / train_size)))
print('validation loss:{:.4f}'.format(val_loss / valid_size))
print('validation accuracy:{:.4f}\n'.format(val_correct.item() /
valid_size))
model.load_state_dict(best_model_wts)
print('best accuracy: {:.4f}'.format(best_val_accu))
return model
def train(batch_size, image_size, steps, ckpt_path):
make_dir(ckpt_path)
optim = Adam(lr=0.01)
generator_net = generator_network(image_size)
discriminator_net = discriminator_network(image_size)
generator_net.compile(optim, loss=content_loss)
discriminator_net.compile(optim, loss="binary_crossentropy")
end_to_end = end_to_end_gan(discriminator_net, generator_net, image_size)
end_to_end.compile(optim,
loss=[content_loss, 'binary_crossentropy'],
loss_weights=[1., 1e-3])
data_iterator = data_loader(batch_size)
for step in range(steps):
real_labels = np.ones((batch_size, 1))
fake_labels = np.zeros((batch_size, 1))
correct_batch, degraded_batch = next(data_iterator)
gen_hr = generator_net.predict(degraded_batch)
discriminator_net.trainable = True
disc_loss_1 = discriminator_net.train_on_batch(correct_batch,
real_labels)
disc_loss_2 = discriminator_net.train_on_batch(gen_hr, fake_labels)
disc_loss = 0.5 * np.add(disc_loss_1, disc_loss_2)
discriminator_net.trainable = False
tf.config.run_functions_eagerly(True)
end_loss = end_to_end.train_on_batch(degraded_batch,
[correct_batch, real_labels])
print('step: ' + str(step))
print('discriminator loss: ', disc_loss)
print('end_loss: ', end_loss)
if step % 100 == 0:
generator_net.save(ckpt_path + '/generator_' + str(step) + '.h5')
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
encoder_states = [state_h, state_c]
decoder_inputs = Input(shape=(None, num_output_features))
decoder_lstm = LSTM(neurons, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
initial_state=encoder_states)
decoder_dense = Dense(num_output_features, activation='linear')
decoder_outputs = decoder_dense(decoder_outputs)
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer=optimizer, loss=loss)
pacing_text = ['LV', 'RV', 'BiV', 'LBBB']
data_dir = '../parse_data'
X, y = data_loader(pacing_text, data_dir, normalize=True)
X_train = X[[0, 2, 3], :, :]
y_train = y[[0, 2, 3], :, :]
X_test = np.expand_dims(X[1, :, :], axis=0)
y_test = np.expand_dims(y[1, :, :], axis=0)
train_data = data_generator(X_train, y_train)
val_data = data_generator(X_test, y_test)
model.fit_generator(train_data,
epochs=50,
steps_per_epoch=8,
validation_data=val_data,
validation_steps=1)
encoder_model = Model(encoder_inputs, encoder_states)
decoder_state_input_h = Input(shape=(neurons, ))
decoder_state_input_c = Input(shape=(neurons, ))
import itertools
from load_data import data_loader
import sys
sys.stdout = open('log.txt', 'w')
from sklearn.cross_validation import KFold
def float32(x):
return np.cast['float32'](x)
NTRAIN = 50000
NTEST = 200
EPOCHS = 100
loader = data_loader()
pathes = ["train/%s.png" % (i) for i in range(1, NTRAIN+1)]
X, X_hog, y = loader.load_data(pathes)
lin = layers.InputLayer((None, 3, 32, 32))
lhog = layers.InputLayer((None, 324))
running_loss += loss.item()
if args.method == 'mdmn' or (args.method == 'darn' and args.mode == 'L2'):
logger.info("Epoch %d, Alpha on %s: %s" % (t, data_names[i], alpha))
alpha_list[i, :, t] = alpha
logger.info("Epoch %d, loss = %.6g" % (t, running_loss))
logger.info("Finish training %s in %.6g seconds" % (data_names[i],
time.time() - time_start))
model.eval()
# Test (use another hold-out target)
test_loader = data_loader(test_insts[i], test_labels[i], batch_size=1000, shuffle=False)
test_acc = 0.
for xt, yt in test_loader:
xt = torch.tensor(xt, requires_grad=False, dtype=torch.float32).to(device)
yt = torch.tensor(yt, requires_grad=False, dtype=torch.int64).to(device)
preds_labels = torch.squeeze(torch.max(model.inference(xt), 1)[1])
test_acc += torch.sum(preds_labels == yt).item()
test_acc /= test_insts[i].shape[0]
logger.info("Test accuracy on %s = %.6g" % (data_names[i], test_acc))
test_results[data_names[i]] = test_acc
np_test_results[i] = test_acc
logger.info("All test accuracies: ")
logger.info(test_results)
# Save results to files
print('validation loss:{:.4f}'.format(val_loss / valid_size))
print('validation accuracy:{:.4f}\n'.format(val_correct.item() /
valid_size))
model.load_state_dict(best_model_wts)
print('best accuracy: {:.4f}'.format(best_val_accu))
return model
model = train_model(epoch)
model.eval()
test_loss = 0
test_correct = 0
model = model.to(device)
testloaders, test_size, class_to_idx = data_loader('test', data_dir)
for inputs, labels in testloaders:
inputs = inputs.to(device)
labels = labels.to(device)
#print(inputs.shape)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
test_loss += loss.item() * inputs.size(0)
test_correct += torch.sum(preds == labels.data)
print('test loss:{:.4f}'.format(test_loss / test_size))
print('test accuracy:{:.4f}\n'.format(test_correct.item() / test_size))
check_point = {
'class_to_idx': class_to_idx,