{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":41880,"databundleVersionId":5677426,"sourceType":"competition"}],"dockerImageVersionId":30635,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# import libraries\nimport os\nimport numpy as np \nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport glob\nfrom math import sqrt\n\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\nfrom sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\nfrom sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.svm import SVC\n\n\nimport lightgbm as lgb\nfrom lightgbm import LGBMClassifier\nfrom sklearn.metrics import roc_auc_score as ras \nfrom imblearn.over_sampling import SMOTE\nfrom sklearn.preprocessing import LabelEncoder\nimport itertools\nfrom itertools import *","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Create Dataset","metadata":{}},{"cell_type":"code","source":"DATA_ROOT_DEFOG = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/defog/'\ndefog = pd.DataFrame()\nfor root, dirs, files in os.walk(DATA_ROOT_DEFOG):\n    for name in files:       \n        f = os.path.join(root, name)\n        df_list= pd.read_csv(f)\n        words = name.split('.')[0]\n        df_list['file']= name.split('.')[0]\n        defog = pd.concat([defog, df_list], axis=0)\n        \nkeys = np.arange(len(defog))\ndefog = defog.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=True)\ndefog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"defog = defog.drop(['Valid','Task'], axis = 1)\ndefog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"defog['IsFOG'] = defog[['StartHesitation', 'Walking','Turn']].any(axis='columns')\nprint('\\n', defog[['Time','StartHesitation', 'Walking','Turn', 'IsFOG']][1047890:1071070])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# making sure there are no missing values:\nprint(len(defog['IsFOG'][defog['IsFOG']==0])+len(defog['IsFOG'][defog['IsFOG']==1]))\n\n# defining the beginings of each file/subj (defog has 91 files):\nsubj_start = (defog['Time'][defog['Time']==0])\nsubj_start_ind = np.array(subj_start.index)\nprint(len(subj_start_ind))\n# defining the ends of each file/subj (doesn't include the last one):\nsubj_end_ind = subj_start_ind[1:] - 1\nprint(len(subj_end_ind))\n\nprint('FOG event at head of subject number: ', np.where(defog['IsFOG'][subj_start_ind]==1))\n\nprint('FOG event at tail of subject number: ',np.where(defog['IsFOG'][subj_end_ind]==1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# FOG Identification","metadata":{}},{"cell_type":"code","source":"x = defog[['AccV','AccML','AccAP']]\ny = defog['IsFOG']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.1, random_state = 1 )","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Create LightGBM Datasets for training and validation \nx_train, x_val, y_train, y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state = 2 )\n\ntrain_data = lgb.Dataset(x_train, label=y_train) \ntest_data = lgb.Dataset(x_val, label=y_val, reference=train_data)  \n\n# Define hyperparameters and objective for LightGBM \nfog_params={\n    'objective': 'binary', #binary target feature\n    'metric': 'auc', \n    'boosting_type': 'gbdt',  #GradientBoostingDecisionTree\n    'learning_rate': 0.03,  \n    'verbose': 1,\n    'max_depth': 6,\n    'num_leaves': 50\n}","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Training a LightGBM Model \nnum_round = 200\n\n\n# Train a LightGBM model using defined parameters, training data, and specified number of rounds \nfog_model = lgb.train(fog_params, train_data, \n                  num_round, valid_sets=[test_data]) ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_train_pred1 = fog_model.predict(x_train)\ny_val_pred1 = fog_model.predict(x_val)\ny_test_pred1 = fog_model.predict(X_test)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Calculate and print the ROC-AUC scores\nprint(\"Training ROC-AUC: \", ras(y_train, y_train_pred1))\nprint(\"Validation ROC-AUC: \", ras(y_val, y_val_pred1)) \nprint(\"Test ROC-AUC: \", ras(Y_test, y_test_pred1)) ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# FOG Classification","metadata":{}},{"cell_type":"code","source":"# Adding additional features for each axis:\n# - rolling mean\n# - rolling standard deviation\n# - rolling maximum\n# - rolling minimum\n\nwindow_size = 200  # 2 seconds window for 100Hz sampling rate\n\n# Calculating rolling window features for each acceleration axis\nfor axis in ['AccV', 'AccML', 'AccAP']:\n    defog[f'{axis}_rolling_mean'] = defog[axis].rolling(window=window_size, min_periods=1).mean()\n    defog[f'{axis}_rolling_std'] = defog[axis].rolling(window=window_size, min_periods=1).std()\n    defog[f'{axis}_rolling_max'] = defog[axis].rolling(window=window_size, min_periods=1).max()\n    defog[f'{axis}_rolling_min'] = defog[axis].rolling(window=window_size, min_periods=1).min()\n\n# Drop rows that have NaN values which might be introduced by rolling window calculations\ndefog.dropna(inplace=True)\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"defog2 = defog[defog['IsFOG'] == True]\ndefog2","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Updating feature selection with rolling window features\nfeature_columns = ['AccV', 'AccML', 'AccAP', \n                   'AccV_rolling_mean', 'AccV_rolling_std', 'AccV_rolling_max', 'AccV_rolling_min',\n                   'AccML_rolling_mean', 'AccML_rolling_std', 'AccML_rolling_max', 'AccML_rolling_min',\n                   'AccAP_rolling_mean', 'AccAP_rolling_std', 'AccAP_rolling_max', 'AccAP_rolling_min']\n\nX = defog2[feature_columns]\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# targets\ny_StartHesitation = defog2['StartHesitation']\ny_Turn = defog2['Turn']\ny_Walking = defog2['Walking']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# # features\n# X = defog2[['AccV', 'AccML', 'AccAP']]\n\n# # targets\n# y_StartHesitation = defog2['StartHesitation']\n# y_Turn = defog2['Turn']\n# y_Walking = defog2['Walking']\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def apply_smote(X, y):\n    smote = SMOTE(random_state=42)\n    X_smote, y_smote = smote.fit_resample(X, y)\n    return X_smote, y_smote","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Splitting the data into training and testing sets for each target variable\nX_train, X_test, y_train_StartHesitation, y_test_StartHesitation = train_test_split(X, y_StartHesitation, test_size=0.2, random_state=42)\n_, _, y_train_Turn, y_test_Turn = train_test_split(X, y_Turn, test_size=0.2, random_state=42)\n_, _, y_train_Walking, y_test_Walking = train_test_split(X, y_Walking, test_size=0.2, random_state=42)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# SMOTE to the training data for each target variable\nX_train_smote_StartHesitation, y_train_smote_StartHesitation = apply_smote(X_train, y_train_StartHesitation)\nX_train_smote_Turn, y_train_smote_Turn = apply_smote(X_train, y_train_Turn)\nX_train_smote_Walking, y_train_smote_Walking = apply_smote(X_train, y_train_Walking)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## LGBM Models for Class","metadata":{}},{"cell_type":"code","source":"# Initialize and train the LightGBM model for each target variable\nlgbm_StartHesitation = LGBMClassifier(objective='binary', random_state=42)\nlgbm_StartHesitation.fit(X_train_smote_StartHesitation, y_train_smote_StartHesitation)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"lgbm_Turn = LGBMClassifier(objective='binary', random_state=42)\nlgbm_Turn.fit(X_train_smote_Turn, y_train_smote_Turn)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"lgbm_Walking = LGBMClassifier(objective='binary', random_state=42)\nlgbm_Walking.fit(X_train_smote_Walking, y_train_smote_Walking)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Get probabilities for the positive class of each target\ny_pred_proba_StartHesitation = lgbm_StartHesitation.predict_proba(X_test)[:, 1]  \ny_pred_proba_Turn = lgbm_Turn.predict_proba(X_test)[:, 1]  \ny_pred_proba_Walking = lgbm_Walking.predict_proba(X_test)[:, 1]  ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Evaluate using ROC AUC for each target variable\nroc_auc_StartHesitation = roc_auc_score(y_test_StartHesitation, y_pred_proba_StartHesitation)\nroc_auc_Turn = roc_auc_score(y_test_Turn, y_pred_proba_Turn)\nroc_auc_Walking = roc_auc_score(y_test_Walking, y_pred_proba_Walking)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(\"ROC AUC for StartHesitation:\", roc_auc_StartHesitation)\nprint(\"ROC AUC for Turn:\", roc_auc_Turn)\nprint(\"ROC AUC for Walking:\", roc_auc_Walking)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Test Predictions","metadata":{}},{"cell_type":"markdown","source":"## Defog","metadata":{}},{"cell_type":"code","source":"TEST_ROOT_DEFOG = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/test/defog/'\ntest_defog = pd.DataFrame()\nfor root, dirs, files in os.walk(TEST_ROOT_DEFOG):\n    for name in files:       \n        f = os.path.join(root, name)\n        df_list= pd.read_csv(f)\n        words = name.split('.')[0]\n        df_list['file']= name.split('.')[0]\n        test_defog = pd.concat([test_defog, df_list], axis=0)\n        \nkeys = np.arange(len(test_defog))\ntest_defog = test_defog.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=True)\ntest_defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog['Id'] = test_defog['file'] + '_' + test_defog['Time'].astype('str')\ntest_defog = test_defog.drop(['file'], axis = 1)\ntest_defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog_df = test_defog.drop(['Time','Id'], axis = 1)\ntest_defog_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"defog_pred_fog = fog_model.predict(test_defog_df)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog['FogProb'] = defog_pred_fog\ntest_defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Fog Classification Predictions","metadata":{}},{"cell_type":"code","source":"window_size = 200  # 2 seconds window for 100Hz sampling rate\n\n# Calculating rolling window features for each acceleration axis\nfor axis in ['AccV', 'AccML', 'AccAP']:\n    test_defog[f'{axis}_rolling_mean'] = test_defog[axis].rolling(window=window_size, min_periods=1).mean()\n    test_defog[f'{axis}_rolling_std'] = test_defog[axis].rolling(window=window_size, min_periods=1).std()\n    test_defog[f'{axis}_rolling_max'] = test_defog[axis].rolling(window=window_size, min_periods=1).max()\n    test_defog[f'{axis}_rolling_min'] = test_defog[axis].rolling(window=window_size, min_periods=1).min()\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Updating feature selection with rolling window features\nfeature_columns = ['AccV', 'AccML', 'AccAP', \n                   'AccV_rolling_mean', 'AccV_rolling_std', 'AccV_rolling_max', 'AccV_rolling_min',\n                   'AccML_rolling_mean', 'AccML_rolling_std', 'AccML_rolling_max', 'AccML_rolling_min',\n                   'AccAP_rolling_mean', 'AccAP_rolling_std', 'AccAP_rolling_max', 'AccAP_rolling_min']\n\nX = test_defog[feature_columns]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog_SH_pred = lgbm_StartHesitation.predict(X)\ntest_defog_T_pred = lgbm_Turn.predict(X)\ntest_defog_W_pred = lgbm_Walking.predict(X)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog['StartHesitation'] = np.sqrt(test_defog_SH_pred * defog_pred_fog)\ntest_defog['Turn'] = np.sqrt(test_defog_T_pred * defog_pred_fog)\ntest_defog['Walking'] = np.sqrt(test_defog_W_pred * defog_pred_fog)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Final Submission","metadata":{}},{"cell_type":"code","source":"test_defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm = test_defog[['Id','StartHesitation','Turn','Walking']]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DATA_ROOT_TDCS = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/tdcsfog/'\ntdcs = pd.DataFrame()\nfor root, dirs, files in os.walk(DATA_ROOT_TDCS):\n    for name in files:       \n        f = os.path.join(root, name)\n        df_list= pd.read_csv(f)\n        words = name.split('.')[0]\n        df_list['file']= name.split('.')[0]\n        tdcs = pd.concat([tdcs, df_list], axis=0)\n        \nkeys = np.arange(len(tdcs))\ntdcs = tdcs.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=True)\ntdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcs['IsFOG'] = tdcs[['StartHesitation', 'Walking','Turn']].any(axis='columns')\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# making sure there are no missing values:\nprint(len(tdcs['IsFOG'][tdcs['IsFOG']==0])+len(tdcs['IsFOG'][tdcs['IsFOG']==1]))\n\n# defining the beginings of each file/subj (defog has 91 files):\nsubj_start = (tdcs['Time'][tdcs['Time']==0])\nsubj_start_ind = np.array(subj_start.index)\nprint(len(subj_start_ind))\n# defining the ends of each file/subj (doesn't include the last one):\nsubj_end_ind = subj_start_ind[1:] - 1\nprint(len(subj_end_ind))\n\nprint('FOG event at head of subject number: ', np.where(tdcs['IsFOG'][subj_start_ind]==1))\n\nprint('FOG event at tail of subject number: ',np.where(tdcs['IsFOG'][subj_end_ind]==1))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x = tdcs[['AccV','AccML','AccAP']]\ny = tdcs['IsFOG']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train, X_test, Y_train, Y_test = train_test_split(x, y, test_size = 0.1, random_state = 1 )","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Create LightGBM Datasets for training and validation \nx_train, x_val, y_train, y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state = 2 )\n\ntrain_data = lgb.Dataset(x_train, label=y_train) \ntest_data = lgb.Dataset(x_val, label=y_val, reference=train_data)  \n\n# Define hyperparameters and objective for LightGBM \nfog_params={\n    'objective': 'binary', #binary target feature\n    'metric': 'auc', \n    'boosting_type': 'gbdt',  #GradientBoostingDecisionTree\n    'learning_rate': 0.03,  \n    'verbose': 1,\n    'max_depth': 6,\n    'num_leaves': 50\n}","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Training a LightGBM Model \nnum_round = 200\n\n\n# Train a LightGBM model using defined parameters, training data, and specified number of rounds \ntdcs_model = lgb.train(fog_params, train_data, \n                  num_round, valid_sets=[test_data]) ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_train_pred1 = tdcs_model.predict(x_train)\ny_val_pred1 = tdcs_model.predict(x_val)\ny_test_pred1 = tdcs_model.predict(X_test)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Calculate and print the ROC-AUC scores\nprint(\"Training ROC-AUC: \", ras(y_train, y_train_pred1))\nprint(\"Validation ROC-AUC: \", ras(y_val, y_val_pred1)) \nprint(\"Test ROC-AUC: \", ras(Y_test, y_test_pred1)) ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Adding additional features for each axis:\n# - rolling mean\n# - rolling standard deviation\n# - rolling maximum\n# - rolling minimum\n\nwindow_size = 200  # 2 seconds window for 100Hz sampling rate\n\n# Calculating rolling window features for each acceleration axis\nfor axis in ['AccV', 'AccML', 'AccAP']:\n    tdcs[f'{axis}_rolling_mean'] = tdcs[axis].rolling(window=window_size, min_periods=1).mean()\n    tdcs[f'{axis}_rolling_std'] = tdcs[axis].rolling(window=window_size, min_periods=1).std()\n    tdcs[f'{axis}_rolling_max'] = tdcs[axis].rolling(window=window_size, min_periods=1).max()\n    tdcs[f'{axis}_rolling_min'] = tdcs[axis].rolling(window=window_size, min_periods=1).min()\n\n# Drop rows that have NaN values which might be introduced by rolling window calculations\ntdcs.dropna(inplace=True)\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcs2 = tdcs[tdcs['IsFOG'] == True]\ntdcs2","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Updating feature selection with rolling window features\nfeature_columns = ['AccV', 'AccML', 'AccAP', \n                   'AccV_rolling_mean', 'AccV_rolling_std', 'AccV_rolling_max', 'AccV_rolling_min',\n                   'AccML_rolling_mean', 'AccML_rolling_std', 'AccML_rolling_max', 'AccML_rolling_min',\n                   'AccAP_rolling_mean', 'AccAP_rolling_std', 'AccAP_rolling_max', 'AccAP_rolling_min']\n\nX = tdcs2[feature_columns]\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# targets\ny_StartHesitation = tdcs2['StartHesitation']\ny_Turn = tdcs2['Turn']\ny_Walking = tdcs2['Walking']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def apply_smote(X, y):\n    smote = SMOTE(random_state=42)\n    X_smote, y_smote = smote.fit_resample(X, y)\n    return X_smote, y_smote","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Splitting the data into training and testing sets for each target variable\nX_train, X_test, y_train_StartHesitation, y_test_StartHesitation = train_test_split(X, y_StartHesitation, test_size=0.2, random_state=42)\n_, _, y_train_Turn, y_test_Turn = train_test_split(X, y_Turn, test_size=0.2, random_state=42)\n_, _, y_train_Walking, y_test_Walking = train_test_split(X, y_Walking, test_size=0.2, random_state=42)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# SMOTE to the training data for each target variable\nX_train_smote_StartHesitation, y_train_smote_StartHesitation = apply_smote(X_train, y_train_StartHesitation)\nX_train_smote_Turn, y_train_smote_Turn = apply_smote(X_train, y_train_Turn)\nX_train_smote_Walking, y_train_smote_Walking = apply_smote(X_train, y_train_Walking)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Initialize and train the LightGBM model for each target variable\nlgbm_StartHesitation = LGBMClassifier(objective='binary', random_state=42)\nlgbm_StartHesitation.fit(X_train_smote_StartHesitation, y_train_smote_StartHesitation)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"lgbm_Turn = LGBMClassifier(objective='binary', random_state=42)\nlgbm_Turn.fit(X_train_smote_Turn, y_train_smote_Turn)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"lgbm_Walking = LGBMClassifier(objective='binary', random_state=42)\nlgbm_Walking.fit(X_train_smote_Walking, y_train_smote_Walking)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Get probabilities for the positive class of each target\ny_pred_proba_StartHesitation = lgbm_StartHesitation.predict_proba(X_test)[:, 1]  \ny_pred_proba_Turn = lgbm_Turn.predict_proba(X_test)[:, 1]  \ny_pred_proba_Walking = lgbm_Walking.predict_proba(X_test)[:, 1]  ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Evaluate using ROC AUC for each target variable\nroc_auc_StartHesitation = roc_auc_score(y_test_StartHesitation, y_pred_proba_StartHesitation)\nroc_auc_Turn = roc_auc_score(y_test_Turn, y_pred_proba_Turn)\nroc_auc_Walking = roc_auc_score(y_test_Walking, y_pred_proba_Walking)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(\"ROC AUC for StartHesitation:\", roc_auc_StartHesitation)\nprint(\"ROC AUC for Turn:\", roc_auc_Turn)\nprint(\"ROC AUC for Walking:\", roc_auc_Walking)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"TEST_ROOT_TDCS= '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/test/tdcsfog/'\ntest_tdcs = pd.DataFrame()\nfor root, dirs, files in os.walk(TEST_ROOT_TDCS):\n    for name in files:       \n        f = os.path.join(root, name)\n        df_list= pd.read_csv(f)\n        words = name.split('.')[0]\n        df_list['file']= name.split('.')[0]\n        test_tdcs = pd.concat([test_tdcs, df_list], axis=0)\n        \nkeys = np.arange(len(test_tdcs))\ntest_tdcs = test_tdcs.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=True)\ntest_tdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs['Id'] = test_tdcs['file'] + '_' + test_tdcs['Time'].astype('str')\ntest_tdcs = test_tdcs.drop(['file'], axis = 1)\ntest_tdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs_df = test_tdcs.drop(['Time','Id'], axis = 1)\ntest_tdcs_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcs_pred_fog = tdcs_model.predict(test_tdcs_df)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs['FogProb'] = tdcs_pred_fog\ntest_tdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"window_size = 200  # 2 seconds window for 100Hz sampling rate\n\n# Calculating rolling window features for each acceleration axis\nfor axis in ['AccV', 'AccML', 'AccAP']:\n    test_tdcs[f'{axis}_rolling_mean'] = test_tdcs[axis].rolling(window=window_size, min_periods=1).mean()\n    test_tdcs[f'{axis}_rolling_std'] = test_tdcs[axis].rolling(window=window_size, min_periods=1).std()\n    test_tdcs[f'{axis}_rolling_max'] = test_tdcs[axis].rolling(window=window_size, min_periods=1).max()\n    test_tdcs[f'{axis}_rolling_min'] = test_tdcs[axis].rolling(window=window_size, min_periods=1).min()\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Updating feature selection with rolling window features\nfeature_columns = ['AccV', 'AccML', 'AccAP', \n                   'AccV_rolling_mean', 'AccV_rolling_std', 'AccV_rolling_max', 'AccV_rolling_min',\n                   'AccML_rolling_mean', 'AccML_rolling_std', 'AccML_rolling_max', 'AccML_rolling_min',\n                   'AccAP_rolling_mean', 'AccAP_rolling_std', 'AccAP_rolling_max', 'AccAP_rolling_min']\n\nX = test_tdcs[feature_columns]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs_SH_pred = lgbm_StartHesitation.predict(X)\ntest_tdcs_T_pred = lgbm_Turn.predict(X)\ntest_tdcs_W_pred = lgbm_Walking.predict(X)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs['StartHesitation'] = np.sqrt(test_tdcs_SH_pred * tdcs_pred_fog)\ntest_tdcs['Turn'] = np.sqrt(test_tdcs_T_pred * tdcs_pred_fog)\ntest_tdcs['Walking'] = np.sqrt(test_tdcs_W_pred * tdcs_pred_fog)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcs","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm2 = test_tdcs[['Id','StartHesitation','Turn','Walking']]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm_final = pd.concat([subm, subm2], ignore_index=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm_final.to_csv(\"submission.csv\",index=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm_final","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}