def train():
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
json_file = open("parameters.json")
parameters = json.load(json_file)
json_file.close()
net = CNNModel(1, 10)
optimizer = torch.optim.Adam(net.parameters(), lr=parameters["lr"])
criterion = nn.BCELoss()
if torch.cuda.is_available():
net = torch.nn.DataParallel(net,
device_ids=range(
torch.cuda.device_count())).cuda()
cudnn.benchmark = True
ecg_dataset = EcgDataset(is_train=True)
train_loader = torch.utils.data.DataLoader(dataset=ecg_dataset,
batch_size=10)
for epoch in range(parameters["num_epochs"]):
net.train()
for i, (data, label) in enumerate(train_loader):
data, label = data.to(device), label.to(device)
output = net(data)
optimizer.zero_grad()
loss = criterion(output, label)
loss.backward()
optimizer.step()
print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch + 1,
parameters["num_epochs"],
loss.item()))
evaluation(net)
def train(train_config):
use_cuda = train_config.num_gpus > 0
if use_cuda:
torch.cuda.manual_seed(train_config.num_gpus)
logger.info("Number of GPUs available: {}".format(train_config.num_gpus))
device = torch.device('cuda' if use_cuda else 'cpu')
model = CNNModel().to(device)
optimizer = optim.Adam(model.parameters(), lr=train_config.lr)
best_train_loss = 0
for epoch in range(1, train_config.num_epochs + 1):
model.train()
train_loss = 0
for batch_idx, sample_batch in enumerate(train_loader):
pdb = sample_batch['pdb']
x = sample_batch['pocket']
y_true = sample_batch['label']
x, y_true = x.to(device), y_true.to(device)
x, y_true = Variable(x), Variable(y_true)
optimizer.zero_grad()
output = model(x)
loss = F.mse_loss(output, y_true)
train_loss += loss.data[0]
loss.backward()
optimizer.step()
if batch_idx % train_config.log_train_freq == 0:
logger.info("Train epoch: {}, Loss: {:.06f}"
.format(epoch, loss.data[0]))
if train_loss < best_train_loss:
utils.save_model(model, train_config.model_dir, logger)
import os
import sys
import time
from data_generator import NeedleData
from model import CNNModel
from project.settings import intermediate_dir
from cnn import unet_1
import theano.sandbox.cuda
theano.sandbox.cuda.use('gpu0')
if __name__ == '__main__':
SPLIT = 5
data_dir = os.path.join(intermediate_dir, "numpy")
for i in range(SPLIT):
i += 1
model, model_id, padding_axis1, padding_axis2 = unet_1.model(
l2_constant=0, lr=1e-4)
ds = NeedleData(padding_axis1, padding_axis2)
#ds.save_train_validation_data() #coment this later
cnn = CNNModel(data_streamer=ds, model=model)
uid = model_id + "br=4_lr=1e-4_bs=128_flipping"
cnn.train(uid=uid,
batch_size=128,
nb_epoch=1000,
split_num=i,
balance=True,
balance_ratio=4,
fliplr=True)
dev_loader = DataLoader(devset, shuffle=False, batch_size=BATCH_SIZE)
test_loader = DataLoader(testset, shuffle=False, batch_size=BATCH_SIZE)
model = CNNModel(torch.tensor(word_vectors, dtype=torch.float32), rel2id)
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
criterion = nn.CrossEntropyLoss()
model.to(DEVICE)
criterion.to(DEVICE)
best_f1_micro = 0.0
waste_epoch = 0
for epoch in range(EPOCH):
running_loss = 0.0
for i, data in enumerate(train_loader):
model.train()
tokens, pos1, pos2, label = data
tokens = tokens.to(DEVICE)
pos1 = pos1.to(DEVICE)
pos2 = pos2.to(DEVICE)
label = label.to(DEVICE)
optimizer.zero_grad()
outputs = model(tokens, pos1, pos2)
loss = criterion(outputs, label)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % PRINT_PER_STEP == PRINT_PER_STEP - 1:
def train_dann(dataset_source, dataset_target, n_epoch, batch_size, in_dim,
h_dims, out_dim, ckpt_save_path):
lr = 1e-3
l_d = 0.1
dataloader_source = torch.utils.data.DataLoader(
dataset=dataset_source,
batch_size=batch_size,
shuffle=True,
)
dataloader_target = torch.utils.data.DataLoader(
dataset=dataset_target,
batch_size=batch_size,
shuffle=True,
)
model = CNNModel(in_dim, h_dims, out_dim)
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
loss_class = torch.nn.CrossEntropyLoss()
loss_domain = torch.nn.CrossEntropyLoss()
if cuda:
model = model.cuda()
loss_class = loss_class.cuda()
loss_domain = loss_domain.cuda()
for p in model.parameters():
p.requires_grad = True
# training
best_acc = 0.0
best_ep = 0
tr_acc_ls = []
te_acc_ls = []
loss_ls = []
for epoch in range(n_epoch):
model.train()
len_dataloader = min(len(dataloader_source), len(dataloader_target))
data_source_iter = iter(dataloader_source)
data_target_iter = iter(dataloader_target)
loss_sum = 0.0
n_s = 0
for i in range(len_dataloader):
# Compute reverse layer parameter alpha
p = float(i + epoch * len_dataloader) / n_epoch / len_dataloader
alpha = 2. / (1. + np.exp(-10 * p)) - 1
# training model using source data
data_s, label_s = data_source_iter.next()
batch_size_s = len(label_s)
n_s += batch_size_s
domain_label = torch.zeros(batch_size_s).long()
if cuda:
data_s = data_s.cuda()
label_s = label_s.cuda()
domain_label = domain_label.cuda()
class_output, domain_output = model(input_data=data_s, alpha=alpha)
loss_c = loss_class(class_output, label_s)
loss_ds = loss_domain(domain_output, domain_label)
# training model using target data
data_t, _ = data_target_iter.next()
batch_size_t = len(data_t)
domain_label = torch.ones(batch_size_t).long()
if cuda:
data_t = data_t.cuda()
domain_label = domain_label.cuda()
_, domain_output = model(input_data=data_t, alpha=alpha)
loss_dt = loss_domain(domain_output, domain_label)
# Compute overall loss and backprop
loss = loss_c + l_d * (loss_dt + loss_ds)
loss_sum += loss.item() * batch_size_s
model.zero_grad()
loss.backward()
optimizer.step()
# logger.info('epoch: {:>4}, [iter: {:>4} / all {:>4}], loss {:8.4f}, '
# 'loss_c: {:8.4f}, loss_ds: {:8.4f}, loss_dt: {:8.4f}\n'
# .format(epoch, i+1, len_dataloader, loss.item(), loss_c.item(), loss_ds.item(), loss_dt.item()))
tr_acc, tr_f1 = evaluate_dann(model, dataset_source, batch_size)
te_acc, te_f1 = evaluate_dann(model, dataset_target, batch_size)
tr_acc_ls.append(tr_acc)
te_acc_ls.append(te_acc)
loss_ls.append(loss_sum)
# If find a better result, save the model
if te_acc > best_acc:
best_acc = te_acc
best_ep = epoch
checkpoint = {"epoch": epoch, "state_dict": model.state_dict()}
torch.save(checkpoint, ckpt_save_path + '.ckpt')
logger.info(
'epoch: {:>4}, loss: {:8.4f}, train acc: {:8.4f}, train f1: {:8.4f},'
' eval acc: {:8.4f}, eval f1: {:8.4f}'.format(
epoch, loss_sum, tr_acc, tr_f1, te_acc, te_f1))
logger.info('=' * 10)
logger.info('best epoch: {:>4}, best acc: {:8.4f}'.format(
best_ep, best_acc))
pickle.dump(tr_acc_ls, open(ckpt_save_path + '.tracc', 'wb'))
pickle.dump(te_acc_ls, open(ckpt_save_path + '.teacc', 'wb'))
pickle.dump(loss_ls, open(ckpt_save_path + '.loss', 'wb'))
dropouts = [dropout for _ in range(len(layer_config))]
for _ in range(5):
model = model_type(data, layer_config, dropouts, batch_norm,
model_type.__name__, save_model=False)
model.train(batch_size=32, epochs=20, verbose=0)
model.evaluate(log_dir="../exploration/model_log.txt")
if __name__ == "__main__":
import tensorflow as tf
from keras import backend as K
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
K.set_session(tf.Session(config=config))
from model import MLPModel, CNNModel, LSTMModel
data = UrbanSoundData(n_mfccs=20, n_augmentations=0)
# all_test_runs()
cnn = CNNModel(data, [64, 128, 512], dropout_probabilities=None, use_batch_norm=True,
log_tensorboard=False, model_name="CNN", save_model=False, overwrite=True)
cnn.train(batch_size=32, epochs=50, verbose=1)
print("Evaluation:", cnn.evaluate())
cnn.visualize_training()
del cnn
