def disagg_fold_new(fold_num, appliance, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations): torch.manual_seed(0) appliance_num = APPLIANCE_ORDER.index(appliance) train, test = get_train_test(num_folds=num_folds, fold_num=fold_num) train = np.vstack([train, aug_data[:num_aug]]) train_aggregate = train[:, 0, :, :].reshape(-1, 24, 1) test_aggregate = test[:, 0, :, :].reshape(-1, 24, 1) train_appliance = train[:, appliance_num, :, :].reshape(-1, 24, 1) test_appliance = test[:, appliance_num, :, :].reshape(-1, 24, 1) gts.append(test_appliance.reshape(-1, 24)) loss_func = nn.L1Loss() r = CustomRNN(cell_type, hidden_size, num_layers, bidirectional) if cuda_av: r = r.cuda() loss_func = loss_func.cuda() # Setting the params all to be non-negative #for param in r.parameters(): # param.data = param.data.abs() optimizer = torch.optim.Adam(r.parameters(), lr=lr) test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) test_y = Variable(torch.Tensor(test_appliance), requires_grad=False) prediction_fold = {} for t in range(1, num_iterations + 1): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) train_y = Variable(torch.Tensor(train_appliance)) if cuda_av: inp = inp.cuda() train_y = train_y.cuda() pred = r(inp) optimizer.zero_grad() loss = loss_func(pred, train_y) if t % 100 == 0: print(t, loss.data[0]) loss.backward() optimizer.step() if t % 200 == 0 and t != 0: if cuda_av: test_inp = test_inp.cuda() pred_test = r(test_inp) pred_test = torch.clamp(pred_test, min=0.) if cuda_av: prediction_fold[t] = pred_test.cpu().data.numpy() else: prediction_fold[t] = pred_test.data.numpy() return prediction_fold, test_appliance
def discriminative(dataset, cur_fold, num_latent, num_iterations): # for cur_fold in range(5): train, test = get_train_test(dataset, num_folds=num_folds, fold_num=cur_fold) #train, valid = train_test_split(train, test_size=0.2, random_state=0) valid = train[int(0.8 * len(train)):].copy() train = train[:int(0.8 * len(train))].copy() valid_gt = valid[:, 1:, :, :] test_gt = test[:, 1:, :, :] train_sc, valid_sc = reshape_for_sc(train), reshape_for_sc(valid) train_data = np.array( [train_sc[:, :, i] for i in range(1, train.shape[1])]).swapaxes(1, 2) c = SparseCoding() c.train(train_data, num_latent=num_latent) valid_pred = c.disaggregate_discriminative(train_sc[:, :, 0].swapaxes(0, 1), valid_sc[:, :, 0].swapaxes(0, 1), num_iter=num_iterations) valid_pred = valid_pred[-1, :, :, :] valid_pred = valid_pred.swapaxes(0, 2).swapaxes(1, 2) valid_pred = valid_pred.reshape(valid_pred.shape[0], valid_pred.shape[1], -1, 24) valid_pred = np.minimum(valid_pred, valid_gt[:, 0:1, :, :]) valid_error = { APPLIANCE_ORDER[i + 1]: mean_absolute_error(valid_pred[:, i, :, :].flatten(), valid_gt[:, i, :, :].flatten()) for i in range(valid_pred.shape[1]) } train_sc, test_sc = reshape_for_sc(train), reshape_for_sc(test) train_data = np.array( [train_sc[:, :, i] for i in range(1, train.shape[1])]).swapaxes(1, 2) c = SparseCoding() c.train(train_data, num_latent=num_latent) test_pred = c.disaggregate_discriminative(train_sc[:, :, 0].swapaxes(0, 1), test_sc[:, :, 0].swapaxes(0, 1), num_iter=num_iterations) test_pred = test_pred[-1, :, :, :] test_pred = test_pred.swapaxes(0, 2).swapaxes(1, 2) test_pred = test_pred.reshape(test_pred.shape[0], test_pred.shape[1], -1, 24) test_pred = np.minimum(test_pred, test_gt[:, 0:1, :, :]) test_error = { APPLIANCE_ORDER[i + 1]: mean_absolute_error(test_pred[:, i, :, :].flatten(), test_gt[:, i, :, :].flatten()) for i in range(test_pred.shape[1]) } return valid_pred, valid_error, valid_gt, test_pred, test_error, test_gt
def nested_stf(dataset, cur_fold, r, lr, num_iter): train, test = get_train_test(dataset, num_folds=num_folds, fold_num=cur_fold) #train, valid = train_test_split(train, test_size=0.2, random_state=0) valid = train[int(0.8*len(train)):].copy() train = train[:int(0.8 * len(train))].copy() valid_gt = valid[:, 1:, :, :] test_gt = test[:, 1:, :, :] valid_copy = valid.copy() valid_copy[:, 1:, :, :] =np.NaN train_valid = np.concatenate([train, valid_copy]) H, A, D, T = stf_4dim_time(tensor=train_valid, r=r, lr=lr, num_iter=num_iter) valid_pred = np.einsum("Hr, Ar, Dr, ATr -> HADT", H, A, D, T)[len(train):, 1:, :, :] valid_error = {APPLIANCE_ORDER[i+1]:mean_absolute_error(valid_pred[:, i,:,:].flatten(), valid_gt[:, i, :, :].flatten()) for i in range(valid_pred.shape[1])} test_copy = test.copy() test_copy[:, 1:, :, :] =np.NaN train_test = np.concatenate([train, test_copy]) H, A, D, T = stf_4dim_time(tensor=train_test, r=r, lr=lr, num_iter=num_iter) test_pred = np.einsum("Hr, Ar, Dr, ATr -> HADT", H, A, D, T)[len(train):, 1:, :, :] test_error = {APPLIANCE_ORDER[i+1]:mean_absolute_error(test_pred[:, i,:,:].flatten(), test_gt[:, i, :, :].flatten()) for i in range(test_pred.shape[1])} return valid_pred, valid_error, valid_gt, test_pred, test_error, test_gt
def nested_stf(dataset, cur_fold, r, lr, num_iter): # valid_error = {} # out = [] # for cur_fold in range(5): # valid_error = {} train, test = get_train_test(dataset, num_folds=num_folds, fold_num=cur_fold) #train, valid = train_test_split(train, test_size=0.2, random_state=0) valid = train[int(0.8 * len(train)):].copy() train = train[:int(0.8 * len(train))].copy() valid_gt = valid[:, 1:, :, :] test_gt = test[:, 1:, :, :] # print ("fold: ", cur_fold, " num_latent: ", r, " lr: ", lr, " num_iter: ", num_iter) #for valid data valid_copy = valid.copy() valid_copy[:, 1:, :, :] = np.NaN train_valid = np.concatenate([train, valid_copy]) H, A, D, T = stf_4dim(tensor=train_valid, r=r, lr=lr, num_iter=num_iter) valid_pred = np.einsum("Hr, Ar, Dr, Tr ->HADT", H, A, D, T)[len(train):, 1:, :, :] valid_error = { APPLIANCE_ORDER[i + 1]: mean_absolute_error(valid_pred[:, i, :, :].flatten(), valid_gt[:, i, :, :].flatten()) for i in range(valid_pred.shape[1]) } #for test data return valid_pred, valid_error, valid_gt
def stf(r=2, lr=1, num_iter=100): out = [] for cur_fold in range(5): train, test = get_train_test(num_folds=num_folds, fold_num=cur_fold) test_copy = test.copy() test_copy[:, 1:, :, :] = np.NaN train_test = np.concatenate([train, test_copy]) H, A, D, T = stf_4dim(tensor=train_test, r=r, lr=lr, num_iter=num_iter) pred = np.einsum("Hr, Ar, Dr, Tr ->HADT", H, A, D, T)[len(train):, 1:, :, :] out.append(pred) return np.concatenate(out)
def stf(dataset, cur_fold, r=2, lr=1, num_iter=100): num_folds = 5 train, test = get_train_test(dataset, num_folds=num_folds, fold_num=cur_fold) test_copy = test.copy() test_copy[:, 1:, :, :] = np.NaN train_test = np.concatenate([train, test_copy]) H, A, D, T = stf_4dim(tensor=train_test, r=r, lr=lr, num_iter=num_iter) pred = np.einsum("Hr, Ar, Dr, Tr ->HADT", H, A, D, T)[len(train):, 1:, :, :] return pred
def non_discriminative(num_latent): out = [] for cur_fold in range(5): train, test = get_train_test(num_folds=num_folds, fold_num=cur_fold) train_sc, test_sc = reshape_for_sc(train), reshape_for_sc(test) train_data = np.array([ train_sc[:, :, i] for i in range(1, train.shape[1]) ]).swapaxes(1, 2) c = SparseCoding() c.train(train_data, num_latent=num_latent) pred = c.disaggregate(test_sc[:, :, 0].swapaxes(0, 1)).swapaxes( 0, 2).swapaxes(1, 2) pred = pred.reshape(pred.shape[0], pred.shape[1], -1, 24) out.append(pred) return np.concatenate(out)
def disagg_fold(fold_num, dataset, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations, p): # print (fold_num, hidden_size, num_layers, bidirectional, lr, num_iterations, p) #print (ORDER) torch.manual_seed(0) num_folds=5 train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) # from sklearn.model_selection import train_test_split # train, valid = train_test_split(train, test_size=0.2, random_state=0) valid = train[int(0.8*len(train)):].copy() train = train[:int(0.8 * len(train))].copy() train_aggregate = train[:, 0, :, :].reshape(-1, train.shape[3], 1) valid_aggregate = valid[:, 0, :, :].reshape(-1, train.shape[3], 1) test_aggregate = test[:, 0, :, :].reshape(-1, train.shape[3], 1) #print (train.shape) #print (valid.shape) #print (test.shape) out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((train_aggregate.shape[0], -1, 1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() out_valid = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_valid[a_num] = Variable( torch.Tensor(valid[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((valid_aggregate.shape[0], -1, 1)))) if cuda_av: out_valid[a_num] = out_valid[a_num].cuda() out_test = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_test[a_num] = Variable( torch.Tensor(test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((test_aggregate.shape[0], -1, 1)))) if cuda_av: out_test[a_num] = out_test[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(cell_type, hidden_size, num_layers, bidirectional, len(ORDER)) # prevent negative #for param in a.parameters(): # param.data = param.data.abs() #print(a) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) inp = Variable(torch.Tensor(train_aggregate.reshape((train_aggregate.shape[0], -1, 1))).type(torch.FloatTensor), requires_grad=True) valid_inp = Variable(torch.Tensor(valid_aggregate), requires_grad=False) if cuda_av: valid_inp = valid_inp.cuda() test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: test_inp = test_inp.cuda() valid_pred = {} train_pred = {} test_pred = {} test_losses = {} valid_losses = {} for t in range(1, num_iterations+1): idx_train = Variable(torch.LongTensor(np.random.choice(range(train_aggregate.shape[0]), 50, replace=True))) inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) valid_out = torch.cat([out_valid[appliance_num] for appliance_num, appliance in enumerate(ORDER)]) test_out = torch.cat([out_test[appliance_num] for appliance_num, appliance in enumerate(ORDER)]) if cuda_av: idx_train = idx_train.cuda() out = torch.cat( [out_train[appliance_num].index_select(0, idx_train) for appliance_num, appliance in enumerate(ORDER)]) inp = inp.cuda().index_select(0, idx_train) out = out.cuda() else: inp = inp.index_select(0, idx_train) out = torch.cat( [out_train[appliance_num].index_select(0, idx_train) for appliance_num, appliance in enumerate(ORDER)]) params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) # print(params) pred = a(*params) optimizer.zero_grad() loss = loss_func(pred, out) if t % 50 == 0: #print(t, loss.data[0]) if cuda_av: valid_inp = valid_inp.cuda() valid_params = [valid_inp, -2] for i in range(len(ORDER)): valid_params.append(None) valid_pr = a(*valid_params) valid_loss = loss_func(valid_pr, valid_out) if cuda_av: test_inp = test_inp.cuda() test_params = [test_inp, -2] for i in range(len(ORDER)): test_params.append(None) test_pr = a(*test_params) test_loss = loss_func(test_pr, test_out) test_losses[t] = test_loss.data[0] valid_losses[t] = valid_loss.data[0] # np.save("./baseline/p_50_loss") if t % 1000 == 0: valid_pr = torch.clamp(valid_pr, min=0.) valid_pred[t] = valid_pr test_pr = torch.clamp(test_pr, min=0.) test_pred[t] = test_pr train_pr = pred train_pr = torch.clamp(train_pr, min=0.) train_pred[t] = train_pr #print("Round:", t, "Training Error:", loss.data[0], "Validation Error:", valid_loss.data[0], "Test Error:", test_loss.data[0]) loss.backward() optimizer.step() # store training prediction # train_pred = torch.clamp(pred, min=0.) # train_pred = torch.split(train_pred, train_aggregate.shape[0]) train_fold = [None for x in range(len(ORDER))] # if cuda_av: # for appliance_num, appliance in enumerate(ORDER): # train_fold[appliance_num] = train_pred[appliance_num].cpu().data.numpy().reshape(-1, 24) # else: # for appliance_num, appliance in enumerate(ORDER): # train_fold[appliance_num] = train_pred[appliance_num].data.numpy().reshape(-1, 24) # test one validation set valid_fold = {} for t in range(1000, num_iterations + 1, 1000): valid_pred[t] = torch.split(valid_pred[t], valid_aggregate.shape[0]) valid_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): valid_fold[t][appliance_num] = valid_pred[t][appliance_num].cpu().data.numpy().reshape(-1, valid.shape[3]) else: for appliance_num, appliance in enumerate(ORDER): valid_fold[t][appliance_num] = valid_pred[t][appliance_num].data.numpy().reshape(-1, valid.shape[3]) test_fold = {} for t in range(1000, num_iterations + 1, 1000): test_pred[t] = torch.split(test_pred[t], test_aggregate.shape[0]) test_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): test_fold[t][appliance_num] = test_pred[t][appliance_num].cpu().data.numpy().reshape(-1, valid.shape[3]) else: for appliance_num, appliance in enumerate(ORDER): test_fold[t][appliance_num] = test_pred[t][appliance_num].data.numpy().reshape(-1, valid.shape[3]) # store ground truth of validation set valid_gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): valid_gt_fold[appliance_num] = valid[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( valid_aggregate.shape[0], -1, 1).reshape(-1, valid.shape[3]) test_gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): test_gt_fold[appliance_num] = test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( test_aggregate.shape[0], -1, 1).reshape(-1, test.shape[3]) # calcualte the error of validation set valid_error = {} for t in range(1000, num_iterations + 1, 1000): valid_error[t] = {} for appliance_num, appliance in enumerate(ORDER): valid_error[t][appliance] = mean_absolute_error(valid_fold[t][appliance_num], valid_gt_fold[appliance_num]) test_error = {} for t in range(1000, num_iterations + 1, 1000): test_error[t] = {} for appliance_num, appliance in enumerate(ORDER): test_error[t][appliance] = mean_absolute_error(test_fold[t][appliance_num], test_gt_fold[appliance_num]) return train_fold, valid_fold, test_fold, valid_error, test_error, valid_losses, test_losses
def disagg_fold(fold_num, dataset, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations, p): # print (fold_num, hidden_size, num_layers, bidirectional, lr, num_iterations, p) print (ORDER) torch.manual_seed(0) num_folds=5 train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) from sklearn.model_selection import train_test_split train, valid = train_test_split(train, test_size=0.2, random_state=0) train_aggregate = train[:, 0, :, :].reshape(-1, 24, 1) valid_aggregate = valid[:, 0, :, :].reshape(-1, 24, 1) test_aggregate = test[:, 0, :, :].reshape(-1, 24, 1) print (train.shape) print (valid.shape) print (test.shape) out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((train_aggregate.shape[0], -1, 1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(cell_type, hidden_size, num_layers, bidirectional, len(ORDER)) # prevent negative #for param in a.parameters(): # param.data = param.data.abs() #print(a) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) inp = Variable(torch.Tensor(train_aggregate.reshape((train_aggregate.shape[0], -1, 1))).type(torch.FloatTensor), requires_grad=True) valid_pred = {} train_pred = {} valid_inp = Variable(torch.Tensor(valid_aggregate), requires_grad=False) if cuda_av: valid_inp = valid_inp.cuda() for t in range(1, num_iterations+1): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([out_train[appliance_num] for appliance_num, appliance in enumerate(ORDER)]) if cuda_av: inp = inp.cuda() out = out.cuda() params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) # print(params) pred = a(*params) optimizer.zero_grad() loss = loss_func(pred, out) if t % 100 == 1: print(t, loss.data[0]) if t%1000 == 0 and t!=0: if cuda_av: valid_inp = valid_inp.cuda() valid_params = [valid_inp, -2] for i in range(len(ORDER)): valid_params.append(None) valid_pr = a(*valid_params) valid_pr = torch.clamp(valid_pr, min=0.) valid_pred[t] = valid_pr train_pr = pred train_pr = torch.clamp(train_pr, min=0.) train_pred[t] = train_pr loss.backward() optimizer.step() # store training prediction train_fold = {} for t in range(1000, num_iterations + 1, 1000): # train_pred[t] = torch.clamp(train_pred[t], min=0.) train_pred[t] = torch.split(train_pred[t], train_aggregate.shape[0]) train_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): train_fold[t][appliance_num] = train_pred[t][appliance_num].cpu().data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): train_fold[t][appliance_num] = train_pred[t][appliance_num].data.numpy().reshape(-1, 24) # test one validation set valid_fold = {} for t in range(1000, num_iterations+1, 1000): valid_pred[t] = torch.split(valid_pred[t], valid_aggregate.shape[0]) valid_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): valid_fold[t][appliance_num] = valid_pred[t][appliance_num].cpu().data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): valid_fold[t][appliance_num] = valid_pred[t][appliance_num].data.numpy().reshape(-1, 24) # store gound truth of validation set gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): gt_fold[appliance_num] = valid[:, APPLIANCE_ORDER.index(appliance), :, :].reshape(valid_aggregate.shape[0], -1, 1).reshape(-1, 24) # calcualte the error of validation set error = {} for t in range(1000, num_iterations+1, 1000): error[t] = {} for appliance_num, appliance in enumerate(ORDER): error[t][appliance] = mean_absolute_error(valid_fold[t][appliance_num], gt_fold[appliance_num]) return train_fold, valid_fold, error
cuda_av = True else: cuda_av = False fold_num = 0 num_folds = 5 cell_type="GRU" hidden_size = 150 lr = 0.1 bidirectional = True appliance = "hvac" torch.manual_seed(0) appliance_num = APPLIANCE_ORDER.index(appliance) train, test = get_train_test(2, num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(train.shape[0], -1, 1) test_aggregate = test[:, 0, :, :].reshape(test.shape[0], -1, 1) train_appliance = train[:, appliance_num, :, :].reshape(train.shape[0], -1, 1) test_appliance = test[:, appliance_num, :, :].reshape(test.shape[0], -1, 1) loss_func = nn.L1Loss() r = CustomRNN(cell_type, hidden_size, 1, bidirectional) if cuda_av: r = r.cuda() loss_func = loss_func.cuda()
def disagg(dataset, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations, p): preds = [] gts = [] for fold_num in range(num_folds): print("-" * 40) sys.stdout.flush() train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(-1, 24) test_aggregate = test[:, 0, :, :].reshape(-1, 24) #ORDER = APPLIANCE_ORDER[1:][:][::-1] # ORDER = ['mw','dw','fridge','dr','hvac'] out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor( train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (train_aggregate.shape[0], -1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() out_test = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_test[a_num] = Variable( torch.Tensor( test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (test_aggregate.shape[0], -1)))) if cuda_av: out_test[a_num] = out_test[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(cell_type, hidden_size, num_layers, bidirectional, num_appliance=len(ORDER)) for param in a.parameters(): param.data = param.data.abs() # print(a) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) inp = Variable(torch.Tensor( train_aggregate.reshape( (train_aggregate.shape[0], -1))).type(torch.FloatTensor), requires_grad=True) for t in range(num_iterations): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([ out_train[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) ot = torch.cat([ out_test[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) if cuda_av: inp = inp.cuda() out = out.cuda() ot = ot.cuda() params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) # print(params) pred = a(*params) optimizer.zero_grad() pred_split = torch.split(pred, pred.size(0) // len(ORDER)) losses = [ loss_func(pred_split[appliance_num], out_train[appliance_num]) * weight_appliance[appliance] for appliance_num, appliance in enumerate(ORDER) ] loss = sum(losses) / len(ORDER) if t % 20 == 0: print(t, loss.data[0]) sys.stdout.flush() loss.backward() optimizer.step() test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: test_inp = test_inp.cuda() params = [test_inp, -2] for i in range(len(ORDER)): params.append(None) pr = a(*params) pr = torch.clamp(pr, min=0.) test_pred = torch.split(pr, test_aggregate.shape[0]) prediction_fold = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): prediction_fold[appliance_num] = test_pred[appliance_num].cpu( ).data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): prediction_fold[appliance_num] = test_pred[ appliance_num].data.numpy().reshape(-1, 24) gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): gt_fold[appliance_num] = test[:, APPLIANCE_ORDER. index(appliance), :, :].reshape( test_aggregate.shape[0], -1, 1).reshape(-1, 24) preds.append(prediction_fold) gts.append(gt_fold) prediction_flatten = {} gt_flatten = {} for appliance_num, appliance in enumerate(ORDER): prediction_flatten[appliance] = [] gt_flatten[appliance] = [] for appliance_num, appliance in enumerate(ORDER): for fold in range(num_folds): prediction_flatten[appliance].append(preds[fold][appliance_num]) gt_flatten[appliance].append(gts[fold][appliance_num]) gt_flatten[appliance] = np.concatenate(gt_flatten[appliance]) prediction_flatten[appliance] = np.concatenate( prediction_flatten[appliance]) err = {} for appliance in ORDER: print(appliance) sys.stdout.flush() err[appliance] = mean_absolute_error(gt_flatten[appliance], prediction_flatten[appliance]) return err
def disagg_fold(fold_num, dataset, lr, num_iterations, p, ORDER): train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) train, valid = train_test_split(train, test_size=0.2, random_state=0) train_aggregate = train[:, 0, :, :].reshape(-1, 24) valid_aggregate = valid[:, 0, :, :].reshape(-1, 24) #ORDER = APPLIANCE_ORDER[1:][:][::-1] out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (train_aggregate.shape[0], -1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() out_valid = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_valid[a_num] = Variable( torch.Tensor(valid[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (valid_aggregate.shape[0], -1)))) if cuda_av: out_valid[a_num] = out_valid[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(num_appliance=len(ORDER)) # for param in a.parameters(): # param.data = param.data.abs() # print(a) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) inp = Variable(torch.Tensor( train_aggregate.reshape( (train_aggregate.shape[0], -1))).type(torch.FloatTensor), requires_grad=True) for t in range(num_iterations): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([ out_train[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) ot = torch.cat([ out_valid[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) if cuda_av: inp = inp.cuda() out = out.cuda() ot = ot.cuda() params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) # print(params) pred = a(*params) optimizer.zero_grad() pred_split = torch.split(pred, pred.size(0) // len(ORDER)) losses = [ loss_func(pred_split[appliance_num], out_train[appliance_num]) * weight_appliance[appliance] for appliance_num, appliance in enumerate(ORDER) ] loss = sum(losses) / len(ORDER) if t % 10 == 0: print(t, loss.data[0]) loss.backward() optimizer.step() train_pred = torch.clamp(pred, min=0.) train_pred = torch.split(train_pred, train_aggregate.shape[0]) train_fold = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): train_fold[appliance_num] = train_pred[appliance_num].cpu( ).data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): train_fold[appliance_num] = train_pred[appliance_num].data.numpy( ).reshape(-1, 24) # test one validation set valid_inp = Variable(torch.Tensor(valid_aggregate), requires_grad=False) if cuda_av: valid_inp = valid_inp.cuda() params = [valid_inp, -2] for i in range(len(ORDER)): params.append(None) pr = a(*params) pr = torch.clamp(pr, min=0.) valid_pred = torch.split(pr, valid_aggregate.shape[0]) valid_fold = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): valid_fold[appliance_num] = valid_pred[appliance_num].cpu( ).data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): valid_fold[appliance_num] = valid_pred[appliance_num].data.numpy( ).reshape(-1, 24) # store gound truth of validation set gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): gt_fold[appliance_num] = valid[:, APPLIANCE_ORDER. index(appliance), :, :].reshape( valid_aggregate.shape[0], -1, 1).reshape(-1, 24) # calcualte the error of validation set error = {} for appliance_num, appliance in enumerate(ORDER): error[appliance] = mean_absolute_error(valid_fold[appliance_num], gt_fold[appliance_num]) return train_fold, valid_fold, error
def disagg_fold(fold_num, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations, order, p): torch.manual_seed(0) train, test = get_train_test(num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(-1, 24, 1) test_aggregate = test[:, 0, :, :].reshape(-1, 24, 1) out_train = [None for temp in range(len(order))] for a_num, appliance in enumerate(order): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (train_aggregate.shape[0], -1, 1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(cell_type, hidden_size, num_layers, bidirectional, order) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) for t in range(num_iterations): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([ out_train[appliance_num] for appliance_num, appliance in enumerate(order) ]) if cuda_av: inp = inp.cuda() out = out.cuda() pred = a(inp, out_train, p) optimizer.zero_grad() loss = loss_func(pred, out) if t % 5 == 0: print(t, loss.data[0]) loss.backward() optimizer.step() test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: test_inp = test_inp.cuda() pr = a(test_inp, {appliance: None for appliance in order}, -2) pr = torch.clamp(pr, min=0.) test_pred = torch.split(pr, test_aggregate.shape[0]) prediction_fold = [None for x in range(len(order))] if cuda_av: for appliance_num, appliance in enumerate(order): prediction_fold[appliance_num] = test_pred[appliance_num].cpu( ).data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(order): prediction_fold[appliance_num] = test_pred[ appliance_num].data.numpy().reshape(-1, 24) gt_fold = [None for x in range(len(order))] for appliance_num, appliance in enumerate(order): gt_fold[appliance_num] = test[:, APPLIANCE_ORDER. index(appliance), :, :].reshape( test_aggregate.shape[0], -1, 1).reshape(-1, 24) return prediction_fold, gt_fold
def disagg_fold(fold_num, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations, order, p): torch.manual_seed(0) train, test = get_train_test(num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(-1, 24, 1) test_aggregate = test[:, 0, :, :].reshape(-1, 24, 1) out_train = {} out_test = {} for a_num, appliance in enumerate(order): out_train[appliance] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (train_aggregate.shape[0], -1, 1)))) out_test[appliance] = Variable( torch.Tensor(test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape( (test_aggregate.shape[0], -1, 1)))) if cuda_av: out_train[appliance] = out_train[appliance].cuda() out_test[appliance] = out_test[appliance].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(cell_type, hidden_size, num_layers, bidirectional, order) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) for t in range(num_iterations): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([ out_train[appliance] for appliance_num, appliance in enumerate(order) ]) if cuda_av: inp = inp.cuda() out = out.cuda() params = [inp, p] for appliance in order: params.append(out_train[appliance]) pred = a(*params) optimizer.zero_grad() loss = loss_func(pred, out) if t % 5 == 0: print(t, loss.data[0]) loss.backward() optimizer.step() test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: test_inp = test_inp.cuda() test_params = [test_inp, -2] for appliance in order: test_params.append(None) pr = a(*test_params) pr = torch.clamp(pr, min=0.) """ for appliance_num, appliance in enumerate(order): print(loss_func(pr[appliance_num], out_test[appliance])) """ return pr
if error < min_error[fold_num]: min_error[fold_num] = error cnn_tree_best_param[fold_num]['lr'] = lr cnn_tree_best_param[fold_num]['order'] = order cnn_tree_best_param[fold_num]['iters'] = it return cnn_tree_errors, min_error, cnn_tree_best_param tensor = np.load("../2015-5appliances.numpy.npy") test_gt = {} valid_gt = {} for fold_num in range(5): test_gt[fold_num] = {} valid_gt[fold_num] = {} train, test = get_train_test(1, 5, fold_num) valid = train[int(0.8 * len(train)):].copy() for idx, appliance in enumerate(APPLIANCE_ORDER[1:-1]): test_gt[fold_num][appliance] = test[:, idx + 1] valid_gt[fold_num][appliance] = valid[:, idx + 1] threshold = {} for appliance in ['hvac', 'fridge', 'dr', 'dw', 'mw']: sample_list = [] for fold_num in range(5): sample_list = np.append(sample_list, [ x for x in test_gt[fold_num][appliance].reshape(1, -1).tolist()[0] if x > ON_THRESHOLD[appliance] ]) mean = np.mean(sample_list) print(appliance, mean)
def disagg_fold(dataset, fold_num, lr, p): train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) valid = train[int(0.8 * len(train)):].copy() train = train[:int(0.8 * len(train))].copy() train_aggregate = train[:, 0, :, :].reshape(train.shape[0], 1, -1, 24) valid_aggregate = valid[:, 0, :, :].reshape(valid.shape[0], 1, -1, 24) test_aggregate = test[:, 0, :, :].reshape(test.shape[0], 1, -1, 24) out_train, out_valid, out_test = preprocess(train, valid, test) loss_func = nn.L1Loss() model = AppliancesCNN(len(ORDER)) optimizer = torch.optim.Adam(model.parameters(), lr=lr) if cuda_av: model = model.cuda() loss_func = loss_func.cuda() inp = Variable(torch.Tensor(train_aggregate), requires_grad=False) valid_inp = Variable(torch.Tensor(valid_aggregate), requires_grad=False) test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: inp = inp.cuda() valid_inp = valid_inp.cuda() test_inp = test_inp.cuda() valid_out = torch.cat([ out_valid[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) test_out = torch.cat([ out_test[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) train_out = torch.cat([ out_train[appliance_num] for appliance_num, appliance in enumerate(ORDER) ]) valid_pred = {} train_pred = {} test_pred = {} train_losses = {} test_losses = {} valid_losses = {} params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) if cuda_av: train_out = train_out.cuda() for t in range(1, num_iterations + 1): pred = model(*params) optimizer.zero_grad() loss = loss_func(pred, train_out) if t % 500 == 0: if cuda_av: valid_inp = valid_inp.cuda() valid_params = [valid_inp, -2] for i in range(len(ORDER)): valid_params.append(None) valid_pr = model(*valid_params) valid_loss = loss_func(valid_pr, valid_out) if cuda_av: test_inp = test_inp.cuda() test_params = [test_inp, -2] for i in range(len(ORDER)): test_params.append(None) test_pr = model(*test_params) test_loss = loss_func(test_pr, test_out) test_losses[t] = test_loss.data[0] valid_losses[t] = valid_loss.data[0] train_losses[t] = loss.data[0] # np.save("./baseline/p_50_loss") if t % 1000 == 0: valid_pr = torch.clamp(valid_pr, min=0.) valid_pred[t] = valid_pr test_pr = torch.clamp(test_pr, min=0.) test_pred[t] = test_pr train_pr = pred train_pr = torch.clamp(train_pr, min=0.) train_pred[t] = train_pr print("Round:", t, "Training Error:", loss.data[0], "Validation Error:", valid_loss.data[0], "Test Error:", test_loss.data[0]) loss.backward() optimizer.step() train_fold = [None for x in range(len(ORDER))] train_fold = {} for t in range(1000, num_iterations + 1, 1000): train_pred[t] = torch.split(train_pred[t], train_aggregate.shape[0]) train_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): train_fold[t][appliance_num] = train_pred[t][ appliance_num].cpu().data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): train_fold[t][appliance_num] = train_pred[t][ appliance_num].data.numpy().reshape(-1, 24) valid_fold = {} for t in range(1000, num_iterations + 1, 1000): valid_pred[t] = torch.split(valid_pred[t], valid_aggregate.shape[0]) valid_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): valid_fold[t][appliance_num] = valid_pred[t][ appliance_num].cpu().data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): valid_fold[t][appliance_num] = valid_pred[t][ appliance_num].data.numpy().reshape(-1, 24) test_fold = {} for t in range(1000, num_iterations + 1, 1000): test_pred[t] = torch.split(test_pred[t], test_aggregate.shape[0]) test_fold[t] = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): test_fold[t][appliance_num] = test_pred[t][appliance_num].cpu( ).data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): test_fold[t][appliance_num] = test_pred[t][ appliance_num].data.numpy().reshape(-1, 24) # store ground truth of validation set train_gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): train_gt_fold[appliance_num] = train[:, APPLIANCE_ORDER. index(appliance), :, :].reshape( train_aggregate.shape[0], -1, 1).reshape(-1, 24) valid_gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): valid_gt_fold[appliance_num] = valid[:, APPLIANCE_ORDER. index(appliance), :, :].reshape( valid_aggregate.shape[0], -1, 1).reshape(-1, 24) test_gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): test_gt_fold[appliance_num] = test[:, APPLIANCE_ORDER. index(appliance), :, :].reshape( test_aggregate.shape[0], -1, 1).reshape(-1, 24) # calcualte the error of validation set train_error = {} for t in range(1000, num_iterations + 1, 1000): train_error[t] = {} for appliance_num, appliance in enumerate(ORDER): train_error[t][appliance] = mean_absolute_error( train_fold[t][appliance_num], train_gt_fold[appliance_num]) valid_error = {} for t in range(1000, num_iterations + 1, 1000): valid_error[t] = {} for appliance_num, appliance in enumerate(ORDER): valid_error[t][appliance] = mean_absolute_error( valid_fold[t][appliance_num], valid_gt_fold[appliance_num]) test_error = {} for t in range(1000, num_iterations + 1, 1000): test_error[t] = {} for appliance_num, appliance in enumerate(ORDER): test_error[t][appliance] = mean_absolute_error( test_fold[t][appliance_num], test_gt_fold[appliance_num]) return train_fold, valid_fold, test_fold, train_error, valid_error, test_error, train_losses, valid_losses, test_losses
def disagg_fold(fold_num, dataset, cell_type, hidden_size, num_layers, bidirectional, lr, num_iterations, p): # print (fold_num, hidden_size, num_layers, bidirectional, lr, num_iterations, p) print (ORDER) torch.manual_seed(0) train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(-1, 24, 1) test_aggregate = test[:, 0, :, :].reshape(-1, 24, 1) out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((train_aggregate.shape[0], -1, 1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(cell_type, hidden_size, num_layers, bidirectional, len(ORDER)) # prevent negative #for param in a.parameters(): # param.data = param.data.abs() #print(a) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) inp = Variable(torch.Tensor(train_aggregate.reshape((train_aggregate.shape[0], -1, 1))).type(torch.FloatTensor), requires_grad=True) for t in range(num_iterations): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([out_train[appliance_num] for appliance_num, appliance in enumerate(ORDER)]) if cuda_av: inp = inp.cuda() out = out.cuda() params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) # print(params) pred = a(*params) optimizer.zero_grad() loss = loss_func(pred, out) if t % 100 == 0: print(t, loss.data[0]) loss.backward() optimizer.step() test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: test_inp = test_inp.cuda() params = [test_inp, -2] for i in range(len(ORDER)): params.append(None) pr = a(*params) pr = torch.clamp(pr, min=0.) test_pred = torch.split(pr, test_aggregate.shape[0]) prediction_fold = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): prediction_fold[appliance_num] = test_pred[appliance_num].cpu().data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): prediction_fold[appliance_num] = test_pred[appliance_num].data.numpy().reshape(-1, 24) gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): gt_fold[appliance_num] = test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape(test_aggregate.shape[0], -1, 1).reshape(-1, 24) return prediction_fold, gt_fold
def dnn_fold(dataset, fold_num, lr, num_iterations, p): print (fold_num) train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(-1, 24) test_aggregate = test[:, 0, :, :].reshape(-1, 24) #ORDER = APPLIANCE_ORDER[1:][:][::-1] out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((train_aggregate.shape[0], -1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() out_test = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_test[a_num] = Variable( torch.Tensor(test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((test_aggregate.shape[0], -1)))) if cuda_av: out_test[a_num] = out_test[a_num].cuda() loss_func = nn.L1Loss() a = AppliancesRNN(num_appliance=len(ORDER)) # for param in a.parameters(): # param.data = param.data.abs() # print(a) if cuda_av: a = a.cuda() loss_func = loss_func.cuda() optimizer = torch.optim.Adam(a.parameters(), lr=lr) inp = Variable(torch.Tensor(train_aggregate.reshape((train_aggregate.shape[0], -1))).type(torch.FloatTensor), requires_grad=True) for t in range(num_iterations): inp = Variable(torch.Tensor(train_aggregate), requires_grad=True) out = torch.cat([out_train[appliance_num] for appliance_num, appliance in enumerate(ORDER)]) ot = torch.cat([out_test[appliance_num] for appliance_num, appliance in enumerate(ORDER)]) if cuda_av: inp = inp.cuda() out = out.cuda() ot = ot.cuda() params = [inp, p] for a_num, appliance in enumerate(ORDER): params.append(out_train[a_num]) # print(params) pred = a(*params) optimizer.zero_grad() pred_split = torch.split(pred, pred.size(0) // len(ORDER)) losses = [loss_func(pred_split[appliance_num], out_train[appliance_num]) * weight_appliance[appliance] for appliance_num, appliance in enumerate(ORDER)] loss = sum(losses)/len(ORDER) if t % 10 == 0: print(t, loss.data[0]) loss.backward() optimizer.step() test_inp = Variable(torch.Tensor(test_aggregate), requires_grad=False) if cuda_av: test_inp = test_inp.cuda() params = [test_inp, -2] for i in range(len(ORDER)): params.append(None) pr = a(*params) pr = torch.clamp(pr, min=0.) test_pred = torch.split(pr, test_aggregate.shape[0]) prediction_fold = [None for x in range(len(ORDER))] if cuda_av: for appliance_num, appliance in enumerate(ORDER): prediction_fold[appliance_num] = test_pred[appliance_num].cpu().data.numpy().reshape(-1, 24) else: for appliance_num, appliance in enumerate(ORDER): prediction_fold[appliance_num] = test_pred[appliance_num].data.numpy().reshape(-1, 24) gt_fold = [None for x in range(len(ORDER))] for appliance_num, appliance in enumerate(ORDER): gt_fold[appliance_num] = test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape(test_aggregate.shape[0], -1, 1).reshape(-1, 24) # preds.append(prediction_fold) # gts.append(gt_fold) return prediction_fold, gt_fold
lr = float(lr) num_iterations = int(num_iterations) ORDER = sys.argv[7:] p = 0 num_folds = 5 torch.manual_seed(0) #ORDER = ['hvac'] preds = [] gts = [] for fold_num in range(5): train, test = get_train_test(dataset, num_folds=num_folds, fold_num=fold_num) train_aggregate = train[:, 0, :, :].reshape(-1, 24) test_aggregate = test[:, 0, :, :].reshape(-1, 24) #ORDER = APPLIANCE_ORDER[1:][:][::-1] out_train = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_train[a_num] = Variable( torch.Tensor(train[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((train_aggregate.shape[0], -1)))) if cuda_av: out_train[a_num] = out_train[a_num].cuda() out_test = [None for temp in range(len(ORDER))] for a_num, appliance in enumerate(ORDER): out_test[a_num] = Variable( torch.Tensor(test[:, APPLIANCE_ORDER.index(appliance), :, :].reshape((test_aggregate.shape[0], -1)))) if cuda_av:
num_hidden = int(num_hidden) num_layers = int(num_layers) num_iterations = int(num_iterations) p = float(p) num_directions = int(num_directions) ORDER = sys.argv[6:len(sys.argv)] from sklearn.metrics import mean_absolute_error import numpy as np import pandas as pd from dataloader import APPLIANCE_ORDER, get_train_test num_folds = 5 train, test = get_train_test(1, num_folds=num_folds, fold_num=0) train_agg = train[:, 0, :].reshape(-1, 24) test_agg = test[:, 0, :].reshape(-1, 24) import torch import torch.nn as nn from torch.autograd import Variable cuda_av = False if torch.cuda.is_available(): cuda_av = True torch.manual_seed(0) np.random.seed(0)