{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"<img  style='width: 100%;height: 200px;' src='data:image/jpeg;base64,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'/>","metadata":{}},{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\n\n\nfrom matplotlib.ticker import MaxNLocator\nimport seaborn as sns\nfrom cycler import cycler\nfrom IPython.display import display\nimport math\nimport os\nimport random\nimport gc\nimport sys\nimport warnings\nwarnings.filterwarnings('ignore')\n\nimport optuna\nfrom colorama import Fore, Back, Style\n\nfrom sklearn.model_selection import StratifiedGroupKFold, StratifiedKFold, train_test_split,GroupKFold\nfrom sklearn.metrics import roc_auc_score\nfrom sklearn.calibration import CalibrationDisplay\nfrom sklearn.preprocessing import StandardScaler,RobustScaler,LabelEncoder\nfrom sklearn.impute import KNNImputer\nfrom sklearn import linear_model\nfrom sklearn.linear_model import HuberRegressor\nfrom sklearn.decomposition import PCA\nfrom sklearn.naive_bayes import BernoulliNB\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.calibration import CalibratedClassifierCV\n\nimport matplotlib.pyplot as plt\n\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.callbacks import ReduceLROnPlateau, LearningRateScheduler, EarlyStopping\nfrom tensorflow.keras.layers import Input, Dense, Activation,  BatchNormalization, Dropout, Concatenate, Embedding,  Flatten, Conv1D\nfrom tensorflow.keras.models import Model","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:12.832454Z","iopub.execute_input":"2022-08-14T14:59:12.832901Z","iopub.status.idle":"2022-08-14T14:59:21.195959Z","shell.execute_reply.started":"2022-08-14T14:59:12.832808Z","shell.execute_reply":"2022-08-14T14:59:21.195016Z"},"_kg_hide-output":true,"_kg_hide-input":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train = pd.read_csv('../input/tabular-playground-series-aug-2022/train.csv')\ntest = pd.read_csv('../input/tabular-playground-series-aug-2022/test.csv')\nsubmission = pd.read_csv('../input/tabular-playground-series-aug-2022/sample_submission.csv')\ntarget = train['failure']\ntrain.drop('failure',axis=1, inplace = True)\ndata = pd.concat([train, test])\ntrain.shape,test.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:21.197674Z","iopub.execute_input":"2022-08-14T14:59:21.198302Z","iopub.status.idle":"2022-08-14T14:59:21.476427Z","shell.execute_reply.started":"2022-08-14T14:59:21.198268Z","shell.execute_reply":"2022-08-14T14:59:21.475188Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<h1> Preprocessing","metadata":{}},{"cell_type":"markdown","source":"\nInitial preprocessing from :\n\nhttps://www.kaggle.com/code/desalegngeb/tps08-logisticregression-and-some-fe\n\nhttps://www.kaggle.com/code/alikayed/tps08-logisticregression-and-some-fe-c83a47","metadata":{}},{"cell_type":"code","source":"# library for coding string values :\n! pip install feature_engine\nfrom feature_engine.encoding import WoEEncoder","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:21.477775Z","iopub.execute_input":"2022-08-14T14:59:21.478057Z","iopub.status.idle":"2022-08-14T14:59:34.931357Z","shell.execute_reply.started":"2022-08-14T14:59:21.478031Z","shell.execute_reply":"2022-08-14T14:59:34.930209Z"},"_kg_hide-output":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"data['m3_missing'] = data['measurement_3'].isnull().astype(np.int8)\ndata['m5_missing'] = data['measurement_5'].isnull().astype(np.int8)\ndata['area'] = data['attribute_2'] * data['attribute_3']\n\nfeature = [f for f in test.columns if f.startswith('measurement') or f=='loading']\n\n# dictionnary of dictionnaries (for the 11 best correlated measurement columns), \n# we will use the dictionnaries below to select the best correlated columns according to the product code)\n# Only for 'measurement_17' we make a 'manual' selection :\nfull_fill_dict ={}\nfull_fill_dict['measurement_17'] = {\n    'A': ['measurement_5','measurement_6','measurement_8'],\n    'B': ['measurement_4','measurement_5','measurement_7'],\n    'C': ['measurement_5','measurement_7','measurement_8','measurement_9'],\n    'D': ['measurement_5','measurement_6','measurement_7','measurement_8'],\n    'E': ['measurement_4','measurement_5','measurement_6','measurement_8'],\n    'F': ['measurement_4','measurement_5','measurement_6','measurement_7'],\n    'G': ['measurement_4','measurement_6','measurement_8','measurement_9'],\n    'H': ['measurement_4','measurement_5','measurement_7','measurement_8','measurement_9'],\n    'I': ['measurement_3','measurement_7','measurement_8']\n}\n\n# collect the name of the next 10 best measurement columns sorted by correlation (except 17 already done above):\ncol = [col for col in test.columns if 'measurement' not in col]+ ['loading','m3_missing','m5_missing']\na = []\nb =[]\nfor x in range(3,17):\n    corr = np.absolute(data.drop(col, axis=1).corr()[f'measurement_{x}']).sort_values(ascending=False)\n    a.append(np.round(np.sum(corr[1:4]),3)) # we add the 3 first lines of the correlation values to get the \"most correlated\"\n    b.append(f'measurement_{x}')\nc = pd.DataFrame()\nc['Selected columns'] = b\nc['correlation total'] = a\nc = c.sort_values(by = 'correlation total',ascending=False).reset_index(drop = True)\nprint(f'Columns selected by correlation sum of the 3 first rows : ')\ndisplay(c.head(10))\n\nfor i in range(10):\n    measurement_col = 'measurement_' + c.iloc[i,0][12:] # we select the next best correlated column \n    fill_dict ={}\n    for x in data.product_code.unique() : \n        corr = np.absolute(data[data.product_code == x].drop(col, axis=1).corr()[measurement_col]).sort_values(ascending=False)\n        measurement_col_dic = {}\n        measurement_col_dic[measurement_col] = corr[1:5].index.tolist()\n        fill_dict[x] = measurement_col_dic[measurement_col]\n    full_fill_dict[measurement_col] =fill_dict\n    \nfeature = [f for f in data.columns if f.startswith('measurement') or f=='loading']\nnullValue_cols = [col for col in train.columns if train[col].isnull().sum()!=0]\n    \nfor code in data.product_code.unique():\n    total_na_filled_by_linear_model = 0\n    print(f'\\n-------- Product code {code} ----------\\n')\n    print(f'filled by linear model :')\n    for measurement_col in list(full_fill_dict.keys()):\n        tmp = data[data.product_code==code]\n        column = full_fill_dict[measurement_col][code]\n        tmp_train = tmp[column+[measurement_col]].dropna(how='any')\n        tmp_test = tmp[(tmp[column].isnull().sum(axis=1)==0)&(tmp[measurement_col].isnull())]\n\n        model = HuberRegressor(epsilon=1.9)\n        model.fit(tmp_train[column], tmp_train[measurement_col])\n        data.loc[(data.product_code==code)&(data[column].isnull().sum(axis=1)==0)&(data[measurement_col].isnull()),measurement_col] = model.predict(tmp_test[column])\n        print(f'{measurement_col} : {len(tmp_test)}')\n        total_na_filled_by_linear_model += len(tmp_test)\n        \n    # others NA columns:\n    NA = data.loc[data[\"product_code\"] == code,nullValue_cols ].isnull().sum().sum()\n    model1 = KNNImputer(n_neighbors=3)\n    data.loc[data.product_code==code, feature] = model1.fit_transform(data.loc[data.product_code==code, feature])\n    print(f'\\n{total_na_filled_by_linear_model} filled by linear model ') \n    print(f'{NA} filled by KNN ')\n    \ndata['measurement_avg'] = data[[f'measurement_{i}' for i in range(3, 17)]].mean(axis=1)","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:34.935984Z","iopub.execute_input":"2022-08-14T14:59:34.936348Z","iopub.status.idle":"2022-08-14T14:59:58.158121Z","shell.execute_reply.started":"2022-08-14T14:59:34.936313Z","shell.execute_reply":"2022-08-14T14:59:58.157288Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def _scale(train_data, val_data, test_data, feats):\n    scaler = StandardScaler()\n    # scaler = PowerTransformer()\n    \n    scaled_train = scaler.fit_transform(train_data[feats])\n    scaled_val = scaler.transform(val_data[feats])\n    scaled_test = scaler.transform(test_data[feats])\n    \n    #back to dataframe\n    new_train = train_data.copy()\n    new_val = val_data.copy()\n    new_test = test_data.copy()\n    \n    new_train[feats] = scaled_train\n    new_val[feats] = scaled_val\n    new_test[feats] = scaled_test\n    \n    assert len(train_data) == len(new_train)\n    assert len(val_data) == len(new_val)\n    assert len(test_data) == len(new_test)\n    \n    return new_train, new_val, new_test","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:58.159481Z","iopub.execute_input":"2022-08-14T14:59:58.160385Z","iopub.status.idle":"2022-08-14T14:59:58.167618Z","shell.execute_reply.started":"2022-08-14T14:59:58.160350Z","shell.execute_reply":"2022-08-14T14:59:58.166666Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train = data.iloc[:train.shape[0],:]\ntest = data.iloc[train.shape[0]:,:]\nprint(train.shape, test.shape)\n\ngroups = train.product_code\nX = train\ny = target","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:58.168968Z","iopub.execute_input":"2022-08-14T14:59:58.169464Z","iopub.status.idle":"2022-08-14T14:59:58.185252Z","shell.execute_reply.started":"2022-08-14T14:59:58.169419Z","shell.execute_reply":"2022-08-14T14:59:58.184108Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Thanks to @MAXSARMENTO \nwoe_encoder = WoEEncoder(variables=['attribute_0'])\nwoe_encoder.fit(X, y)\nX = woe_encoder.transform(X)\ntest = woe_encoder.transform(test)","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:58.186436Z","iopub.execute_input":"2022-08-14T14:59:58.187216Z","iopub.status.idle":"2022-08-14T14:59:58.257614Z","shell.execute_reply.started":"2022-08-14T14:59:58.187183Z","shell.execute_reply":"2022-08-14T14:59:58.256477Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"select_feature = ['loading',\n                  'attribute_0',\n                  'measurement_17',\n                  'measurement_0',\n                  'measurement_1',\n                  'measurement_2',\n                  'area',\n                  'm3_missing',\n                  'm5_missing',\n                  'measurement_avg']","metadata":{"execution":{"iopub.status.busy":"2022-08-14T14:59:58.261575Z","iopub.execute_input":"2022-08-14T14:59:58.261945Z","iopub.status.idle":"2022-08-14T14:59:58.267941Z","shell.execute_reply.started":"2022-08-14T14:59:58.261909Z","shell.execute_reply":"2022-08-14T14:59:58.266766Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"seeds = [4, 8, 12, 24, 48, 64, 86, 128, 256]\nlr_test = np.zeros(len(test))\nlr_auc = 0\n\nfor i, seed in enumerate(seeds):\n    print('------- Seed:%2d -------' % (seeds[i]))\n    np.random.seed(seed)\n\n    kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)\n    for fold_idx, (train_idx, val_idx) in enumerate(kf.split(X, y,groups=train.product_code)):\n        x_train, x_val = X.iloc[train_idx], X.iloc[val_idx]\n        y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]\n        x_train, x_val, x_test = _scale(x_train, x_val, test, select_feature)\n\n        model = linear_model.LogisticRegression(max_iter=200, C=0.0001, penalty='l2', solver='newton-cg')\n        model.fit(x_train[select_feature], y_train)\n\n        val_preds = model.predict_proba(x_val[select_feature])[:, 1]\n        roc = round(roc_auc_score(y_val, val_preds), 5)\n        print(\"FOLD: \", fold_idx+1, \" ROC-AUC:\", roc)\n        lr_auc += roc_auc_score(y_val, val_preds) / (5 * 5)\n        lr_test += model.predict_proba(x_test[select_feature])[:, 1] / len(seeds)\n        \n    print('')","metadata":{"execution":{"iopub.status.busy":"2022-08-14T15:33:08.921623Z","iopub.execute_input":"2022-08-14T15:33:08.922333Z","iopub.status.idle":"2022-08-14T15:33:13.097082Z","shell.execute_reply.started":"2022-08-14T15:33:08.922296Z","shell.execute_reply":"2022-08-14T15:33:13.095598Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission['failure'] = lr_test\nsubmission.to_csv(f\"./submission.csv\", index=False)","metadata":{},"execution_count":null,"outputs":[]}]}