Revisiting Machine Learning Datasets - Energy Efficiency (HVAC heating and cooling loads)

inputData = pd.read_excel("./data/ENB2012_data.xlsx")
inputDataRaw = inputData.copy(deep=True)
names = ["Relative Compactness",
         "Surface Area",
         "Wall Area",
         "Roof Area",
         "Overall Height",
         "Orientation",
         "Glazing Area",
         "Glazing Area Distribution",
         "Heating Load",
         "Cooling Load"]
inputData.columns = names
display(inputData.sample(10))
display(inputData.describe())

plt.close('all')
plt.figure(figsize=(10,12))
idx = 1
for col in inputData:
    plt.subplot((inputData.shape[-1] // 2) + (inputData.shape[-1] % 2 ),2, idx)
    idx += 1
    plt.boxplot(inputData[col], meanline=False, notch=False, labels=[''])
    plt.title(col)
plt.tight_layout()
plt.show()

pd.plotting.scatter_matrix(inputData, figsize=(15,15));

plt.figure(figsize=(10,10))
sns.heatmap(inputData.corr(), annot=True, cmap="Blues")
plt.show()

y = inputDataRaw.copy(deep=True)
y.drop(["X1","X2", "X3", "X4", "X5", "X6","X7","X8"], axis=1, inplace=True)
X = inputDataRaw.copy(deep=True)
X.drop(["Y1","Y2"], axis=1, inplace=True)
scaler = MaxAbsScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled,y, test_size=0.25, random_state=42)

datasets = {}
datasets[0] = {'X_train': X_train, 
               'X_test' : X_test,
               'y_train': y_train["Y1"].values, 
               'y_test' : y_test["Y1"].values}
datasets[1] = {'X_train': X_train, 
               'X_test' : X_test,
               'y_train': y_train["Y2"].values, 
               'y_test' : y_test["Y2"].values}

import time
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MaxAbsScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_log_error, mean_squared_error, mean_absolute_error
import sklearn.metrics
from tpot import TPOTRegressor

inputData = pd.read_excel("./data/ENB2012_data.xlsx")
y = inputData.copy(deep=True)
y.drop(["X1","X2", "X3", "X4", "X5", "X6","X7","X8"], axis=1, inplace=True)
X = inputData.copy(deep=True)
X.drop(["Y1","Y2"], axis=1, inplace=True)
scaler = MaxAbsScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled,
                                                    y,
                                                    test_size=0.25,
                                                    random_state=42)
tpot = TPOTRegressor(max_time_mins=60,
                     verbosity=21,
                     n_jobs=-1)
tpot.fit(X_train,y_train["Y1"].values)
tpot.export('energy_efficieny_heating_load.py')

y_predictions = tpot.predict(X_test)
r2 = sklearn.metrics.r2_score(y_test["Y1"].values, y_predictions)
mae = sklearn.metrics.mean_absolute_error(y_test["Y1"].values, y_predictions)
mse = sklearn.metrics.mean_squared_error(y_test["Y1"].values, y_predictions)
rmse = np.sqrt(mse)
print("R2 score:", r2)
print("MAE:", mae)
print("MSE:", mse)
print("RMSE:", rmse)

tpot = TPOTRegressor(max_time_mins=60,
                     verbosity=21,
                     n_jobs=-1)
tpot.fit(X_train,y_train["Y2"].values)
tpot.export('energy_efficieny_cooling_load.py')

y_predictions = tpot.predict(X_test)
r2 = sklearn.metrics.r2_score(y_test["Y2"].values, y_predictions)
mae = sklearn.metrics.mean_absolute_error(y_test["Y2"].values, y_predictions)
mse = sklearn.metrics.mean_squared_error(y_test["Y2"].values, y_predictions)
rmse = np.sqrt(mse)
print("R2 score:", r2)
print("MAE:", mae)
print("MSE:", mse)
print("RMSE:", rmse)

# heating load

import numpy as np
import pandas as pd
from sklearn.feature_selection import SelectFwe, f_regression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline, make_union
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeRegressor
from tpot.builtins import StackingEstimator
from xgboost import XGBRegressor
from sklearn.preprocessing import FunctionTransformer
from copy import copy

# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
            train_test_split(features, tpot_data['target'].values, random_state=None)

# Average CV score on the training set was:-0.14438142720136646
exported_pipeline = make_pipeline(
    make_union(
        make_pipeline(
            StackingEstimator(estimator=DecisionTreeRegressor(max_depth=1, min_samples_leaf=13, min_samples_split=8)),
            SelectFwe(score_func=f_regression, alpha=0.002)
        ),
        make_union(
            FunctionTransformer(copy),
            FunctionTransformer(copy)
        )
    ),
    StandardScaler(),
    XGBRegressor(learning_rate=0.1, max_depth=9, min_child_weight=1, n_estimators=100, nthread=1, subsample=0.7000000000000001)
)

exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)

# Cooling heat

import numpy as np
import pandas as pd
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline, make_union
from tpot.builtins import StackingEstimator
from xgboost import XGBRegressor

# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
            train_test_split(features, tpot_data['target'].values, random_state=None)

# Average CV score on the training set was:-0.766588545649422
exported_pipeline = make_pipeline(
    StackingEstimator(estimator=GradientBoostingRegressor(alpha=0.9, learning_rate=0.001, loss="ls", max_depth=10, max_features=0.7000000000000001, min_samples_leaf=17, min_samples_split=20, n_estimators=100, subsample=0.1)),
    XGBRegressor(learning_rate=0.5, max_depth=9, min_child_weight=14, n_estimators=100, nthread=1, subsample=1.0)
)

exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)