import os import logging from flask import Flask import config from utils import Log app = Flask(__name__) app.secret_key = config.secret_key if not os.path.exists(config.logs_dir): os.mkdir(config.logs_dir) file_handler = logging.FileHandler(config.log_config.get("filename")) file_handler.setLevel(config.log_config.get("level")) file_handler.setFormatter(config.log_config.get("format")) log = Log(file_handler, "Tag API") log.info("Tag API started.") import blueprints
device), batchs['label'].to(device) out = net(sig, other) f1, accuracy, recall = f1_score(out.cpu().data.numpy(), label.cpu().data.numpy()) f1_all.append(f1) acc_all.append(accuracy) recall_all.append(recall) log.logging_flush(f' valid b:{i}/{len(dataloader)} ') f1_all, acc_all, recall_all = np.mean(f1_all), np.mean( acc_all), np.mean(recall_all) log.logging(f'f1:{f1_all} acc:{acc_all} recall:{recall_all}') return f1_all if __name__ == '__main__': log = Log(save_dir) if torch.cuda.is_available(): device = torch.device("cuda") log.logging('using cuda backend.') else: device = torch.device("cpu") all_split = np.arange(len(train_set)) train_split, val_split = all_split[:int(len(all_split) * 0.8)], all_split[ int(len(all_split) * 0.8):] dataloader = DataLoader(train_set, batch_size=batch_size, num_workers=n_cpu, sampler=RandomSampler(train_split))
def main(opt): dataLoader = trafficDataLoader(opt.taskID, opt.finterval) opt.nNode = dataLoader.nNode opt.dimFeature = dataLoader.dimFeature data = dataLoader.data # [n, T] # scale data using MinMaxScaler scaler = MinMaxScaler() scaler.fit(data) scaler_data = scaler.transform(data) # scale data using MaxAbsScaler # scaler = MaxAbsScaler() # scaler.fit(data) # scaler_data = scaler.transform(data) data = np.transpose(scaler_data) # [T, n] data = data[np.newaxis, :, :, np.newaxis] # load A and set 1 on the diagonal and zeros elsewhere of each node A = dataLoader.A A = opt.alpha * A + np.eye(opt.nNode) if opt.test is not None: opt.nNode = opt.test data = data[:, :, :opt.nNode, :] A = np.eye(opt.nNode) # convert data and A to tensor and randomize weights in hState data = torch.from_numpy(data) # [b, T, n, d] A = torch.from_numpy(A[np.newaxis, :, :]) # [b, n, n] hState = torch.randn(opt.batchSize, opt.dimHidden, opt.nNode).double() # [b, D, n] opt.interval = data.size(1) yLastPred = 0 # set model configuration log = Log(opt, timStart) net = GRNN(opt) criterion = nn.MSELoss() optimizer = optim.Adam(net.parameters(), lr=opt.lr) # optimizer = torch_core.AdamW(net.parameters(), lr=opt.lr, weight_decay=1e-1) net.double() print(net) if opt.cuda: net.cuda() criterion.cuda() data = data.cuda() A = A.cuda() hState = hState.cuda() # set plot details if opt.showNum != None: plt.style.use('ggplot') plt.figure(1, figsize=(10, 5)) plt.xlabel(f'Iteration (data on {opt.finterval}-min interval)' ) # iteration = lenBptt + (# propogations - 1) plt.ylabel('Scaled Speed') plt.title(f'GRNN{opt.grnnID} + Adam: Edge {opt.showNum}') # plt.ion # turn interactive mode on # create static legend data_color = '#484D6D' learning_color = '#DA5552' patchA = mpatches.Patch(color=data_color, label='data') patchB = mpatches.Patch(color=learning_color, label='learning curve') plt.legend(handles=[patchA, patchB]) # use cuDNN along with cuda to train faster torch.backends.cudnn.benchmark = True # begin training for t in range(opt.interval - opt.truncate): x = data[:, t:(t + opt.truncate), :, :] # batch, interval, node, feature y = data[:, (t + 1):(t + opt.truncate + 1), :, :] for i in range(opt.nIter): O, _ = net(x, hState, A) # data, hState, A hState = hState.data loss = criterion(O, y) #criterion(y_true, y_pred) MSE = criterion(O[:, -1, :, :], y[:, -1, :, :]) optimizer.zero_grad() loss.backward() # compute gradients optimizer.step() # update parameters # get explained variance score variance = explained_variance_score(O[-1, -1, :, -1].data, y[-1, -1, :, -1].data) # log to tensor in matlab file # TODO: unscale the results before saving, show timestamp log.prediction[:, t, :, :] = O[:, -1, :, :].data log.mseLoss[t] = MSE.data log.varianceScore[t] = variance # show and save log training details log.showIterState(t) _, hState = net.propogator(x[:, 0, :, :], hState, A) hState = hState.data # print(O.shape) # update plot of training model at each iteration if opt.showNum != None: if t == 0: # x = scaler.inverse_transform(x[-1, :, opt.showNum, -1].cpu().data.numpy()) # O = scaler.inverse_transform(O[-1, :, opt.showNum, -1].cpu().data.numpy()) if opt.cuda: transform_x_temp = np.zeros((opt.truncate, data.size(1))) transform_x_temp[:, 0] = np.reshape( x[0, :, opt.showNum, 0].cpu().data.numpy().flatten(), (opt.truncate, 1)).flatten() x = scaler.inverse_transform( transform_x_temp)[:, [0]].flatten() transform_O_temp = np.zeros((opt.truncate, data.size(1))) transform_O_temp[:, 0] = np.reshape( O[0, :, opt.showNum, 0].cpu().data.numpy().flatten(), (opt.truncate, 1)).flatten() O = scaler.inverse_transform( transform_O_temp)[:, [0]].flatten() plt.plot([v for v in range(opt.truncate)], x, color=data_color, linestyle='-', linewidth=1.5) plt.plot([v + 1 for v in range(opt.truncate)], O, color=learning_color, linestyle='-') else: transform_x_temp = np.zeros((opt.truncate, data.size(1))) transform_x_temp[:, 0] = np.reshape( x[0, :, opt.showNum, 0].data.numpy().flatten(), (opt.truncate, 1)).flatten() x = scaler.inverse_transform( transform_x_temp)[:, [0]].flatten() transform_O_temp = np.zeros((opt.truncate, data.size(1))) transform_O_temp[:, 0] = np.reshape( O[0, :, opt.showNum, 0].data.numpy().flatten(), (opt.truncate, 1)).flatten() O = scaler.inverse_transform( transform_O_temp)[:, [0]].flatten() plt.plot([v for v in range(opt.truncate)], x, color=data_color, linestyle='-', linewidth=1.5) plt.plot([v + 1 for v in range(opt.truncate)], O, color=learning_color, linestyle='-') else: # x = scaler.inverse_transform(x[-1, -2:, opt.showNum, -1].cpu().data.numpy()) # O = scaler.inverse_transform(O[-1, -1, opt.showNum, -1]) # these blocks are going to explode if opt.cuda: transform_x_temp = np.zeros((2, data.size(1))) transform_x_temp[:, 0] = np.reshape( x[0, -2:, opt.showNum, 0].cpu().data.numpy().flatten(), (2, 1)).flatten() x = scaler.inverse_transform(transform_x_temp)[:, [0]] transform_O_temp = np.zeros((1, data.size(1))) transform_O_temp[:, 0] = np.reshape( O[0, -1, opt.showNum, 0].cpu().data.numpy().flatten(), (1, 1)).flatten() O = scaler.inverse_transform(transform_O_temp)[:, [0]] plt.plot([t + opt.truncate - 2, t + opt.truncate - 1], x, color=data_color, linestyle='-', linewidth=1.5) plt.plot([t + opt.truncate - 1, t + opt.truncate], [yLastPred, O], color=learning_color, linestyle='-') else: transform_x_temp = np.zeros((2, data.size(1))) transform_x_temp[:, 0] = np.reshape( x[0, -2:, opt.showNum, 0].data.numpy().flatten(), (2, 1)).flatten() x = scaler.inverse_transform(transform_x_temp)[:, [0]] transform_O_temp = np.zeros((1, data.size(1))) transform_O_temp[:, 0] = np.reshape( O[0, -1, opt.showNum, 0].data.numpy().flatten(), (1, 1)).flatten() O = scaler.inverse_transform(transform_O_temp)[:, [0]] plt.plot([t + opt.truncate - 2, t + opt.truncate - 1], x, color=data_color, linestyle='-', linewidth=1.5) plt.plotkind([t + opt.truncate - 1, t + opt.truncate], [yLastPred, O], color=learning_color, linestyle='-') plt.savefig( f'result/experiment/grnn{opt.grnnID}-{opt.finterval}int-{opt.taskID}tid-{opt.alpha}a-{opt.truncate}T-{opt.dimHidden}D-{opt.nIter}i-{opt.lr}lr-{opt.manualSeed}ms-{opt.batchSize}b-{opt.showNum}sn.jpg' ) # updates the graph at some interval plt.draw() plt.pause(0.7) yLastPred = O[-1] log.saveResult(t) # save trained model as pt file torch.save( { 'epoch': opt.nIter, 'model_state_dict': net.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'loss': criterion }, f'result/experiment/grnn{opt.grnnID}-{opt.finterval}int-{opt.taskID}tid-{opt.alpha}a-{opt.truncate}T-{opt.dimHidden}D-{opt.nIter}i-{opt.lr}lr-{opt.manualSeed}ms-{opt.batchSize}b-{opt.showNum}sn.pt' ) if opt.showNum != None: plt.savefig( f'result/experiment/grnn{opt.grnnID}-{opt.finterval}int-{opt.interval}int-{opt.taskID}tid-{opt.alpha}a-{opt.truncate}T-{opt.dimHidden}D-{opt.nIter}i-{opt.lr}lr-{opt.manualSeed}ms-{opt.batchSize}b-{opt.showNum}sn.jpg' ) # plt.ioff() # interactive mode off plt.show() # terminate app exit(1)
def main(config, home_path): # load model if config.model == 'c3d': model, params = VioNet_C3D(config, home_path) elif config.model == 'convlstm': model, params = VioNet_ConvLSTM(config) elif config.model == 'densenet': model, params = VioNet_densenet(config, home_path) elif config.model == 'densenet_lean': model, params = VioNet_densenet_lean(config, home_path) elif config.model == 'resnet50': model, params = VioNet_Resnet(config, home_path) elif config.model == 'densenet2D': model, params = VioNet_Densenet2D(config) elif config.model == 'i3d': model, params = VioNet_I3D(config) elif config.model == 's3d': model, params = VioNet_S3D(config) else: model, params = VioNet_densenet_lean(config, home_path) # dataset dataset = config.dataset # sample_size = config.sample_size stride = config.stride sample_duration = config.sample_duration # cross validation phase cv = config.num_cv input_mode = config.input_type sample_size, norm = build_transforms_parameters(model_type=config.model) # train set crop_method = GroupRandomScaleCenterCrop(size=sample_size) # if input_mode == 'rgb': # norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) # elif input_mode == 'dynamic-images': # # norm = Normalize([0.49778724, 0.49780366, 0.49776983], [0.09050678, 0.09017131, 0.0898702 ]) # norm = Normalize([38.756858/255, 3.88248729/255, 40.02898126/255], [110.6366688/255, 103.16065604/255, 96.29023126/255]) # else: # norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) train_temporal_transform = build_temporal_transformation( config, config.train_temporal_transform) spatial_transform = Compose( [crop_method, GroupRandomHorizontalFlip(), ToTensor(), norm]) target_transform = Label() train_batch = config.train_batch if dataset == RWF_DATASET: # train_data = VioDB(g_path + '/VioDB/{}_jpg/frames/'.format(dataset), # g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv), 'training', # spatial_transform, temporal_transform, target_transform, dataset, # tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path)) train_data = VioDB( os.path.join(home_path, RWF_DATASET.upper(), 'frames/'), os.path.join(home_path, VIO_DB_DATASETS, "rwf-2000_jpg1.json"), 'training', spatial_transform, train_temporal_transform, target_transform, dataset, tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path), input_type=config.input_type) else: train_data = VioDB( os.path.join(home_path, VIO_DB_DATASETS, dataset + '_jpg'), #g_path + '/VioDB/{}_jpg/'.format(dataset), os.path.join(home_path, VIO_DB_DATASETS, '{}_jpg{}.json'.format( dataset, cv)), #g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv), 'training', spatial_transform, train_temporal_transform, target_transform, dataset, tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path), input_type=config.input_type) train_loader = DataLoader(train_data, batch_size=train_batch, shuffle=True, num_workers=0, pin_memory=True) # val set crop_method = GroupScaleCenterCrop(size=sample_size) # if input_mode == 'rgb': # norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) # elif input_mode == 'dynamic-images': # norm = Normalize([0.49778724, 0.49780366, 0.49776983], [0.09050678, 0.09017131, 0.0898702 ]) val_temporal_transform = build_temporal_transformation( config, config.val_temporal_transform) spatial_transform = Compose([crop_method, ToTensor(), norm]) target_transform = Label() val_batch = config.val_batch if dataset == RWF_DATASET: # val_data = VioDB(g_path + '/VioDB/{}_jpg/frames/'.format(dataset), # g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv), 'validation', # spatial_transform, temporal_transform, target_transform, dataset, # tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path)) val_data = VioDB( os.path.join(home_path, RWF_DATASET.upper(), 'frames/'), os.path.join(home_path, VIO_DB_DATASETS, "rwf-2000_jpg1.json"), 'validation', spatial_transform, val_temporal_transform, target_transform, dataset, tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path), input_type=config.input_type) else: val_data = VioDB( os.path.join(home_path, VIO_DB_DATASETS, dataset + '_jpg'), #g_path + '/VioDB/{}_jpg/'.format(dataset), os.path.join(home_path, VIO_DB_DATASETS, '{}_jpg{}.json'.format( dataset, cv)), #g_path + '/VioDB/{}_jpg{}.json'.format(dataset, cv), 'validation', spatial_transform, val_temporal_transform, target_transform, dataset, tmp_annotation_path=os.path.join(g_path, config.temp_annotation_path), input_type=config.input_type) val_loader = DataLoader(val_data, batch_size=val_batch, shuffle=False, num_workers=4, pin_memory=True) template = '{}_fps{}_{}_split({})_input({})_TmpTransform({})_Info({})'.format( config.model, sample_duration, dataset, cv, input_mode, config.train_temporal_transform, config.additional_info) log_path = os.path.join(home_path, PATH_LOG, template) # chk_path = os.path.join(PATH_CHECKPOINT, template) tsb_path = os.path.join(home_path, PATH_TENSORBOARD, template) for pth in [log_path, tsb_path]: if not os.path.exists(pth): os.mkdir(pth) print('tensorboard dir:', tsb_path) writer = SummaryWriter(tsb_path) # log batch_log = Log(log_path + '/batch_log.csv', ['epoch', 'batch', 'iter', 'loss', 'acc', 'lr']) epoch_log = Log(log_path + '/epoch_log.csv', ['epoch', 'loss', 'acc', 'lr']) val_log = Log(log_path + '/val_log.csv', ['epoch', 'loss', 'acc']) train_val_log = Log( log_path + '/train_val_LOG.csv', ['epoch', 'train_loss', 'train_acc', 'lr', 'val_loss', 'val_acc']) # prepare criterion = nn.CrossEntropyLoss().to(device) learning_rate = config.learning_rate momentum = config.momentum weight_decay = config.weight_decay optimizer = torch.optim.SGD(params=params, lr=learning_rate, momentum=momentum, weight_decay=weight_decay) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, verbose=True, factor=config.factor, min_lr=config.min_lr) acc_baseline = config.acc_baseline loss_baseline = 1 for i in range(config.num_epoch): train_loss, train_acc, lr = train(i, train_loader, model, criterion, optimizer, device, batch_log, epoch_log) val_loss, val_acc = val(i, val_loader, model, criterion, device, val_log) epoch = i + 1 train_val_log.log({ 'epoch': epoch, 'train_loss': train_loss, 'train_acc': train_acc, 'lr': lr, 'val_loss': val_loss, 'val_acc': val_acc }) writer.add_scalar('training loss', train_loss, epoch) writer.add_scalar('training accuracy', train_acc, epoch) writer.add_scalar('validation loss', val_loss, epoch) writer.add_scalar('validation accuracy', val_acc, epoch) scheduler.step(val_loss) if val_acc > acc_baseline or (val_acc >= acc_baseline and val_loss < loss_baseline): torch.save( model.state_dict(), os.path.join( home_path, PATH_CHECKPOINT, '{}_fps{}_{}{}_{}_{:.4f}_{:.6f}.pth'.format( config.model, sample_duration, dataset, cv, epoch, val_acc, val_loss))) acc_baseline = val_acc loss_baseline = val_loss