def main():
X_Train, X_Test, y_Train, y_Test, test_dates = load_data()
X_Train = X_Train.values
X_Test = X_Test.values
y_Train = y_Train.values
y_Test = y_Test.values
# Construct tensors
X_train_ = torch.from_numpy(X_Train).float().cuda()
Y_train_ = torch.from_numpy(y_Train).float().cuda()
X_test_ = torch.from_numpy(X_Test).float().cuda()
Y_test_ = torch.from_numpy(y_Test).float().cuda()
variables_rmse = {'X_train_': X_train_, 'Y_train_': Y_train_, 'X_test_': X_test_, 'Y_test_': Y_test_}
model_rmse = model_classes.Net(X_Train, y_Train, [200, 200])
model_rmse.cuda()
model_rmse, iteration_list, train_loss_arr, test_loss_arr = nets.run_rmse_net(model_rmse, variables_rmse, X_Train, y_Train)
train_rmse, test_rmse, pred_train, pred_test = nets.eval_net(model_rmse, variables_rmse)
pred_values = pred_test.cpu().detach().numpy()
pred_values = pd.DataFrame(pred_values, index = test_dates)
datetime_fossil_demand(pred_values)
def run_weighted_rmse_net_helper(X_train, Y_train, X_test, Y_test, params, weights, i):
X_train_ = torch.tensor(X_train[:,:-1], dtype=torch.float, device=DEVICE)
Y_train_ = torch.tensor(Y_train, dtype=torch.float, device=DEVICE)
X_test_ = torch.tensor(X_test[:,:-1], dtype=torch.float, device=DEVICE)
Y_test_ = torch.tensor(Y_test, dtype=torch.float, device=DEVICE)
model = model_classes.Net(X_train[:,:-1], Y_train, [200, 200])
if USE_GPU:
model = model.cuda()
opt = optim.Adam(model.parameters(), lr=1e-3)
solver = model_classes.SolveScheduling(params)
for j in range(100):
model.train()
batch_train_weightrmse(100, i*100 + j, X_train_.data, Y_train_.data, model, opt, weights.data)
# Rebalance weights
model.eval()
mu_pred_train, sig_pred_train = model(X_train_)
Y_sched_train = solver(mu_pred_train.double(), sig_pred_train.double())
weights2 = task_loss_no_mean(
Y_sched_train.float(), Y_train_, params)
if USE_GPU:
weights2 = weights2.cuda()
model.set_sig(X_train_, Y_train_)
return model, weights2
def run_task_net(model, variables, params, X_train, Y_train, args):
opt = optim.Adam(model.parameters(), lr=1e-4)
solver = model_classes.SolveScheduling(params)
# For early stopping
prev_min = 0
hold_costs = []
model_states = []
num_stop_rounds = 20
for i in range(1000):
opt.zero_grad()
model.train()
mu_pred_train, sig_pred_train = model(variables['X_train_'])
Y_sched_train = solver(mu_pred_train.double(), sig_pred_train.double())
train_loss = task_loss(
Y_sched_train.float(),variables['Y_train_'], params)
train_loss.sum().backward()
model.eval()
mu_pred_test, sig_pred_test = model(variables['X_test_'])
Y_sched_test = solver(mu_pred_test.double(), sig_pred_test.double())
test_loss = task_loss(
Y_sched_test.float(), variables['Y_test_'], params)
mu_pred_hold, sig_pred_hold = model(variables['X_hold_'])
Y_sched_hold = solver(mu_pred_hold.double(), sig_pred_hold.double())
hold_loss = task_loss(
Y_sched_hold.float(), variables['Y_hold_'], params)
opt.step()
print(i, train_loss.sum().data[0], test_loss.sum().data[0],
hold_loss.sum().data[0])
with open(os.path.join(args.save, 'task_losses.txt'), 'a') as f:
f.write('{} {} {} {}\n'.format(i, train_loss.sum().data[0],
test_loss.sum().data[0], hold_loss.sum().data[0]))
# Early stopping
hold_costs.append(hold_loss.sum().data[0])
model_states.append(model.state_dict().copy())
if i > 0 and i % num_stop_rounds == 0:
idx = hold_costs.index(min(hold_costs))
if prev_min == hold_costs[idx]:
model.eval()
best_model = model_classes.Net(
X_train[:,:-1], Y_train, [200, 200])
best_model.load_state_dict(model_states[idx])
best_model.cuda()
return best_model
else:
prev_min = hold_costs[idx]
hold_costs = [prev_min]
model_states = [model_states[idx]]
return model
def main():
parser = argparse.ArgumentParser(
description='Run storage task net experiments.')
parser.add_argument('--save',
type=str,
metavar='save-folder',
help='prefix to add to save path')
parser.add_argument('--nRuns',
type=int,
default=10,
metavar='runs',
help='number of runs')
parser.add_argument('--paramSet',
type=int,
choices=range(4),
default=0,
metavar='hyperparams',
help='(lambda, epsilon) in given row of Table 1')
args = parser.parse_args()
save_folder_main = 'params{}'.format(args.paramSet) if args.save is None \
else '{}-params{}'.format(args.save, args.paramSet)
save_folder_main = os.path.join('results', save_folder_main)
setproctitle.setproctitle('storage-{}'.format(args.paramSet))
# Initialize problem parameters
params = init_params(args.paramSet)
bsz = 500
# Train, test split
train_frac = 0.8
input_tensors = get_train_test_split(params, train_frac)
loaders = get_loaders_tt(input_tensors, bsz)
if not os.path.exists(save_folder_main):
os.makedirs(save_folder_main)
for run in range(args.nRuns):
save_folder = os.path.join(save_folder_main, str(run))
if not os.path.exists(save_folder):
os.makedirs(save_folder)
# Randomly construct hold-out set for task net training.
tensors_task = get_train_hold_split(input_tensors, 0.8, save_folder)
loaders_task = get_loaders_tth(tensors_task, bsz)
# Run and eval rmse-minimizing net
model_rmse = model_classes.Net(tensors_task['X_train'],
tensors_task['Y_train'], [200, 200],
params['T'])
if USE_GPU:
model_rmse = model_rmse.cuda()
model_rmse = nets.run_rmse_net(model_rmse, loaders_task, params,
tensors_task)
nets.eval_net('rmse_net', model_rmse, loaders_task, params,
save_folder)
# Run and eval task-minimizing net
model_task = model_classes.Net(tensors_task['X_train'],
tensors_task['Y_train'], [200, 200],
params['T'])
if USE_GPU:
model_task = model_task.cuda()
model_task = nets.run_rmse_net(model_task, loaders_task, params,
tensors_task) # seed with rmse soln
model_task = \
nets.run_task_net(model_task, loaders_task, params, args, tensors_task)
nets.eval_net('task_net', model_task, loaders_task, params,
save_folder)
calc_stats.calc_stats(
map(lambda x: os.path.join(save_folder_main, str(x)),
range(args.nRuns)), save_folder_main)
def run_rmse_net(model, loaders, params, tensors_task):
opt = optim.Adam(model.parameters(), lr=1e-3)
# For early stopping
prev_min = 0
hold_costs = []
model_states = []
num_stop_rounds = 20
for i in range(1000):
# train
model.train()
total_train_loss = 0
m_train = 0
for (batch, (X_train, Y_train)) in enumerate(loaders['train']):
if USE_GPU:
X_train_, Y_train_ = X_train.cuda(), Y_train.cuda()
else:
X_train_, Y_train_ = X_train, Y_train
opt.zero_grad()
train_loss = nn.MSELoss()(model(X_train_), Y_train_)
total_train_loss += train_loss.item() * X_train_.size(0)
m_train += X_train_.size(0)
train_loss.backward()
opt.step()
# evaluate on test
model.eval()
total_test_loss = 0
m_test = 0
for (batch, (X_test, Y_test)) in enumerate(loaders['test']):
if USE_GPU:
X_test_, Y_test_ = X_test.cuda(), Y_test.cuda()
else:
X_test_, Y_test_ = X_test, Y_test
test_loss = nn.MSELoss()(model(X_test_), Y_test_)
total_test_loss += test_loss.item() * X_test_.size(0)
m_test += X_test_.size(0)
model.eval()
total_hold_loss = 0
m_hold = 0
for (batch, (X_hold, Y_hold)) in enumerate(loaders['hold']):
if USE_GPU:
X_hold_, Y_hold_ = X_hold.cuda(), Y_hold.cuda()
else:
X_hold_, Y_hold_ = X_hold, Y_hold
hold_loss = nn.MSELoss()(model(X_hold_), Y_hold_)
total_hold_loss += hold_loss.item() * X_hold_.size(0)
m_hold += X_hold_.size(0)
print(i, total_train_loss / m_train, total_test_loss / m_test,
total_hold_loss / m_hold)
# Early stopping
hold_costs.append(total_hold_loss)
model_states.append(model.state_dict().copy())
if i > 0 and i % num_stop_rounds == 0:
idx = hold_costs.index(min(hold_costs))
if prev_min == hold_costs[idx]:
model.eval()
best_model = model_classes.Net(tensors_task['X_train'],
tensors_task['Y_train'],
[200, 200], params['T'])
best_model.load_state_dict(model_states[idx])
if USE_GPU:
best_model = best_model.cuda()
return best_model
else:
prev_min = hold_costs[idx]
hold_costs = [prev_min]
model_states = [model_states[idx]]
return model
def run_task_net(model, loader, params, args, tensors_task):
opt = optim.Adam(model.parameters(), lr=1e-4)
solver = model_classes.ScheduleBattery(params)
# For early stopping
prev_min = 0
hold_costs = []
model_states = []
num_stop_rounds = 20
for i in range(1000):
# train
model.train()
total_train_loss = 0
m_train = 0
for (batch, (X_train, Y_train)) in enumerate(loader['train']):
opt.zero_grad()
if USE_GPU:
X_train, Y_train = X_train.cuda(), Y_train.cuda()
preds_train = model(X_train)
train_loss = task_loss(solver(preds_train), Y_train, params).sum()
total_train_loss += train_loss.item() * X_train.size(0)
m_train += X_train.size(0)
train_loss.backward()
# test
model.eval()
total_test_loss = 0
m_test = 0
for (batch, (X_test, Y_test)) in enumerate(loader['test']):
if USE_GPU:
X_test, Y_test = X_test.cuda(), Y_test.cuda()
preds_test = model(X_test)
test_loss = task_loss(solver(preds_test), Y_test, params).sum()
total_test_loss += test_loss.item() * X_test.size(0)
m_test += X_test.size(0)
# hold
model.eval()
total_hold_loss = 0
m_hold = 0
for (batch, (X_hold, Y_hold)) in enumerate(loader['hold']):
if USE_GPU:
X_hold, Y_hold = X_hold.cuda(), Y_hold.cuda()
preds_hold = model(X_hold)
hold_loss = task_loss(solver(preds_hold), Y_hold, params).sum()
total_hold_loss += hold_loss.item() * X_hold.size(0)
m_hold += X_hold.size(0)
print(i, total_train_loss / m_train, total_test_loss / m_test,
total_hold_loss / m_hold)
# Early stopping
hold_costs.append(total_hold_loss)
model_states.append(model.state_dict().copy())
if i > 0 and i % num_stop_rounds == 0:
idx = hold_costs.index(min(hold_costs))
if prev_min == hold_costs[idx]:
model.eval()
best_model = model_classes.Net(tensors_task['X_train'],
tensors_task['Y_train'],
[200, 200], params['T'])
best_model.load_state_dict(model_states[idx])
if USE_GPU:
best_model = best_model.cuda()
return best_model
else:
prev_min = hold_costs[idx]
hold_costs = [prev_min]
model_states = [model_states[idx]]
return model
def main():
parser = argparse.ArgumentParser(
description='Run electricity scheduling task net experiments.')
parser.add_argument('--save',
type=str,
required=True,
metavar='save-folder',
help='save folder path')
parser.add_argument('--nRuns',
type=int,
default=10,
metavar='runs',
help='number of runs')
args = parser.parse_args()
setproctitle.setproctitle('pdonti.' + args.save)
X1, Y1 = load_data_with_features('pjm_load_data_2008-11.txt')
X2, Y2 = load_data_with_features('pjm_load_data_2012-16.txt')
X = np.concatenate((X1, X2), axis=0)
Y = np.concatenate((Y1, Y2), axis=0)
# Train, test split.
n_tt = int(len(X) * 0.8)
X_train, Y_train = X[:n_tt], Y[:n_tt]
X_test, Y_test = X[n_tt:], Y[n_tt:]
# Construct tensors (without intercepts).
X_train_ = Variable(torch.Tensor(X_train[:, :-1])).cuda()
Y_train_ = Variable(torch.Tensor(Y_train)).cuda()
X_test_ = Variable(torch.Tensor(X_test[:, :-1])).cuda()
Y_test_ = Variable(torch.Tensor(Y_test)).cuda()
variables_rmse = {
'X_train_': X_train_,
'Y_train_': Y_train_,
'X_test_': X_test_,
'Y_test_': Y_test_
}
for run in range(args.nRuns):
save_folder = os.path.join(args.save, str(run))
if not os.path.exists(save_folder):
os.makedirs(save_folder)
# Generation scheduling problem params.
params = {"n": 24, "c_ramp": 0.4, "gamma_under": 50, "gamma_over": 0.5}
# Run and eval rmse-minimizing net
model_rmse = model_classes.Net(X_train[:, :-1], Y_train, [200, 200])
model_rmse.cuda()
model_rmse = nets.run_rmse_net(model_rmse, variables_rmse, X_train,
Y_train)
nets.eval_net("rmse_net", model_rmse, variables_rmse, params,
save_folder)
# Run and eval task cost-weighted rmse-minimizing net (model defined/updated internally)
model_rmse_weighted = nets.run_weighted_rmse_net(
X_train, Y_train, X_test, Y_test, params)
nets.eval_net("weighted_rmse_net", model_rmse_weighted, variables_rmse,
params, save_folder)
# Randomly construct hold-out set for task net training.
th_frac = 0.8
inds = np.random.permutation(X_train.shape[0])
train_inds = inds[:int(X_train.shape[0] * th_frac)]
hold_inds = inds[int(X_train.shape[0] * th_frac):]
X_train2, X_hold2 = X_train[train_inds, :], X_train[hold_inds, :]
Y_train2, Y_hold2 = Y_train[train_inds, :], Y_train[hold_inds, :]
X_train2_ = Variable(torch.Tensor(X_train2[:, :-1])).cuda()
Y_train2_ = Variable(torch.Tensor(Y_train2)).cuda()
X_hold2_ = Variable(torch.Tensor(X_hold2[:, :-1])).cuda()
Y_hold2_ = Variable(torch.Tensor(Y_hold2)).cuda()
variables_task = {
'X_train_': X_train2_,
'Y_train_': Y_train2_,
'X_hold_': X_hold2_,
'Y_hold_': Y_hold2_,
'X_test_': X_test_,
'Y_test_': Y_test_
}
# Run and eval task-minimizing net, building off rmse net results.
model_task = model_classes.Net(X_train2[:, :-1], Y_train2, [200, 200])
model_task.cuda()
model_task = nets.run_rmse_net(model_task, variables_task, X_train2,
Y_train2)
model_task = nets.run_task_net(model_task, variables_task, params,
X_train2, Y_train2, args)
nets.eval_net("task_net", model_task, variables_task, params,
save_folder)
plot.plot_results(
map(lambda x: os.path.join(args.save, str(x)), range(args.nRuns)),
args.save)
