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'))
