{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":81933,"databundleVersionId":9643020,"sourceType":"competition"},{"sourceId":7453542,"sourceType":"datasetVersion","datasetId":921302},{"sourceId":9448132,"sourceType":"datasetVersion","datasetId":5742470},{"sourceId":9448136,"sourceType":"datasetVersion","datasetId":5742473},{"sourceId":10229352,"sourceType":"datasetVersion","datasetId":6324642},{"sourceId":10235140,"sourceType":"datasetVersion","datasetId":6328781}],"dockerImageVersionId":30805,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"In this notebook, I run a model from last year’s competition to detect sleep periods based on anglez and enmo. \n\nAfter detecting these sleep periods, I generated some features relevant to them.\n\n\nNotes:\n- I ran one of my models from last year. For more details, please visit [here](https://www.kaggle.com/competitions/child-mind-institute-detect-sleep-states/discussion/459597)\n- Approximately 60% of the data has timesteps of 5 seconds, while the remaining data does not. This notebook does not address this noise.\n- Time zone information is not included; I expect that it has already been corrected by host.","metadata":{}},{"cell_type":"code","source":"import datetime\nimport gc\nimport os\nimport sys\nfrom glob import glob\nimport matplotlib.pyplot as plt\nfrom pathlib import Path\n\nfrom glob import glob\nimport numpy as np\nimport pandas as pd\nimport polars as pl\nimport torch\nimport yaml\nfrom tqdm import tqdm\n\n# TRAIN_OR_TEST = \"train\"\n\n# paths = glob(\n#     f\"/kaggle/input/child-mind-institute-problematic-internet-use/series_{TRAIN_OR_TEST}.parquet/id=*/part-0.parquet\"\n# )\n# print(len(paths))","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-12-18T13:18:08.349161Z","iopub.execute_input":"2024-12-18T13:18:08.349405Z","iopub.status.idle":"2024-12-18T13:18:13.087149Z","shell.execute_reply.started":"2024-12-18T13:18:08.349379Z","shell.execute_reply":"2024-12-18T13:18:13.086407Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import random\nimport torch\ndef seed_everything(seed):\n    random.seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    np.random.seed(seed)\n    torch.manual_seed(seed)\n    torch.cuda.manual_seed(seed)\n    torch.backends.cudnn.deterministic = True\n    torch.backends.cudnn.benchmark = True\nseed_everything(2027)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:13.088831Z","iopub.execute_input":"2024-12-18T13:18:13.089521Z","iopub.status.idle":"2024-12-18T13:18:13.099153Z","shell.execute_reply.started":"2024-12-18T13:18:13.089483Z","shell.execute_reply":"2024-12-18T13:18:13.098364Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Preprocess\n\nFirst, prepare the features used in my sleep detection model. Please refer to the implementation by [@tatamikenn](https://www.kaggle.com/tatamikenn) [here](https://www.kaggle.com/code/tatamikenn/sleep-hdcza-a-pure-heuristic-approach-lb-0-447).","metadata":{}},{"cell_type":"code","source":"def transform(df, night_offset=20):\n    return (\n        df.with_columns(\n            [\n                (pl.col(\"timestamp\").dt.year() - 2000).cast(pl.Int8).alias(\"year\"),\n                pl.col(\"timestamp\").dt.month().cast(pl.Int8).alias(\"month\"),\n                pl.col(\"timestamp\").dt.day().cast(pl.Int8).alias(\"day\"),\n                pl.col(\"timestamp\").dt.hour().cast(pl.Int8).alias(\"hour\"),\n                pl.col(\"timestamp\").dt.minute().cast(pl.Int8).alias(\"minute\"),\n                pl.col(\"timestamp\").dt.second().cast(pl.Int8).alias(\"second\"),\n                pl.col(\"timestamp\").dt.weekday().cast(pl.Int8).alias(\"weekday\"),\n            ]\n        )\n        .with_columns( \n            pl.when(pl.col(\"hour\") < night_offset)\n            .then(pl.col(\"timestamp\"))\n            .otherwise(pl.col(\"timestamp\") + pl.duration(days=1))\n            .dt.date()\n            .alias(\"night_group\"),\n        )\n        .with_columns(\n            [\n                (\n                    pl.col(\"series_id\") + pl.lit(\"_\") + pl.col(\"night_group\").cast(pl.Datetime).dt.strftime(\"%Y%m%d\")\n                ).alias(\"group_id\"),\n            ]\n        )\n        .with_columns(\n            [\n                pl.col(\"timestamp\").cum_count().over(\"group_id\").alias(\"norm_step\"),\n            ]\n        )\n        .drop([\"night_group\"])\n    )\n\n\ndef transform_series(df):\n    return transform(df).with_columns(\n        [\n            (pl.col(\"enmo\") == 0).alias(\"is_enmo_clipped\"),\n        ]\n    )\n\n\ndef transform_events(df):\n    return (\n        transform(df)\n        .with_columns(\n            [\n                pl.col(\"night\").cast(pl.UInt32).alias(\"night\"),\n            ]\n        )\n        .pivot([\"step\", \"timestamp\", \"tz_offset\"], [\"series_id\", \"group_id\", \"night\"], \"event\")\n    )\n\n\ndef add_feature(\n    df,\n    day_group_col=\"group_id\",\n    term1=(5 * 60) // 5,\n    term2=(30 * 60) // 5,\n    term3=(60 * 60) // 5,\n    min_threshold=0.005,\n    max_threshold=0.04,\n    center=True,\n):\n    return (\n        df.with_columns(\n            [\n                pl.col(\"anglez\").diff(1).abs().alias(\"anglez_diff\"),\n                pl.col(\"enmo\").diff(1).abs().alias(\"enmo_diff\"),\n            ]\n        )\n        .with_columns(\n            [\n                pl.col(\"anglez_diff\")\n                .rolling_median(term1, center=center)  # 5 min window\n                .alias(\"anglez_diff_median_5min\"),\n                pl.col(\"enmo_diff\")\n                .rolling_median(term1, center=center)  # 5 min window\n                .alias(\"enmo_diff_median_5min\"),\n            ]\n        )\n        .with_columns(\n            [\n                pl.col(\"anglez_diff_median_5min\")\n                .quantile(0.1)\n                .clip(min_threshold, max_threshold)\n                .over(day_group_col)\n                .alias(\"critical_threshold\")\n            ]\n        )\n        .with_columns([(pl.col(\"anglez_diff_median_5min\") < pl.col(\"critical_threshold\") * 15).alias(\"is_static\")])\n        .with_columns(\n            [\n                pl.col(\"is_static\").cast(pl.Int32).rolling_sum(term2, center=center).alias(\"is_static_sum_30min\"),\n            ]\n        )\n        .with_columns([(pl.col(\"is_static_sum_30min\") == ((30 * 60) // 5)).alias(\"tmp\")])\n        .with_columns(\n            [\n                pl.col(\"tmp\").shift(term2 // 2).alias(\"tmp_left\"),\n                pl.col(\"tmp\").shift(-(term2 // 2)).alias(\"tmp_right\"),\n            ]\n        )\n        .with_columns(\n            [\n                (pl.col(\"tmp_left\") | pl.col(\"tmp_right\")).alias(\"is_sleep_block\"),\n            ]\n        )\n        .drop([\"tmp\", \"tmp_left\", \"tmp_right\"])\n        .with_columns([pl.col(\"is_sleep_block\").not_().alias(\"is_gap\")])\n        .with_columns([pl.col(\"is_gap\").cast(pl.Int32).rolling_sum(term3, center=center).alias(\"gap_length\")])\n        .with_columns([(pl.col(\"gap_length\") == term3).alias(\"tmp\")])\n        .with_columns(\n            [\n                pl.col(\"tmp\").shift(term3 // 2).alias(\"tmp_left\"),\n                pl.col(\"tmp\").shift(-(term3 // 2)).alias(\"tmp_right\"),\n            ]\n        )\n        .with_columns(\n            [\n                (pl.col(\"tmp_left\") | pl.col(\"tmp_right\")).alias(\"is_large_gap\"),\n            ]\n        )\n        .drop([\"tmp\", \"tmp_left\", \"tmp_right\"])\n        .with_columns([pl.col(\"is_large_gap\").not_().alias(\"is_sleep_episode\")])\n        #\n        # extract longest sleep episode\n        #\n        .with_columns(\n            [\n                # extract false->true transition\n                (\n                    (\n                        pl.col(\"is_sleep_episode\")\n                        & pl.col(\"is_sleep_episode\").shift(1, fill_value=pl.lit(False)).not_()\n                    )\n                    .cum_sum()\n                    .over(\"group_id\")\n                ).alias(\"sleep_episode_id\")\n            ]\n        )\n        .with_columns(\n            [pl.col(\"is_sleep_episode\").sum().over([\"group_id\", \"sleep_episode_id\"]).alias(\"sleep_episode_length\")]\n        )\n        .with_columns([pl.col(\"sleep_episode_length\").max().over([\"group_id\"]).alias(\"max_sleep_episode_length\")])\n        .with_columns(\n            [\n                (\n                    pl.col(\"is_sleep_episode\") & (pl.col(\"sleep_episode_length\") == pl.col(\"max_sleep_episode_length\"))\n                ).alias(\"is_longest_sleep_episode\")\n            ]\n        )\n    )\n\n\nuse_columns = [\n    \"series_id\",\n    \"step\",\n    \"is_longest_sleep_episode\",\n    \"is_sleep_block\",\n    \"is_gap\",\n    \"is_large_gap\",\n    \"is_sleep_episode\",\n    \"is_static\",\n]\n\ndef create_heuristic(paths, train_or_test):\n    for path in tqdm(paths):\n        sdf = pl.read_parquet(path)\n    \n        # dummy timestamp\n        sdf = sdf.with_columns((pl.col(\"time_of_day\") == 0).cast(pl.Int32).cum_sum().alias(\"day_offset\"))\n        sdf = sdf.with_columns(\n            (\n                datetime.datetime(2020, 1, 1)\n                + (pl.col(\"day_offset\") * 86400_000_000 + pl.col(\"time_of_day\") / 1000).cast(pl.Duration(\"us\"))\n            ).alias(\"timestamp\")\n        )\n    \n        sdf = sdf.with_columns(pl.lit(path.split(\"/\")[-2]).alias(\"series_id\"))\n        sdf = sdf.sort(\"step\")\n        sdf = transform_series(sdf)\n        sdf = add_feature(sdf)\n        sdf = sdf[use_columns].fill_null(False)\n    \n        sidf = path.split(\"/\")[-2]\n        save_path = f\"/kaggle/working/heuristic_features/{train_or_test}/{sidf}.parquet\"\n        os.makedirs(os.path.dirname(save_path), exist_ok=True)\n        sdf.write_parquet(save_path)","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:13.100154Z","iopub.execute_input":"2024-12-18T13:18:13.100387Z","iopub.status.idle":"2024-12-18T13:18:13.121025Z","shell.execute_reply.started":"2024-12-18T13:18:13.100363Z","shell.execute_reply":"2024-12-18T13:18:13.120286Z"},"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Sleep Detection","metadata":{}},{"cell_type":"code","source":"if True:\n    sys.path.append(\"/kaggle/input/cmi-2023-src\")\n    from consts import ANGLEZ_MEAN, ANGLEZ_STD, ENMO_MEAN, ENMO_STD\n    from torch_models.dataset import ZzzPatchDataset\n    from torch_models.models import ZzzConv1dGRUModel, ZzzTransformerGRUModel, ZzzWaveGRUModel\n\n    from utils.feature_contena import Features\n    from utils.lightning_utils import MyLightningDataModule, MyLightningModule\n    from utils.set_seed import seed_base_torch\n    from utils.torch_template import EnsembleModel","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:13.122364Z","iopub.execute_input":"2024-12-18T13:18:13.122593Z","iopub.status.idle":"2024-12-18T13:18:28.491608Z","shell.execute_reply.started":"2024-12-18T13:18:13.122571Z","shell.execute_reply":"2024-12-18T13:18:28.490907Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def detection(paths=f\"/kaggle/input/child-mind-institute-problematic-internet-use/series_train.parquet/id=*/part-0.parquet\", train_or_test=\"train\"):\n    MODEL_NAME = \"patch_transformer_gru\"\n    \n    PACKAGE_DIR = Path(\"/kaggle/input/cmi-2023-src\")\n    CFG = yaml.safe_load(open(PACKAGE_DIR / \"config.yaml\", \"r\"))\n    BLOCK_SIZE = CFG[MODEL_NAME][\"execution\"][\"block_size\"]\n    \n    CFG[\"output_dir\"] = f\"/kaggle/input/cmi-2023-output/{CFG[MODEL_NAME]['execution']['best_exp_id']}\"\n    \n    seed_base_torch(CFG[\"env\"][\"seed\"])\n    \n    DEVICE = \"cuda\"\n    \n    files = glob(\n        paths\n    )\n    \n    features = Features()\n    features.add_num_features([\"anglez\", \"enmo\"])\n    features.add_num_features([\"anglez_diff\", \"enmo_diff\"])\n    features.add_num_features([\"same_count\"])\n    features.add_num_features([\"large_diff_count\"])\n    features.add_num_features([\"same_count_shift_plus\", \"same_count_shift_minus\"])\n    features.add_num_features([\"is_longest_sleep_episode\", \"is_sleep_block\"])\n    \n    # transformer + gru\n    model = ZzzTransformerGRUModel(\n        max_len=BLOCK_SIZE // CFG[MODEL_NAME][\"execution\"][\"patch_size\"],\n        input_numerical_size=len(features.all_features()) * CFG[MODEL_NAME][\"execution\"][\"patch_size\"],\n        **CFG[MODEL_NAME][\"params\"],\n    )\n    trn_models = [\n        MyLightningModule.load_from_checkpoint(\n            os.path.join(\"/kaggle/input/cmi-2023-output/exp_160\", f\"logs/best_model_fold{fold}.ckpt\"),\n            model=model,\n            map_location=torch.device(DEVICE),\n        ).to(DEVICE)\n        for fold in range(5 if len(files) > 100 else 1)\n    ]\n    \n    models = trn_models\n    model = EnsembleModel(models).to(DEVICE)\n    model.eval()\n    \n    all_oof_dfs = []\n    for file in tqdm(files):\n        # load file\n        df = pd.read_parquet(file)\n        if len(df) < BLOCK_SIZE:\n            continue\n        time_of_days = df[\"time_of_day\"].values\n    \n        # same_count\n        DAY_STEPS = 12 * 60 * 24\n        n_days = int(len(df) // DAY_STEPS) + 1\n        df[\"same_count\"] = 0\n        for day in range(-n_days, n_days + 1):\n            if day == 0:\n                continue\n            df[\"_anglez_diff\"] = df[\"anglez\"].diff(DAY_STEPS * day)\n            df[\"_anglez_diff\"] = df[\"_anglez_diff\"].fillna(1)\n            df[\"same_count\"] += (df[\"_anglez_diff\"] == 0).astype(int)\n        df[\"same_count\"] = (df[\"same_count\"].clip(0, 5) - 2.5) / 2.5\n    \n        SHIFT_STEPS = 12 * 60 * 6  # 6h\n        df[\"same_count_shift_plus\"] = df[\"same_count\"].shift(SHIFT_STEPS).fillna(1.0).astype(np.float16)\n        df[\"same_count_shift_minus\"] = df[\"same_count\"].shift(-SHIFT_STEPS).fillna(1.0).astype(np.float16)\n    \n        # features\n        df[\"anglez_diffabs\"] = df[\"anglez\"].diff().abs().fillna(0)\n        df[\"large_diff\"] = (df[\"anglez_diffabs\"] > 5).astype(int)\n        df[\"large_diff_count\"] = df[\"large_diff\"].rolling(10, center=True).mean().fillna(0)\n        df[\"large_diff_count\"] = (df[\"large_diff_count\"] - 0.5) * 2\n    \n        # normalize\n        df[\"anglez\"] = (df[\"anglez\"] - ANGLEZ_MEAN) / ANGLEZ_STD\n        df[\"enmo\"] = (df[\"enmo\"] - ENMO_MEAN) / ENMO_STD\n        df[\"anglez_diff\"] = df[\"anglez\"].diff().fillna(0)\n        df[\"enmo_diff\"] = df[\"enmo\"].diff().fillna(0)\n    \n        # heuristic_features by @bilzard\n        sid = file.split(\"/\")[-2]\n        df[\"series_id\"] = sid\n        path = f\"/kaggle/working/heuristic_features/{train_or_test}/{sid}.parquet\"\n        hdf = pd.read_parquet(path)\n        df = pd.concat([df, hdf.drop(columns=[\"series_id\", \"step\"])], axis=1)\n        df[[\"is_longest_sleep_episode\", \"is_sleep_block\"]] = df[[\"is_longest_sleep_episode\", \"is_sleep_block\"]] * 2 - 1\n    \n        # split\n        dfs = []\n        df = df.sort_values(\"step\").reset_index(drop=True)\n        for start in range(0, len(df), BLOCK_SIZE // 8):\n            end = start + BLOCK_SIZE\n            if end > len(df):\n                end = len(df) - len(df) % CFG[MODEL_NAME][\"execution\"][\"patch_size\"]\n                start = end - BLOCK_SIZE\n                assert start >= 0\n            assert df.iloc[start][\"step\"] % CFG[MODEL_NAME][\"execution\"][\"patch_size\"] == 0\n            dfs.append(df.iloc[start:end])\n        gc.collect()\n    \n        # inference\n        train_dataset = ZzzPatchDataset(\n            dfs, mode=\"test\", features=features, patch_size=CFG[MODEL_NAME][\"execution\"][\"patch_size\"]\n        )\n        valid_dataset = ZzzPatchDataset(\n            dfs, mode=\"test\", features=features, patch_size=CFG[MODEL_NAME][\"execution\"][\"patch_size\"]\n        )\n        data_module = MyLightningDataModule(train_dataset, valid_dataset, batch_size=64)\n        preds = []\n        with torch.no_grad():\n            for X in data_module.val_dataloader():\n                pred = torch.sigmoid(model(X.to(\"cuda\"))).detach().cpu().numpy() * 10\n                preds.append(pred)\n    \n        oof_dfs = []\n        for pred, df in zip(np.vstack(preds), dfs):\n            df = df.iloc[\n                CFG[MODEL_NAME][\"execution\"][\"patch_size\"] // 2 : len(df) : CFG[MODEL_NAME][\"execution\"][\"patch_size\"]\n            ].reset_index(drop=True)\n            df[[\"wakeup_oof\", \"onset_oof\"]] = pred\n            oof_dfs.append(df[[\"series_id\", \"step\", \"wakeup_oof\", \"onset_oof\"]])\n    \n        oof_df = pd.concat(oof_dfs)\n        oof_df = oof_df.groupby([\"series_id\", \"step\"]).mean().reset_index().sort_values([\"series_id\", \"step\"])\n        oof_df = oof_df[[\"series_id\", \"step\", \"wakeup_oof\", \"onset_oof\"]]\n        oof_df[\"step\"] = oof_df[\"step\"].astype(int)\n    \n        del preds, oof_dfs\n        gc.collect()\n    \n        train = oof_df.reset_index(drop=True)\n        train[\"time_of_day\"] = time_of_days[\n            CFG[MODEL_NAME][\"execution\"][\"patch_size\"] // 2 :: CFG[MODEL_NAME][\"execution\"][\"patch_size\"]\n        ][: len(train)]\n        all_oof_dfs.append(train[[\"series_id\", \"step\", \"wakeup_oof\", \"onset_oof\", \"time_of_day\"]])\n        # del dfs, df\n        gc.collect()\n\n    # save\n    for df in tqdm(all_oof_dfs):\n        save_path = f\"/kaggle/working/features/sleep_detection/{train_or_test}/{df['series_id'].iloc[0]}.parquet\"\n        os.makedirs(os.path.dirname(save_path), exist_ok=True)\n        df.to_parquet(save_path, index=False)","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:28.493063Z","iopub.execute_input":"2024-12-18T13:18:28.493851Z","iopub.status.idle":"2024-12-18T13:18:28.513910Z","shell.execute_reply.started":"2024-12-18T13:18:28.493812Z","shell.execute_reply":"2024-12-18T13:18:28.512922Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # check!\n# sample_file = \"/kaggle/working/features/sleep_detection/id=0d279d77.parquet\"\n\n# df = pl.read_parquet(sample_file)\n# df = df.with_columns(pl.col(\"step\").cast(pl.UInt32)).drop(\"time_of_day\")\n# sid = df[\"series_id\"][0]\n\n# sensor_df = pl.read_parquet(\n#     f\"/kaggle/input/child-mind-institute-problematic-internet-use/series_{TRAIN_OR_TEST}.parquet/{sid}/part-0.parquet\"\n# ).with_columns((pl.col(\"time_of_day\") == 0).cum_sum().alias(\"day\"))\n\n# sensor_df = sensor_df.join(df, on=\"step\", how=\"left\").with_columns(\n#     pl.col(\"onset_oof\").interpolate(),\n#     pl.col(\"wakeup_oof\").interpolate(),\n# )\n\n# for (day, ), day_df in sensor_df.group_by(\"day\", maintain_order=True):\n#     fig, axs = plt.subplots(3, 1, figsize=(20, 3))\n#     times = np.linspace(0, 24, len(day_df))\n#     axs[0].plot(times, day_df[\"enmo\"])\n#     axs[0].set_ylabel(\"enmo\")\n#     axs[1].plot(times, day_df[\"anglez\"])\n#     axs[1].set_ylabel(\"anglez\")\n#     axs[2].plot(times, day_df[\"onset_oof\"])\n#     axs[2].plot(times, day_df[\"wakeup_oof\"])\n#     axs[2].set_ylabel(\"oof\")\n#     axs[2].set_ylim(0, 10)\n#     plt.tight_layout()\n#     plt.show()\n#     if day > 5:\n#         break","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:28.515117Z","iopub.execute_input":"2024-12-18T13:18:28.515456Z","iopub.status.idle":"2024-12-18T13:18:28.546159Z","shell.execute_reply.started":"2024-12-18T13:18:28.515419Z","shell.execute_reply":"2024-12-18T13:18:28.545522Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Feature Engineering","metadata":{}},{"cell_type":"code","source":"time_of_day_max = 86400000000000\n# all_files = sorted(glob(\"/kaggle/working/features/sleep_detection/*.parquet\"))\n# len(all_files)","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:28.547164Z","iopub.execute_input":"2024-12-18T13:18:28.547492Z","iopub.status.idle":"2024-12-18T13:18:28.560627Z","shell.execute_reply.started":"2024-12-18T13:18:28.547458Z","shell.execute_reply":"2024-12-18T13:18:28.559757Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def feature_engineering(paths=\"/kaggle/working/features/sleep_detection/train/*.parquet\", data_paths=\"/kaggle/input/child-mind-institute-problematic-internet-use/series_train.parquet\", train_or_test=\"train\"):\n    features = []\n    debug_count = 0\n    all_files = sorted(glob(paths))\n    for file in tqdm(all_files):\n        df = pl.read_parquet(file)\n        df = df.with_columns(pl.col(\"step\").cast(pl.UInt32)).drop(\"time_of_day\")\n        sid = df[\"series_id\"][0]\n    \n        sensor_df = pl.read_parquet(\n            f\"{data_paths}/{sid}/part-0.parquet\"\n        ).with_columns((pl.col(\"time_of_day\") == 0).cum_sum().alias(\"day\"))\n    \n        feature = {\n            \"id\": sid,\n            \"length\": df.shape[0],\n            \"day\": sensor_df[\"relative_date_PCIAT\"].max() - sensor_df[\"relative_date_PCIAT\"].min(),\n        }\n    \n        # skip if time step is not 5sec\n        diffs = sensor_df[\"time_of_day\"].diff().drop_nulls().unique()\n        if set(diffs) != set([-86395000000000, 5000000000]):\n            features.append(feature)\n            continue\n    \n        sensor_df = (\n            sensor_df.join(df, on=\"step\", how=\"left\")\n            .sort(\"step\")\n            .with_columns(\n                pl.col(\"onset_oof\").interpolate(),\n                pl.col(\"wakeup_oof\").interpolate(),\n            )\n        )\n    \n        # onset = 15:00~3:00, wakeup = 3:00~15:00\n        onset_start = time_of_day_max / 24 * 15  # 15:00\n        onset_end = time_of_day_max / 24 * 3  # 3:00\n        sensor_df = sensor_df.with_columns(\n            ((pl.col(\"time_of_day\") > onset_start) | (pl.col(\"time_of_day\") < onset_end)).alias(\"onset_duration\"),\n        ).with_columns(\n            pl.col(\"onset_duration\").cast(pl.Int32).diff().fill_null(0).abs().cum_sum().alias(\"onset_wakeup_duration\")\n        )\n    \n        # get sleep period\n        sleep_info = []\n        for _, df in sensor_df.group_by(\"onset_wakeup_duration\", maintain_order=True):\n            is_onset = df[\"onset_duration\"][0]\n            if is_onset:\n                max_idx = df[\"onset_oof\"].arg_max()\n                if max_idx is None:\n                    continue\n                max_score = df[\"onset_oof\"][max_idx]\n                step = df[\"step\"][max_idx]\n    \n                # date\n                start_time = df[\"time_of_day\"][0] / time_of_day_max * 24\n                if start_time >= 15:\n                    day = df[\"day\"][0]\n                    week_day = df[\"weekday\"][0]\n                else:\n                    day = df[\"day\"][0] - 1\n                    week_day = df[\"weekday\"][0] - 1\n                    if week_day == 0:\n                        week_day = 7\n            else:\n                max_idx = df[\"wakeup_oof\"].arg_max()\n                if max_idx is None:\n                    continue\n                max_score = df[\"wakeup_oof\"][max_idx]\n                step = df[\"step\"][max_idx]\n    \n                # date\n                start_time = df[\"time_of_day\"][0] / time_of_day_max * 24\n                day = df[\"day\"][0] - 1\n                week_day = df[\"weekday\"][0] - 1\n    \n            info = {\n                \"day\": day,\n                \"weekday\": week_day,\n                \"type\": \"onset\" if is_onset else \"wakeup\",\n                \"step\": step,\n                \"max_score\": max_score,\n                \"time\": df[\"time_of_day\"][max_idx] / time_of_day_max * 24,\n            }\n            sleep_info.append(info)\n        sleep_df = pl.DataFrame(sleep_info)\n    \n        # merge\n        sleep_df = (\n            sleep_df.filter(pl.col(\"type\") == \"onset\")\n            .drop(\"type\")\n            .rename(\n                {\n                    \"max_score\": \"onset_score\",\n                    \"step\": \"onset_step\",\n                    \"time\": \"onset_time\",\n                }\n            )\n            .join(\n                sleep_df.filter(pl.col(\"type\") == \"wakeup\")\n                .drop([\"type\", \"weekday\"])\n                .rename(\n                    {\n                        \"max_score\": \"wakeup_score\",\n                        \"step\": \"wakeup_step\",\n                        \"time\": \"wakeup_time\",\n                    }\n                ),\n                on=\"day\",\n            )\n        ).select(\n            [\"day\", \"weekday\", \"onset_time\", \"wakeup_time\", \"onset_step\", \"wakeup_step\", \"onset_score\", \"wakeup_score\"]\n        )\n    \n        # feature engineering\n        sleep_lengths = []  # wakeup - onset\n        sleep_enmo_mean = []  \n        sleep_enmo_std = []  \n        sleep_light_mean = []\n        sleep_light_std = [] \n        for i in range(len(sleep_df)):\n            # sleep period\n            start = sleep_df[\"onset_step\"][i]\n            end = sleep_df[\"wakeup_step\"][i]\n            if sleep_df[\"onset_score\"][i] < 1 or sleep_df[\"wakeup_score\"][i] < 1:\n                sleep_lengths.append(np.nan)\n                sleep_enmo_mean.append(np.nan)\n                sleep_enmo_std.append(np.nan)\n                sleep_light_mean.append(np.nan)\n                sleep_light_std.append(np.nan)\n                continue\n    \n            # sleep length\n            length = end - start\n            sleep_lengths.append(length * 5 / 60 / 60)  # hour\n    \n            # enmo\n            enmo_mean = sensor_df[\"enmo\"][start:end].mean()\n            enmo_std = sensor_df[\"enmo\"][start:end].std()\n            sleep_enmo_mean.append(enmo_mean)\n            sleep_enmo_std.append(enmo_std)\n    \n            # light\n            light_mean = sensor_df[\"light\"][start:end].mean()\n            light_std = sensor_df[\"light\"][start:end].std()\n            sleep_light_mean.append(light_mean)\n            sleep_light_std.append(light_std)\n            \n        sleep_df = sleep_df.with_columns(\n            pl.DataFrame(\n                {\n                    \"sleep_length\": sleep_lengths,\n                    \"sleep_enmo_mean\": sleep_enmo_mean,\n                    \"sleep_enmo_std\": sleep_enmo_std,\n                    \"sleep_light_mean\": sleep_light_mean,\n                    \"sleep_light_std\": sleep_light_std,\n                }\n            )\n        )\n        \n        # leave only high confidence periods\n        sleep_df = sleep_df.filter((pl.col(\"wakeup_score\") > 1) & (pl.col(\"onset_score\") > 1))\n        if debug_count < 3:\n            display(sleep_df.head())\n        debug_count += 1\n            \n    \n        # agg\n        feature.update(\n            {\n                \"sleep_measurement_count\": sleep_df.shape[0],\n                \"sleep_length_mean\": sleep_df[\"sleep_length\"].mean(),\n                \"sleep_length_std\": sleep_df[\"sleep_length\"].std(),\n                \"sleep_start_mean\": sleep_df[\"onset_time\"].mean(),\n                \"sleep_start_std\": sleep_df[\"onset_time\"].std(),\n                \"sleep_end_mean\": sleep_df[\"wakeup_time\"].mean(),\n                \"sleep_end_std\": sleep_df[\"wakeup_time\"].std(),\n                \"sleep_enmo_mean_mean\": sleep_df[\"sleep_enmo_mean\"].mean(),\n                \"sleep_enmo_mean_std\": sleep_df[\"sleep_enmo_mean\"].std(),\n                \"sleep_enmo_std_mean\": sleep_df[\"sleep_enmo_std\"].mean(),\n                \"sleep_enmo_std_std\": sleep_df[\"sleep_enmo_std\"].std(),\n                \"sleep_light_mean_mean\": sleep_df[\"sleep_light_mean\"].mean(),\n                \"sleep_light_mean_std\": sleep_df[\"sleep_light_mean\"].std(),\n                \"sleep_light_std_mean\": sleep_df[\"sleep_light_std\"].mean(),\n                \"sleep_light_std_std\": sleep_df[\"sleep_light_std\"].std(),\n            }\n        )\n        features.append(feature)\n    output_dir = f\"/kaggle/working/features/{train_or_test}\"\n    os.makedirs(output_dir, exist_ok=True)\n    feature_df = pl.DataFrame(features).with_columns(pl.col(\"id\").str.slice(3, 8))\n    feature_df.write_csv(f\"/kaggle/working/features/{train_or_test}/sleep_features.csv\")\n    print(feature_df.head())","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:28.561835Z","iopub.execute_input":"2024-12-18T13:18:28.562092Z","iopub.status.idle":"2024-12-18T13:18:28.582077Z","shell.execute_reply.started":"2024-12-18T13:18:28.562069Z","shell.execute_reply":"2024-12-18T13:18:28.581211Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"create_heuristic(paths=glob(\"/kaggle/input/child-mind-institute-problematic-internet-use/series_test.parquet/id=*/part-0.parquet\"), train_or_test=\"test\")\ndetection(paths=\"/kaggle/input/child-mind-institute-problematic-internet-use/series_test.parquet/id=*/part-0.parquet\", train_or_test=\"test\")\nfeature_engineering(paths=\"/kaggle/working/features/sleep_detection/test/*.parquet\", data_paths=\"/kaggle/input/child-mind-institute-problematic-internet-use/series_test.parquet\", train_or_test=\"test\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:28.583007Z","iopub.execute_input":"2024-12-18T13:18:28.583254Z","iopub.status.idle":"2024-12-18T13:18:35.807671Z","shell.execute_reply.started":"2024-12-18T13:18:28.583229Z","shell.execute_reply":"2024-12-18T13:18:35.806755Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# create_heuristic(paths=glob(\"/kaggle/input/child-mind-institute-problematic-internet-use/series_train.parquet/id=*/part-0.parquet\"), train_or_test=\"train\")\n# detection(paths=\"/kaggle/input/child-mind-institute-problematic-internet-use/series_train.parquet/id=*/part-0.parquet\", train_or_test=\"train\")\n# feature_engineering(paths=\"/kaggle/working/features/sleep_detection/train/*.parquet\", data_paths=\"/kaggle/input/child-mind-institute-problematic-internet-use/series_train.parquet\", train_or_test=\"train\")\n","metadata":{"execution":{"iopub.status.busy":"2024-12-18T13:18:35.810435Z","iopub.execute_input":"2024-12-18T13:18:35.810724Z","iopub.status.idle":"2024-12-18T13:18:35.814523Z","shell.execute_reply.started":"2024-12-18T13:18:35.810684Z","shell.execute_reply":"2024-12-18T13:18:35.813561Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport os\nimport re\nimport copy\nimport pickle\nfrom sklearn.base import clone\nfrom sklearn.metrics import cohen_kappa_score\nfrom sklearn.model_selection import StratifiedKFold\nfrom scipy.optimize import minimize\nfrom concurrent.futures import ThreadPoolExecutor\nfrom tqdm import tqdm\nimport polars as pl\nimport polars.selectors as cs\nimport matplotlib.pyplot as plt\nfrom matplotlib.ticker import MaxNLocator, FormatStrFormatter, PercentFormatter\nimport seaborn as sns\n\nfrom sklearn.preprocessing import StandardScaler\nimport matplotlib.pyplot as plt\nfrom keras.models import Model\nfrom keras.layers import Input, Dense\nfrom keras.optimizers import Adam\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\n\nfrom colorama import Fore, Style\nfrom IPython.display import clear_output\nimport warnings\nfrom lightgbm import LGBMRegressor\nfrom xgboost import XGBRegressor\nfrom catboost import CatBoostRegressor\nfrom sklearn.ensemble import VotingRegressor, RandomForestRegressor, GradientBoostingRegressor\nfrom sklearn.impute import SimpleImputer, KNNImputer\nfrom sklearn.pipeline import Pipeline\n\nimport plotly.express as px\n\nwarnings.filterwarnings('ignore')\npd.options.display.max_columns = None\nSEED = 42\nn_splits = 5","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:35.815602Z","iopub.execute_input":"2024-12-18T13:18:35.815916Z","iopub.status.idle":"2024-12-18T13:18:39.670136Z","shell.execute_reply.started":"2024-12-18T13:18:35.815891Z","shell.execute_reply":"2024-12-18T13:18:39.669367Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class AutoEncoder(nn.Module):\n    def __init__(self, input_dim, encoding_dim):\n        super(AutoEncoder, self).__init__()\n        self.encoder = nn.Sequential(\n            nn.Linear(input_dim, encoding_dim*3),\n            nn.ReLU(),\n            nn.Linear(encoding_dim*3, encoding_dim*2),\n            nn.ReLU(),\n            nn.Linear(encoding_dim*2, encoding_dim),\n            nn.ReLU()\n        )\n        self.decoder = nn.Sequential(\n            nn.Linear(encoding_dim, encoding_dim*2),\n            nn.ReLU(),\n            nn.Linear(encoding_dim*2, encoding_dim*3),\n            nn.ReLU(),\n            nn.Linear(encoding_dim*3, input_dim),\n            nn.Sigmoid()\n        )\n\n        \n    def forward(self, x):\n        encoded = self.encoder(x)\n        decoded = self.decoder(encoded)\n        return decoded\n\n\ndef perform_autoencoder(df, encoding_dim=50, epochs=50, batch_size=32):\n    scaler = StandardScaler()\n    df_scaled = scaler.fit_transform(df)\n    \n    data_tensor = torch.FloatTensor(df_scaled)\n    \n    input_dim = data_tensor.shape[1]\n    autoencoder = AutoEncoder(input_dim, encoding_dim)\n    \n    criterion = nn.MSELoss()\n    optimizer = optim.Adam(autoencoder.parameters())\n    \n    for epoch in range(epochs):\n        for i in range(0, len(data_tensor), batch_size):\n            batch = data_tensor[i : i + batch_size]\n            optimizer.zero_grad()\n            reconstructed = autoencoder(batch)\n            loss = criterion(reconstructed, batch)\n            loss.backward()\n            optimizer.step()\n            \n        if (epoch + 1) % 10 == 0:\n            print(f'Epoch [{epoch + 1}/{epochs}], Loss: {loss.item():.4f}]')\n                 \n    with torch.no_grad():\n        encoded_data = autoencoder.encoder(data_tensor).numpy()\n        \n    df_encoded = pd.DataFrame(encoded_data, columns=[f'Enc_{i + 1}' for i in range(encoded_data.shape[1])])\n    \n    return df_encoded","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:39.671149Z","iopub.execute_input":"2024-12-18T13:18:39.671872Z","iopub.status.idle":"2024-12-18T13:18:39.680917Z","shell.execute_reply.started":"2024-12-18T13:18:39.671844Z","shell.execute_reply":"2024-12-18T13:18:39.680072Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def process_file(filename, dirname):\n    df = pd.read_parquet(os.path.join(dirname, filename, 'part-0.parquet'))\n    df.drop('step', axis=1, inplace=True)\n    return df.describe().values.reshape(-1), filename.split('=')[1]\n\n\ndef load_time_series(dirname) -> pd.DataFrame:\n    ids = os.listdir(dirname)\n    with ThreadPoolExecutor() as executor:\n        results = list(tqdm(executor.map(lambda fname: process_file(fname, dirname), ids), total=len(ids)))\n    stats, indexes = zip(*results)\n    df = pd.DataFrame(stats, columns=[f\"stat_{i}\" for i in range(len(stats[0]))])\n    df['id'] = indexes\n    return df\n\ndef update(df):\n    global cat_c\n    for c in cat_c: \n        df[c] = df[c].fillna('Missing')\n        df[c] = df[c].astype('category')\n    return df\n\ndef create_mapping(column, dataset):\n    unique_values = dataset[column].unique()\n    return {value: idx for idx, value in enumerate(unique_values)}\n\ndef quadratic_weighted_kappa(y_true, y_pred):\n    return cohen_kappa_score(y_true, y_pred, weights='quadratic')\n\ndef threshold_Rounder(oof_non_rounded, thresholds):\n    return np.where(oof_non_rounded < thresholds[0], 0,\n                    np.where(oof_non_rounded < thresholds[1], 1,\n                             np.where(oof_non_rounded < thresholds[2], 2, 3)))\n\ndef evaluate_predictions(thresholds, y_true, oof_non_rounded):\n    rounded_p = threshold_Rounder(oof_non_rounded, thresholds)\n    return -quadratic_weighted_kappa(y_true, rounded_p)\n\ndef TrainML(model_class, X, y, test_data):\n    SKF = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED)\n    \n    train_S = []\n    test_S = []\n    \n    oof_non_rounded = np.zeros(len(y), dtype=float) \n    oof_rounded = np.zeros(len(y), dtype=int) \n    test_preds = np.zeros((len(test_data), n_splits))\n\n    for fold, (train_idx, test_idx) in enumerate(tqdm(SKF.split(X, y), desc=\"Training Folds\", total=n_splits)):\n        X_train, X_val = X.iloc[train_idx], X.iloc[test_idx]\n        y_train, y_val = y.iloc[train_idx], y.iloc[test_idx]\n        model = clone(model_class)\n        model.fit(X_train, y_train)\n\n        y_train_pred = model.predict(X_train)\n        y_val_pred = model.predict(X_val)\n\n        oof_non_rounded[test_idx] = y_val_pred\n        y_val_pred_rounded = y_val_pred.round(0).astype(int)\n        oof_rounded[test_idx] = y_val_pred_rounded\n\n        train_kappa = quadratic_weighted_kappa(y_train, y_train_pred.round(0).astype(int))\n        val_kappa = quadratic_weighted_kappa(y_val, y_val_pred_rounded)\n\n        train_S.append(train_kappa)\n        test_S.append(val_kappa)\n        \n        test_preds[:, fold] = model.predict(test_data)\n        \n        print(f\"Fold {fold+1} - Train QWK: {train_kappa:.4f}, Validation QWK: {val_kappa:.4f}\")\n        clear_output(wait=True)\n    print(f\"Mean Train QWK --> {np.mean(train_S):.4f}\")\n    print(f\"Mean Validation QWK ---> {np.mean(test_S):.4f}\")\n\n    KappaOPtimizer = minimize(evaluate_predictions,\n                              x0=[0.5, 1.5, 2.5], args=(y, oof_non_rounded), \n                              method='Nelder-Mead')\n    assert KappaOPtimizer.success, \"Optimization did not converge.\"\n    print('OPTIMIZED THRESHOLDS', KappaOPtimizer.x)\n    oof_tuned = threshold_Rounder(oof_non_rounded, KappaOPtimizer.x)\n    tKappa = quadratic_weighted_kappa(y, oof_tuned)\n\n    print(f\"----> || Optimized QWK SCORE :: {Fore.CYAN}{Style.BRIGHT} {tKappa:.3f}{Style.RESET_ALL}\")\n\n    tpm = test_preds.mean(axis=1)\n    tpTuned = threshold_Rounder(tpm, KappaOPtimizer.x)\n    \n    submission = pd.DataFrame({\n        'id': sample['id'],\n        'sii': tpTuned\n    })\n    optimized_thresholds = KappaOPtimizer.x\n    return submission, oof_tuned, oof_non_rounded, y, optimized_thresholds\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:39.682067Z","iopub.execute_input":"2024-12-18T13:18:39.682357Z","iopub.status.idle":"2024-12-18T13:18:39.704501Z","shell.execute_reply.started":"2024-12-18T13:18:39.682317Z","shell.execute_reply":"2024-12-18T13:18:39.703775Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/train.csv')\ntest = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/test.csv')\nsample = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/sample_submission.csv')\n\ntotal_features = list(test.columns)\ntotal_features.remove('id')\n\ncat_c = ['Basic_Demos-Enroll_Season', 'CGAS-Season', 'Physical-Season', \n          'Fitness_Endurance-Season', 'FGC-Season', 'BIA-Season', \n          'PAQ_A-Season', 'PAQ_C-Season', 'SDS-Season', 'PreInt_EduHx-Season']","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:39.705387Z","iopub.execute_input":"2024-12-18T13:18:39.705621Z","iopub.status.idle":"2024-12-18T13:18:39.778921Z","shell.execute_reply.started":"2024-12-18T13:18:39.705599Z","shell.execute_reply":"2024-12-18T13:18:39.778377Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"noseason_features = ['Basic_Demos-Age', 'Basic_Demos-Sex',\n                'CGAS-CGAS_Score', 'Physical-BMI',\n                'Physical-Height', 'Physical-Weight', 'Physical-Waist_Circumference',\n                'Physical-Diastolic_BP', 'Physical-HeartRate', 'Physical-Systolic_BP',\n                'Fitness_Endurance-Max_Stage',\n                'Fitness_Endurance-Time_Mins', 'Fitness_Endurance-Time_Sec',\n                'FGC-FGC_CU', 'FGC-FGC_CU_Zone', 'FGC-FGC_GSND',\n                'FGC-FGC_GSND_Zone', 'FGC-FGC_GSD', 'FGC-FGC_GSD_Zone', 'FGC-FGC_PU',\n                'FGC-FGC_PU_Zone', 'FGC-FGC_SRL', 'FGC-FGC_SRL_Zone', 'FGC-FGC_SRR',\n                'FGC-FGC_SRR_Zone', 'FGC-FGC_TL', 'FGC-FGC_TL_Zone',\n                'BIA-BIA_Activity_Level_num', 'BIA-BIA_BMC', 'BIA-BIA_BMI',\n                'BIA-BIA_BMR', 'BIA-BIA_DEE', 'BIA-BIA_ECW', 'BIA-BIA_FFM',\n                'BIA-BIA_FFMI', 'BIA-BIA_FMI', 'BIA-BIA_Fat', 'BIA-BIA_Frame_num',\n                'BIA-BIA_ICW', 'BIA-BIA_LDM', 'BIA-BIA_LST', 'BIA-BIA_SMM',\n                'BIA-BIA_TBW', 'PAQ_A-PAQ_A_Total',\n                'PAQ_C-PAQ_C_Total', 'SDS-SDS_Total_Raw',\n                'SDS-SDS_Total_T',\n                'PreInt_EduHx-computerinternet_hoursday', 'BMI_Age','Internet_Hours_Age','BMI_Internet_Hours',\n                'BFP_BMI', 'FFMI_BFP', 'FMI_BFP', 'LST_TBW', 'BFP_BMR', 'BFP_DEE', 'BMR_Weight', 'DEE_Weight',\n                'SMM_Height', 'Muscle_to_Fat', 'Hydration_Status', 'ICW_TBW','BMI_PHR']","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:39.780012Z","iopub.execute_input":"2024-12-18T13:18:39.780799Z","iopub.status.idle":"2024-12-18T13:18:39.786524Z","shell.execute_reply.started":"2024-12-18T13:18:39.780762Z","shell.execute_reply":"2024-12-18T13:18:39.785754Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_ts = load_time_series(\"/kaggle/input/child-mind-institute-problematic-internet-use/series_train.parquet\")\ntest_ts = load_time_series(\"/kaggle/input/child-mind-institute-problematic-internet-use/series_test.parquet\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:18:39.787323Z","iopub.execute_input":"2024-12-18T13:18:39.787593Z","iopub.status.idle":"2024-12-18T13:19:50.299874Z","shell.execute_reply.started":"2024-12-18T13:18:39.787570Z","shell.execute_reply":"2024-12-18T13:19:50.298912Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"df_train = train_ts.drop('id', axis=1)\ndf_test = test_ts.drop('id', axis=1)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:50.300794Z","iopub.execute_input":"2024-12-18T13:19:50.301057Z","iopub.status.idle":"2024-12-18T13:19:50.306156Z","shell.execute_reply.started":"2024-12-18T13:19:50.301033Z","shell.execute_reply":"2024-12-18T13:19:50.305280Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"df_total = pd.concat([df_train, df_test], axis=0, ignore_index=True)\ndf_total","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:50.307345Z","iopub.execute_input":"2024-12-18T13:19:50.307674Z","iopub.status.idle":"2024-12-18T13:19:50.396562Z","shell.execute_reply.started":"2024-12-18T13:19:50.307639Z","shell.execute_reply":"2024-12-18T13:19:50.395699Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# train_ts_encoded = perform_autoencoder(df_train, encoding_dim=60, epochs=100, batch_size=32)\n# test_ts_encoded = perform_autoencoder(df_test, encoding_dim=60, epochs=100, batch_size=32)\ntotal_ts_encoded = perform_autoencoder(df_total, encoding_dim=60, epochs=100, batch_size=32)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:50.397475Z","iopub.execute_input":"2024-12-18T13:19:50.397726Z","iopub.status.idle":"2024-12-18T13:19:58.894839Z","shell.execute_reply.started":"2024-12-18T13:19:50.397684Z","shell.execute_reply":"2024-12-18T13:19:58.893985Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"time_series_cols = train_ts.columns.tolist()\ntime_series_cols.remove(\"id\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:58.895927Z","iopub.execute_input":"2024-12-18T13:19:58.896220Z","iopub.status.idle":"2024-12-18T13:19:58.900733Z","shell.execute_reply.started":"2024-12-18T13:19:58.896191Z","shell.execute_reply":"2024-12-18T13:19:58.899753Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sleep = pd.read_csv(\"/kaggle/input/sleep-detection/sleep_features.csv\")\ntest_sleep = pd.read_csv(\"/kaggle/working/features/test/sleep_features.csv\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:58.901790Z","iopub.execute_input":"2024-12-18T13:19:58.902335Z","iopub.status.idle":"2024-12-18T13:19:58.925887Z","shell.execute_reply.started":"2024-12-18T13:19:58.902294Z","shell.execute_reply":"2024-12-18T13:19:58.925202Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"sleep_cols = train_sleep.columns.tolist()\nsleep_cols.remove(\"id\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:58.926863Z","iopub.execute_input":"2024-12-18T13:19:58.927631Z","iopub.status.idle":"2024-12-18T13:19:58.931239Z","shell.execute_reply.started":"2024-12-18T13:19:58.927598Z","shell.execute_reply":"2024-12-18T13:19:58.930520Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"rm -rf /kaggle/working/features\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:58.932301Z","iopub.execute_input":"2024-12-18T13:19:58.932596Z","iopub.status.idle":"2024-12-18T13:19:59.991665Z","shell.execute_reply.started":"2024-12-18T13:19:58.932568Z","shell.execute_reply":"2024-12-18T13:19:59.990460Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"rm -rf /kaggle/working/heuristic_features","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:19:59.993085Z","iopub.execute_input":"2024-12-18T13:19:59.993339Z","iopub.status.idle":"2024-12-18T13:20:01.020543Z","shell.execute_reply.started":"2024-12-18T13:19:59.993316Z","shell.execute_reply":"2024-12-18T13:20:01.019571Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!pip -q install /kaggle/input/pytorchtabnet/pytorch_tabnet-4.1.0-py3-none-any.whl","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-18T13:20:01.021901Z","iopub.execute_input":"2024-12-18T13:20:01.022186Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from pytorch_tabnet.tab_model import TabNetRegressor\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def feature_engineering(df):\n    season_cols = [col for col in df.columns if 'Season' in col]\n    df = df.drop(season_cols, axis=1) \n    df['BMI_Age'] = df['Physical-BMI'] * df['Basic_Demos-Age']\n    df['Internet_Hours_Age'] = df['PreInt_EduHx-computerinternet_hoursday'] * df['Basic_Demos-Age']\n    df['BMI_Internet_Hours'] = df['Physical-BMI'] * df['PreInt_EduHx-computerinternet_hoursday']\n    df['BFP_BMI'] = df['BIA-BIA_Fat'] / df['BIA-BIA_BMI']\n    df['FFMI_BFP'] = df['BIA-BIA_FFMI'] / df['BIA-BIA_Fat']\n    df['FMI_BFP'] = df['BIA-BIA_FMI'] / df['BIA-BIA_Fat']\n    df['LST_TBW'] = df['BIA-BIA_LST'] / df['BIA-BIA_TBW']\n    df['BFP_BMR'] = df['BIA-BIA_Fat'] * df['BIA-BIA_BMR']\n    df['BFP_DEE'] = df['BIA-BIA_Fat'] * df['BIA-BIA_DEE']\n    df['BMR_Weight'] = df['BIA-BIA_BMR'] / df['Physical-Weight']\n    df['DEE_Weight'] = df['BIA-BIA_DEE'] / df['Physical-Weight']\n    df['SMM_Height'] = df['BIA-BIA_SMM'] / df['Physical-Height']\n    df['Muscle_to_Fat'] = df['BIA-BIA_SMM'] / df['BIA-BIA_FMI']\n    df['Hydration_Status'] = df['BIA-BIA_TBW'] / df['Physical-Weight']\n    df['ICW_TBW'] = df['BIA-BIA_ICW'] / df['BIA-BIA_TBW']\n    df['BMI_PHR'] = df['Physical-BMI'] * df['Physical-HeartRate']\n    \n    return df","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sub2 = pd.merge(train, train_ts, how=\"left\", on='id')\ntest_sub2 = pd.merge(test, test_ts, how=\"left\", on='id')\n\nimputer = KNNImputer(n_neighbors=5)\nnumeric_cols = train.select_dtypes(include=['float64', 'int64']).columns\nimputed_data = imputer.fit_transform(train_sub2[numeric_cols])\ntrain_imputed = pd.DataFrame(imputed_data, columns=numeric_cols)\ntrain_imputed['sii'] = train_imputed['sii'].round().astype(int)\n\nfor col in train_sub2.columns:\n    if col not in numeric_cols:\n        train_imputed[col] = train_sub2[col]\n        \ntrain_sub2 = train_imputed\n\ntrain_sub2 = feature_engineering(train_sub2)\ntrain_sub2 = train_sub2.dropna(subset='sii', ignore_index=True)\ntest_sub2 = feature_engineering(test_sub2)\n\ntrain_sub2 = train_sub2.drop('id', axis=1)\ntest_sub2  = test_sub2.drop('id', axis=1)   ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"features_sub2 = noseason_features + time_series_cols\n\n# train_sub2 = pd.merge(train, train_ts, how=\"left\", on='id')\n# test_sub2 = pd.merge(test, test_ts, how=\"left\", on='id')\n\ntrain_sub2 = train_sub2.dropna(subset='sii')\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"if np.any(np.isinf(train_sub2)):\n    train_sub2 = train_sub2.replace([np.inf, -np.inf], np.nan)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"X_sub2 = train_sub2[features_sub2]\ny_sub2 = train_sub2['sii']\ntest_sub2 = test_sub2[features_sub2]","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Model parameters for LightGBM\nParams = {\n    'learning_rate': 0.046,\n    'max_depth': 12,\n    'num_leaves': 478,\n    'min_data_in_leaf': 13,\n    'feature_fraction': 0.893,\n    'bagging_fraction': 0.784,\n    'bagging_freq': 4,\n    'lambda_l1': 10,  # Increased from 6.59\n    'lambda_l2': 0.01,  # Increased from 2.68e-06\n    'device': 'cpu'\n\n}\n\n\n# XGBoost parameters\nXGB_Params = {\n    'learning_rate': 0.05,\n    'max_depth': 6,\n    'n_estimators': 200,\n    'subsample': 0.8,\n    'colsample_bytree': 0.8,\n    'reg_alpha': 1,  # Increased from 0.1\n    'reg_lambda': 5,  # Increased from 1\n    'random_state': SEED,\n    'tree_method': 'gpu_hist',\n\n}\n\n\nCatBoost_Params = {\n    'learning_rate': 0.05,\n    'depth': 6,\n    'iterations': 200,\n    'random_seed': SEED,\n    'verbose': 0,\n    'l2_leaf_reg': 10,  # Increase this value\n    'task_type': 'GPU'\n\n}","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# New: TabNet\n\nfrom sklearn.base import BaseEstimator, RegressorMixin\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.model_selection import train_test_split\nfrom pytorch_tabnet.callbacks import Callback\nimport os\nimport torch\nfrom pytorch_tabnet.callbacks import Callback\n\nclass TabNetWrapper(BaseEstimator, RegressorMixin):\n    def __init__(self, **kwargs):\n        self.model = TabNetRegressor(**kwargs)\n        self.kwargs = kwargs\n        self.imputer = SimpleImputer(strategy='median')\n        self.best_model_path = 'best_tabnet_model.pt'\n        \n    def fit(self, X, y):\n        # Handle missing values\n        X_imputed = self.imputer.fit_transform(X)\n        \n        if hasattr(y, 'values'):\n            y = y.values\n            \n        # Create internal validation set\n        X_train, X_valid, y_train, y_valid = train_test_split(\n            X_imputed, \n            y, \n            test_size=0.2,\n            random_state=42\n        )\n        \n        # Train TabNet model\n        history = self.model.fit(\n            X_train=X_train,\n            y_train=y_train.reshape(-1, 1),\n            eval_set=[(X_valid, y_valid.reshape(-1, 1))],\n            eval_name=['valid'],\n            eval_metric=['mse'],\n            max_epochs=200,\n            patience=20,\n            batch_size=1024,\n            virtual_batch_size=128,\n            num_workers=0,\n            drop_last=False,\n            callbacks=[\n                TabNetPretrainedModelCheckpoint(\n                    filepath=self.best_model_path,\n                    monitor='valid_mse',\n                    mode='min',\n                    save_best_only=True,\n                    verbose=True\n                )\n            ]\n        )\n        \n        # Load the best model\n        if os.path.exists(self.best_model_path):\n            self.model.load_model(self.best_model_path)\n            os.remove(self.best_model_path)  # Remove temporary file\n        \n        return self\n    \n    def predict(self, X):\n        X_imputed = self.imputer.transform(X)\n        return self.model.predict(X_imputed).flatten()\n    \n    def __deepcopy__(self, memo):\n        # Add deepcopy support for scikit-learn\n        cls = self.__class__\n        result = cls.__new__(cls)\n        memo[id(self)] = result\n        for k, v in self.__dict__.items():\n            setattr(result, k, deepcopy(v, memo))\n        return result\n\n# TabNet hyperparameters\nTabNet_Params = {\n    'n_d': 64,              # Width of the decision prediction layer\n    'n_a': 64,              # Width of the attention embedding for each step\n    'n_steps': 5,           # Number of steps in the architecture\n    'gamma': 1.5,           # Coefficient for feature selection regularization\n    'n_independent': 2,     # Number of independent GLU layer in each GLU block\n    'n_shared': 2,          # Number of shared GLU layer in each GLU block\n    'lambda_sparse': 1e-4,  # Sparsity regularization\n    'optimizer_fn': torch.optim.Adam,\n    'optimizer_params': dict(lr=2e-2, weight_decay=1e-5),\n    'mask_type': 'entmax',\n    'scheduler_params': dict(mode=\"min\", patience=10, min_lr=1e-5, factor=0.5),\n    'scheduler_fn': torch.optim.lr_scheduler.ReduceLROnPlateau,\n    'verbose': 1,\n    'device_name': 'cuda' if torch.cuda.is_available() else 'cpu'\n}\n\nclass TabNetPretrainedModelCheckpoint(Callback):\n    def __init__(self, filepath, monitor='val_loss', mode='min', \n                 save_best_only=True, verbose=1):\n        super().__init__()  # Initialize parent class\n        self.filepath = filepath\n        self.monitor = monitor\n        self.mode = mode\n        self.save_best_only = save_best_only\n        self.verbose = verbose\n        self.best = float('inf') if mode == 'min' else -float('inf')\n        \n    def on_train_begin(self, logs=None):\n        self.model = self.trainer  # Use trainer itself as model\n        \n    def on_epoch_end(self, epoch, logs=None):\n        logs = logs or {}\n        current = logs.get(self.monitor)\n        if current is None:\n            return\n        \n        # Check if current metric is better than best\n        if (self.mode == 'min' and current < self.best) or \\\n           (self.mode == 'max' and current > self.best):\n            if self.verbose:\n                print(f'\\nEpoch {epoch}: {self.monitor} improved from {self.best:.4f} to {current:.4f}')\n            self.best = current\n            if self.save_best_only:\n                self.model.save_model(self.filepath)  # Save the entire model","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Create model instances\nLight = LGBMRegressor(**Params, random_state=SEED, verbose=-1, n_estimators=300)\nXGB_Model = XGBRegressor(**XGB_Params)\nCatBoost_Model = CatBoostRegressor(**CatBoost_Params)\nTabNet_Model = TabNetWrapper(**TabNet_Params) \nvoting_model = VotingRegressor(estimators=[\n    ('lightgbm', Light),\n    ('xgboost', XGB_Model),\n    ('catboost', CatBoost_Model),\n],weights=[4.0,4.0,5.0])\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"submission2, _, _, _, _= TrainML(voting_model, X_sub2, y_sub2, test_sub2)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sub5 = pd.merge(train, train_sleep, how=\"left\", on='id')\ntest_sub5 = pd.merge(test, test_sleep, how=\"left\", on='id')\n# print(train_sub5)\nimputer = KNNImputer(n_neighbors=5)\nnumeric_cols = train.select_dtypes(include=['float64', 'int64']).columns\nimputed_data = imputer.fit_transform(train_sub5[numeric_cols])\ntrain_imputed = pd.DataFrame(imputed_data, columns=numeric_cols)\ntrain_imputed['sii'] = train_imputed['sii'].round().astype(int)\n\nfor col in train_sub5.columns:\n    if col not in numeric_cols:\n        train_imputed[col] = train_sub5[col]\n        \ntrain_sub2 = train_imputed\n\ntrain_sub5 = feature_engineering(train_sub5)\ntrain_sub5 = train_sub5.dropna(subset='sii', ignore_index=True)\ntest_sub5 = feature_engineering(test_sub5)\n\ntrain_sub5 = train_sub5.drop('id', axis=1)\ntest_sub5  = test_sub5.drop('id', axis=1) \n\nfeatures_sub5 = noseason_features + sleep_cols\n\n# train_sub2 = pd.merge(train, train_ts, how=\"left\", on='id')\n# test_sub2 = pd.merge(test, test_ts, how=\"left\", on='id')\n\ntrain_sub5 = train_sub5.dropna(subset='sii')\n\nif np.any(np.isinf(train_sub5)):\n    train_sub5 = train_sub5.replace([np.inf, -np.inf], np.nan)\n\nX_sub5 = train_sub5[features_sub5]\ny_sub5 = train_sub5['sii']\ntest_sub5 = test_sub5[features_sub5]\n\nsubmission5, _, _, _, _= TrainML(voting_model, X_sub5, y_sub5, test_sub5)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sub3 = pd.merge(train, train_ts, how=\"left\", on='id')\ntest_sub3 = pd.merge(test, test_ts, how=\"left\", on='id')\n\ntrain_sub3 = train_sub3.drop('id', axis=1)\ntest_sub3 = test_sub3.drop('id', axis=1) ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"features_sub3 = total_features + time_series_cols","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sub3 = train_sub3.dropna(subset='sii')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sub3 = update(train_sub3)\ntest_sub3 = update(test_sub3)\n\nfor col in cat_c:\n    mapping = create_mapping(col, train_sub3)\n    mappingTe = create_mapping(col, test_sub3)\n    \n    train_sub3[col] = train_sub3[col].replace(mapping).astype(int)\n    test_sub3[col] = test_sub3[col].replace(mappingTe).astype(int)\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"Params = {\n    'learning_rate': 0.046,\n    'max_depth': 12,\n    'num_leaves': 478,\n    'min_data_in_leaf': 13,\n    'feature_fraction': 0.893,\n    'bagging_fraction': 0.784,\n    'bagging_freq': 4,\n    'lambda_l1': 10,  # Increased from 6.59\n    'lambda_l2': 0.01  # Increased from 2.68e-06\n}\n\n\n# XGBoost parameters\nXGB_Params = {\n    'learning_rate': 0.05,\n    'max_depth': 6,\n    'n_estimators': 200,\n    'subsample': 0.8,\n    'colsample_bytree': 0.8,\n    'reg_alpha': 1,  # Increased from 0.1\n    'reg_lambda': 5,  # Increased from 1\n    'random_state': SEED\n}\n\n\nCatBoost_Params = {\n    'learning_rate': 0.05,\n    'depth': 6,\n    'iterations': 200,\n    'random_seed': SEED,\n    'cat_features': cat_c,\n    'verbose': 0,\n    'l2_leaf_reg': 10  # Increase this value\n}\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"Light = LGBMRegressor(**Params, random_state=SEED, verbose=-1, n_estimators=300)\nXGB_Model = XGBRegressor(**XGB_Params)\nCatBoost_Model = CatBoostRegressor(**CatBoost_Params)\n\n# Combine models using Voting Regressor\nvoting_model = VotingRegressor(estimators=[\n    ('lightgbm', Light),\n    ('xgboost', XGB_Model),\n    ('catboost', CatBoost_Model)\n])\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"X_sub3 = train_sub3[features_sub3]\ny_sub3 = train_sub3['sii']\ntest_sub3 = test_sub3[features_sub3]","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"submission3, _, _, _, _= TrainML(voting_model, X_sub3, y_sub3, test_sub3)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_sub6 = pd.merge(train, train_sleep, how=\"left\", on='id')\ntest_sub6 = pd.merge(test, test_sleep, how=\"left\", on='id')\n\ntrain_sub6 = train_sub6.drop('id', axis=1)\ntest_sub6 = test_sub6.drop('id', axis=1) \n\nfeatures_sub6 = total_features + sleep_cols\n\ntrain_sub6 = train_sub6.dropna(subset='sii')\n\ntrain_sub6 = update(train_sub6)\ntest_sub6 = update(test_sub6)\n\nfor col in cat_c:\n    mapping = create_mapping(col, train_sub6)\n    mappingTe = create_mapping(col, test_sub6)\n    \n    train_sub6[col] = train_sub6[col].replace(mapping).astype(int)\n    test_sub6[col] = test_sub6[col].replace(mappingTe).astype(int)\n\nX_sub6 = train_sub6[features_sub6]\ny_sub6 = train_sub6['sii']\ntest_sub6 = test_sub6[features_sub6]\n\nsubmission6, _, _, _, _= TrainML(voting_model, X_sub6, y_sub6, test_sub6)\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"imputer = SimpleImputer(strategy='median')\n\nensemble = VotingRegressor(estimators=[\n    ('lgb', Pipeline(steps=[('imputer', imputer), ('regressor', LGBMRegressor(random_state=SEED))])),\n    ('xgb', Pipeline(steps=[('imputer', imputer), ('regressor', XGBRegressor(random_state=SEED))])),\n    ('cat', Pipeline(steps=[('imputer', imputer), ('regressor', CatBoostRegressor(random_state=SEED, silent=True))])),\n    ('rf', Pipeline(steps=[('imputer', imputer), ('regressor', RandomForestRegressor(random_state=SEED))])),\n    ('gb', Pipeline(steps=[('imputer', imputer), ('regressor', GradientBoostingRegressor(random_state=SEED))]))\n])\n\n\nsubmission4, _, _, _, _= TrainML(ensemble, X_sub3, y_sub3, test_sub3)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"submission7, _, _, _, _= TrainML(ensemble, X_sub6, y_sub6, test_sub6)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"sub1 = submission2\nsub2 = submission3\nsub3 = submission4\nsub5 = submission5\nsub6 = submission6\nsub7 = submission7\n\nsub1 = sub1.sort_values(by='id').reset_index(drop=True)\nsub2 = sub2.sort_values(by='id').reset_index(drop=True)\nsub3 = sub3.sort_values(by='id').reset_index(drop=True)\nsub5 = sub5.sort_values(by='id').reset_index(drop=True)\nsub6 = sub6.sort_values(by='id').reset_index(drop=True)\nsub7 = sub7.sort_values(by='id').reset_index(drop=True)\n\ncombined = pd.DataFrame({\n    'id': sub1['id'],\n    'sii_1': sub1['sii'],\n    'sii_2': sub2['sii'],\n    'sii_3': sub3['sii'],\n    'sii_5': sub5['sii'],\n    'sii_6': sub6['sii'],\n    'sii_7': sub7['sii']\n})\n\ndef majority_vote(row):\n    return row.mode()[0]\n\ncombined['final_sii'] = combined[['sii_1', 'sii_3', 'sii_5', 'sii_6']].apply(majority_vote, axis=1)\nprint(combined)\nfinal_submission = combined[['id', 'final_sii']].rename(columns={'final_sii': 'sii'})\n\nfinal_submission.to_csv('submission.csv', index=False)\n\nprint(\"Majority voting completed and saved to 'Final_Submission.csv'\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# sub1 = submission2\n# sub2 = submission3\n# sub3 = submission4\n# sub5 = submission5\n# sub6 = submission6\n# sub7 = submission7\n\n# sub1 = sub1.sort_values(by='id').reset_index(drop=True)\n# sub2 = sub2.sort_values(by='id').reset_index(drop=True)\n# sub3 = sub3.sort_values(by='id').reset_index(drop=True)\n# sub5 = sub5.sort_values(by='id').reset_index(drop=True)\n# sub6 = sub6.sort_values(by='id').reset_index(drop=True)\n# sub7 = sub7.sort_values(by='id').reset_index(drop=True)\n\n# combined = pd.DataFrame({\n#     'id': sub1['id'],\n#     'sii_1': sub1['sii'],\n#     'sii_2': sub2['sii'],\n#     'sii_3': sub3['sii'],\n#     'sii_5': sub5['sii'],\n#     'sii_6': sub6['sii'],\n#     'sii_7': sub7['sii']\n# })\n\n# def majority_vote(row):\n#     return row.mode()[0]\n\n# combined['final_sii'] = combined[['sii_5', 'sii_6', 'sii_7']].apply(majority_vote, axis=1)\n# print(combined)\n# final_submission = combined[['id', 'final_sii']].rename(columns={'final_sii': 'sii'})\n\n# final_submission.to_csv('submission.csv', index=False)\n\n# print(\"Majority voting completed and saved to 'Final_Submission.csv'\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"final_submission","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}