{"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\nimport gc\n\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_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 sklearn.metrics import average_precision_score as aps\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":"def read_and_process_data(data_root, drop_columns=['Valid', 'Task']):\n    \"\"\"\n    Read and process CSV files from a directory.\n\n    Parameters:\n    - data_root: The root directory containing the CSV files.\n    - drop_columns: List of columns to be dropped from the dataframes.\n\n    Returns:\n    - A pandas DataFrame containing concatenated and processed data.\n    \"\"\"\n    data = pd.DataFrame()\n    for root, _, files in os.walk(data_root):\n        for name in files:\n            file_path = os.path.join(root, name)\n            df = pd.read_csv(file_path)\n            # Drop the columns only if they exist in the dataframe\n            df = df.drop(columns=[col for col in drop_columns if col in df.columns], axis=1)\n            df['file'] = name.split('.')[0]\n            data = pd.concat([data, df], axis=0)\n            \n    data.reset_index(drop=True, inplace=True)\n    return data \n\ndef add_rolling_window_features(data, window_size=200, feature_columns=['AccV', 'AccML', 'AccAP']):\n    \"\"\"\n    Add rolling window features to the dataset.\n\n    Parameters:\n    - data: The pandas DataFrame to which the features will be added.\n    - window_size: The size of the rolling window. 2 seconds window for 100Hz sampling rate\n    - feature_columns: The columns to calculate the rolling features for.\n\n    Returns:\n    - The pandas DataFrame with the new rolling window features added.\n    \"\"\"\n    for axis in feature_columns:\n        data[f'{axis}_rolling_mean'] = data[axis].rolling(window=window_size, min_periods=1).mean()\n        data[f'{axis}_rolling_std'] = data[axis].rolling(window=window_size, min_periods=1).std()\n        data[f'{axis}_rolling_max'] = data[axis].rolling(window=window_size, min_periods=1).max()\n        data[f'{axis}_rolling_min'] = data[axis].rolling(window=window_size, min_periods=1).min()\n    \n    data.dropna(inplace=True)\n    return data\n\n# Define the root directories for the data\nDATA_ROOT_DEFOG = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/defog/'\nDATA_ROOT_TDCSFOG = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/tdcsfog/' \n\n# Process the DEFOG and TDCSFOG datasets\ndefog = read_and_process_data(DATA_ROOT_DEFOG)\ndefog = add_rolling_window_features(defog)\ndefog['IsFOG'] = defog[['StartHesitation', 'Walking', 'Turn']].any(axis='columns')\n\ntdcsfog = read_and_process_data(DATA_ROOT_TDCSFOG)\ntdcsfog = add_rolling_window_features(tdcsfog)\ntdcsfog['IsFOG'] = tdcsfog[['StartHesitation', 'Walking', 'Turn']].any(axis='columns')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# FOG Identification","metadata":{}},{"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']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"xde = defog[feature_columns]\nyde = defog['IsFOG']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"defog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"xtdcs = tdcsfog[feature_columns]\nytdcs = tdcsfog['IsFOG']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Defog Detection","metadata":{}},{"cell_type":"code","source":"# Create LightGBM Datasets for training and validation \nxde_train, xde_val, yde_train, yde_val = train_test_split(xde, yde, test_size = 0.1, random_state = 2 )\n\ntrain_data = lgb.Dataset(xde_train, label=yde_train) \ntest_data = lgb.Dataset(xde_val, label=yde_val, reference=train_data)  \n\n# Define hyperparameters and objective for LightGBM \nfog_params={\n    'objective': 'binary', #binary target feature\n    'metric': 'average_precision', \n    'boosting_type': 'gbdt',  #GradientBoostingDecisionTree\n    'learning_rate': 0.18,\n    'verbose': 1,\n    'max_depth': 10,\n    'num_leaves': 80,\n    'is_unbalance':True\n}","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Training a LightGBM Model \nnum_round = 1000\n\n\n# Train a LightGBM model for defog using defined parameters, training data, and specified number of rounds \ndefog_model = lgb.train(fog_params, train_data, \n                  num_round, valid_sets=[test_data])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# TDCSfog Detection","metadata":{}},{"cell_type":"code","source":"# Create LightGBM Datasets for training and validation \nxtdcs_train, xtdcs_val, ytdcs_train, ytdcs_val = train_test_split(xtdcs, ytdcs, test_size = 0.1, random_state = 2 )\n\ntrain_data = lgb.Dataset(xtdcs_train, label=ytdcs_train) \ntest_data = lgb.Dataset(xtdcs_val, label=ytdcs_val, reference=train_data)  ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Training a LightGBM Model \nnum_round = 1000\n\n\n# Train a LightGBM model for tdcsfog using defined parameters, training data, and specified number of rounds \ntdcsfog_model = lgb.train(fog_params, train_data, \n                  num_round, valid_sets=[test_data])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# FOG Classification","metadata":{}},{"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":"markdown","source":"## Defog Model","metadata":{}},{"cell_type":"code","source":"# Train Classification models on Fog events only\ndefog2 = defog[defog['IsFOG'] == True]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X = defog2[feature_columns]","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":"# Splitting the data into training and testing sets for each target variable\nX_train, X_test_defog, 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":"# Define hyperparameters and objective for LightGBM\nparams = {\n    'objective': 'binary',\n    'metric': 'average_precision',\n    'boosting_type': 'gbdt',\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":"# Preparing LightGBM datasets for StartHesitation\ntrain_data_StartHesitation = lgb.Dataset(X_train_smote_StartHesitation, label=y_train_smote_StartHesitation)\ntest_data_StartHesitation = lgb.Dataset(X_test_defog, label=y_test_StartHesitation, reference=train_data_StartHesitation)\n\nnum_round = 300\n# Training a LightGBM model for StartHesitation\nde_model_StartHesitation = lgb.train(params, train_data_StartHesitation, num_round, valid_sets=[test_data_StartHesitation])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Preparing LightGBM datasets for Turn\ntrain_data_Turn = lgb.Dataset(X_train_smote_Turn, label=y_train_smote_Turn)\ntest_data_Turn = lgb.Dataset(X_test_defog, label=y_test_Turn, reference=train_data_Turn)\n\nnum_round = 600\n# Training a LightGBM model for Turn\nde_model_Turn = lgb.train(params, train_data_Turn, num_round, valid_sets=[test_data_Turn])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Preparing LightGBM datasets for Walking\ntrain_data_Walking = lgb.Dataset(X_train_smote_Walking, label=y_train_smote_Walking)\ntest_data_Walking = lgb.Dataset(X_test_defog, label=y_test_Walking, reference=train_data_Walking)\n\nnum_round = 800\n# Training a LightGBM model for Walking\nde_model_Walking = lgb.train(params, train_data_Walking, num_round, valid_sets=[test_data_Walking])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# clear memory\ngc.collect()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## TDCSfog Model","metadata":{}},{"cell_type":"code","source":"tdcsfog2 = tdcsfog[tdcsfog['IsFOG'] == True]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X = tdcsfog2[feature_columns]\n\n# targets\ny_StartHesitation = tdcsfog2['StartHesitation']\ny_Turn = tdcsfog2['Turn']\ny_Walking = tdcsfog2['Walking']","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_tdcs, 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)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Define hyperparameters and objective for LightGBM\nparams = {\n    'objective': 'binary',\n    'metric': 'average_precision',\n    'boosting_type': 'gbdt',\n    'learning_rate': 0.06,\n    'verbose': 1,\n    'max_depth': 6,\n    'num_leaves': 50\n}","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Preparing LightGBM datasets for StartHesitation\ntrain_data_StartHesitation = lgb.Dataset(X_train_smote_StartHesitation, label=y_train_smote_StartHesitation)\ntest_data_StartHesitation = lgb.Dataset(X_test_tdcs, label=y_test_StartHesitation, reference=train_data_StartHesitation)\n\nnum_round = 1000\n# Training a LightGBM model for StartHesitation\ntdcs_model_StartHesitation = lgb.train(params, train_data_StartHesitation, num_round, valid_sets=[test_data_StartHesitation])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Preparing LightGBM datasets for Turn\ntrain_data_Turn = lgb.Dataset(X_train_smote_Turn, label=y_train_smote_Turn)\ntest_data_Turn = lgb.Dataset(X_test_tdcs, label=y_test_Turn, reference=train_data_Turn)\n\nnum_round = 700\n# Training a LightGBM model for Turn\ntdcs_model_Turn = lgb.train(params, train_data_Turn, num_round, valid_sets=[test_data_Turn])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Preparing LightGBM datasets for Walking\ntrain_data_Walking = lgb.Dataset(X_train_smote_Walking, label=y_train_smote_Walking)\ntest_data_Walking = lgb.Dataset(X_test_tdcs, label=y_test_Walking, reference=train_data_Walking)\n\nnum_round = 1000\n# Training a LightGBM model for Walking\ntdcs_model_Walking = lgb.train(params, train_data_Walking, num_round, valid_sets=[test_data_Walking])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Delete some old training data for memory space\ndel [\n    defog, defog2,\n     tdcsfog, tdcsfog2,\n     X, y_StartHesitation, y_Turn, y_Walking,\n     X_train, y_train_StartHesitation, y_test_StartHesitation,\n     y_train_Turn, y_test_Turn, y_train_Walking, y_test_Walking,\n     X_train_smote_StartHesitation, y_train_smote_StartHesitation,\n     X_train_smote_Turn, y_train_smote_Turn,\n     X_train_smote_Walking, y_train_smote_Walking\n    ]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gc.collect()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Test Predictions","metadata":{}},{"cell_type":"code","source":"TEST_ROOT_DEFOG = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/test/defog/'\n\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        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)","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)","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_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_ROOT_TDCSFOG = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/test/tdcsfog/'\n\ntest_tdcsfog = pd.DataFrame()\nfor root, dirs, files in os.walk(TEST_ROOT_TDCSFOG):\n    for name in files:       \n        f = os.path.join(root, name)\n        df_list= pd.read_csv(f)\n        df_list['file']= name.split('.')[0]\n        test_tdcsfog = pd.concat([test_tdcsfog, df_list], axis=0)\n        \nkeys = np.arange(len(test_tdcsfog))\ntest_tdcsfog = test_tdcsfog.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcsfog['Id'] = test_tdcsfog['file'] + '_' + test_tdcsfog['Time'].astype('str')\ntest_tdcsfog = test_tdcsfog.drop(['file'], axis = 1)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Calculating rolling window features for each acceleration axis\nfor axis in ['AccV', 'AccML', 'AccAP']:\n    test_tdcsfog[f'{axis}_rolling_mean'] = test_tdcsfog[axis].rolling(window=window_size, min_periods=1).mean()\n    test_tdcsfog[f'{axis}_rolling_std'] = test_tdcsfog[axis].rolling(window=window_size, min_periods=1).std()\n    test_tdcsfog[f'{axis}_rolling_max'] = test_tdcsfog[axis].rolling(window=window_size, min_periods=1).max()\n    test_tdcsfog[f'{axis}_rolling_min'] = test_tdcsfog[axis].rolling(window=window_size, min_periods=1).min()\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Defog Identification","metadata":{}},{"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":"defog_pred = defog_model.predict(X)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Add momentum to defog identification; FOG event continuity\nde_len = len(defog_pred)\ndefog_pred = np.insert(defog_pred, 0, 0)\ndefog_pred_fog = [(defog_pred[i]/8) + defog_pred[i+1] for i in range(de_len)]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_defog['FogProb'] = defog_pred_fog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Defog Classification Predictions","metadata":{}},{"cell_type":"code","source":"test_defog_SH_pred = de_model_StartHesitation.predict(X)\ntest_defog_T_pred = de_model_Turn.predict(X)\ntest_defog_W_pred = de_model_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)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## TDCSfog Identification","metadata":{}},{"cell_type":"code","source":"X = test_tdcsfog[feature_columns]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcsfog_pred = tdcsfog_model.predict(X)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcs_len = len(tdcsfog_pred)\ntdcsfog_pred = np.insert(tdcsfog_pred, 0, 0)\ntdcsfog_pred_fog = [(tdcsfog_pred[i]/8) + tdcsfog_pred[i+1] for i in range(tdcs_len)]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcsfog['FogProb'] = tdcsfog_pred_fog","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## TDCSfog Classification Predictions","metadata":{}},{"cell_type":"code","source":"test_tdcsfog_SH_pred = tdcs_model_StartHesitation.predict(X)\ntest_tdcsfog_T_pred = tdcs_model_Turn.predict(X)\ntest_tdcsfog_W_pred = tdcs_model_Walking.predict(X)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_tdcsfog['StartHesitation'] = np.sqrt(test_tdcsfog_SH_pred * tdcsfog_pred_fog)\ntest_tdcsfog['Turn'] = np.sqrt(test_tdcsfog_T_pred * tdcsfog_pred_fog)\ntest_tdcsfog['Walking'] = np.sqrt(test_tdcsfog_W_pred * tdcsfog_pred_fog)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gc.collect()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Final Submission","metadata":{}},{"cell_type":"code","source":"subm_de = test_defog[['Id','StartHesitation','Turn','Walking']]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm_tdcs = test_tdcsfog[['Id','StartHesitation','Turn','Walking']]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm = pd.concat([subm_de, subm_tdcs], ignore_index=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"subm.to_csv(\"submission.csv\",index=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}