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