{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import os\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom pylab import rcParams\nfrom tqdm import tqdm\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report, average_precision_score\nfrom sklearn.preprocessing import RobustScaler, StandardScaler\nfrom statsmodels.tsa.seasonal import seasonal_decompose\nfrom statsmodels.tsa.stattools import adfuller\nfrom statsmodels.graphics.tsaplots import plot_acf\nfrom statsmodels.tsa.stattools import acf\nfrom scipy.signal import stft\nimport catboost as cat\nfrom sklearn.utils.class_weight import compute_class_weight","metadata":{"execution":{"iopub.status.busy":"2023-06-19T08:19:31.832631Z","iopub.execute_input":"2023-06-19T08:19:31.833014Z","iopub.status.idle":"2023-06-19T08:19:31.841122Z","shell.execute_reply.started":"2023-06-19T08:19:31.832984Z","shell.execute_reply":"2023-06-19T08:19:31.839754Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"random_state = 42","metadata":{"execution":{"iopub.status.busy":"2023-06-19T08:19:32.415400Z","iopub.execute_input":"2023-06-19T08:19:32.415799Z","iopub.status.idle":"2023-06-19T08:19:32.419991Z","shell.execute_reply.started":"2023-06-19T08:19:32.415767Z","shell.execute_reply":"2023-06-19T08:19:32.419086Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# TDCSFOG MODEL","metadata":{}},{"cell_type":"code","source":"# Set the directory path to the folder containing the CSV files.\ntdcsfog_path = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/tdcsfog'\n\n# Initialize an empty list to store the dataframes.\ntdcsfog_list = []\n\n# Loop through each file in the directory and read it into a dataframe.\nfor file_name in tqdm(os.listdir(tdcsfog_path)):\n    if file_name.endswith('.csv'):\n        file_path = os.path.join(tdcsfog_path, file_name)\n        file = pd.read_csv(file_path)\n        tdcsfog_list.append(file)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_window(x, threshhold = 0.2, winsize = 100):\n    f, t, Zxx = stft(x, nperseg=winsize)\n    tmp = np.zeros_like(t)\n    tmp[np.sum(np.abs(Zxx)[2:-10, :], axis=0) > threshhold] = 1\n    tmp[0] = 0\n    tmp[-1] = 0\n    tmp[-2] = 0\n    ind = np.arange(len(x))\n    window = tmp[ind // int(t[1] - t[0])]\n    return window.astype(bool)\n\ndef get_decomposition(x, threshhold=1.5, winsize=200, period=140):\n    window = get_window(x, threshhold=threshhold, winsize=winsize)\n    new_window = np.where(window)[0][period//2:-period//1]\n    #new_window = np.arange(len(x))[period//2:-period//1]\n    decompose = seasonal_decompose(x[window], period=period)\n    #decompose = seasonal_decompose(x, period=period)\n    trend = x.copy()\n    seasonal = np.zeros_like(trend)\n    resid = np.zeros_like(trend)\n    trend[new_window] = decompose.trend[period//2:-period//1]\n    seasonal[new_window] = decompose.seasonal[period//2:-period//1]\n    resid[new_window] = decompose.resid[period//2:-period//1]\n    return trend, seasonal, resid","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"period = 140\n\nfor i in tqdm(range(len(tdcsfog_list))):\n    x = tdcsfog_list[i].AccV.values\n    tdcsfog_list[i]['AccV_trend'], tdcsfog_list[i]['AccV_seasonal'], tdcsfog_list[i]['AccV_resid'] = get_decomposition(x, period=period)\n    x = tdcsfog_list[i].AccML.values\n    tdcsfog_list[i]['AccML_trend'], tdcsfog_list[i]['AccML_seasonal'], tdcsfog_list[i]['AccML_resid'] = get_decomposition(x, period=period)\n    x = tdcsfog_list[i].AccAP.values\n    tdcsfog_list[i]['AccAP_trend'], tdcsfog_list[i]['AccAP_seasonal'], tdcsfog_list[i]['AccAP_resid'] = get_decomposition(x, period=period)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for i in tqdm(range(len(tdcsfog_list))):\n    tdcsfog_list[i]['AccML_trend_1000'] = tdcsfog_list[i]['AccML_trend'].rolling(1000).std()\n    tdcsfog_list[i]['AccML_trend_2000'] = tdcsfog_list[i]['AccML_trend'].rolling(2000).std()\n    tdcsfog_list[i]['AccML_trend_6000'] = tdcsfog_list[i]['AccML_trend'].rolling(6000).std()\n    tdcsfog_list[i]['AccV_trend_1000'] = tdcsfog_list[i]['AccV_trend'].rolling(1000).std()\n    tdcsfog_list[i]['AccV_trend_2000'] = tdcsfog_list[i]['AccV_trend'].rolling(2000).std()\n    tdcsfog_list[i]['AccV_trend_6000'] = tdcsfog_list[i]['AccV_trend'].rolling(6000).std()\n    tdcsfog_list[i]['AccAP_trend_1000'] = tdcsfog_list[i]['AccAP_trend'].rolling(1000).std()\n    tdcsfog_list[i]['AccAP_trend_2000'] = tdcsfog_list[i]['AccAP_trend'].rolling(2000).std()\n    tdcsfog_list[i]['AccAP_trend_6000'] = tdcsfog_list[i]['AccAP_trend'].rolling(6000).std()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_size = 0.6\ntr_split = int(len(tdcsfog_list) * train_size)\n\npermut = np.random.RandomState(seed=random_state).permutation(np.arange(len(tdcsfog_list))).astype(int)\ntr_df  = pd.concat([tdcsfog_list[i] for i in permut[:tr_split]], axis=0)\nval_df = pd.concat([tdcsfog_list[i] for i in permut[tr_split:]], axis=0)\n\nprint(len(tr_df), len(val_df))\n\ncolomns = ['AccV', 'AccML', 'AccAP', \n           'AccV_trend','AccML_trend','AccAP_trend', \n           'AccML_trend_1000','AccML_trend_2000', 'AccML_trend_6000',\n           'AccV_trend_1000','AccV_trend_2000', 'AccV_trend_6000',\n           'AccAP_trend_1000','AccAP_trend_2000', 'AccAP_trend_6000']\n\ntrain_size = 3000000\nval_size = 1000000\n\n# Turn model\nX_train = tr_df[colomns].values[:train_size]\ny_train = tr_df['Turn'].values[:train_size]\nX_test = val_df[colomns].values[:val_size]\ny_test = val_df['Turn'].values[:val_size]\n\nclasses = np.unique(y_train)\nweights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)\nclass_weights = dict(zip(classes, weights))\n\nt_model_t = cat.CatBoostClassifier(iterations=200,\n                               depth=2,\n                               learning_rate=0.3,\n                               class_weights=class_weights,\n                               loss_function='Logloss'\n                              )\nt_model_t.fit(X_train, y_train)\n\n\ny_pred = t_model_t.predict(X_test)\nprint(classification_report(y_test, y_pred))\n\ny_scores = t_model_t.predict_proba(X_test)[:, 1]\nprint(f'Av pres: {average_precision_score(y_test, y_scores)}')\n\n\n# StartHesitation model\n\nX_train = tr_df[colomns].values[:train_size]\ny_train = tr_df['StartHesitation'].values[:train_size]\nX_test = val_df[colomns].values[:val_size]\ny_test = val_df['StartHesitation'].values[:val_size]\n\nclasses = np.unique(y_train)\nweights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)\nclass_weights = dict(zip(classes, weights))\n\nt_model_sh = cat.CatBoostClassifier(iterations=200,\n                               depth=2,\n                               learning_rate=0.3,\n                               class_weights=class_weights,\n                               loss_function='Logloss'\n                              )\nt_model_sh.fit(X_train, y_train)\n\n\ny_pred = t_model_sh.predict(X_test)\nprint(classification_report(y_test, y_pred))\n\ny_scores = t_model_sh.predict_proba(X_test)[:, 1]\nprint(f'Av pres: {average_precision_score(y_test, y_scores)}')\n\n\n# Walking model\n\nX_train = tr_df[colomns].values[:train_size]\ny_train = tr_df['Walking'].values[:train_size]\nX_test = val_df[colomns].values[:val_size]\ny_test = val_df['Walking'].values[:val_size]\n\nclasses = np.unique(y_train)\nweights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)\nclass_weights = dict(zip(classes, weights))\n\nt_model_w = cat.CatBoostClassifier(iterations=200,\n                               depth=2,\n                               learning_rate=0.3,\n                               class_weights=class_weights,\n                               loss_function='Logloss'\n                              )\nt_model_w.fit(X_train, y_train)\n\n\ny_pred = t_model_w.predict(X_test)\nprint(classification_report(y_test, y_pred))\n\ny_scores = t_model_w.predict_proba(X_test)[:, 1]\nprint(f'Av pres: {average_precision_score(y_test, y_scores)}')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# DEFOG MODEL","metadata":{}},{"cell_type":"code","source":"def get_test_decomposition(x, period=140):\n    decompose = seasonal_decompose(x, period=period)\n    trend = decompose.trend\n    seasonal = decompose.seasonal\n    resid = decompose.resid\n    return trend, seasonal, resid","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Set the directory path to the folder containing the CSV files.\ndefog_path = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/defog'\n\n# Initialize an empty list to store the dataframes.\ndefog_list = []\n\n# Loop through each file in the directory and read it into a dataframe.\nfor file_name in tqdm(os.listdir(defog_path)):\n    if file_name.endswith('.csv'):\n        file_path = os.path.join(defog_path, file_name)\n        file = pd.read_csv(file_path)\n        defog_list.append(file)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"period = 140\n\nfor i in tqdm(range(len(defog_list))):\n    x = defog_list[i].AccV.values\n    defog_list[i]['AccV_trend'], defog_list[i]['AccV_seasonal'], defog_list[i]['AccV_resid'] = get_test_decomposition(x, period=period)\n    x = defog_list[i].AccML.values\n    defog_list[i]['AccML_trend'], defog_list[i]['AccML_seasonal'], defog_list[i]['AccML_resid'] = get_test_decomposition(x, period=period)\n    x = defog_list[i].AccAP.values\n    defog_list[i]['AccAP_trend'], defog_list[i]['AccAP_seasonal'], defog_list[i]['AccAP_resid'] = get_test_decomposition(x, period=period)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for i in tqdm(range(len(defog_list))):\n    defog_list[i]['AccML_trend_1000'] = defog_list[i]['AccML_trend'].rolling(1000).std()\n    defog_list[i]['AccML_trend_2000'] = defog_list[i]['AccML_trend'].rolling(2000).std()\n    defog_list[i]['AccML_trend_6000'] = defog_list[i]['AccML_trend'].rolling(6000).std()\n    defog_list[i]['AccV_trend_1000'] = defog_list[i]['AccV_trend'].rolling(1000).std()\n    defog_list[i]['AccV_trend_2000'] = defog_list[i]['AccV_trend'].rolling(2000).std()\n    defog_list[i]['AccV_trend_6000'] = defog_list[i]['AccV_trend'].rolling(6000).std()\n    defog_list[i]['AccAP_trend_1000'] = defog_list[i]['AccAP_trend'].rolling(1000).std()\n    defog_list[i]['AccAP_trend_2000'] = defog_list[i]['AccAP_trend'].rolling(2000).std()\n    defog_list[i]['AccAP_trend_6000'] = defog_list[i]['AccAP_trend'].rolling(6000).std()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_size = 0.6\ntr_split = int(len(defog_list) * train_size)\n\npermut = np.random.RandomState(seed=random_state).permutation(np.arange(len(defog_list))).astype(int)\ntr_df  = pd.concat([defog_list[i] for i in permut[:tr_split]], axis=0)\nval_df = pd.concat([defog_list[i] for i in permut[tr_split:]], axis=0)\n\nlen(tr_df), len(val_df)\n\ntrain_size = 3000000\nval_size = 1000000\n\ncolomns = ['AccV', 'AccML', 'AccAP', \n           'AccV_trend','AccML_trend','AccAP_trend', \n           'AccML_trend_1000','AccML_trend_2000', 'AccML_trend_6000',\n           'AccV_trend_1000','AccV_trend_2000', 'AccV_trend_6000',\n           'AccAP_trend_1000','AccAP_trend_2000', 'AccAP_trend_6000']\n\n\n# Turn model\nX_train = tr_df[colomns].values[:train_size]\ny_train = tr_df['Turn'].values[:train_size]\nX_test = val_df[colomns].values[:val_size]\ny_test = val_df['Turn'].values[:val_size]\n\nclasses = np.unique(y_train)\nweights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)\nclass_weights = dict(zip(classes, weights))\n\nd_model_t = cat.CatBoostClassifier(iterations=200,\n                               depth=2,\n                               learning_rate=0.3,\n                               class_weights=class_weights,\n                               loss_function='Logloss'\n                              )\nd_model_t.fit(X_train, y_train)\n\n\ny_pred = d_model_t.predict(X_test)\nprint(classification_report(y_test, y_pred))\n\ny_scores = d_model_t.predict_proba(X_test)[:, 1]\nprint(f'Av pres: {average_precision_score(y_test, y_scores)}')\n\n\n# StartHesitation model\n\nX_train = tr_df[colomns].values[:train_size]\ny_train = tr_df['StartHesitation'].values[:train_size]\nX_test = val_df[colomns].values[:val_size]\ny_test = val_df['StartHesitation'].values[:val_size]\n\nclasses = np.unique(y_train)\nweights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)\nclass_weights = dict(zip(classes, weights))\n\nd_model_sh = cat.CatBoostClassifier(iterations=200,\n                               depth=2,\n                               learning_rate=0.3,\n                               class_weights=class_weights,\n                               loss_function='Logloss'\n                              )\nd_model_sh.fit(X_train, y_train)\n\n\ny_pred = d_model_sh.predict(X_test)\nprint(classification_report(y_test, y_pred))\n\ny_scores = d_model_sh.predict_proba(X_test)[:, 1]\nprint(f'Av pres: {average_precision_score(y_test, y_scores)}')\n\n\n# Walking model\n\nX_train = tr_df[colomns].values[:train_size]\ny_train = tr_df['Walking'].values[:train_size]\nX_test = val_df[colomns].values[:val_size]\ny_test = val_df['Walking'].values[:val_size]\n\nclasses = np.unique(y_train)\nweights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)\nclass_weights = dict(zip(classes, weights))\n\nd_model_w = cat.CatBoostClassifier(iterations=200,\n                               depth=2,\n                               learning_rate=0.3,\n                               class_weights=class_weights,\n                               loss_function='Logloss'\n                              )\nd_model_w.fit(X_train, y_train)\n\n\ny_pred = d_model_w.predict(X_test)\nprint(classification_report(y_test, y_pred))\n\ny_scores = d_model_w.predict_proba(X_test)[:, 1]\nprint(f'Av pres: {average_precision_score(y_test, y_scores)}')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# TEST INFERENCE","metadata":{}},{"cell_type":"code","source":"input_folder = \"/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction\"\n\ntest_tdcsfog_path = os.path.join(input_folder, 'test', 'tdcsfog', '003f117e14.csv')\ntest_defog_path = os.path.join(input_folder, 'test', 'defog', '02ab235146.csv')\n\ntest_tdcsfog_df = pd.read_csv(test_tdcsfog_path)\ntest_defog_df = pd.read_csv(test_defog_path)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def preprocess_test_data(_df, period=140):\n    x = _df.AccV.values\n    _df['AccV_trend'], _, _ = get_test_decomposition(x, period)\n    x = _df.AccAP.values\n    _df['AccAP_trend'], _, _ = get_test_decomposition(x, period)\n    x = _df.AccML.values\n    _df['AccML_trend'], _, _ = get_test_decomposition(x, period)\n    \n    _df['AccML_trend_1000'] = _df['AccML_trend'].rolling(1000).std()\n    _df['AccML_trend_2000'] = _df['AccML_trend'].rolling(2000).std()\n    _df['AccML_trend_6000'] = _df['AccML_trend'].rolling(6000).std()\n    _df['AccV_trend_1000'] = _df['AccV_trend'].rolling(1000).std()\n    _df['AccV_trend_2000'] = _df['AccV_trend'].rolling(2000).std()\n    _df['AccV_trend_6000'] = _df['AccV_trend'].rolling(6000).std()\n    _df['AccAP_trend_1000'] = _df['AccAP_trend'].rolling(1000).std()\n    _df['AccAP_trend_2000'] = _df['AccAP_trend'].rolling(2000).std()\n    _df['AccAP_trend_6000'] = _df['AccAP_trend'].rolling(6000).std()\n    \n    return _df\n\n\n# def prepare_submit(test_t, test_d, t_model_t, t_model_sh, t_model_w, d_model_t, d_model_sh, d_model_w):\n#     colomns = ['AccV', 'AccML', 'AccAP', \n#            'AccV_trend','AccML_trend','AccAP_trend', \n#            'AccML_trend_1000','AccML_trend_2000', 'AccML_trend_6000',\n#            'AccV_trend_1000','AccV_trend_2000', 'AccV_trend_6000',\n#            'AccAP_trend_1000','AccAP_trend_2000', 'AccAP_trend_6000']\n    \n# #     test_tdcsfog_df = preprocess_test_data(test_tdcsfog_df).fillna(0)\n# #     test_defog_df = preprocess_test_data(test_defog_df).fillna(0)\n    \n#     submission_list = []\n    \n#     test_t['Id'] = test_t['Time'].apply(lambda time: f\"003f117e14_{time}\")\n#     test_t['Turn'] = t_model_t.predict(test_t[colomns])\n#     test_t['StartHesitation'] = t_model_sh.predict(test_t[colomns])\n#     test_t['Walking'] = t_model_w.predict(test_t[colomns]) \n#     submission_list.append(test_t[['Id', 'StartHesitation', 'Turn', 'Walking']])\n    \n#     test_d['Id'] = test_d['Time'].apply(lambda time: f\"02ab235146_{time}\")\n#     test_d['Turn'] = d_model_t.predict(test_d[colomns])\n#     test_d['StartHesitation'] = d_model_sh.predict(test_d[colomns])\n#     test_d['Walking'] = d_model_w.predict(test_d[colomns])\n#     submission_list.append(test_d[['Id', 'StartHesitation', 'Turn', 'Walking']])\n    \n#     submission = pd.concat(submission_list).reset_index(drop=True)\n    \n#     return submission","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"colomns = ['AccV', 'AccML', 'AccAP', \n           'AccV_trend','AccML_trend','AccAP_trend', \n           'AccML_trend_1000','AccML_trend_2000', 'AccML_trend_6000',\n           'AccV_trend_1000','AccV_trend_2000', 'AccV_trend_6000',\n           'AccAP_trend_1000','AccAP_trend_2000', 'AccAP_trend_6000']\n\ntest_folders = [\n    os.path.join(input_folder, 'test', 'tdcsfog'),    \n    os.path.join(input_folder, 'test', 'defog'),\n]\n\nsubmission_list = []\nfor folder in test_folders:\n    for fn in os.listdir(folder):\n        series_id = fn.split('.')[0]\n        series = pd.read_csv(os.path.join(folder, fn))\n        series = preprocess_test_data(series).fillna(0)\n        series['Id'] = series['Time'].apply(lambda time: f\"{series_id}_{time}\")\n        \n        if 'defog' in folder:\n            series['StartHesitation'] = d_model_sh.predict(series[colomns])\n            series['Turn'] = d_model_t.predict(series[colomns])\n            series['Walking'] = d_model_w.predict(series[colomns])\n        else:\n            series['StartHesitation'] = t_model_sh.predict(series[colomns])\n            series['Turn'] = t_model_t.predict(series[colomns])\n            series['Walking'] = t_model_w.predict(series[colomns])\n            \n        submission_list.append(series[['Id', 'StartHesitation', 'Turn', 'Walking']])","metadata":{"execution":{"iopub.status.busy":"2023-06-19T08:19:53.438043Z","iopub.execute_input":"2023-06-19T08:19:53.438443Z","iopub.status.idle":"2023-06-19T08:19:54.375209Z","shell.execute_reply.started":"2023-06-19T08:19:53.438410Z","shell.execute_reply":"2023-06-19T08:19:54.374140Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# test_tdcsfog_df = preprocess_test_data(test_tdcsfog_df).fillna(0)\n# test_defog_df = preprocess_test_data(test_defog_df).fillna(0)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# submission = prepare_submit(test_tdcsfog_df, test_defog_df, \n#                            t_model_t, t_model_sh, t_model_w,\n#                            d_model_t, d_model_sh, d_model_w)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission = pd.concat(submission_list).reset_index(drop=True)\nsubmission.to_csv('submission.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2023-06-19T08:19:58.188027Z","iopub.execute_input":"2023-06-19T08:19:58.188464Z","iopub.status.idle":"2023-06-19T08:19:58.702839Z","shell.execute_reply.started":"2023-06-19T08:19:58.188421Z","shell.execute_reply":"2023-06-19T08:19:58.701883Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# colomns = ['AccAP', 'AccV_trend','AccML_trend','AccAP_trend']\n\n# X_train = tr_df[colomns].values[:train_size]\n# y_train = tr_df['Turn'].values[:train_size]\n# X_test = val_df[colomns].values[:val_size]\n# y_test = val_df['Turn'].values[:val_size]\n# print(y_train.mean(), y_test.mean())\n\n\n# model = RandomForestClassifier(n_estimators=100, \n#                                max_depth=4, \n#                                min_samples_leaf=20, \n#                                n_jobs=-1, \n#                                class_weight='balanced')\n# model.fit(X_train, y_train)\n\n# y_pred = model.predict(X_test)\n# print(classification_report(y_test, y_pred))\n\n# y_scores = model.predict_proba(X_test)[:, 1]\n# print(f'Av pres: {average_precision_score(y_test, y_scores)}')","metadata":{"execution":{"iopub.status.busy":"2023-06-19T00:21:42.366625Z","iopub.status.idle":"2023-06-19T00:21:42.367019Z","shell.execute_reply.started":"2023-06-19T00:21:42.366834Z","shell.execute_reply":"2023-06-19T00:21:42.366852Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}