{"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":"gpu","dataSources":[{"sourceId":81933,"databundleVersionId":9643020,"sourceType":"competition"},{"sourceId":9682055,"sourceType":"datasetVersion","datasetId":5918194}],"dockerImageVersionId":30786,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"!pip install tsflex --no-index --find-links=file:///kaggle/input/cmi-time-series-tools \n!pip install seglearn --no-index --find-links=file:///kaggle/input/cmi-time-series-tools  ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np \nimport pandas as pd \nimport polars as pl\nfrom os.path import join\nimport os\nfrom tqdm import tqdm\nfrom sklearn.base import BaseEstimator, TransformerMixin\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import LabelEncoder, StandardScaler\nfrom sklearn.metrics import mean_squared_error\nfrom sklearn.model_selection import train_test_split, StratifiedKFold, KFold\nfrom sklearn.base import clone\nfrom sklearn.model_selection import GridSearchCV, RandomizedSearchCV\nfrom sklearn.neighbors import KNeighborsRegressor\n\nfrom seglearn.feature_functions import base_features, emg_features\nfrom tsflex.features import FeatureCollection, MultipleFeatureDescriptors\nfrom tsflex.features.integrations import seglearn_feature_dict_wrapper\n\nfrom lightgbm import LGBMRegressor\nfrom xgboost import XGBRegressor\nfrom sklearn.metrics import cohen_kappa_score\nfrom sklearn.metrics import make_scorer, cohen_kappa_score\n\nimport warnings\nwarnings.filterwarnings('ignore')","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-10-30T21:21:57.460430Z","iopub.execute_input":"2024-10-30T21:21:57.460853Z","iopub.status.idle":"2024-10-30T21:22:01.674629Z","shell.execute_reply.started":"2024-10-30T21:21:57.460802Z","shell.execute_reply":"2024-10-30T21:22:01.673603Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"base_dir = \"/kaggle/input/child-mind-institute-problematic-internet-use\"\ntrain_dir = join(base_dir, \"train.csv\")\ntest_dir = join(base_dir, \"test.csv\")\nsample_dir = join(base_dir, \"sample_submission.csv\")\n\ntrain_parquet = join(base_dir, \"series_train.parquet/\")\ntest_parquet = join(base_dir, \"series_test.parquet/\")","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:22:01.675778Z","iopub.execute_input":"2024-10-30T21:22:01.676348Z","iopub.status.idle":"2024-10-30T21:22:01.682122Z","shell.execute_reply.started":"2024-10-30T21:22:01.676311Z","shell.execute_reply":"2024-10-30T21:22:01.680822Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class TSPipeline:\n    @staticmethod\n    def build_tsflex_features(df: pd.DataFrame):\n\n        df = df.to_pandas()\n        len = df.shape[0]\n\n        basic_feats = MultipleFeatureDescriptors(\n            functions=seglearn_feature_dict_wrapper(base_features()),\n            series_names=['X', 'Y', 'Z', 'enmo', 'anglez', 'light', 'battery_voltage'],\n            windows=[len],\n            strides=[len],\n        )\n        \n        emg_feats = emg_features()\n        del emg_feats['simple square integral']\n        \n        emg_feats = MultipleFeatureDescriptors(\n            functions=seglearn_feature_dict_wrapper(emg_feats),\n            series_names=['X', 'Y', 'Z', 'enmo', 'anglez', 'light', 'battery_voltage'],\n            windows=[len],\n            strides=[len],\n        )\n        \n        fc = FeatureCollection([basic_feats, emg_feats])\n        \n        df = fc.calculate(df,\n                          return_df=True, \n                          include_final_window=True, \n                          approve_sparsity=True, \n                          window_idx=\"begin\").astype(np.float32)\n\n        return df","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:22:01.684323Z","iopub.execute_input":"2024-10-30T21:22:01.684632Z","iopub.status.idle":"2024-10-30T21:22:01.696632Z","shell.execute_reply.started":"2024-10-30T21:22:01.684600Z","shell.execute_reply":"2024-10-30T21:22:01.695717Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def read_file(path) -> np.ndarray: \n    df = pl.read_parquet(path)\n    df = df.pipe(TSPipeline.build_tsflex_features)\n    return df.to_numpy().flatten()","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:22:01.697823Z","iopub.execute_input":"2024-10-30T21:22:01.698171Z","iopub.status.idle":"2024-10-30T21:22:01.710588Z","shell.execute_reply.started":"2024-10-30T21:22:01.698140Z","shell.execute_reply":"2024-10-30T21:22:01.709731Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def load_time_series(dir_path: str) -> dict:\n    time_series_store = {}\n    file_ind = os.listdir(dir_path)\n    for file_name in tqdm(file_ind):\n        file_id = file_name.split('=')[1]\n        file_path = os.path.join(dir_path + file_name, 'part-0.parquet')\n        df = read_file(file_path)\n        time_series_store[file_id] = df\n        \n    return time_series_store","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:22:01.711778Z","iopub.execute_input":"2024-10-30T21:22:01.712051Z","iopub.status.idle":"2024-10-30T21:22:01.720715Z","shell.execute_reply.started":"2024-10-30T21:22:01.712020Z","shell.execute_reply":"2024-10-30T21:22:01.719836Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_time_series_store = load_time_series(train_parquet)\ntrain_time_series_store = pd.DataFrame(train_time_series_store).T\ntrain_time_series_store.columns = [f'f{i}' for i in range(train_time_series_store.shape[1])]\ntrain_time_series_store = train_time_series_store.reset_index()\ntrain_time_series_store.rename(columns={'index': 'id'}, inplace=True)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test_time_series_store = load_time_series(test_parquet)\ntest_time_series_store = pd.DataFrame(test_time_series_store).T\ntest_time_series_store.columns = [f'f{i}' for i in range(test_time_series_store.shape[1])]\ntest_time_series_store = test_time_series_store.reset_index()\ntest_time_series_store.rename(columns={'index': 'id'}, inplace=True)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train = pd.read_csv(train_dir)\ntest = pd.read_csv(test_dir)\nsample = pd.read_csv(sample_dir)","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:33:09.871538Z","iopub.execute_input":"2024-10-30T21:33:09.871921Z","iopub.status.idle":"2024-10-30T21:33:09.940861Z","shell.execute_reply.started":"2024-10-30T21:33:09.871883Z","shell.execute_reply":"2024-10-30T21:33:09.939954Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"sii_count = train['sii'].isna().replace({True: 'NaN', False: 'Number'})\nsii_count.value_counts()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"missing_percent = train.isnull().mean() * 100 \nmissing_percent = missing_percent.to_frame().reset_index() \nmissing_percent.columns = ['columns_name', 'missing_percentage'] \nmissing_percent = missing_percent[missing_percent['missing_percentage'] > 50] \nmissing_percent","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train = train.dropna(subset=['sii'])\n\nfeatures_cols = list(set(train.columns).intersection(set(test.columns)))  \n\ntest = test[features_cols]\ntrain = train[features_cols + ['sii']]\n\nnumeric_columns = train.select_dtypes(include = ['float64', 'int64']).columns\ncategorical_columns = train.select_dtypes(include=['category', 'object']).columns","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class PreprocessingHelper(BaseEstimator, TransformerMixin):   \n    def __init__(self): \n        \n        self.attribute_deleted = []                # признаки у которых более 50% пропусков\n        \n        self.base_num_algoritm_storage = {}        # храним mse если в качестве пропусков вставим среднее\n        self.base_cat_algoritm_storage = {}\n        self.best_model_storage = {}\n        self.best_scaller_storage = {}\n        self.best_model_score_storage = {}\n        \n        self.base_num_algoritm_predict = {}\n        self.base_cat_algoritm_predict = {}\n        self.base_scale_storage = {}\n        \n        self.mapping_cat_storage = {}\n        \n        self.label_encoder = LabelEncoder()        # для кодирования категориальных переменных\n        self.scaler = StandardScaler()\n        \n        self.SEED = 42\n        self.stratified_splits = 5\n        self.skfolds = StratifiedKFold(n_splits=self.stratified_splits, shuffle=True, random_state=self.SEED)\n        \n        self.neigh = KNeighborsRegressor() \n        self.param_grid = {'n_neighbors': [3, 5, 7, 9],                \n                           'weights': ['uniform', 'distance'],         \n                           'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute'],  \n                           'p': [1, 2]}  \n        self.pred_isna_values = {}\n        \n    def base_num_algoritm(self, y) -> float:\n        return np.mean(y, axis = 0)\n\n    def build_base_scale(self, y) -> float:\n        return np.std(y)\n\n    def base_cat_algoritm(self, y) -> str:\n        return y.mode()[0]     \n    \n    def create_stratified_kfold(self, X: pd.DataFrame) -> pd.DataFrame:      \n        y = X['sii']\n        _ = X.pop('sii') \n        \n        for num_fold, (train_index, val_index) in enumerate(self.skfolds.split(X, y)): \n            X.loc[val_index, 'fold'] = int(num_fold)\n        return X\n    \n    def fit(self, X, y=None):\n        X_num, X_cat, X_df = X   \n        \n        missing_percent = X_df.isnull().mean() * 100 \n        missing_percent = missing_percent.to_frame().reset_index() \n        missing_percent.columns = ['columns_name', 'missing_percentage'] \n        missing_percent = missing_percent[missing_percent['missing_percentage'] > 50] \n        self.attribute_deleted  = list(missing_percent.columns_name)\n       \n        columns_num_isna = X_num.columns[X_num.isna().any()]  \n        for columns in columns_num_isna:\n            if columns not in self.attribute_deleted:\n                feature_with_isna = X_num[columns].dropna()  \n                base_pred = self.base_num_algoritm(feature_with_isna) \n                self.base_scale_storage[columns] = self.build_base_scale(feature_with_isna)\n                self.base_num_algoritm_predict[columns] = base_pred\n                base_pred = pd.Series([base_pred] * feature_with_isna.shape[0])\n                self.base_num_algoritm_storage[columns] = mean_squared_error(feature_with_isna, base_pred)\n        \n        for columns in X_cat:\n            if columns not in self.attribute_deleted:\n                feature_with_isna = X_cat[columns].dropna()  \n                base_pred = self.base_cat_algoritm(feature_with_isna)\n                self.base_cat_algoritm_predict[columns] = base_pred\n                feature_with_isna = self.label_encoder.fit_transform(feature_with_isna)\n                classes = self.label_encoder.classes_\n                encoded_values = self.label_encoder.transform(classes)\n                mapping_cat =  dict(zip(classes, encoded_values))\n                self.mapping_cat_storage[columns] = mapping_cat\n                base_pred = mapping_cat[base_pred]\n                base_pred = pd.Series([base_pred] * feature_with_isna.shape[0])   \n                self.base_cat_algoritm_storage[columns] = mean_squared_error(feature_with_isna, base_pred)\n                \n        return self\n    \n    def build_pred_isna_values(self, \n                               best_model_score: float,\n                               base_algo_stor: dict,  # self.base_cat_algoritm_storage or self.base_num_algoritm_storage\n                               columns: str,\n                               pred_isna_val: dict,\n                               best_model,\n                               test: pd.DataFrame) -> dict:\n\n        if best_model_score < base_algo_stor[columns]:\n            print('model recovery')\n            final_pred = best_model.predict(test) \n            final_pred = np.round(final_pred)   \n            pred_isna_val[columns] = {'index': test.index, 'final_pred': final_pred}\n        else:\n            print('base algo recovery')\n            if columns in self.base_num_algoritm_storage:\n                final_pred = self.base_num_algoritm_predict[columns] \n            else:\n                final_pred = self.base_cat_algoritm_predict[columns]\n            final_pred = [final_pred] * test.shape[0]\n            pred_isna_val[columns] = {'index': test.index, 'final_pred': final_pred}\n\n        return pred_isna_val\n\n    def transform_test(self, X: pd.DataFrame, X_num: list, columns = None, training = True) -> pd.DataFrame:\n        # как тест для которого мы восстанавливаем данные из train тк и основной тест\n        if training:\n            _ = X.pop('sii') \n            num_cat = [c for c in X.columns if c in X_num and c not in ['Basic_Demos-Sex']]\n            test_fold_scalar = self.best_scaller_storage[columns].transform(X[num_cat])    \n            test_fold_scalar = pd.DataFrame(data = test_fold_scalar, columns = num_cat)\n            for col in num_cat:\n                X.loc[:, col] = test_fold_scalar[col].values\n            X = X.replace({True: 1, False: 0})\n            return X\n\n        else:\n            num_cat = [c for c in X.columns if c in X_num and c not in ['Basic_Demos-Sex']]\n            \n            for col in num_cat:\n                if col in self.base_scale_storage:\n                    mean = self.base_num_algoritm_predict[col]\n                    scale = self.base_scale_storage[col] \n                    \n                    for ind, val in X[col].dropna().items():\n                        val = (val - mean) / scale\n                        X.loc[ind, col] = val\n                        \n            X = X.replace({True: 1, False: 0})\n            return X\n\n    def transform(self, X, training = True) -> pd.DataFrame:\n        if training:\n            X_num, X_cat, X_df = X \n            # удаление тех столбцов которые имеют более 50% пропусков\n            X_df = X_df.drop(self.attribute_deleted, axis=1)\n            # восстановим остальные пропущенные значения\n            self.x_columns_isna = X_df.columns[X_df.isna().any()].tolist()   # колонки в которых есть пропуски\n        else:\n            print('training is False')\n            X_num, X_cat, test = X\n            \n            test = test.drop(self.attribute_deleted, axis=1)\n            test_df = test.copy()\n            \n            self.pred_isna_values = {}\n    \n            test = test.dropna(axis=1)\n            _ = test.pop('id')\n            ohe_cat = [c for c in test.columns if c in X_cat]\n            test = pd.get_dummies(test, columns = ohe_cat, prefix = ohe_cat)\n            test = self.transform_test(test, X_num, training = False)\n            \n        # возможно придется делать отдельно для кат отдельно для нум признаков\n        for columns in self.x_columns_isna:\n            print(f'column: {columns}')\n\n            if training:\n                \n                dropna_X_df = X_df.dropna(axis=1)\n                _ = dropna_X_df.pop('id')\n                ohe_cat = [c for c in dropna_X_df.columns if c in X_cat]\n                dropna_X_df = pd.get_dummies(dropna_X_df, columns = ohe_cat, prefix = ohe_cat)\n                # добавим таргетный признак (который имеет пропуски)\n                dropna_X_df[columns] = X_df[columns]\n                # обычная dropna убирает символы с пропусками, символы с пропусками перейдут в тест\n                train = dropna_X_df.dropna()  \n                test_mask = dropna_X_df.isnull().any(axis=1)\n                test = dropna_X_df[test_mask]\n                _ = test.pop(columns)   \n                train = train.reset_index(drop=True)\n                train = self.create_stratified_kfold(train)\n               \n                for i in range(self.stratified_splits):\n                    train_fold = train[train['fold'] != i] \n                    valid_fold = train[train['fold'] == i] \n                    train_fold_target = train_fold.pop(columns)\n                    valid_fold_target = valid_fold.pop(columns)\n                    # Избавимся от колонки fold\n                    _ = train_fold.pop('fold')\n                    _ = valid_fold.pop('fold')\n                    \n                    # масштабируем \n                    num_cat = [c for c in train_fold.columns if c in X_num and c not in ['Basic_Demos-Sex']] \n                    train_fold_scalar = self.scaler.fit_transform(train_fold[num_cat])  \n                    valid_fold_scalar = self.scaler.transform(valid_fold[num_cat])\n                    train_fold_scalar = pd.DataFrame(data = train_fold_scalar, columns = num_cat)\n                    valid_fold_scalar = pd.DataFrame(data = valid_fold_scalar, columns = num_cat)\n                    \n                    for col in num_cat:\n                        train_fold.loc[:, col] = train_fold_scalar[col].values\n                        valid_fold.loc[:, col] = valid_fold_scalar[col].values\n                        \n                    train_fold = train_fold.replace({True: 1, False: 0})\n                    valid_fold = valid_fold.replace({True: 1, False: 0})\n    \n                    # обучение для восстановления признаков\n                    model = clone(self.neigh)\n                    search = GridSearchCV(model, self.param_grid, scoring = 'neg_mean_squared_error')\n    \n                    if columns in self.mapping_cat_storage:\n                        train_fold_target = train_fold_target.replace(\n                            self.mapping_cat_storage[columns]\n                        )\n                        valid_fold_target = valid_fold_target.replace(\n                            self.mapping_cat_storage[columns]\n                        )\n                        \n                    search.fit(train_fold, train_fold_target)\n                    predictions = search.predict(valid_fold)   \n                    predictions = np.round(predictions)\n                    mse_fold = mean_squared_error(valid_fold_target, predictions)\n                  \n                    if i == 0:\n                        best_model_score = mse_fold\n                        self.best_model_score_storage[columns] = best_model_score\n                        \n                        best_model = search.best_estimator_   \n                        self.best_model_storage[columns] = best_model\n                        \n                        self.best_scaller_storage[columns] = self.scaler\n                        \n                    elif mse_fold < best_model_score:\n                        # Если улучшилось качество на фолде \n                        best_model_score = mse_fold\n                        self.best_model_score_storage[columns] = best_model_score\n\n                        best_model = search.best_estimator_\n                        self.best_model_storage[columns] = best_model\n                        \n                        self.best_scaller_storage[columns] = self.scaler\n                        \n                # нужно так же отмасштабировать test \n                print('training is True')\n                test = self.transform_test(test, X_num, columns)\n                \n            if columns in self.base_num_algoritm_storage:\n\n                self.pred_isna_values = self.build_pred_isna_values(self.best_model_score_storage[columns], \n                                                                    self.base_num_algoritm_storage,\n                                                                    columns, \n                                                                    self.pred_isna_values, \n                                                                    self.best_model_storage[columns], \n                                                                    test)\n            else:\n                self.pred_isna_values = self.build_pred_isna_values(self.best_model_score_storage[columns], \n                                                                    self.base_cat_algoritm_storage,\n                                                                    columns, \n                                                                    self.pred_isna_values, \n                                                                    self.best_model_storage[columns], \n                                                                    test)\n                \n        for columns in self.pred_isna_values:\n            index = self.pred_isna_values[columns]['index']\n            values = self.pred_isna_values[columns]['final_pred']\n            for ind, val in zip(index, values):\n                if training:\n                    \n                    unic_column_meanings = X_df[columns].dropna()\n                    if len(set(unic_column_meanings)) == 2 and val not in set(unic_column_meanings):\n                        if columns in self.base_num_algoritm_storage:\n                            X_df.loc[ind, columns] = self.base_cat_algoritm(unic_column_meanings)\n                        else:\n                            X_df.loc[ind, columns] = self.base_cat_algoritm_predict[columns]\n                    else:\n                        X_df.loc[ind, columns] = val\n\n                elif pd.isna(test_df.loc[ind, columns]):\n                    \n                    unic_column_meanings = test_df[columns].dropna()\n                    if len(set(unic_column_meanings)) == 2 and val not in set(unic_column_meanings):\n                        if columns in self.base_num_algoritm_storage:\n                            test_df.loc[ind, columns] = self.base_cat_algoritm(unic_column_meanings)\n                        else:\n                            test_df.loc[ind, columns] = self.base_cat_algoritm_predict[columns]\n                    else:        \n                        test_df.loc[ind, columns] = val\n\n        # сделать one hot кодирование или посмотри как это сделанно в другом ноутбуке\n        # как вариант можно закодировать значения через self.mapping_cat_storage\n        if training:\n            X_cat = X_df.select_dtypes(include=['category', 'object']).columns\n            ohe_cat = [c for c in X_df.columns if c in X_cat and c not in ['id', 'sii']]\n            \n            for columns in ohe_cat:\n                X_df[columns] = X_df[columns].replace(\n                    self.mapping_cat_storage[columns])\n                \n            result_df = X_df\n            \n        else:\n            X_cat = test_df.select_dtypes(include=['category', 'object']).columns\n            ohe_cat = [c for c in test_df.columns if c in X_cat and c not in ['id']]\n            \n            for columns in ohe_cat:\n                test_df[columns] = test_df[columns].replace(\n                    self.mapping_cat_storage[columns])\n\n            result_df = test_df\n\n        # масштабировать не будем т.к тогда мы отскалируем сразу все значения а это не правильно\n        return result_df","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class DataFrameSelector(BaseEstimator, TransformerMixin):\n    \n    def __init__(self, numeric_columns: pd.Series, categorical_columns: pd.Series):\n        self.numeric_columns = numeric_columns\n        self.categorical_columns = categorical_columns\n        \n    def fit(self, X, y=None):\n        return self\n    \n    def transform(self, X: pd.DataFrame) -> tuple:\n        self.numeric_columns = [i for i in self.numeric_columns if i in X.columns]\n        self.categorical_columns = [i for i in self.categorical_columns if i in X.columns]\n        return X[self.numeric_columns], X[self.categorical_columns], X","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# те даные которые мы получаем","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"metadata_pipeline = Pipeline(steps=[\n    ('selector', DataFrameSelector(numeric_columns, categorical_columns)),\n    ('Preprocessing', PreprocessingHelper())\n    ])\n\ntrain = metadata_pipeline.fit_transform(train)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test = metadata_pipeline.named_steps['Preprocessing'].transform(\n        metadata_pipeline.named_steps['selector'].transform(test), training = False)","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:34:31.800474Z","iopub.execute_input":"2024-10-30T21:34:31.800869Z","iopub.status.idle":"2024-10-30T21:34:31.852814Z","shell.execute_reply.started":"2024-10-30T21:34:31.800833Z","shell.execute_reply":"2024-10-30T21:34:31.851795Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:34:38.954768Z","iopub.execute_input":"2024-10-30T21:34:38.955459Z","iopub.status.idle":"2024-10-30T21:34:38.961995Z","shell.execute_reply.started":"2024-10-30T21:34:38.955419Z","shell.execute_reply":"2024-10-30T21:34:38.961030Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# отмасштабируем сразу для всех ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train = pd.merge(train, train_time_series_store, how=\"left\", on='id')\ntest = pd.merge(test, test_time_series_store, how=\"left\", on='id')\n\ntrain = train.drop('id', axis=1)\ntest = test.drop('id', axis=1)","metadata":{"execution":{"iopub.status.busy":"2024-10-30T21:44:58.811833Z","iopub.execute_input":"2024-10-30T21:44:58.812206Z","iopub.status.idle":"2024-10-30T21:44:58.819409Z","shell.execute_reply.started":"2024-10-30T21:44:58.812173Z","shell.execute_reply":"2024-10-30T21:44:58.818484Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train.fillna(value=0, inplace=True)\ntest.fillna(value=0, inplace=True)","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train.head()","metadata":{"execution":{"iopub.status.busy":"2024-10-28T20:17:04.332952Z","iopub.execute_input":"2024-10-28T20:17:04.333299Z","iopub.status.idle":"2024-10-28T20:17:04.337209Z","shell.execute_reply.started":"2024-10-28T20:17:04.333255Z","shell.execute_reply":"2024-10-28T20:17:04.336240Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"scaler = StandardScaler()\n# к этому нужно еще добавить колонки с f0 f1 из тайм сериес данных\nnum_columns = [c for c in train.columns if c in numeric_columns and c not in ['Basic_Demos-Sex', 'sii']] ","metadata":{"execution":{"iopub.status.busy":"2024-10-30T15:45:31.842869Z","iopub.execute_input":"2024-10-30T15:45:31.843302Z","iopub.status.idle":"2024-10-30T15:45:31.870560Z","shell.execute_reply.started":"2024-10-30T15:45:31.843264Z","shell.execute_reply":"2024-10-30T15:45:31.869621Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"num_columns = num_columns + train_time_series_store.columns.drop('id').to_list()","metadata":{"execution":{"iopub.status.busy":"2024-10-30T15:45:52.935249Z","iopub.execute_input":"2024-10-30T15:45:52.935656Z","iopub.status.idle":"2024-10-30T15:45:52.944796Z","shell.execute_reply.started":"2024-10-30T15:45:52.935618Z","shell.execute_reply":"2024-10-30T15:45:52.943551Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_scalar = scaler.fit_transform(train[num_columns])  \ntest_scalar = scaler.transform(test[num_columns])\n\ntrain_scalar = pd.DataFrame(data = train_scalar, columns = num_columns)\ntest_scalar = pd.DataFrame(data = test_scalar, columns = num_columns)\n\nfor col in num_columns:\n    train.loc[:, col] = train_scalar[col].values\n    test.loc[:, col] = test_scalar[col].values","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train.head()","metadata":{"execution":{"iopub.status.busy":"2024-10-30T15:46:13.346916Z","iopub.execute_input":"2024-10-30T15:46:13.347687Z","iopub.status.idle":"2024-10-30T15:46:13.353054Z","shell.execute_reply.started":"2024-10-30T15:46:13.347648Z","shell.execute_reply":"2024-10-30T15:46:13.351924Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test.head()","metadata":{"execution":{"iopub.status.busy":"2024-10-30T15:48:34.757566Z","iopub.execute_input":"2024-10-30T15:48:34.758479Z","iopub.status.idle":"2024-10-30T15:48:34.763453Z","shell.execute_reply.started":"2024-10-30T15:48:34.758433Z","shell.execute_reply":"2024-10-30T15:48:34.762395Z"},"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":{"execution":{"iopub.status.busy":"2024-10-29T19:00:50.852036Z","iopub.execute_input":"2024-10-29T19:00:50.852488Z","iopub.status.idle":"2024-10-29T19:00:50.860912Z","shell.execute_reply.started":"2024-10-29T19:00:50.852447Z","shell.execute_reply":"2024-10-29T19:00:50.860058Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"lgb_params = {\n    'learning_rate': np.linspace(0.01, 0.1, num=100).tolist(),  \n    'max_depth': [3, 5, 8, 10, 12],\n    'n_estimators': list(range(10, 400, 5)),\n    'num_leaves': list(range(10, 500, 5)),\n    'min_data_in_leaf': list(range(10, 50, 3)),\n    'feature_fraction': [round(x, 3) for x in np.linspace(0.3, 1.0, num=40)],  \n    'bagging_fraction': [round(x, 3) for x in np.linspace(0.3, 1.0, num=40)],  \n    'bagging_freq': list(range(2, 60, 2)),\n    'lambda_l1': np.linspace(0, 5, num=40).tolist(),\n    'lambda_l2': np.linspace(0, 5, num=40).tolist(),\n    'device': ['gpu']\n}","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"xgb_params = {\n    'learning_rate': np.linspace(0.01, 0.1, num=100).tolist(),\n    'max_depth': [3, 5, 8, 10, 12, 14],\n    'n_estimators': list(range(10, 400, 5)),\n    'subsample': np.arange(0.1, 1.01, 0.05).tolist(),\n    'colsample_bytree': np.arange(0.1, 1.01, 0.05).tolist(),\n    'reg_alpha': np.arange(0.1, 10, 0.5).tolist(), \n    'reg_lambda': np.arange(0.1, 10, 0.5).tolist(),\n    'random_state': [42],\n    'tree_method': ['hist', 'approx', 'gpu_hist'],\n    'device': ['cuda']\n}","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:00:27.921455Z","iopub.execute_input":"2024-10-30T17:00:27.921876Z","iopub.status.idle":"2024-10-30T17:00:27.932536Z","shell.execute_reply.started":"2024-10-30T17:00:27.921835Z","shell.execute_reply":"2024-10-30T17:00:27.931709Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def quadratic_weighted_kappa(y_true, y_pred):\n    return cohen_kappa_score(y_true, y_pred, weights='quadratic')","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:00:29.984158Z","iopub.execute_input":"2024-10-30T17:00:29.984544Z","iopub.status.idle":"2024-10-30T17:00:29.991920Z","shell.execute_reply.started":"2024-10-30T17:00:29.984506Z","shell.execute_reply":"2024-10-30T17:00:29.990793Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def search_optimal_param(X: pd.DataFrame, model, param: dict):\n    \n    skfolds = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n    \n    x = X.copy()\n    y = x['sii']\n    _ = x.pop('sii') \n    \n    for num_fold, (train_index, val_index) in enumerate(skfolds.split(x, y)):\n        print('fold: ', num_fold+1)\n        X_train, X_val = x.iloc[train_index], x.iloc[val_index]\n        y_train, y_val = y.iloc[train_index], y.iloc[val_index]\n        \n        model_fold = clone(model)\n        kappa_scorer = make_scorer(cohen_kappa_score)\n        search = RandomizedSearchCV(model_fold, param, scoring = kappa_scorer)\n        \n        search.fit(X_train, y_train)\n        predictions = search.predict(X_val)  \n        predictions = np.round(predictions)\n        \n        kappa_fold = quadratic_weighted_kappa(y_val, predictions)\n        \n        if num_fold == 0:\n            best_model_score = kappa_fold\n            best_model = search.best_estimator_  \n            best_params = search.best_params_\n            print('kappa: ', kappa_fold)\n            print('best_params:', best_params)\n            \n        elif kappa_fold > best_model_score:\n            best_model_score = kappa_fold\n            best_model = search.best_estimator_  \n            best_params = search.best_params_\n            print('kappa: ', kappa_fold)\n            print('best_params:', best_params)\n            \n    return best_model, best_params, best_model_score","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nxgb = XGBRegressor()\n\nxgb_best_model = 0\nxgb_best_params = 0\nxgb_best_score = 0\n\nBOLD = '\\033[1m'\nRESET = '\\033[0m'\n    \nfor i in range(10):\n    print('batch: ', i)\n    if i == 0:\n        xgb_batch_model, xgb_batch_params, xgb_batch_score = search_optimal_param(train, xgb, xgb_params)\n        \n        xgb_best_model = xgb_batch_model\n        xgb_best_params = xgb_batch_params\n        xgb_best_score = xgb_batch_score\n        \n    else:\n        xgb_batch_model, xgb_batch_params, xgb_batch_score = search_optimal_param(train, xgb, xgb_params)\n        if xgb_batch_score > xgb_best_score:\n            \n            xgb_best_model = xgb_batch_model\n            xgb_best_params = xgb_batch_params\n            xgb_best_score = xgb_batch_score\n            \n            print(f\"{BOLD}{'new best_batch kappa: ' + str(xgb_best_score)}{RESET}\")\n            print(f\"{BOLD}{'new_best_batch_params:'}{RESET}\", xgb_best_params)\n'''","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"xgb_best_params = {'tree_method': 'gpu_hist',\n                   'subsample': 0.7000000000000002,\n                   'reg_lambda': 1.1,\n                   'reg_alpha': 9.6,\n                   'random_state': 42,\n                   'n_estimators': 120,\n                   'max_depth': 5,\n                   'learning_rate': 0.08818181818181818,\n                   'device': 'cuda',\n                   'colsample_bytree': 0.45000000000000007}\n\n# такие параметры при kappa - 0.4580302214051334","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:00:32.566022Z","iopub.execute_input":"2024-10-30T17:00:32.566410Z","iopub.status.idle":"2024-10-30T17:00:32.571223Z","shell.execute_reply.started":"2024-10-30T17:00:32.566373Z","shell.execute_reply":"2024-10-30T17:00:32.570266Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#lgb = LGBMRegressor(verbose=-1)\n\n#lgb_best_model, lgb_best_params, lgb_best_score = search_optimal_param(train, lgb, lgb_params)","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:00:34.504487Z","iopub.execute_input":"2024-10-30T17:00:34.504910Z","iopub.status.idle":"2024-10-30T17:00:34.515461Z","shell.execute_reply.started":"2024-10-30T17:00:34.504871Z","shell.execute_reply":"2024-10-30T17:00:34.514470Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"lgb_best_params = {'num_leaves': 365, \n                   'n_estimators': 245, \n                   'min_data_in_leaf': 16, \n                   'max_depth': 8, \n                   'learning_rate': 0.06909090909090909, \n                   'lambda_l2': 3.7179487179487176, \n                   'lambda_l1': 0.3846153846153846, \n                   'feature_fraction': 0.587, \n                   'device': 'gpu', \n                   'bagging_freq': 22, \n                   'bagging_fraction': 0.408}\n\n# kappa:  0.42409826476896084","metadata":{"execution":{"iopub.status.busy":"2024-10-29T18:38:38.020341Z","iopub.execute_input":"2024-10-29T18:38:38.020731Z","iopub.status.idle":"2024-10-29T18:38:38.025199Z","shell.execute_reply.started":"2024-10-29T18:38:38.020692Z","shell.execute_reply":"2024-10-29T18:38:38.024145Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from catboost import CatBoostRegressor\nfrom sklearn.ensemble import VotingRegressor\nfrom sklearn.impute import SimpleImputer\n\nfrom IPython.display import clear_output\nfrom scipy.optimize import minimize\nfrom colorama import Fore, Style","metadata":{"execution":{"iopub.status.busy":"2024-10-29T18:55:54.329177Z","iopub.execute_input":"2024-10-29T18:55:54.329957Z","iopub.status.idle":"2024-10-29T18:55:54.334037Z","shell.execute_reply.started":"2024-10-29T18:55:54.329916Z","shell.execute_reply":"2024-10-29T18:55:54.332994Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def 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)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def TrainML(model_class, test_data):\n    X = train.drop(['sii'], axis=1).values\n    y = train['sii'].values\n\n    X_res, y_res = X, y\n\n    SKF = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED)\n    train_S = []\n    test_S = []\n    oof_non_rounded = np.zeros(len(y_res), dtype=float)\n    oof_rounded = np.zeros(len(y_res), dtype=int)\n    test_preds = np.zeros((len(test_data), n_splits))\n\n    for fold, (train_idx, val_idx) in enumerate(SKF.split(X_res, y_res)):\n        X_train, X_val = X_res[train_idx], X_res[val_idx]\n        y_train, y_val = y_res[train_idx], y_res[val_idx]\n\n        model = clone(model_class)\n        model.fit(X_train, y_train)\n        y_train_pred = model.predict(X_train)\n        y_val_pred = model.predict(X_val)\n\n        oof_non_rounded[val_idx] = y_val_pred\n        y_val_pred_rounded = np.round(y_val_pred).astype(int)\n        oof_rounded[val_idx] = y_val_pred_rounded\n\n        train_kappa = quadratic_weighted_kappa(y_train, np.round(y_train_pred).astype(int))\n        val_kappa = quadratic_weighted_kappa(y_val, y_val_pred_rounded)\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\n    print(f\"Mean Train QWK --> {np.mean(train_S):.4f}\")\n    print(f\"Mean Validation QWK ---> {np.mean(test_S):.4f}\")\n\n    # Optimize thresholds with Nelder-Mead method\n    KappaOptimizer = minimize(evaluate_predictions, x0=[0.5, 1.5, 2.5], args=(y_res, oof_non_rounded), method='Nelder-Mead')\n    assert KappaOptimizer.success, \"Optimization did not converge.\"\n    oof_tuned = threshold_Rounder(oof_non_rounded, KappaOptimizer.x)\n    tKappa = quadratic_weighted_kappa(y_res, oof_tuned)\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    submission = pd.DataFrame({\n        'id': sample['id'],\n        'sii': tpTuned\n    })\n\n    return submission","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"SEED = 42","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# CatBoost parameters including specification of categorical features\nCatBoost_Params = {\n    'learning_rate': 0.05,\n    'depth': 6,\n    'iterations': 200,\n    'random_seed': SEED,\n    'cat_features': categorical_columns,  # Important: ensure this parameter is configured correctly\n    'verbose': 0,\n    'l2_leaf_reg': 100,\n    'task_type': 'GPU'\n}","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Create model instances\nLight = LGBMRegressor(**lgb_best_params, verbose=-1)  \nXGB_Model = XGBRegressor(**xgb_best_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], weights=[20, 10,])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"n_splits = 5","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"sample = pd.read_csv('/kaggle/input/child-mind-institute-problematic-internet-use/sample_submission.csv')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"Submission = TrainML(voting_model, test.values)","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Save submission\nSubmission.to_csv('submission.csv', index=False)\nprint(Submission['sii'].value_counts())","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"Submission","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:13:03.850536Z","iopub.execute_input":"2024-10-30T17:13:03.850932Z","iopub.status.idle":"2024-10-30T17:13:03.856590Z","shell.execute_reply.started":"2024-10-30T17:13:03.850894Z","shell.execute_reply":"2024-10-30T17:13:03.855538Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:16:36.077382Z","iopub.execute_input":"2024-10-30T17:16:36.077796Z","iopub.status.idle":"2024-10-30T17:16:36.083686Z","shell.execute_reply.started":"2024-10-30T17:16:36.077749Z","shell.execute_reply":"2024-10-30T17:16:36.082651Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:16:38.464568Z","iopub.execute_input":"2024-10-30T17:16:38.464983Z","iopub.status.idle":"2024-10-30T17:16:38.470164Z","shell.execute_reply.started":"2024-10-30T17:16:38.464942Z","shell.execute_reply":"2024-10-30T17:16:38.469193Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:16:45.838942Z","iopub.execute_input":"2024-10-30T17:16:45.839323Z","iopub.status.idle":"2024-10-30T17:16:45.845493Z","shell.execute_reply.started":"2024-10-30T17:16:45.839290Z","shell.execute_reply":"2024-10-30T17:16:45.844323Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:17:53.632296Z","iopub.execute_input":"2024-10-30T17:17:53.632962Z","iopub.status.idle":"2024-10-30T17:17:53.646735Z","shell.execute_reply.started":"2024-10-30T17:17:53.632919Z","shell.execute_reply":"2024-10-30T17:17:53.645737Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:17:57.126161Z","iopub.execute_input":"2024-10-30T17:17:57.127041Z","iopub.status.idle":"2024-10-30T17:17:57.130999Z","shell.execute_reply.started":"2024-10-30T17:17:57.127000Z","shell.execute_reply":"2024-10-30T17:17:57.129945Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:17:59.179441Z","iopub.execute_input":"2024-10-30T17:17:59.180150Z","iopub.status.idle":"2024-10-30T17:17:59.185117Z","shell.execute_reply.started":"2024-10-30T17:17:59.180108Z","shell.execute_reply":"2024-10-30T17:17:59.184061Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:20:54.279068Z","iopub.execute_input":"2024-10-30T17:20:54.279874Z","iopub.status.idle":"2024-10-30T17:20:54.285549Z","shell.execute_reply.started":"2024-10-30T17:20:54.279830Z","shell.execute_reply":"2024-10-30T17:20:54.284434Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:20:56.503579Z","iopub.execute_input":"2024-10-30T17:20:56.503982Z","iopub.status.idle":"2024-10-30T17:20:56.508471Z","shell.execute_reply.started":"2024-10-30T17:20:56.503941Z","shell.execute_reply":"2024-10-30T17:20:56.507440Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2024-10-30T17:20:58.746329Z","iopub.execute_input":"2024-10-30T17:20:58.747273Z","iopub.status.idle":"2024-10-30T17:20:58.753872Z","shell.execute_reply.started":"2024-10-30T17:20:58.747230Z","shell.execute_reply":"2024-10-30T17:20:58.752949Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nif best_model_score < self.base_num_algoritm_storage[columns]:\n\n    final_pred = best_model.predict(test) \n    final_pred = np.round(final_pred)  \n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\nelse:\n    final_pred = self.base_num_algoritm_predict[columns]\n    final_pred = [final_pred] * test.shape[0]\n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\n\n\nif best_model_score < self.base_cat_algoritm_storage[columns]:\n    final_pred = best_model.predict(test) \n    final_pred = np.round(final_pred)   \n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\nelse:\n    # тут мы не смогли улучшить базовый алгортм поэтому должны все еще использовать среднее для восстановления\n    final_pred = self.base_cat_algoritm_predict[columns]          \n    final_pred = [final_pred] * test.shape[0]\n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\n'''\n","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":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nif best_model_score < self.base_num_algoritm_storage[columns]:\n\n    final_pred = best_model.predict(test) \n    final_pred = np.round(final_pred)  \n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\nelse:\n    final_pred = self.base_num_algoritm_predict[columns]\n    final_pred = [final_pred] * test.shape[0]\n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\n\n\nif best_model_score < self.base_cat_algoritm_storage[columns]:\n    final_pred = best_model.predict(test) \n    final_pred = np.round(final_pred)   \n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\nelse:\n    # тут мы не смогли улучшить базовый алгортм поэтому должны все еще использовать среднее для восстановления\n    final_pred = self.base_cat_algoritm_predict[columns]          \n    final_pred = [final_pred] * test.shape[0]\n    self.pred_isna_values[columns] = {'index': test.index, 'final_pred': final_pred}\n'''","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null}]}