def __init__(self, adj_mx, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.) # logging. self._log_dir = self._get_log_dir(kwargs) self._writer = SummaryWriter(self._log_dir + '/runs/') log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) # data set self._data = utils.load_dataset(**self._data_kwargs) self.standard_scaler = self._data['scaler'] self.num_nodes = int(self._model_kwargs.get('num_nodes', 1)) self.input_dim = int(self._model_kwargs.get('input_dim', 1)) self.seq_len = int(self._model_kwargs.get('seq_len')) # for the encoder self.output_dim = int(self._model_kwargs.get('output_dim', 1)) self.use_curriculum_learning = bool( self._model_kwargs.get('use_curriculum_learning', False)) self.horizon = int(self._model_kwargs.get('horizon', 1)) # for the decoder # setup model garnn_model = GARNNModel(adj_mx, self._logger, **self._model_kwargs) self.garnn_model = garnn_model.cuda() if torch.cuda.is_available() else garnn_model self._logger.info("Model created") self._epoch_num = self._train_kwargs.get('epoch', 0) if self._epoch_num > 0: self.load_model()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--checkpoint', required=True, type=str, help='pretrained model') parser.add_argument('--dataset', default='VOT2017', help='dataset test') parser.add_argument('--dataset_root', default=None) parser.add_argument('--cfg', required=True) args = parser.parse_args() with open(args.cfg) as f: tracker_config = yaml.load(f.read()) # prepare model net = models.__dict__[tracker_config['MODEL']](padding_mode='constant') net = load_pretrain(net, args.checkpoint) net = net.eval().cuda() # prepare tracker tracker_config = tracker_config['TRACKER'][args.dataset] tracker = SESiamFCTracker(net, **tracker_config) print('Tracker') print(tracker) # prepare video dataset = load_dataset(args.dataset, root=args.dataset_root) video_keys = list(dataset.keys()).copy() # tracking all videos in benchmark for video in video_keys: track(tracker, dataset[video], dataset_name=args.dataset)
def main(config): logger = config.get_logger('train') graph_pkl_filename = 'data/sensor_graph/adj_mx_unix.pkl' _, _, adj_mat = utils.load_graph_data(graph_pkl_filename) data = utils.load_dataset( dataset_dir='data/METR-LA', batch_size=config["arch"]["args"]["batch_size"], test_batch_size=config["arch"]["args"]["batch_size"]) for k, v in data.items(): if hasattr(v, 'shape'): print((k, v.shape)) train_data_loader = data['train_loader'] val_data_loader = data['val_loader'] num_train_sample = data['x_train'].shape[0] num_val_sample = data['x_val'].shape[0] # get number of iterations per epoch for progress bar num_train_iteration_per_epoch = math.ceil( num_train_sample / config["arch"]["args"]["batch_size"]) num_val_iteration_per_epoch = math.ceil( num_val_sample / config["arch"]["args"]["batch_size"]) # setup data_loader instances # data_loader = config.initialize('data_loader', module_data) # valid_data_loader = data_loader.split_validation() # build model architecture, then print to console adj_arg = {"adj_mat": adj_mat} model = config.initialize('arch', module_arch, **adj_arg) # model = getattr(module_arch, config['arch']['type'])(config['arch']['args'], adj_arg) logger.info(model) # get function handles of loss and metrics loss = config.initialize('loss', module_metric, **{"scaler": data['scaler']}) metrics = [getattr(module_metric, met) for met in config['metrics']] # build optimizer, learning rate scheduler. delete every lines containing lr_scheduler for disabling scheduler trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = config.initialize('optimizer', torch.optim, trainable_params) lr_scheduler = config.initialize('lr_scheduler', torch.optim.lr_scheduler, optimizer) trainer = DCRNNTrainer(model, loss, metrics, optimizer, config=config, data_loader=train_data_loader, valid_data_loader=val_data_loader, lr_scheduler=lr_scheduler, len_epoch=num_train_iteration_per_epoch, val_len_epoch=num_val_iteration_per_epoch) trainer.train()
def __init__(self, data_type, LOAD_INITIAL, adj_mx, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.) # logging. self._log_dir = self._get_log_dir(kwargs) # self._writer = SummaryWriter('runs/' + self._log_dir) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) # data set self._data = utils.load_dataset(**self._data_kwargs) self.standard_scaler = self._data['scaler'] self.num_nodes = int(self._model_kwargs.get('num_nodes', 1)) self.input_dim = int(self._model_kwargs.get('input_dim', 1)) self.seq_len = int( self._model_kwargs.get('seq_len')) # for the encoder self.output_dim = int(self._model_kwargs.get('output_dim', 1)) self.use_curriculum_learning = bool( self._model_kwargs.get('use_curriculum_learning', False)) self.horizon = int(self._model_kwargs.get('horizon', 1)) # for the decoder # setup model # dcrnn_model = DCRNNModel(adj_mx, self._logger, **self._model_kwargs) dcrnn_model = STGCN(self.num_nodes, self.input_dim, self.seq_len, self.horizon) self.dcrnn_model = dcrnn_model.cuda() if torch.cuda.is_available( ) else dcrnn_model self._logger.info("Model created") self._epoch_num = self._train_kwargs.get('epoch', 0) # if self._epoch_num > 0: #事实上self._epoch_num的预设值确实为0 # self.load_model() self.data_type = data_type self.LOAD_INITIAL = LOAD_INITIAL if LOAD_INITIAL: self.load_lfx() self.A_wave = torch.from_numpy(get_normalized_adj(adj_mx)).to(device)
def main(config): logger = config.get_logger('train') graph_pkl_filename = 'data/sensor_graph/top10_graph.pkl' # _, _, adj_mat = utils.load_graph_data(graph_pkl_filename) graphs = utils.load_dynamic_graph(graph_pkl_filename) # (952, 207, 207) data = utils.load_dataset(dataset_dir='data/METR-LA', graphs=graphs, batch_size=config["arch"]["args"]["batch_size"], test_batch_size=config["arch"]["args"]["batch_size"]) for k, v in data.items(): if hasattr(v, 'shape'): print((k, v.shape)) train_data_loader = data['train_loader'] val_data_loader = data['val_loader'] # get number of iterations per epoch for progress bar num_train_iteration_per_epoch = data['train_loader'].num_batch num_val_iteration_per_epoch = data['val_loader'].num_batch # build model architecture, then print to console model = config.initialize('arch', module_arch) logger.info(model) # get function handles of loss and metrics loss = config.initialize('loss', module_metric, **{"scaler": data['scaler']}) metrics = [getattr(module_metric, met) for met in config['metrics']] # build optimizer, learning rate scheduler. delete every lines containing lr_scheduler for disabling scheduler trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = config.initialize('optimizer', torch.optim, trainable_params) lr_scheduler = config.initialize('lr_scheduler', torch.optim.lr_scheduler, optimizer) trainer = DCRNNTrainer(model, loss, metrics, optimizer, config=config, data_loader=train_data_loader, valid_data_loader=val_data_loader, lr_scheduler=lr_scheduler, len_epoch=num_train_iteration_per_epoch, val_len_epoch=num_val_iteration_per_epoch) trainer.train()
def __init__(self, adj_mx, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') # Data preparation self._data = utils.load_dataset(**self._data_kwargs) for k, v in self._data.items(): if hasattr(v, 'shape'): print((k, v.shape)) # Build models. scaler = self._data['scaler'] self._train_model = MPNNModel( is_training=True, scaler=scaler, batch_size=self._data_kwargs['batch_size'], message_size=16, adj_mx=adj_mx, **self._model_kwargs) self._test_model = MPNNModel( is_training=False, scaler=scaler, batch_size=self._data_kwargs['test_batch_size'], message_size=16, adj_mx=adj_mx, **self._model_kwargs) # Learning rate. self._base_lr = 0.01 # Configure optimizer self._optimizer = torch.optim.Adam( lr=1e-2, params=self._train_model.parameters()) # Calculate loss output_dim = self._model_kwargs.get('output_dim') null_val = 0. self._loss_fn = masked_mae_loss(scaler, null_val) self._epoch = 0
def builtin_train(args): # load dataset and model (train_images, train_labels), (test_images, test_labels) = load_dataset(args.data) input_shape = train_images[:args.batch_size, :, :, :].shape output_size = max(train_labels) + 1 model = load_model(input_shape=input_shape, output_size=output_size) # loss, optimizer, metrics, setting model.compile( optimizer=tf.keras.optimizers.Adam(), loss="sparse_categorical_crossentropy", metrics=["accuracy"], ) # model.summary() # set tensorboard configs # logdir = os.path.join(args.logdir, get_current_time()) logdir_name = "log" logdir = os.path.dirname(os.path.abspath(__file__)) logdir = logdir + os.sep + logdir_name tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir) # dataset config (and validation, callback config) fit_params = {} fit_params["batch_size"] = args.batch_size fit_params["epochs"] = args.max_epoch if args.steps_per_epoch: fit_params["steps_per_epoch"] = args.steps_per_epoch fit_params["verbose"] = 1 fit_params["callbacks"] = [tensorboard_callback] fit_params["validation_data"] = (test_images, test_labels) # start train and test gpu_setup() model.fit(train_images, train_labels, **fit_params)
def main(args): cfg = read_cfg_file(args.config_filename) log_dir = _get_log_dir(cfg) log_level = cfg.get('log_level', 'INFO') logger = utils.get_logger(log_dir, __name__, 'info.log', level=log_level) device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') # all edge_index in same dataset is same # edge_index = adjacency_to_edge_index(adj_mx) # alreay added self-loop logger.info(cfg) # batch_size = cfg['data']['batch_size'] # test_batch_size = cfg['data']['test_batch_size'] # edge_index = utils.load_pickle(cfg['data']['edge_index_pkl_filename']) hz = cfg['data'].get('name', 'nothz') == 'hz' adj_mx_list = [] graph_pkl_filename = cfg['data']['graph_pkl_filename'] if not isinstance(graph_pkl_filename, list): graph_pkl_filename = [graph_pkl_filename] src = [] dst = [] for g in graph_pkl_filename: if hz: adj_mx = utils.load_graph_data_hz(g) else: _, _, adj_mx = utils.load_graph_data(g) for i in range(len(adj_mx)): adj_mx[i, i] = 0 adj_mx_list.append(adj_mx) adj_mx = np.stack(adj_mx_list, axis=-1) if cfg['model'].get('norm', False): print('row normalization') adj_mx = adj_mx / (adj_mx.sum(axis=0) + 1e-18) src, dst = adj_mx.sum(axis=-1).nonzero() edge_index = torch.tensor([src, dst], dtype=torch.long, device=device) edge_attr = torch.tensor(adj_mx[adj_mx.sum(axis=-1) != 0], dtype=torch.float, device=device) output_dim = cfg['model']['output_dim'] for i in range(adj_mx.shape[-1]): logger.info(adj_mx[..., i]) # print(adj_mx.shape) (207, 207) if hz: dataset = utils.load_dataset_hz(**cfg['data'], scaler_axis=(0, 1, 2, 3)) else: dataset = utils.load_dataset(**cfg['data']) for k, v in dataset.items(): if hasattr(v, 'shape'): logger.info((k, v.shape)) model = Net(cfg).to(device) model.load_state_dict(torch.load(cfg['model']['save_path']), strict=False) evaluate(model=model, dataset=dataset, dataset_type='test', edge_index=edge_index, edge_attr=edge_attr, device=device, output_dim=output_dim, logger=logger, cfg=cfg, format_result=True)
print(preprocess_sentence(sp_sentence).encode('utf-8')) path_to_file = os.path.join(os.getcwd(), "hin.txt") en_1, hi_1 = create_dataset(path_to_file, None) en_path = "/home/shravan/Downloads/indic_languages_corpus/bilingual/hi-en/train.en" hi_path = "/home/shravan/Downloads/indic_languages_corpus/bilingual/hi-en/train.hi" en_2, hi_2 = create_new_dataset(en_path, hi_path) en = en_1 + en_2 hi = hi_1 + hi_2 # Try experimenting with the size of that dataset num_examples = 80000 input_tensor, target_tensor, inp_lang, targ_lang = load_dataset(path_to_file, num_examples) # Calculate max_length of the target tensors max_length_targ, max_length_inp = max_length(target_tensor), max_length(input_tensor) # Creating training and validation sets using an 80-20 split input_tensor_train, input_tensor_val, target_tensor_train, target_tensor_val = train_test_split(input_tensor, target_tensor, test_size=0.2) # Show length print(len(input_tensor_train), len(target_tensor_train), len(input_tensor_val), len(target_tensor_val)) print ("Input Language; index to word mapping") convert(inp_lang, input_tensor_train[0]) print () print ("Target Language; index to word mapping")
def __init__(self, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') # logging. self._log_dir = self._get_log_dir(kwargs) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) self._writer = tf.summary.FileWriter(self._log_dir) self._logger.info(kwargs) # Data preparation # load data set self._data = utils.load_dataset(**self._data_kwargs) # print(self._data.keys()) # print(len(self._data)) # print(self._data['x_train'].shape) # print(self._data['y_train'].shape) # print(self._data['x_val'].shape) # print(self._data['y_val'].shape) # print(self._data['x_test'].shape) # print(self._data['y_test'].shape) # exit() # (23974, 12, 207, 2) # (23974, 12, 207, 2) # (3425, 12, 207, 2) # (3425, 12, 207, 2) # (6850, 12, 207, 2) # (6850, 12, 207, 2) # import our node2vec data and replace # but how do we comply with the dimensions # we can plant the same into every time step, but what about the same dimension # exit() # I think we just need to attach our node to vector here for k, v in self._data.items(): if hasattr(v, 'shape'): self._logger.info((k, v.shape)) # Build models. scaler = self._data['scaler'] # scaler is the mean and standard deviation pre-computed and stored # used to normalize data and de-normalize data # print(scaler) # exit() with tf.name_scope('Train'): # Batch size is a term used in machine learning and refers to the number of training examples utilised in one iteration. with tf.variable_scope('DCRNN', reuse=False): self._train_model = DCRNNModel( is_training=True, scaler=scaler, batch_size=self._data_kwargs['batch_size'], adj_matrix_file=self._data_kwargs['graph_pkl_filename'], **self._model_kwargs) with tf.name_scope('Test'): with tf.variable_scope('DCRNN', reuse=True): self._test_model = DCRNNModel( is_training=False, scaler=scaler, batch_size=self._data_kwargs['test_batch_size'], adj_matrix_file=self._data_kwargs['graph_pkl_filename'], **self._model_kwargs) # Learning rate. self._lr = tf.get_variable('learning_rate', shape=(), initializer=tf.constant_initializer(0.01), trainable=False) self._new_lr = tf.placeholder(tf.float32, shape=(), name='new_learning_rate') self._lr_update = tf.assign(self._lr, self._new_lr, name='lr_update') # Configure optimizer optimizer_name = self._train_kwargs.get('optimizer', 'adam').lower() epsilon = float(self._train_kwargs.get('epsilon', 1e-3)) optimizer = tf.train.AdamOptimizer(self._lr, epsilon=epsilon) if optimizer_name == 'sgd': optimizer = tf.train.GradientDescentOptimizer(self._lr, ) elif optimizer_name == 'amsgrad': optimizer = AMSGrad(self._lr, epsilon=epsilon) # Calculate loss output_dim = self._model_kwargs.get('output_dim') # preds is a placeholder of outputs, which is a stacked tensor preds = self._train_model.outputs # print(preds.eval()) # exit() # You must feed a value for placeholder tensor labels = self._train_model.labels[..., :output_dim] null_val = 0. self._loss_fn = masked_mae_loss(scaler, null_val) self._train_loss = self._loss_fn(preds=preds, labels=labels) tvars = tf.trainable_variables() grads = tf.gradients(self._train_loss, tvars) max_grad_norm = kwargs['train'].get('max_grad_norm', 1.) grads, _ = tf.clip_by_global_norm(grads, max_grad_norm) global_step = tf.train.get_or_create_global_step() self._train_op = optimizer.apply_gradients(zip(grads, tvars), global_step=global_step, name='train_op') # print(type(self._train_op)) # exit() max_to_keep = self._train_kwargs.get('max_to_keep', 100) self._epoch = 0 self._saver = tf.train.Saver(tf.global_variables(), max_to_keep=max_to_keep) # Log model statistics. total_trainable_parameter = utils.get_total_trainable_parameter_size() self._logger.info('Total number of trainable parameters: {:d}'.format( total_trainable_parameter)) for var in tf.global_variables(): self._logger.debug('{}, {}'.format(var.name, var.get_shape()))
def __init__(self, save_adj_name, temperature, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') self.temperature = float(temperature) self.opt = self._train_kwargs.get('optimizer') self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.) self.ANNEAL_RATE = 0.00003 self.temp_min = 0.1 self.save_adj_name = save_adj_name self.epoch_use_regularization = self._train_kwargs.get('epoch_use_regularization') self.num_sample = self._train_kwargs.get('num_sample') # logging. self._log_dir = self._get_log_dir(kwargs) self._writer = SummaryWriter('runs/' + self._log_dir) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) # data set self._data = utils.load_dataset(**self._data_kwargs) self.standard_scaler = self._data['scaler'] ### Feas if self._data_kwargs['dataset_dir'] == 'data/METR-LA': df = pd.read_hdf('./data/metr-la.h5') elif self._data_kwargs['dataset_dir'] == 'data/PEMS-BAY': df = pd.read_hdf('./data/pems-bay.h5') else: df = pd.read_csv('./data/pmu_normalized.csv', header=None) df = df.transpose() num_samples = df.shape[0] num_train = round(num_samples * 0.7) df = df[:num_train].values scaler = utils.StandardScaler(mean=df.mean(), std=df.std()) train_feas = scaler.transform(df) self._train_feas = torch.Tensor(train_feas).to(device) print(self._train_feas.shape) k = self._train_kwargs.get('knn_k') knn_metric = 'cosine' from sklearn.neighbors import kneighbors_graph g = kneighbors_graph(train_feas.T, k, metric=knn_metric) g = np.array(g.todense(), dtype=np.float32) self.adj_mx = torch.Tensor(g).to(device) self.num_nodes = int(self._model_kwargs.get('num_nodes', 1)) self.input_dim = int(self._model_kwargs.get('input_dim', 1)) self.seq_len = int(self._model_kwargs.get('seq_len')) # for the encoder self.output_dim = int(self._model_kwargs.get('output_dim', 1)) self.use_curriculum_learning = bool( self._model_kwargs.get('use_curriculum_learning', False)) self.horizon = int(self._model_kwargs.get('horizon', 1)) # for the decoder # setup model GTS_model = GTSModel(self.temperature, self._logger, **self._model_kwargs) self.GTS_model = GTS_model.cuda() if torch.cuda.is_available() else GTS_model self._logger.info("Model created") self._epoch_num = self._train_kwargs.get('epoch', 0) if self._epoch_num > 0: self.load_model()
def main(): device = torch.device(args.device) _, _, adj_mx = utils.load_adj(args.adjdata, args.adjtype) supports = [torch.tensor(i).to(device) for i in adj_mx] if args.randomadj: adjinit = None else: adjinit = supports[0] if args.aptonly: supports = None if args.lstm: print('Selected LSTM-FC model') # --device cuda:0 --nhid 256 --weight_decay 0.0005 --learning_rate 0.001 --isolated_sensors False --num_sensors 207 --checkpoint data/metr-la/pretrained/graph_wavenet_repr.pth args.nhid = 256 args.weight_decay = 0.0005 args.learning_rate = 0.001 args.num_sensors = 207 args.isolated_sensors = False model = LSTMNet.from_args(args, device, supports=0, aptinit=0) model.to(device) if args.checkpoint: model.load_checkpoint(torch.load(args.checkpoint)) else: # --device cuda:0 --gcn_bool --addaptadj --checkpoint data/metr-la/pretrained/graph_wavenet_repr.pth print('Selected Graph Wavenet model') model = gwnet(device, args.num_nodes, args.dropout, supports=supports, gcn_bool=args.gcn_bool, addaptadj=args.addaptadj, aptinit=adjinit) model.to(device) model.load_state_dict(torch.load(args.checkpoint)) model.eval() print('model load successfully') print('Evaluating with simulated sensor failure...') ds = utils.load_dataset(args.data, args.batch_size, args.batch_size, args.batch_size) dataloader = ds.data scaler = dataloader['scaler'] category = 'val' loader = dataloader[category + '_loader'] preds, realy = compute_preds(scaler, loader, model, device) print(preds.shape, realy.shape) # Augment for 12 sensors on the map # dis_sensors = [3, 4, 5, 6, 12, 15, 16, 17, 23, 26, 29, 30, 33, 38, 48, 56, 64, 65, 80, 91, 93, 101, 124, 133, 134, # 136, 138, 144, 154, 155, 157, 159, 160, 161, 162, 163, 165, 166, 170, 174, 187, 188, 191, 192, 193, # 195, 196] dis_sensors = range(206) #[189, 200, 18, 35, 50, 21, 121, 189, 126] # Augmentation pattern, disable all sensors individually all_preds = [] for idx, s in tqdm(enumerate(dis_sensors)): augmentation_matrix = np.zeros(207) augmentation_matrix[s] = 1 # Generate augmented datasets augmented_dataloader = loader.augment(augmentation_matrix) # Do inference [3392, 207, 12] aug_preds, _ = compute_preds(scaler, augmented_dataloader, model, device) # relative_err = MAPE(normal) - MAPE(augmented) # mae error per sensor before - error per sensor after err_rel = (realy != 0).astype( np.uint8) * (np.abs(preds - realy) - np.abs(aug_preds - realy)) # Scale relative_err per 'frame' with softmax, then average over time. all_preds.append(err_rel) print(err_rel.shape) pred_mx = np.stack(all_preds) # Aggregate over time pred_mx = np.sum(pred_mx, axis=1) / pred_mx.shape[1] print(pred_mx.shape) if args.lstm: ds.experiment_save(pred_mx, 'results/lstm_preds') else: ds.experiment_save(pred_mx, 'results/graph_wavenet_preds') # Heatmap plot = np.sum(pred_mx[:, dis_sensors, ...], axis=2) for i in range(plot.shape[0]): plot[i, i] = 0.0 sns.heatmap(plot, cmap="RdYlBu") ds.experiment_save_plot(plt, 'viz/hm.pdf')
def __init__(self, adj_mx, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') # logging. self._log_dir = self._get_log_dir(kwargs) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) self._writer = tf.summary.FileWriter(self._log_dir) self._logger.info(kwargs) # Data preparation self._data = utils.load_dataset( **self._data_kwargs) # return 3 DataLoaders and 1 scaler for k, v in self._data.items(): if hasattr(v, 'shape'): self._logger.info((k, v.shape)) # Build models. scaler = self._data['scaler'] with tf.name_scope( 'Train' ): # reuse、variable_scope讲解:https://www.jianshu.com/p/ab0d38725f88 with tf.variable_scope( 'DCRNN', reuse=False): # reuse==False的含义: 该作用域下创建的变量不会重用 self._train_model = DCRNNModel( is_training=True, scaler=scaler, batch_size=self._data_kwargs['batch_size'], adj_mx=adj_mx, **self._model_kwargs) with tf.name_scope('Test'): with tf.variable_scope('DCRNN', reuse=True): # 测试时创建的变量可以重用 self._test_model = DCRNNModel( is_training=False, scaler=scaler, batch_size=self._data_kwargs['test_batch_size'], adj_mx=adj_mx, **self._model_kwargs) # Learning rate. self._lr = tf.get_variable('learning_rate', shape=(), initializer=tf.constant_initializer(0.01), trainable=False) self._new_lr = tf.placeholder(tf.float32, shape=(), name='new_learning_rate') self._lr_update = tf.assign(self._lr, self._new_lr, name='lr_update') # Configure optimizer optimizer_name = self._train_kwargs.get('optimizer', 'adam').lower() # 默认是'adam' epsilon = float(self._train_kwargs.get('epsilon', 1e-3)) optimizer = tf.train.AdamOptimizer(self._lr, epsilon=epsilon) if optimizer_name == 'sgd': optimizer = tf.train.GradientDescentOptimizer(self._lr, ) elif optimizer_name == 'amsgrad': optimizer = AMSGrad(self._lr, epsilon=epsilon) # Calculate loss output_dim = self._model_kwargs.get( 'output_dim') # output_dim在配置文件里写的1,指只预测speed这一个特征 preds = self._train_model.outputs labels = self._train_model.labels[..., :output_dim] null_val = 0. self._loss_fn = masked_mae_loss(scaler, null_val) self._train_loss = self._loss_fn(preds=preds, labels=labels) tvars = tf.trainable_variables() grads = tf.gradients(self._train_loss, tvars) max_grad_norm = kwargs['train'].get('max_grad_norm', 1.) grads, _ = tf.clip_by_global_norm( grads, max_grad_norm ) # 在一次迭代更新中,所有权重的梯度的平方和在一个设定范围以内,这个范围就是clip_gradient. global_step = tf.train.get_or_create_global_step() self._train_op = optimizer.apply_gradients(zip(grads, tvars), global_step=global_step, name='train_op') max_to_keep = self._train_kwargs.get('max_to_keep', 100) self._epoch = 0 self._saver = tf.train.Saver( tf.global_variables(), max_to_keep=max_to_keep) # Saver将保存最近的max_to_keep个模型 # Log model statistics. total_trainable_parameter = utils.get_total_trainable_parameter_size() self._logger.info('Total number of trainable parameters: {:d}'.format( total_trainable_parameter)) for var in tf.global_variables(): self._logger.debug('{}, {}'.format(var.name, var.get_shape()))
def __init__(self): with open('data/dcrnn_la.yaml') as f_la, open( 'data/dcrnn_bay.yaml') as f_bay: config_la = yaml.load(f_la, Loader=yaml.FullLoader) config_bay = yaml.load(f_bay, Loader=yaml.FullLoader) sensor_ids1, sensor_id_to_ind1, adj_mx_la = load_graph_data( config_la['data'].get('graph_pkl_filename')) sensor_ids2, sensor_id_to_ind2, adj_mx_bay = load_graph_data( config_bay['data'].get('graph_pkl_filename')) self._kwargs = config_la self._data_kwargs = config_la.get('data') self._model_kwargs = config_la.get('model') self._data_kwargs2 = config_bay.get('data') self._model_kwargs2 = config_bay.get('model') self._train_kwargs = config_la.get('train') self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.) # logging. self._log_dir = self._get_log_dir(config_la) self._writer = SummaryWriter('runs/' + self._log_dir) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) # data set self._data = utils.load_dataset(**self._data_kwargs) self._data2 = utils.load_dataset(**self._data_kwargs2) self.standard_scaler = self._data['scaler'] self.standard_scaler2 = self._data2['scaler'] self._logger.info('Setting: {}'.format(args.setting)) self._logger.info("Party A trn samples: {}".format( self._data['train_loader'].size)) self._logger.info("Party A vld samples: {}".format( self._data['val_loader'].size)) self._logger.info("Party A tst samples: {}".format( self._data['test_loader'].size)) self._logger.info("Party B trn samples: {}".format( self._data2['train_loader'].size)) self._logger.info("Party B vld samples: {}".format( self._data2['val_loader'].size)) self._logger.info("Party B tst samples: {}".format( self._data2['test_loader'].size)) self.num_nodes = int(self._model_kwargs.get('num_nodes', 1)) self.num_nodes2 = int(self._model_kwargs2.get('num_nodes', 1)) self._logger.info("num_nodes: {}".format(self.num_nodes)) self._logger.info("num_nodes2: {}".format(self.num_nodes2)) self.input_dim = int(self._model_kwargs.get('input_dim', 1)) self.seq_len = int( self._model_kwargs.get('seq_len')) # for the encoder self.output_dim = int(self._model_kwargs.get('output_dim', 1)) self.use_curriculum_learning = bool( self._model_kwargs.get('use_curriculum_learning', False)) self.horizon = int(self._model_kwargs.get('horizon', 1)) # for the decoder # setup model dcrnn_model = DCRNNModel(adj_mx_la, self._logger, **self._model_kwargs) dcrnn_model2 = DCRNNModel(adj_mx_bay, self._logger, **self._model_kwargs2) if torch.cuda.is_available(): # dcrnn_model = nn.DataParallel(dcrnn_model) # dcrnn_model2 = nn.DataParallel(dcrnn_model2) self.dcrnn_model = dcrnn_model.cuda() self.dcrnn_model2 = dcrnn_model2.cuda() else: self.dcrnn_model = dcrnn_model self.dcrnn_model2 = dcrnn_model2 self._logger.info("Models created") self._logger.info('Local epochs:' + str(args.local_epochs)) self._epoch_num = self._train_kwargs.get('epoch', 0) if self._epoch_num > 0: self.load_model(self._epoch_num) # use PySyft for SPDZ if args.setting == 'fedavg' and args.spdz: import syft as sy self._logger.info('Using SPDZ for FedAvg') hook = sy.TorchHook(torch) self.party_workers = [ sy.VirtualWorker(hook, id="party{:d}".format(i)) for i in range(2) ] self.crypto = sy.VirtualWorker(hook, id="crypto") # DP if args.dp: class HiddenPrints: def __enter__(self): self._original_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') def __exit__(self, exc_type, exc_val, exc_tb): sys.stdout.close() sys.stdout = self._original_stdout def find_sigma(eps, batches_per_lot, dataset_size): lotSize = batches_per_lot * args.batch_size # L N = dataset_size delta = min(10**(-5), 1 / N) lotsPerEpoch = N / lotSize q = lotSize / N # Sampling ratio T = args.epochs * lotsPerEpoch # Total number of lots def compute_dp_sgd_wrapper(_sigma): with HiddenPrints(): return compute_dp_sgd_privacy.compute_dp_sgd_privacy( n=N, batch_size=lotSize, noise_multiplier=_sigma, epochs=args.epochs, delta=delta)[0] - args.epsilon sigma = newton(compute_dp_sgd_wrapper, x0=0.5, tol=1e-4) # adjust x0 to avoid error with HiddenPrints(): actual_eps = compute_dp_sgd_privacy.compute_dp_sgd_privacy( n=N, batch_size=lotSize, noise_multiplier=sigma, epochs=args.epochs, delta=delta)[0] # print('Batches_per_lot={}, q={}, T={}, sigma={}'.format(batches_per_lot, q, T, sigma)) # print('actual epslion = {}'.format(actual_eps)) return sigma self._logger.info('Epsilon: ' + str(args.epsilon)) self._logger.info('Lotsize_scaler: ' + str(args.lotsize_scaler)) lotsizes = [ N**.5 * args.lotsize_scaler for N in [ self._data['train_loader'].size, self._data2['train_loader'].size ] ] batches_per_lot_list = list( map(lambda lotsize: max(round(lotsize / args.batch_size), 1), lotsizes)) batches_per_lot_list = [ min(bpl, loader_len) for bpl, loader_len in zip(batches_per_lot_list, [ self._data['train_loader'].num_batch, self._data2['train_loader'].num_batch ]) ] self._logger.info('Batches per lot: ' + str(batches_per_lot_list)) sigma_list = [ find_sigma(args.epsilon, bpl, N) for bpl, N in zip(batches_per_lot_list, [ self._data['train_loader'].size, self._data2['train_loader'].size ]) ] self._logger.info('Sigma: ' + str(sigma_list)) for mod, bpl, sig in zip([self.dcrnn_model, self.dcrnn_model2], batches_per_lot_list, sigma_list): mod.batch_per_lot = bpl mod.sigma = sig self.dcrnn_model.batch_per_lot = batches_per_lot_list[0] self.dcrnn_model.sigma = sigma_list[0] self.dcrnn_model2.batch_per_lot = batches_per_lot_list[1] self.dcrnn_model2.sigma = sigma_list[1] self._lastNoiseShape = None self._noiseToAdd = None
def main(args): cfg = read_cfg_file(args.config_filename) log_dir = _get_log_dir(cfg) log_level = cfg.get('log_level', 'INFO') logger = utils.get_logger(log_dir, __name__, 'info.log', level=log_level) device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') # all edge_index in same dataset is same # edge_index = adjacency_to_edge_index(adj_mx) # alreay added self-loop logger.info(cfg) batch_size = cfg['data']['batch_size'] test_batch_size = cfg['data']['test_batch_size'] # edge_index = utils.load_pickle(cfg['data']['edge_index_pkl_filename']) hz = cfg['data'].get('name', 'nothz') == 'hz' adj_mx_list = [] graph_pkl_filename = cfg['data']['graph_pkl_filename'] if not isinstance(graph_pkl_filename, list): graph_pkl_filename = [graph_pkl_filename] src = [] dst = [] for g in graph_pkl_filename: if hz: adj_mx = utils.load_graph_data_hz(g) else: _, _, adj_mx = utils.load_graph_data(g) for i in range(len(adj_mx)): adj_mx[i, i] = 0 adj_mx_list.append(adj_mx) adj_mx = np.stack(adj_mx_list, axis=-1) if cfg['model'].get('norm', False): print('row normalization') adj_mx = adj_mx / (adj_mx.sum(axis=0) + 1e-18) src, dst = adj_mx.sum(axis=-1).nonzero() edge_index = torch.tensor([src, dst], dtype=torch.long, device=device) edge_attr = torch.tensor(adj_mx[adj_mx.sum(axis=-1) != 0], dtype=torch.float, device=device) output_dim = cfg['model']['output_dim'] for i in range(adj_mx.shape[-1]): logger.info(adj_mx[..., i]) # print(adj_mx.shape) (207, 207) if hz: dataset = utils.load_dataset_hz(**cfg['data'], scaler_axis=(0, 1, 2, 3)) else: dataset = utils.load_dataset(**cfg['data']) for k, v in dataset.items(): if hasattr(v, 'shape'): logger.info((k, v.shape)) scaler = dataset['scaler'] scaler_torch = utils.StandardScaler_Torch(scaler.mean, scaler.std, device=device) logger.info('scaler.mean:{}, scaler.std:{}'.format(scaler.mean, scaler.std)) model = Net(cfg).to(device) # model.apply(init_weights) criterion = nn.L1Loss(reduction='mean') optimizer = optim.Adam(model.parameters(), lr=cfg['train']['base_lr'], eps=cfg['train']['epsilon']) scheduler = StepLR2(optimizer=optimizer, milestones=cfg['train']['steps'], gamma=cfg['train']['lr_decay_ratio'], min_lr=cfg['train']['min_learning_rate']) max_grad_norm = cfg['train']['max_grad_norm'] train_patience = cfg['train']['patience'] val_steady_count = 0 last_val_mae = 1e6 horizon = cfg['model']['horizon'] for epoch in range(cfg['train']['epochs']): total_loss = 0 i = 0 begin_time = time.perf_counter() train_iterator = dataset['train_loader'].get_iterator() model.train() for _, (x, y, xtime, ytime) in enumerate(train_iterator): optimizer.zero_grad() y = y[:, :horizon, :, :output_dim] sequences, y = collate_wrapper(x=x, y=y, edge_index=edge_index, edge_attr=edge_attr, device=device) y_pred = model(sequences) y_pred = scaler_torch.inverse_transform(y_pred) y = scaler_torch.inverse_transform(y) loss = criterion(y_pred, y) loss.backward() clip_grad_norm_(model.parameters(), max_grad_norm) optimizer.step() total_loss += loss.item() i += 1 val_result = evaluate(model=model, dataset=dataset, dataset_type='val', edge_index=edge_index, edge_attr=edge_attr, device=device, output_dim=output_dim, logger=logger, detail=False, cfg=cfg) val_mae, _, _ = val_result time_elapsed = time.perf_counter() - begin_time logger.info(('Epoch:{}, train_mae:{:.2f}, val_mae:{},' 'r_loss={:.2f},lr={}, time_elapsed:{}').format( epoch, total_loss / i, val_mae, 0, str(scheduler.get_lr()), time_elapsed)) if last_val_mae > val_mae: logger.info('val_mae decreased from {:.2f} to {:.2f}'.format( last_val_mae, val_mae)) last_val_mae = val_mae val_steady_count = 0 else: val_steady_count += 1 # after per epoch, run evaluation on test dataset. if (epoch + 1) % cfg['train']['test_every_n_epochs'] == 0: evaluate(model=model, dataset=dataset, dataset_type='test', edge_index=edge_index, edge_attr=edge_attr, device=device, output_dim=output_dim, logger=logger, cfg=cfg) if (epoch + 1) % cfg['train']['save_every_n_epochs'] == 0: save_dir = log_dir if not os.path.exists(save_dir): os.mkdir(save_dir) config_path = os.path.join(save_dir, 'config-{}.yaml'.format(epoch + 1)) epoch_path = os.path.join(save_dir, 'epoch-{}.pt'.format(epoch + 1)) torch.save(model.state_dict(), epoch_path) with open(config_path, 'w') as f: from copy import deepcopy save_cfg = deepcopy(cfg) save_cfg['model']['save_path'] = epoch_path f.write(yaml.dump(save_cfg, Dumper=Dumper)) if train_patience <= val_steady_count: logger.info('early stopping.') break scheduler.step()
def __init__(self, data_type, LOAD_INITIAL, adj_mx, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') self.max_grad_norm = self._train_kwargs.get('max_grad_norm', 1.) # logging. self._log_dir = self._get_log_dir(kwargs) # self._writer = SummaryWriter('runs/' + self._log_dir) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) # data set self._data = utils.load_dataset(**self._data_kwargs) self.standard_scaler = self._data['scaler'] self.num_nodes = int(self._model_kwargs.get('num_nodes', 1)) self.input_dim = int(self._model_kwargs.get('input_dim', 1)) self.seq_len = int( self._model_kwargs.get('seq_len')) # for the encoder self.output_dim = int(self._model_kwargs.get('output_dim', 1)) self.use_curriculum_learning = bool( self._model_kwargs.get('use_curriculum_learning', False)) self.horizon = int(self._model_kwargs.get('horizon', 1)) # for the decoder # features, (dist, e_in_out, e_in_out) = np.load('./data/feat_stmetanet.npy', allow_pickle=True) # features, (dist, e_in_out, e_in_out) = np.load('./data/feat_stmetanet_metrla.npy', allow_pickle=True) features, (dist, e_in_out, e_in_out) = np.load('./data/feat_stmetanet_BJ500.npy', allow_pickle=True) # features, (dist, e_in_out, e_in_out) = np.load('/home/lifuxian/BikeNYC/feat_stmetanet.npy', allow_pickle=True) self.features = torch.from_numpy(features).to(device) # setup model # dcrnn_model = DCRNNModel(adj_mx, self._logger, **self._model_kwargs) dcrnn_model = STMetaNet( graph=(dist, e_in_out, e_in_out), #Tuple[np.ndarray, list, list], n_preds=self.horizon, input_dim=self.input_dim, output_dim=self.output_dim, cl_decay_steps=2000, rnn_types=['NormalGRU', 'MetaGRU'], # rnn_types = ['NormalGRU', 'NormalGRU'], rnn_hiddens=[32, 32], meta_hiddens=[16, 2], # geo_hiddens = [20, 32, 32] # geo_hiddens = [20, 32, 32] #list的首个元素表示features的维度(20维) geo_hiddens=[11, 32, 32] # list的首个元素表示features的维度(11维) ) self.dcrnn_model = dcrnn_model.cuda() if torch.cuda.is_available( ) else dcrnn_model self._logger.info("Model created") self._epoch_num = self._train_kwargs.get('epoch', 0) # if self._epoch_num > 0: #事实上self._epoch_num的预设值确实为0 # self.load_model() self.data_type = data_type self.LOAD_INITIAL = LOAD_INITIAL if LOAD_INITIAL: self.load_lfx()
def __init__(self, is_training=True, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._train_kwargs = kwargs.get('train') self._test_kwargs = kwargs.get('test') self._model_kwargs = kwargs.get('model') self._alg_name = self._kwargs.get('alg') # data args self._dataset = self._data_kwargs.get('dataset') self._test_size = self._data_kwargs.get('test_size') self._valid_size = self._data_kwargs.get('valid_size') self._test_batch_size = self._data_kwargs.get('test_batch_size') # logging. self._log_dir = self._get_log_dir(kwargs) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, 'info.log', level=log_level) self._logger.info(kwargs) # Model's Args self._rnn_units = self._model_kwargs.get('rnn_units') self._seq_len = self._model_kwargs.get('seq_len') self._horizon = self._model_kwargs.get('horizon') self._input_dim = self._model_kwargs.get('input_dim') self._output_dim = self._model_kwargs.get('output_dim') self._rnn_layers = self._model_kwargs.get('rnn_layers') self._verified_percentage = self._model_kwargs.get('verified_percentage') # Train's args self._drop_out = self._train_kwargs.get('dropout') self._epochs = self._train_kwargs.get('epochs') self._batch_size = self._data_kwargs.get('batch_size') self._optimizer = self._train_kwargs.get('optimizer') # Test's args self._run_times = self._test_kwargs.get('run_times') # Load data self._data = utils.load_dataset(seq_len=self._seq_len, horizon=self._horizon, input_dim=self._input_dim, output_dim=self._output_dim, dataset=self._dataset, test_size=self._test_size, valid_size=self._valid_size, verified_percentage=self._verified_percentage) self.callbacks_list = [] self._checkpoints = ModelCheckpoint( self._log_dir + "best_model.hdf5", monitor='val_loss', verbose=1, save_best_only=True, mode='auto', period=1) self._earlystop = EarlyStopping(monitor='val_loss', patience=self._train_kwargs.get('patience'), verbose=1, mode='auto') self._time_callback = TimeHistory() self.callbacks_list.append(self._checkpoints) self.callbacks_list.append(self._earlystop) self.callbacks_list.append(self._time_callback) self.model = self._model_construction(is_training=is_training)
def __init__(self, args, adj_mx, **kwargs): self._kwargs = kwargs self._data_kwargs = kwargs.get('data') self._model_kwargs = kwargs.get('model') self._train_kwargs = kwargs.get('train') # logging. self._log_dir = self._get_log_dir(kwargs) log_level = self._kwargs.get('log_level', 'INFO') self._logger = utils.get_logger(self._log_dir, __name__, kwargs['name'] + '_info.log', level=log_level) self._writer = tf.summary.FileWriter(self._log_dir) self._logger.info(kwargs) # Data preparation if self._data_kwargs.get('data_type') == 'npz': self._data = utils.load_dataset(**self._data_kwargs) elif self._data_kwargs.get('data_type') == 'csv': self._data = utils.load_dataset_from_csv(**self._data_kwargs) for k, v in self._data.items(): if hasattr(v, 'shape'): self._logger.info((k, v.shape)) # Build models. scaler = self._data['scaler'] with tf.name_scope('Train'): with tf.variable_scope('DCRNN', reuse=False): self._train_model = DCRNNModel( args=args, is_training=True, scaler=scaler, batch_size=self._data_kwargs['batch_size'], adj_mx=adj_mx, **self._model_kwargs) with tf.name_scope('Test'): with tf.variable_scope('DCRNN', reuse=True): self._test_model = DCRNNModel( args=args, is_training=False, scaler=scaler, batch_size=self._data_kwargs['test_batch_size'], adj_mx=adj_mx, **self._model_kwargs) # Learning rate. self._lr = tf.get_variable('learning_rate', shape=(), initializer=tf.constant_initializer(0.01), trainable=False) self._new_lr = tf.placeholder(tf.float32, shape=(), name='new_learning_rate') self._lr_update = tf.assign(self._lr, self._new_lr, name='lr_update') # Configure optimizer optimizer_name = self._train_kwargs.get('optimizer', 'adam').lower() epsilon = float(self._train_kwargs.get('epsilon', 1e-3)) optimizer = tf.train.AdamOptimizer(self._lr, epsilon=epsilon) if optimizer_name == 'sgd': optimizer = tf.train.GradientDescentOptimizer(self._lr, ) elif optimizer_name == 'amsgrad': optimizer = AMSGrad(self._lr, epsilon=epsilon) # Calculate loss output_dim = self._model_kwargs.get('output_dim') preds = self._train_model.outputs labels = self._train_model.labels[..., :output_dim] null_val = 0. self._loss_fn = masked_mae_loss(scaler, null_val) self._mape_fn = masked_mape(scaler, null_val) self._rmse_fn = masked_rmse_loss(scaler, null_val) self._train_loss = self._loss_fn(preds=preds, labels=labels) tvars = tf.trainable_variables() grads = tf.gradients(self._train_loss, tvars) max_grad_norm = kwargs['train'].get('max_grad_norm', 1.) grads, _ = tf.clip_by_global_norm(grads, max_grad_norm) global_step = tf.train.get_or_create_global_step() self._train_op = optimizer.apply_gradients(zip(grads, tvars), global_step=global_step, name='train_op') max_to_keep = self._train_kwargs.get('max_to_keep', 100) self._epoch = 0 self._saver = tf.train.Saver(tf.global_variables(), max_to_keep=max_to_keep) # Log model statistics. total_trainable_parameter = utils.get_total_trainable_parameter_size() self._logger.info('Total number of trainable parameters: {:d}'.format( total_trainable_parameter)) for var in tf.global_variables(): self._logger.debug('{}, {}'.format(var.name, var.get_shape()))
def main(config): logger = config.get_logger('test') graph_pkl_filename = 'data/sensor_graph/adj_mx_unix.pkl' _, _, adj_mat = utils.load_graph_data(graph_pkl_filename) data = utils.load_dataset(dataset_dir='data/METR-LA', batch_size=config["arch"]["args"]["batch_size"], test_batch_size=config["arch"]["args"]["batch_size"]) test_data_loader = data['test_loader'] scaler = data['scaler'] num_test_iteration= math.ceil(data['x_test'].shape[0] / config["arch"]["args"]["batch_size"]) # build model architecture adj_arg = {"adj_mat": adj_mat} model = config.initialize('arch', module_arch, **adj_arg) logger.info(model) logger.info('Loading checkpoint: {} ...'.format(config.resume)) checkpoint = torch.load(config.resume) state_dict = checkpoint['state_dict'] if config['n_gpu'] > 1: model = torch.nn.DataParallel(model) model.load_state_dict(state_dict) # prepare model for testing device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = model.to(device) model.eval() total_loss = 0.0 y_preds = torch.FloatTensor([]) y_truths = data['y_test'] # (6850, 12, 207, 2) y_truths = scaler.inverse_transform(y_truths) predictions = [] groundtruth = list() with torch.no_grad(): for i, (x, y) in tqdm(enumerate(test_data_loader.get_iterator()), total=num_test_iteration): x = torch.FloatTensor(x).cuda() y = torch.FloatTensor(y).cuda() outputs = model(x, y, 0) # (seq_length+1, batch_size, num_nodes*output_dim) (13, 50, 207*1) y_preds = torch.cat([y_preds, outputs], dim=1) y_preds = torch.transpose(y_preds, 0, 1) y_preds = y_preds.detach().numpy() # cast to numpy array print("--------test results--------") for horizon_i in range(y_truths.shape[1]): y_truth = np.squeeze(y_truths[:, horizon_i, :, 0]) # (6850, 207) y_pred = scaler.inverse_transform(y_preds[:, horizon_i, :]) # (6850, 207) predictions.append(y_pred) groundtruth.append(y_truth) mae = metrics.masked_mae_np(y_pred, y_truth, null_val=0) mape = metrics.masked_mape_np(y_pred, y_truth, null_val=0) rmse = metrics.masked_rmse_np(y_pred, y_truth, null_val=0) print( "Horizon {:02d}, MAE: {:.2f}, MAPE: {:.4f}, RMSE: {:.2f}".format( horizon_i + 1, mae, mape, rmse ) ) log = {"Horizon": horizon_i+1, "MAE": mae, "MAPE": mape, "RMSE": rmse} logger.info(log) outputs = { 'predictions': predictions, 'groundtruth': groundtruth } # serialize test data np.savez_compressed('saved/results/dcrnn_predictions.npz', **outputs) print('Predictions saved as {}.'.format('saved/results/dcrnn_predictions.npz'))