Utilizing Bagging & Stacking Ensembles to Predict Sleep Score

# View a head of the data to find out about column naming issues, and missing values 
test = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /November Sleep Data - Sheet1.csv")
test.head(10)

nov = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /November Sleep Data - Sheet1.csv")
dec = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /December Sleep data - Sheet1.csv")
jan = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /January sleep data - Sheet1.csv")
feb = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /February sleep data - Sheet1 (1).csv")
mar = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /March sleep data - Sheet1.csv")
apr = pd.read_csv("/Users/rileysvensson/Desktop/GSB 545 - Advanced Machine Learning/data /April sleep data - Sheet1.csv")

# Rename Column with Month name to appropriate name Weekday, as this is what the column holds
apr.rename(columns={'APRIL': 'WEEKDAY'}, inplace=True)
nov.rename(columns={'NOVEMBER': 'WEEKDAY'}, inplace=True)
dec.rename(columns={'DECEMBER': 'WEEKDAY'}, inplace=True)
jan.rename(columns={'JANUARY': 'WEEKDAY'}, inplace=True)
feb.rename(columns={'FEBEUARY': 'WEEKDAY'}, inplace=True)
mar.rename(columns={'MARCH': 'WEEKDAY'}, inplace=True)

# Fix naming of columns to have consistency across all 6 files 
jan.rename(columns={'HEART RATE UNDER RESTING': 'HEART RATE BELOW RESTING'}, inplace=True)
feb.rename(columns={'SLEEP SQORE': 'SLEEP SCORE'}, inplace=True)
mar.rename(columns={'HEARTRATE BELOW RESTING': 'HEART RATE BELOW RESTING'}, inplace=True)


# Stack these df's to create a complete dataset
sleep_data_total = pd.concat([nov, dec, jan, feb, mar, apr], ignore_index=True)

# Drop rows with any missing values
sleep_data = sleep_data_total.dropna()
sleep_data.head(10)

sleep_data_final = sleep_data.copy()

# Splitting the 'SLEEP TIME' column into 'Sleep Start' and 'Sleep End'
sleep_data_final[['Sleep Start', 'Sleep End']] = sleep_data_final['SLEEP TIME'].str.split(' - ', expand=True)

# Convert Hours of Sleep to float, some times in hh:mm format only
sleep_data_final['HOURS OF SLEEP'] = sleep_data_final['HOURS OF SLEEP'].apply(
    lambda x: pd.to_timedelta(x if x.count(':') == 2 else x + ':00').total_seconds() / 3600  # seconds
)

# Converting Deep Sleep + REM to be decimals for calculation, strip % sign, make float type, and divide by 100
sleep_data_final['DEEP SLEEP'] = sleep_data_final['DEEP SLEEP'].str.rstrip('%').astype(float) / 100
sleep_data_final['REM SLEEP'] = sleep_data_final['REM SLEEP'].str.rstrip('%').astype(float) / 100
sleep_data_final['HEART RATE BELOW RESTING'] = sleep_data_final['HEART RATE BELOW RESTING'].str.rstrip('%').astype(float) / 100


# Creating an interaction between (Hours of Sleep & REM Sleep %) and (Hours of Sleep * Deep Sleep %)
sleep_data_final['Hours REM Sleep'] = sleep_data_final['HOURS OF SLEEP'] * sleep_data_final['REM SLEEP']
sleep_data_final['Hours Deep Sleep'] = sleep_data_final['HOURS OF SLEEP'] * sleep_data_final['DEEP SLEEP']
sleep_data_final['Hours HRBR'] = sleep_data_final['HOURS OF SLEEP'] * sleep_data_final['HEART RATE BELOW RESTING']

# Calculate total sleep time, so we can divide HRS of SLEEP by it to find % sleeping

def add_am_pm(time_str):
    # Check if 'AM' or 'PM' is already present
    if 'am' in time_str.lower() or 'pm' in time_str.lower():
        return time_str
    hour = int(time_str.split(':')[0])
    return time_str + ('PM' if 7 <= hour <= 11 else 'AM')

# Apply the function to correct the time format
sleep_data_final['Sleep Start'] = sleep_data_final['Sleep Start'].apply(add_am_pm)
sleep_data_final['Sleep End'] = sleep_data_final['Sleep End'].apply(add_am_pm)

