def main(train_dataset=None, validation_dataset=None, test_dataset=None, epoch=30, batch_size=128, logdir=None, run=1, variation=1, checkpoint=None): """HAR Model Trainer Train the `ConvLSTM` model with several `variation` of `ConvLSTMHyperparameter`. The model is trained with dataset from `train_dataset`, validated with dataset from `validation_dataset` and tested with dataset from `test_dataset`. Training summary and checkpoints is saved to `logdir`. A log directory is created for each variation, started from number provided to `run`. To restore a checkpoint before training or testing, provide the path to `checkpoint`. Args: - `train_dataset`: path to train dataset - `validation_dataset`: path to validation dataset - `test_dataset`: path to test dataset - `epoch`: number of epoch to train - `batch_size`: mini batch size used for training - `logdir`: path to save checkpoint and summary - `run`: number of run for the first variation, used for log directory naming - `variation`: number of hyperparameter variation - `checkpoint`: checkpoint path to restore """ hyperparameters = convlstm_hyperparamter(variation) for i, hyperparameter in enumerate(hyperparameters): run_logdir = os.path.join(logdir, 'run' + str(i + run)) model = ConvLSTM(hyperparameter, run_logdir) print('Run %d/%d' % (i + 1, variation)) print_hyperparameter_notes(hyperparameter) write_hyperparameter_notes(hyperparameter, run_logdir) if train_dataset and validation_dataset: train_data = load(train_dataset, NUM_TARGET, WINDOW_SIZE) validation_data = load(validation_dataset, NUM_TARGET, WINDOW_SIZE) if train_data.data.any() and validation_data.data.any(): model.train(train_data, validation_data, epoch, batch_size, checkpoint) if test_dataset: test_data = load(test_dataset, NUM_TARGET, WINDOW_SIZE) if test_data.data.any(): prediction = model.test(test_data, batch_size, checkpoint) model.confusion_matrix(prediction, test_data.target) tf.reset_default_graph()
criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2)) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=opt.milestones, gamma=0.5) header = ['epoch/total_epoch', 'test_mse'] with open(test_mse_path, 'w') as testcsvmes: # open trainfile writertest = csv.writer(testcsvmes) writertest.writerow(header) # trainning for epoch in range(1, opt.n_epoch + 1): print('\repoch {}'.format(epoch)) scheduler.step() print('*' * 10) model.train() for i, (input, label) in enumerate(train_loader): if use_gpu: input = torch.FloatTensor(input).cuda() label = torch.FloatTensor(label).cuda() else: input = torch.FloatTensor(input) label = torch.FloatTensor(label) #label = label.squeeze() # foreward pred = model(input) loss = criterion(pred, label) # backward optimizer.zero_grad()