def __init__(self,
wind_size=52,
pred_step=1,
data_type='us',
split_param=[0.6, 0.2, 0.2],
seed=3,
gcn_layer_num=2,
dropout=0.4):
self.setup_seed(seed)
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
print('VGCN')
self.dataset = GlobalFlu(wind_size=wind_size,
pred_step=pred_step,
data_type=data_type,
split_param=split_param)
self.dataset.to_tensor()
self.dataset.to_device(self.device)
self.epochs = 200
self.count = 0
self.loss_type = 'mse'
self.dropout = dropout
self.gcn_layer_num = gcn_layer_num
self.pred_nums = None
self.min_loss = 1e10
self.batch_size = 30
self.build_model()
def __init__(self,
wind_size=52,
pred_step=1,
layer_num=2,
data_type='us',
split_param=[0.6, 0.2, 0.2],
seed=3,
mlp_layer_num=2,
gcn_layer_num=2,
alpha=0):
self.setup_seed(seed)
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
print('VGCN')
self.dataset = GlobalFlu(wind_size=wind_size,
pred_step=pred_step,
data_type=data_type,
split_param=split_param)
self.dataset.to_tensor()
self.dataset.to_device(self.device)
self.adj = generate_rvgsn_adj(self.dataset.node_size).to(self.device)
self.epochs = 200
self.count = 0
self.loss_type = 'mse'
self.alpha = alpha
self.mlp_layer_num = mlp_layer_num
self.gcn_layer_num = gcn_layer_num
self.mid_channels = 256
self.pred_nums = None
self.min_loss = 1e10
self.batch_size = 30
self.build_model()
def __init__(self,
wind_size=52,
pred_step=1,
layer_num=2,
data_type='us',
split_param=[0.6, 0.2, 0.2],
seed=3):
self.setup_seed(seed)
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
print('VGIN')
self.dataset = GlobalFlu(wind_size=wind_size,
pred_step=pred_step,
data_type=data_type,
split_param=split_param)
self.dataset.to_tensor()
self.dataset.to_device(self.device)
self.adj = torch.full([self.dataset.node_size, self.dataset.node_size],
1,
dtype=torch.float32).to(self.device)
self.epochs = 200
self.count = 0
self.loss_type = 'mse'
self.alpha = 0.00005
self.layer_num = layer_num
self.pred_nums = None
self.min_loss = 1e10
self.batch_size = 30
self.build_model()
def __init__(self,
wind_size=52,
pred_step=1,
data_type='us',
split_param=[0.6, 0.2, 0.2],
seed=3):
self.setup_seed(seed)
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
print('TCN')
self.dataset = GlobalFlu(wind_size=wind_size,
pred_step=pred_step,
data_type=data_type,
split_param=split_param)
self.dataset.to_tensor()
self.dataset.to_device(self.device)
self.pred_step = pred_step
self.epochs = 200
self.count = 0
self.loss_type = 'mse'
self.alpha = 0.001
self.pred_nums = None
self.min_loss = 1e10
self.batch_size = self.dataset.train_index.shape[0]
# self.batch_size = 30
# print(self.dataset.node_ft_mat.size())
self.build_model()
def __init__(self,
data_type='us',
split_param=[0.6, 0.2, 0.2],
wind_size=12,
pred_step=1):
self.dataset = GlobalFlu(data_type=data_type,
split_param=split_param,
wind_size=wind_size,
pred_step=pred_step)
self.params = {
'booster': 'gbtree',
'n_estimators': 200,
'max_depth': 10, # max_depth [缺省值=6]
'eta': 0.08, # learning_rate
'silent': 1, # 为0打印运行信息；设置为1静默模式，不打印
'nthread': 4, # 运行时占用cpu数
'gamma': 0.0, # min_split_loss]（分裂最小loss）参数的值越大，算法越保守
'min_child_weight': 5, # 决定最小叶子节点样本权重和,缺省值=1,避免过拟合. 值过高，会导致欠拟合
'learning_rate': 0.1,
'num_boost_round': 2000,
'objective': 'reg:squarederror',
'random_state': 7,
}
self.model = None
def __init__(self, wind_size=52, pred_step=1, layer=2, data_type='us', split_param=[0.6, 0.2, 0.2], seed=3):
self.setup_seed(seed)
print('GATFullTrainer wind_size={} pred_step={}, data_type={}'.format(wind_size, pred_step, data_type))
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# self.device = 'cpu'
self.dataset = GlobalFlu(wind_size=wind_size, pred_step=pred_step, data_type=data_type, split_param=split_param)
self.dataset.to_tensor()
self.dataset.to_device(self.device)
self.adj = torch.full([self.dataset.node_size, self.dataset.node_size], 1, dtype=torch.float32).to(self.device)
self.layer_num = layer
self.epochs = 200
self.count = 0
self.loss_type = 'mse'
self.pred_nums = None
self.min_loss = 1e10
self.batch_size = 30
# self.batch_size = self.dataset.train_index.shape[0]
self.build_model()
def __init__(self,
data_type='us',
split_param=[0.6, 0.2, 0.2],
wind_size=12,
pred_step=1):
print(
'LinearRegression wind_size={} pred_step={}, data_type={}'.format(
wind_size, pred_step, data_type))
self.dataset = GlobalFlu(data_type=data_type,
split_param=split_param,
wind_size=wind_size,
pred_step=pred_step)
self.model = LinearRegression()
def __init__(self,
data_type='us',
split_param=[0.6, 0.2, 0.2],
wind_size=12,
pred_step=1):
self.n = 200
print('AdaBoost n = ', self.n)
self.dataset = GlobalFlu(data_type=data_type,
split_param=split_param,
wind_size=wind_size,
pred_step=pred_step)
self.base_estimator = DecisionTreeRegressor(min_impurity_split=5,
min_samples_leaf=1,
splitter='random')
self.model = AdaBoostRegressor(n_estimators=self.n, loss='square')
def __init__(self,
data_type='us',
split_param=[0.6, 0.2, 0.2],
wind_size=12,
pred_step=1):
self.n_neighbors = 4
self.weights = 'uniform'
print('KNN n_neighbors = {}, weights = {}'.format(
self.n_neighbors, self.weights))
self.dataset = GlobalFlu(data_type=data_type,
split_param=split_param,
wind_size=wind_size,
pred_step=pred_step)
self.model = KNeighborsRegressor(n_neighbors=self.n_neighbors,
weights=self.weights)
class VirtualGCNTrainer(object):
def __init__(self,
wind_size=52,
pred_step=1,
layer_num=2,
data_type='us',
split_param=[0.6, 0.2, 0.2],
seed=3,
mlp_layer_num=2,
gcn_layer_num=2,
alpha=0):
self.setup_seed(seed)
self.device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
print('VGCN')
self.dataset = GlobalFlu(wind_size=wind_size,
pred_step=pred_step,
data_type=data_type,
split_param=split_param)
self.dataset.to_tensor()
self.dataset.to_device(self.device)
self.adj = generate_rvgsn_adj(self.dataset.node_size).to(self.device)
self.epochs = 200
self.count = 0
self.loss_type = 'mse'
self.alpha = alpha
self.mlp_layer_num = mlp_layer_num
self.gcn_layer_num = gcn_layer_num
self.mid_channels = 256
self.pred_nums = None
self.min_loss = 1e10
self.batch_size = 30
self.build_model()
def build_model(self):
self.model = Model(node_num=self.dataset.node_size,
in_channels=self.dataset.node_feature_size,
out_channels=self.dataset.label_size,
mid_channels=self.mid_channels,
mlp_layer_num=self.mlp_layer_num,
gcn_layer_num=self.gcn_layer_num,
dropout=0.3,
bias=True).to(self.device)
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-3)
self.best_res = 0
def setup_seed(self, seed):
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True
def train(self):
self.model.train()
train_size = self.dataset.train_index.shape[0]
shuffle_idx = torch.randperm(train_size)
for idx in range(train_size // self.batch_size):
self.optimizer.zero_grad()
right_bound = min((idx + 1) * self.batch_size, train_size + 1)
shuffle_batch_idx = shuffle_idx[idx * self.batch_size:right_bound]
batch_idx = self.dataset.train_index[shuffle_batch_idx]
batch_node_label = self.dataset.label_mat[batch_idx]
out, adj = self.model(self.dataset.ft_mat, self.adj)
out = out[batch_idx]
if self.loss_type == 'mse':
reg_loss = F.mse_loss(out, batch_node_label, reduction='mean')
if self.loss_type == 'mape':
reg_loss = self.mape_loss(out, batch_node_label)
if self.loss_type == 'mae':
reg_loss = self.mae_loss(out, batch_node_label)
loss = reg_loss
loss.backward()
self.optimizer.step()
def test(self):
self.model.eval()
pred, adj = self.model(self.dataset.ft_mat, self.adj)
label = self.dataset.label_mat.to('cpu').detach().numpy()
pred = pred.to('cpu').detach().numpy()
train_mse, train_mae, train_mape = evaluate_regression(
pred[self.dataset.train_index], label[self.dataset.train_index])
valid_mse, valid_mae, valid_mape = evaluate_regression(
pred[self.dataset.valid_index], label[self.dataset.valid_index])
test_mse, test_mae, test_mape = evaluate_regression(
pred[self.dataset.test_index], label[self.dataset.test_index])
return train_mse, valid_mse, test_mse, train_mae, valid_mae, test_mae, \
train_mape, valid_mape, test_mape, pred
def mape_loss(self, pred, label):
errors = torch.abs((pred - label) / label)
errors = errors / label.size()[0]
loss = torch.sum(errors)
return loss
def mae_loss(self, pred, label):
errors = torch.abs(pred - label)
loss = torch.mean(errors)
return loss
def print_best_res(self):
train_mse, valid_mse, test_mse, train_mae, valid_mae, test_mae, \
train_mape, valid_mape, test_mape, epoch = self.best_res
msg_log = 'Epoch: {:03d}, MSE: {:.4f}, Val: {:.4f}, Test: {:.4f}, ' \
'MAE: {:.4f}, Val: {:.4f}, Test: {:.4f}, ' \
'MAPE: {:.4f}, Val: {:.4f}, Test: {:.4f}'.format(
epoch, train_mse, valid_mse, test_mse, train_mae, valid_mae, test_mae, \
train_mape, valid_mape, test_mape)
print(msg_log)
def start(self, display=True):
self.test_acc_list = []
for epoch in range(1, self.epochs):
self.train()
train_mse, valid_mse, test_mse, train_mae, valid_mae, test_mae, \
train_mape, valid_mape, test_mape, pred = self.test()
if valid_mse < self.min_loss:
self.min_loss = valid_mse
self.pred_nums = pred
self.best_res = [train_mse, valid_mse, test_mse, train_mae, valid_mae, test_mae, \
train_mape, valid_mape, test_mape]
self.best_res.append(epoch)
if display:
mse_log = 'Epoch: {:03d}, MES Train: {:.4f}, Val: {:.4f}, Test: {:.4f}'
print(mse_log.format(epoch, train_mse, valid_mse, test_mse))
mae_log = 'Epoch: {:03d}, MAE Train: {:.4f}, Val: {:.4f}, Test: {:.4f}'
print(mae_log.format(epoch, train_mae, valid_mae, test_mae))
mape_log = 'Epoch: {:03d}, MAPE Train: {:.4f}, Val: {:.4f}, Test: {:.4f}'
print(mape_log.format(epoch, train_mape, valid_mape,
test_mape))
self.print_best_res()
train_mse, valid_mse, test_mse, train_mae, valid_mae, test_mae, \
train_mape, valid_mape, test_mape, epoch = self.best_res
return test_mse, test_mae, test_mape
def __init__(self, data_type='us', split_param=[0.6, 0.2, 0.2], wind_size=12, pred_step=1):
print('Random Forest')
self.n = 200
self.dataset = GlobalFlu(data_type=data_type, split_param=split_param, wind_size=wind_size, pred_step=pred_step)
self.model = RandomForestRegressor(n_estimators=self.n, max_depth=None, min_samples_leaf=1)