# Now attempt to convert to datetime
sleep_data_final['Sleep Start'] = pd.to_datetime(sleep_data_final['Sleep Start'], format='%I:%M%p', errors='coerce')
sleep_data_final['Sleep End'] = pd.to_datetime(sleep_data_final['Sleep End'], format='%I:%M%p', errors='coerce')

# Function to calculate duration considering possible midnight crossover
def calculate_duration(row):
    start = row['Sleep Start']
    end = row['Sleep End']
    if pd.isnull(start) or pd.isnull(end):
        return None
    if end < start:
        end += pd.Timedelta(days=1)
    return (end - start).total_seconds() / 3600

# Apply duration calculation to get Total Sleep Time
sleep_data_final['Total Sleep Time'] = sleep_data_final.apply(calculate_duration, axis=1)

# Drop repeated columns used to calculate Total Sleep Time
sleep_data_final.drop(['SLEEP TIME','Sleep Start','Sleep End'], axis = 1)

# Calculate Rate of Sleeping (Hours of Sleep / Total Sleep Time)
sleep_data_final['Sleep Rate'] = sleep_data_final['HOURS OF SLEEP'] / sleep_data_final['Total Sleep Time']

features = sleep_data_final.drop(['SLEEP TIME','Sleep Start','Sleep End'], axis = 1)

# Date should be converted from an object to Datetime, and split to YEAR, MONTH, DAY
features['DATE'] = pd.to_datetime(features['DATE'])

features['YEAR'] = features['DATE'].dt.year
features['MONTH'] = features['DATE'].dt.month
features['DAY'] = features['DATE'].dt.day

features_final = features.dropna()

features_final.head(10)

# Define X and Y sets

X = features_final.drop(["SLEEP SCORE", "DATE","DAY","WEEKDAY","YEAR"], axis = 1)
y = features_final["SLEEP SCORE"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state= 2)

# Model 1 - Dummify everything needed and scale numerical columns, All Predictors
ct_all = ColumnTransformer(
  [
    ("dummify", OneHotEncoder(sparse_output = False, handle_unknown='ignore'),
    make_column_selector(dtype_include=object)),
    ("standardize", StandardScaler(), make_column_selector(dtype_include=np.float64))  #keep int64 as is
  ],
  remainder = "passthrough" 
).set_output(transform = "pandas")

# Define base models within the preprocessing pipeline to apply consistent scaling/dummification

base_models = [
    ('knn', Pipeline([
        ('preprocessor', ct_all),
        ('regressor', KNeighborsRegressor(n_neighbors=15)) #experimented with different values 5,10,15,20
    ])),
    ('svr', Pipeline([
        ('preprocessor', ct_all),
        ('regressor', SVR(kernel='linear'))  # linear kernel performed best
    ])),
    ('bagging_tree', Pipeline([
        ('preprocessor', ct_all),
        ('regressor', BaggingRegressor(n_estimators=100, random_state=2))  #n_estimators was optimal at 100
    ])),
    ('random_forest', Pipeline([
        ('preprocessor', ct_all),
        ('regressor', RandomForestRegressor(n_estimators=100, random_state=2))  #n_estimators was optimal at 100
    ])),
    ('gradient_boosting', Pipeline([
        ('preprocessor', ct_all),
        ('regressor', GradientBoostingRegressor(n_estimators=100, random_state=2))  #n_estimators was optimal at 100
    ])),
    ('ridge', Pipeline([
        ('preprocessor', ct_all),
        ('regressor', Ridge(alpha=0.8))  # experimented with 0.5 - 1.0, + 0.1
    ]))
]

# Define the final regressor method, typically Linear or Logistic, makes sense to use Linear here 
final_regressor = LinearRegression()

# Create the stacking ensemble
stacking_regressor = StackingRegressor(estimators=base_models, final_estimator=final_regressor, cv=5)

# Fit the stacking model on the training data
stacking_regressor.fit(X_train, y_train)

# Predict/evaluate the model on the Test data
stacking_predictions = stacking_regressor.predict(X_test)
stacking_mae = mean_absolute_error(y_test, stacking_predictions)

# Stacking model performance 
print("Stacking Model MAE: ", stacking_mae)