{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Introduction\n\nI am doing this for learning purposes. Pretty early on I realised that this would not be a winner, but maybe you can make this into useful model? This model achieved ~ 0.788 on the leaderboard.\n\nIf you have any suggestions on how this could be improved please leave a commment :)\n\n","metadata":{}},{"cell_type":"code","source":"import numpy as np \nimport pandas as pd\nimport os, gc\nimport matplotlib.pyplot as plt\n\nimport sklearn\nfrom sklearn.model_selection import StratifiedKFold\n\nfrom tensorflow.keras import layers\nfrom tensorflow import keras\nimport tensorflow as tf\nfrom keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau,LearningRateScheduler\n\n# directories to save various things\nos.mkdir(\"./models\")\nos.mkdir(\"./predictions\")","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2022-08-12T04:29:38.082802Z","iopub.execute_input":"2022-08-12T04:29:38.083171Z","iopub.status.idle":"2022-08-12T04:29:44.219346Z","shell.execute_reply.started":"2022-08-12T04:29:38.083138Z","shell.execute_reply":"2022-08-12T04:29:44.21837Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"import os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:30:23.851266Z","iopub.execute_input":"2022-08-12T04:30:23.851857Z","iopub.status.idle":"2022-08-12T04:30:23.866683Z","shell.execute_reply.started":"2022-08-12T04:30:23.851821Z","shell.execute_reply":"2022-08-12T04:30:23.86574Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"/kaggle/input/amex-default-prediction/sample_submission.csv\n/kaggle/input/amex-default-prediction/train_data.csv\n/kaggle/input/amex-default-prediction/test_data.csv\n/kaggle/input/amex-default-prediction/train_labels.csv\n/kaggle/input/amex-processed/test_ids\n/kaggle/input/amex-processed/train_processed(1).ftr\n/kaggle/input/amex-processed/test_processed.ftr\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Install package to convert 1d features into 2d \n\nDeepInsight paper for this package - https://www.nature.com/articles/s41598-019-47765-6https://www.nature.com/articles/s41598-019-47765-6","metadata":{}},{"cell_type":"code","source":"# TO convert 1d data to 2d images - https://pypi.org/project/tab2img/\n!pip install tab2img","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:29:44.220845Z","iopub.execute_input":"2022-08-12T04:29:44.22151Z","iopub.status.idle":"2022-08-12T04:29:53.773447Z","shell.execute_reply.started":"2022-08-12T04:29:44.221473Z","shell.execute_reply":"2022-08-12T04:29:53.772244Z"},"trusted":true},"execution_count":4,"outputs":[{"name":"stdout","text":"Requirement already satisfied: tab2img in /opt/conda/lib/python3.7/site-packages (0.0.2)\n\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n\u001b[0m","output_type":"stream"}]},{"cell_type":"code","source":"from tab2img.converter import Tab2Img","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:29.339797Z","iopub.execute_input":"2022-08-12T04:31:29.340382Z","iopub.status.idle":"2022-08-12T04:31:29.345244Z","shell.execute_reply.started":"2022-08-12T04:31:29.340341Z","shell.execute_reply":"2022-08-12T04:31:29.34402Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"# import your favourite dataset\n\ntrain = pd.read_feather(\"/kaggle/input/amex-processed/train_processed(1).ftr\")","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:29.88132Z","iopub.execute_input":"2022-08-12T04:31:29.881754Z","iopub.status.idle":"2022-08-12T04:31:31.218803Z","shell.execute_reply.started":"2022-08-12T04:31:29.881717Z","shell.execute_reply":"2022-08-12T04:31:31.217802Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"train.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:31.62464Z","iopub.execute_input":"2022-08-12T04:31:31.62572Z","iopub.status.idle":"2022-08-12T04:31:31.632039Z","shell.execute_reply.started":"2022-08-12T04:31:31.625682Z","shell.execute_reply":"2022-08-12T04:31:31.630961Z"},"trusted":true},"execution_count":12,"outputs":[{"execution_count":12,"output_type":"execute_result","data":{"text/plain":"(458913, 435)"},"metadata":{}}]},{"cell_type":"code","source":"train.columns","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:32.859796Z","iopub.execute_input":"2022-08-12T04:31:32.860398Z","iopub.status.idle":"2022-08-12T04:31:32.870118Z","shell.execute_reply.started":"2022-08-12T04:31:32.860361Z","shell.execute_reply":"2022-08-12T04:31:32.868974Z"},"trusted":true},"execution_count":13,"outputs":[{"execution_count":13,"output_type":"execute_result","data":{"text/plain":"Index(['B_1_last', 'B_11_last', 'B_12_last', 'B_13_last', 'B_14_last',\n       'B_16_last', 'B_18_last', 'B_19_last', 'B_2_last', 'B_20_last',\n       ...\n       'S_11_max', 'S_12_max', 'S_23_max', 'S_25_max', 'S_26_max', 'S_27_max',\n       'S_3_max', 'S_5_max', 'S_7_max', 'S_8_max'],\n      dtype='object', length=435)"},"metadata":{}}]},{"cell_type":"code","source":"target = pd.read_csv(\"../input/amex-default-prediction/train_labels.csv\").target","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:33.644588Z","iopub.execute_input":"2022-08-12T04:31:33.644958Z","iopub.status.idle":"2022-08-12T04:31:34.461471Z","shell.execute_reply.started":"2022-08-12T04:31:33.644911Z","shell.execute_reply":"2022-08-12T04:31:34.460504Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\nss  = StandardScaler()","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:34.463399Z","iopub.execute_input":"2022-08-12T04:31:34.463758Z","iopub.status.idle":"2022-08-12T04:31:34.468596Z","shell.execute_reply.started":"2022-08-12T04:31:34.463722Z","shell.execute_reply":"2022-08-12T04:31:34.467692Z"},"trusted":true},"execution_count":15,"outputs":[]},{"cell_type":"code","source":"# Scale the data\ntrain_data = train.iloc[:, :-1]\ntrain_labels = train.iloc[:, -1]\ntrain_data = ss.fit_transform(train_data)","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:35:07.349259Z","iopub.execute_input":"2022-08-12T04:35:07.35031Z","iopub.status.idle":"2022-08-12T04:35:07.4406Z","shell.execute_reply.started":"2022-08-12T04:35:07.35022Z","shell.execute_reply":"2022-08-12T04:35:07.439246Z"},"trusted":true},"execution_count":1,"outputs":[{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_17/3093373707.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Scale the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtrain_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mtrain_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mtrain_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mNameError\u001b[0m: name 'train' is not defined"],"ename":"NameError","evalue":"name 'train' is not defined","output_type":"error"}]},{"cell_type":"code","source":"train.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:41.127484Z","iopub.execute_input":"2022-08-12T04:31:41.128414Z","iopub.status.idle":"2022-08-12T04:31:41.135066Z","shell.execute_reply.started":"2022-08-12T04:31:41.128366Z","shell.execute_reply":"2022-08-12T04:31:41.134066Z"},"trusted":true},"execution_count":17,"outputs":[{"execution_count":17,"output_type":"execute_result","data":{"text/plain":"(458913, 435)"},"metadata":{}}]},{"cell_type":"code","source":"# transform 1d tabular data to images\nconverter = Tab2Img()\nimages = converter.fit_transform(train, target.values)\n","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:41.74431Z","iopub.execute_input":"2022-08-12T04:31:41.745046Z","iopub.status.idle":"2022-08-12T04:31:49.37709Z","shell.execute_reply.started":"2022-08-12T04:31:41.745006Z","shell.execute_reply":"2022-08-12T04:31:49.376003Z"},"trusted":true},"execution_count":18,"outputs":[]},{"cell_type":"code","source":"images.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:49.378968Z","iopub.execute_input":"2022-08-12T04:31:49.379562Z","iopub.status.idle":"2022-08-12T04:31:49.386567Z","shell.execute_reply.started":"2022-08-12T04:31:49.379525Z","shell.execute_reply":"2022-08-12T04:31:49.385447Z"},"trusted":true},"execution_count":19,"outputs":[{"execution_count":19,"output_type":"execute_result","data":{"text/plain":"(458913, 21, 21)"},"metadata":{}}]},{"cell_type":"code","source":"# Take note of this you will need it later\n\nimages[0].shape","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:49.388165Z","iopub.execute_input":"2022-08-12T04:31:49.390067Z","iopub.status.idle":"2022-08-12T04:31:49.398922Z","shell.execute_reply.started":"2022-08-12T04:31:49.390031Z","shell.execute_reply":"2022-08-12T04:31:49.397674Z"},"trusted":true},"execution_count":20,"outputs":[{"execution_count":20,"output_type":"execute_result","data":{"text/plain":"(21, 21)"},"metadata":{}}]},{"cell_type":"markdown","source":"### Let's have a look at our \"images\"","metadata":{}},{"cell_type":"code","source":"fig, ax = plt.subplots(3, 4, figsize=(15, 10))\nax = ax.flatten()\nfor i in range(12):\n    ax[i].title.set_text(f\"target = {target[i]}\")\n    ax[i].imshow(images[i], cmap = \"gray\")\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:49.40213Z","iopub.execute_input":"2022-08-12T04:31:49.402981Z","iopub.status.idle":"2022-08-12T04:31:50.430921Z","shell.execute_reply.started":"2022-08-12T04:31:49.402915Z","shell.execute_reply":"2022-08-12T04:31:50.430005Z"},"trusted":true},"execution_count":21,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1080x720 with 12 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"#### Wanna buy a credit default NFT?\n\nIf you stare for long enough you will see an ape staring back at you.\n\n![](https://lh3.googleusercontent.com/u2AhOwaxh5_bzM5QhW_TtWvgOQfxPVH3pqTVEfvilZTbO54xse23z8Yud519xsTCHdbbRNq3D2GCgtGoC1U6plRsc2trYiQ6PHrQZtY=w600)","metadata":{}},{"cell_type":"markdown","source":"#### Build a model using keras layers api","metadata":{}},{"cell_type":"code","source":"def build_model():\n\n    input_layer = keras.Input(shape=(21, 21, 1))\n    csv_layer = keras.Input(shape=(435,))\n    x2 = layers.Dense(64, activation='swish', name=\"dense1_csv\")(csv_layer)\n#     x2 = layers.Flatten(name=\"flatten_csv\")(x2)\n   \n    x = layers.Conv2D(64, 5, strides=2, activation = \"swish\", padding=\"same\")(input_layer)\n    x = layers.Conv2D(64, 3, strides=2, activation = \"swish\", padding=\"same\")(x)\n    x = layers.MaxPooling2D(3, strides=2, padding=\"same\")(x)\n    x = layers.BatchNormalization()(x)\n    x = layers.Dropout(0.4)(x)\n    \n    x = layers.Conv2D(32, 5, strides=2, activation = \"swish\", padding=\"same\")(x)\n    x = layers.Conv2D(32, 3, strides=2, activation = \"swish\", padding=\"same\")(x)\n    x = layers.MaxPooling2D(3, strides=2, padding=\"same\")(x)\n    x = layers.BatchNormalization()(x)\n    x = layers.Dropout(0.4)(x)\n    \n    # FC and predict\n    x = layers.Flatten()(x)\n    x1 = Concatenate()([x, x2])\n    x = layers.Dense(100,activation = \"swish\")(x1)\n    x = layers.Dropout(0.4)(x)\n    x = layers.Dense(10,activation = \"swish\")(x)\n    output = layers.Dense(1, activation=\"sigmoid\")(x)\n    model = keras.Model(inputs=[input_layer, csv_layer], outputs=output)\n\n    return model","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:50.432193Z","iopub.execute_input":"2022-08-12T04:31:50.432956Z","iopub.status.idle":"2022-08-12T04:31:50.444643Z","shell.execute_reply.started":"2022-08-12T04:31:50.432898Z","shell.execute_reply":"2022-08-12T04:31:50.443677Z"},"trusted":true},"execution_count":22,"outputs":[]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:50.446101Z","iopub.execute_input":"2022-08-12T04:31:50.446553Z","iopub.status.idle":"2022-08-12T04:31:50.45965Z","shell.execute_reply.started":"2022-08-12T04:31:50.446514Z","shell.execute_reply":"2022-08-12T04:31:50.458664Z"},"trusted":true},"execution_count":23,"outputs":[{"execution_count":23,"output_type":"execute_result","data":{"text/plain":"(458913, 435)"},"metadata":{}}]},{"cell_type":"markdown","source":"How about a UNET style architecture?","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.layers import Input, Dense, Concatenate\n\ndef build_UNET():\n\n    input_layer = Input(shape=(21, 21, 1))\n    csv_layer = Input(shape=(435,))\n    x2 = layers.Flatten(name=\"flatten_csv\")(csv_layer)\n   \n    x = layers.ZeroPadding2D(((11,0),(11,0)))(input_layer)\n    #print(x.shape)\n\n    conv1 = layers.Conv2D(8, (3,3), activation='swish', padding=\"same\")(x)\n    conv1 = layers.Conv2D(8, (3,3), activation='swish', padding=\"same\")(conv1)\n    #print(f\"conv1 shape {conv1.shape}\")\n    pool1 = layers.MaxPooling2D(pool_size=(2,2))(conv1)\n\n    conv2 = layers.Conv2D(16, (3,3), activation='swish', padding=\"same\")(pool1)\n    conv2 = layers.Conv2D(16, (3,3), activation='swish', padding=\"same\")(conv2)\n    #print(f\"conv2 shape {conv2.shape}\")\n    pool2 = layers.MaxPooling2D(pool_size=(2,2))(conv2)\n\n    conv3 = layers.Conv2D(32, (3,3), activation='swish', padding=\"same\")(pool2)\n    conv3 = layers.Conv2D(32, (3,3), activation='swish', padding=\"same\")(conv3)\n    #print(f\"conv3 shape {conv3.shape}\")\n    pool3 = layers.MaxPooling2D(pool_size=(2,2))(conv3)\n\n    conv4 = layers.Conv2D(64, (3,3), activation='swish', padding=\"same\")(pool3)\n    conv4 = layers.Conv2D(64, (3,3), activation='swish', padding=\"same\")(conv4)\n    #print(f\"conv4 shape {conv4.shape}\")\n    pool4 = layers.MaxPooling2D(pool_size=(2,2))(conv4)\n    \n    convm = layers.Conv2D(128, (3,3), activation='swish', padding=\"same\")(pool4)\n    convm = layers.Conv2D(128, (3,3), activation='swish', padding=\"same\")(convm)\n    #print(f\"convm shape {convm.shape}\")\n\n    ### UP\n\n    up5 = layers.UpSampling2D(size=(2,2))(convm)\n    #print(f\"up5 shape {up5.shape}\")\n    cat5 = Concatenate()([up5, conv4])\n    conv5 = layers.Conv2D(64, (3,3), activation='swish',padding=\"same\")(cat5)\n    conv5 = layers.Conv2D(64, (3,3), activation='swish',padding=\"same\")(conv5)\n    #print(f\"conv5 shape {conv5.shape}\")\n    conv5 = layers.BatchNormalization()(conv5)\n\n    up6 = layers.UpSampling2D(size=(2,2))(conv5)\n    #print(f\"up6 shape {up6.shape}\")\n    cat6 = Concatenate()([up6, conv3])\n    conv6 = layers.Conv2D(32, (3,3), activation='swish', padding=\"same\")(cat6)\n    conv6 = layers.Conv2D(32, (3,3), activation='swish', padding=\"same\")(conv6)\n    #print(f\"conv6 shape {conv6.shape}\")\n    conv6 = layers.BatchNormalization()(conv6)\n\n    up7 = layers.UpSampling2D(size=(2,2))(conv6)\n    #print(f\"up7 shape {up7.shape}\")\n    cat7 = Concatenate()([up7, conv2])\n    conv7 = layers.Conv2D(16, (3,3), activation='swish', padding=\"same\")(cat7)\n    conv7 = layers.Conv2D(16, (3,3), activation='swish', padding=\"same\")(conv7)\n    #print(f\"conv7 shape {conv7.shape}\")\n    x = layers.BatchNormalization()(conv7)\n    \n    up8 = layers.UpSampling2D(size=(2,2))(conv7)\n    #print(f\"up8 shape {up8.shape}\")\n    cat8 = Concatenate()([up8, conv1])\n    conv8 = layers.Conv2D(8, (3,3), activation='swish', padding=\"same\")(cat8)\n    conv8 = layers.Conv2D(8, (3,3), activation='swish', padding=\"same\")(conv8)\n    #print(f\"conv8 shape {conv8.shape}\")\n    x = layers.BatchNormalization()(conv8)\n\n    # predict\n    x = layers.Conv2D(32, kernel_size=(3,3), strides=1, padding=\"same\")(x)\n    x = layers.Flatten()(x)\n    x2 = tf.keras.layers.Dense(128, activation='relu', name=\"dense1_csv\")(x2)\n    x2 = layers.BatchNormalization()(x2)\n    x1 = Concatenate()([x, x2])\n    x1 = layers.Dropout(0.5)(x1)\n    x1 = layers.Dense(10)(x1)\n    output = layers.Dense(1, activation=\"sigmoid\")(x1)\n    model = keras.Model(inputs=[input_layer, csv_layer], outputs=output)\n\n    return model","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:52.750656Z","iopub.execute_input":"2022-08-12T04:31:52.751042Z","iopub.status.idle":"2022-08-12T04:31:52.775839Z","shell.execute_reply.started":"2022-08-12T04:31:52.751007Z","shell.execute_reply":"2022-08-12T04:31:52.7748Z"},"trusted":true},"execution_count":24,"outputs":[]},{"cell_type":"code","source":"build_UNET().summary()","metadata":{"execution":{"iopub.status.busy":"2022-08-12T04:31:54.239855Z","iopub.execute_input":"2022-08-12T04:31:54.24033Z","iopub.status.idle":"2022-08-12T04:31:57.569721Z","shell.execute_reply.started":"2022-08-12T04:31:54.240292Z","shell.execute_reply":"2022-08-12T04:31:57.568708Z"},"trusted":true},"execution_count":25,"outputs":[{"name":"stderr","text":"2022-08-12 04:31:54.407653: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:54.551539: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:54.552351: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:54.554173: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\nTo enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n2022-08-12 04:31:54.554487: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:54.555230: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:54.555875: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:56.897291: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:56.898165: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:56.898874: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2022-08-12 04:31:56.899495: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 15403 MB memory:  -> device: 0, name: Tesla P100-PCIE-16GB, pci bus id: 0000:00:04.0, compute capability: 6.0\n","output_type":"stream"},{"name":"stdout","text":"Model: \"model\"\n__________________________________________________________________________________________________\nLayer (type)                    Output Shape         Param #     Connected to                     \n==================================================================================================\ninput_1 (InputLayer)            [(None, 21, 21, 1)]  0                                            \n__________________________________________________________________________________________________\nzero_padding2d (ZeroPadding2D)  (None, 32, 32, 1)    0           input_1[0][0]                    \n__________________________________________________________________________________________________\nconv2d (Conv2D)                 (None, 32, 32, 8)    80          zero_padding2d[0][0]             \n__________________________________________________________________________________________________\nconv2d_1 (Conv2D)               (None, 32, 32, 8)    584         conv2d[0][0]                     \n__________________________________________________________________________________________________\nmax_pooling2d (MaxPooling2D)    (None, 16, 16, 8)    0           conv2d_1[0][0]                   \n__________________________________________________________________________________________________\nconv2d_2 (Conv2D)               (None, 16, 16, 16)   1168        max_pooling2d[0][0]              \n__________________________________________________________________________________________________\nconv2d_3 (Conv2D)               (None, 16, 16, 16)   2320        conv2d_2[0][0]                   \n__________________________________________________________________________________________________\nmax_pooling2d_1 (MaxPooling2D)  (None, 8, 8, 16)     0           conv2d_3[0][0]                   \n__________________________________________________________________________________________________\nconv2d_4 (Conv2D)               (None, 8, 8, 32)     4640        max_pooling2d_1[0][0]            \n__________________________________________________________________________________________________\nconv2d_5 (Conv2D)               (None, 8, 8, 32)     9248        conv2d_4[0][0]                   \n__________________________________________________________________________________________________\nmax_pooling2d_2 (MaxPooling2D)  (None, 4, 4, 32)     0           conv2d_5[0][0]                   \n__________________________________________________________________________________________________\nconv2d_6 (Conv2D)               (None, 4, 4, 64)     18496       max_pooling2d_2[0][0]            \n__________________________________________________________________________________________________\nconv2d_7 (Conv2D)               (None, 4, 4, 64)     36928       conv2d_6[0][0]                   \n__________________________________________________________________________________________________\nmax_pooling2d_3 (MaxPooling2D)  (None, 2, 2, 64)     0           conv2d_7[0][0]                   \n__________________________________________________________________________________________________\nconv2d_8 (Conv2D)               (None, 2, 2, 128)    73856       max_pooling2d_3[0][0]            \n__________________________________________________________________________________________________\nconv2d_9 (Conv2D)               (None, 2, 2, 128)    147584      conv2d_8[0][0]                   \n__________________________________________________________________________________________________\nup_sampling2d (UpSampling2D)    (None, 4, 4, 128)    0           conv2d_9[0][0]                   \n__________________________________________________________________________________________________\nconcatenate (Concatenate)       (None, 4, 4, 192)    0           up_sampling2d[0][0]              \n                                                                 conv2d_7[0][0]                   \n__________________________________________________________________________________________________\nconv2d_10 (Conv2D)              (None, 4, 4, 64)     110656      concatenate[0][0]                \n__________________________________________________________________________________________________\nconv2d_11 (Conv2D)              (None, 4, 4, 64)     36928       conv2d_10[0][0]                  \n__________________________________________________________________________________________________\nbatch_normalization (BatchNorma (None, 4, 4, 64)     256         conv2d_11[0][0]                  \n__________________________________________________________________________________________________\nup_sampling2d_1 (UpSampling2D)  (None, 8, 8, 64)     0           batch_normalization[0][0]        \n__________________________________________________________________________________________________\nconcatenate_1 (Concatenate)     (None, 8, 8, 96)     0           up_sampling2d_1[0][0]            \n                                                                 conv2d_5[0][0]                   \n__________________________________________________________________________________________________\nconv2d_12 (Conv2D)              (None, 8, 8, 32)     27680       concatenate_1[0][0]              \n__________________________________________________________________________________________________\nconv2d_13 (Conv2D)              (None, 8, 8, 32)     9248        conv2d_12[0][0]                  \n__________________________________________________________________________________________________\nbatch_normalization_1 (BatchNor (None, 8, 8, 32)     128         conv2d_13[0][0]                  \n__________________________________________________________________________________________________\nup_sampling2d_2 (UpSampling2D)  (None, 16, 16, 32)   0           batch_normalization_1[0][0]      \n__________________________________________________________________________________________________\nconcatenate_2 (Concatenate)     (None, 16, 16, 48)   0           up_sampling2d_2[0][0]            \n                                                                 conv2d_3[0][0]                   \n__________________________________________________________________________________________________\nconv2d_14 (Conv2D)              (None, 16, 16, 16)   6928        concatenate_2[0][0]              \n__________________________________________________________________________________________________\nconv2d_15 (Conv2D)              (None, 16, 16, 16)   2320        conv2d_14[0][0]                  \n__________________________________________________________________________________________________\nup_sampling2d_3 (UpSampling2D)  (None, 32, 32, 16)   0           conv2d_15[0][0]                  \n__________________________________________________________________________________________________\nconcatenate_3 (Concatenate)     (None, 32, 32, 24)   0           up_sampling2d_3[0][0]            \n                                                                 conv2d_1[0][0]                   \n__________________________________________________________________________________________________\nconv2d_16 (Conv2D)              (None, 32, 32, 8)    1736        concatenate_3[0][0]              \n__________________________________________________________________________________________________\nconv2d_17 (Conv2D)              (None, 32, 32, 8)    584         conv2d_16[0][0]                  \n__________________________________________________________________________________________________\ninput_2 (InputLayer)            [(None, 435)]        0                                            \n__________________________________________________________________________________________________\nbatch_normalization_3 (BatchNor (None, 32, 32, 8)    32          conv2d_17[0][0]                  \n__________________________________________________________________________________________________\nflatten_csv (Flatten)           (None, 435)          0           input_2[0][0]                    \n__________________________________________________________________________________________________\nconv2d_18 (Conv2D)              (None, 32, 32, 32)   2336        batch_normalization_3[0][0]      \n__________________________________________________________________________________________________\ndense1_csv (Dense)              (None, 128)          55808       flatten_csv[0][0]                \n__________________________________________________________________________________________________\nflatten (Flatten)               (None, 32768)        0           conv2d_18[0][0]                  \n__________________________________________________________________________________________________\nbatch_normalization_4 (BatchNor (None, 128)          512         dense1_csv[0][0]                 \n__________________________________________________________________________________________________\nconcatenate_4 (Concatenate)     (None, 32896)        0           flatten[0][0]                    \n                                                                 batch_normalization_4[0][0]      \n__________________________________________________________________________________________________\ndropout (Dropout)               (None, 32896)        0           concatenate_4[0][0]              \n__________________________________________________________________________________________________\ndense (Dense)                   (None, 10)           328970      dropout[0][0]                    \n__________________________________________________________________________________________________\ndense_1 (Dense)                 (None, 1)            11          dense[0][0]                      \n==================================================================================================\nTotal params: 879,037\nTrainable params: 878,573\nNon-trainable params: 464\n__________________________________________________________________________________________________\n","output_type":"stream"}]},{"cell_type":"markdown","source":"### Amex metric","metadata":{}},{"cell_type":"code","source":"# COMPETITION METRIC FROM Konstantin Yakovlev\n# https://www.kaggle.com/kyakovlev\n# https://www.kaggle.com/competitions/amex-default-prediction/discussion/327534\n\ndef amex_metric_mod(y_true, y_pred):\n\n    labels = np.transpose(np.array([y_true, y_pred]))\n    labels = labels[labels[:, 1].argsort()[::-1]]\n    weights = np.where(labels[:, 0] == 0, 20, 1)\n    cut_vals = labels[np.cumsum(weights) <= int(0.04 * np.sum(weights))]\n    top_four = np.sum(cut_vals[:, 0]) / np.sum(labels[:, 0])\n\n    gini = [0, 0]\n    for i in [1, 0]:\n        labels = np.transpose(np.array([y_true, y_pred]))\n        labels = labels[labels[:, i].argsort()[::-1]]\n        weight = np.where(labels[:, 0] == 0, 20, 1)\n        weight_random = np.cumsum(weight / np.sum(weight))\n        total_pos = np.sum(labels[:, 0] * weight)\n        cum_pos_found = np.cumsum(labels[:, 0] * weight)\n        lorentz = cum_pos_found / total_pos\n        gini[i] = np.sum((lorentz - weight_random) * weight)\n\n    return 0.5 * (gini[1] / gini[0] + top_four)","metadata":{"execution":{"iopub.status.busy":"2022-07-28T07:46:11.858985Z","iopub.execute_input":"2022-07-28T07:46:11.859822Z","iopub.status.idle":"2022-07-28T07:46:11.870366Z","shell.execute_reply.started":"2022-07-28T07:46:11.85978Z","shell.execute_reply":"2022-07-28T07:46:11.869183Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### I briefly investigated using ImageDataGenerator to augment training, but seeing as these aren't really \"images\" I would be surprised if it helps","metadata":{}},{"cell_type":"markdown","source":"<!-- datagen = tf.keras.preprocessing.image.ImageDataGenerator(\n    zca_epsilon =  1e-7, # defualt 1e-6\n    zca_whitening = True\n) -->","metadata":{"execution":{"iopub.status.busy":"2022-07-24T13:16:41.796316Z","iopub.execute_input":"2022-07-24T13:16:41.797251Z","iopub.status.idle":"2022-07-24T13:16:41.807572Z","shell.execute_reply.started":"2022-07-24T13:16:41.797212Z","shell.execute_reply":"2022-07-24T13:16:41.806601Z"}}},{"cell_type":"code","source":"kfold = sklearn.model_selection.StratifiedKFold(n_splits=3)\n\nbatch_size = 1000\n\ndef run(images, target, train):\n    fold_scores = []\n\n    for fold, (trn_idx, val_idx) in enumerate(kfold.split(images, target)):\n        tf.keras.backend.clear_session()\n        \n        \n        # set random seed for fold\n        tf.random.set_seed(7453)\n        \n        \n        X_train, X_train2, y_train = images[trn_idx], train[trn_idx], target[trn_idx]\n        X_val,  X_val2, y_val = images[val_idx], train[val_idx], target[val_idx]\n        print(f\"#### fold: {fold +1} ####\")\n\n        initial_learning_rate = 0.01\n        epochs = 75\n        lr = ReduceLROnPlateau(monitor=\"val_loss\", \n                               factor=0.7, \n                               patience=10, \n                               verbose=0)\n\n        model = build_UNET()\n        \n        model.compile(\n            loss=tf.keras.losses.BinaryCrossentropy(),\n            optimizer=tf.keras.optimizers.Adam(\n                learning_rate=initial_learning_rate, \n                beta_1=0.9,\n                beta_2=0.999,\n                epsilon=1e-07,\n                amsgrad=False\n            ),\n            metrics=[\"accuracy\"],\n        )\n\n        mcp_save = tf.keras.callbacks.ModelCheckpoint(\n            f\"./models/best_model_{fold}.hdf5\",\n            save_best_only=True,\n            monitor=\"val_loss\",\n            mode=\"auto\",\n        )\n\n        ES = EarlyStopping(\n            monitor=\"val_loss\",\n            min_delta=0,\n            patience=10,\n            verbose=0,\n            mode=\"auto\",\n            baseline=None,\n            restore_best_weights=True,\n        )\n\n        history = model.fit(\n            [X_train, X_train2],\n            y_train,\n            epochs=epochs,\n            verbose=1,\n            batch_size=batch_size,\n            validation_data=(\n                    [X_val, X_val2], \n                    y_val, \n                    ),\n            callbacks=[lr, mcp_save, ES],\n        )\n\n        y_pred = model.predict([X_val, X_val2], \n                               batch_size=batch_size, \n                               verbose=0).ravel()\n\n        score = amex_metric_mod(y_val, y_pred)\n        print(f\"Fold {fold + 1}: {score}\")\n\n        fold_scores.append(score)\n        del (\n            model,\n            history,\n            mcp_save,\n        )\n\n        del y_pred, score, X_train, y_train, X_val, y_val\n        gc.collect()\n        \n        # for testing\n        # if fold == 0: break\n\n    gc.collect()\n    print(f\"Overall score: {np.mean(fold_scores, axis=0)}\")\n    del fold_scores","metadata":{"execution":{"iopub.status.busy":"2022-07-28T07:46:18.106942Z","iopub.execute_input":"2022-07-28T07:46:18.107344Z","iopub.status.idle":"2022-07-28T07:46:18.122046Z","shell.execute_reply.started":"2022-07-28T07:46:18.107307Z","shell.execute_reply":"2022-07-28T07:46:18.12099Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# TRAINING\n\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\nmodels = run(images, target, train)","metadata":{"execution":{"iopub.status.busy":"2022-07-28T07:46:19.34147Z","iopub.execute_input":"2022-07-28T07:46:19.342168Z","iopub.status.idle":"2022-07-28T08:21:05.545608Z","shell.execute_reply.started":"2022-07-28T07:46:19.342128Z","shell.execute_reply":"2022-07-28T08:21:05.544537Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Inference","metadata":{}},{"cell_type":"code","source":"# Free memory for predictions\ndel images\ngc.collect()","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:23:43.292965Z","iopub.execute_input":"2022-07-28T08:23:43.294173Z","iopub.status.idle":"2022-07-28T08:23:43.604653Z","shell.execute_reply.started":"2022-07-28T08:23:43.294118Z","shell.execute_reply":"2022-07-28T08:23:43.603674Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Transform test set","metadata":{}},{"cell_type":"code","source":"test = pd.read_feather(\"../input/amex-processed/test_processed.ftr\")","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:23:48.244172Z","iopub.execute_input":"2022-07-28T08:23:48.244799Z","iopub.status.idle":"2022-07-28T08:23:57.665862Z","shell.execute_reply.started":"2022-07-28T08:23:48.244757Z","shell.execute_reply":"2022-07-28T08:23:57.664675Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# scale data\ntest1 = ss.transform(test)","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:24:03.363538Z","iopub.execute_input":"2022-07-28T08:24:03.36433Z","iopub.status.idle":"2022-07-28T08:24:08.516825Z","shell.execute_reply.started":"2022-07-28T08:24:03.364289Z","shell.execute_reply":"2022-07-28T08:24:08.515676Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# generate images of test set\ntest = converter.transform(test1)","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:24:20.206808Z","iopub.execute_input":"2022-07-28T08:24:20.207835Z","iopub.status.idle":"2022-07-28T08:24:28.720103Z","shell.execute_reply.started":"2022-07-28T08:24:20.207779Z","shell.execute_reply":"2022-07-28T08:24:28.719021Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Test \"images\"","metadata":{}},{"cell_type":"code","source":"fig, ax = plt.subplots(3, 4, figsize=(15, 10))\nax = ax.flatten()\nfor i in range(12):\n    ax[i].title.set_text(f\"test image {i}\")\n    ax[i].imshow(test[i], cmap = \"gray\")\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:24:36.656554Z","iopub.execute_input":"2022-07-28T08:24:36.65748Z","iopub.status.idle":"2022-07-28T08:24:37.760549Z","shell.execute_reply.started":"2022-07-28T08:24:36.657439Z","shell.execute_reply":"2022-07-28T08:24:37.759554Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Make predictions","metadata":{}},{"cell_type":"code","source":"# predictions\n\nfor num, model in enumerate(os.listdir(\"./models/\")):\n    # loop to make predictions in chunks\n    preds = []\n    model = keras.models.load_model(\"./models/\" + model)\n    chunk_size = int(test.shape[0] / 10)\n    for start in range(0, test.shape[0], chunk_size):\n        test_subset = test[start : start + chunk_size]\n        test_subset1 = test1[start : start + chunk_size]\n        preds.extend(model.predict([test_subset, test_subset1], batch_size=batch_size, verbose=0).flatten())\n\n    # loop to save predictions\n    sub = pd.read_csv(\"../input/amex-default-prediction/sample_submission.csv\")\n    del sub[\"prediction\"]\n    sub[\"prediction\"] = preds\n    sub.to_csv(f\"./predictions/{num}_preds.csv\")\n    del sub, model\n    gc.collect()","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:26:10.808918Z","iopub.execute_input":"2022-07-28T08:26:10.809651Z","iopub.status.idle":"2022-07-28T08:28:00.347416Z","shell.execute_reply.started":"2022-07-28T08:26:10.809593Z","shell.execute_reply":"2022-07-28T08:28:00.346297Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# get submission data\nsub = pd.read_csv(\"../input/amex-default-prediction/sample_submission.csv\")\ndel sub[\"prediction\"]\ngc.collect()","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:28:08.127184Z","iopub.execute_input":"2022-07-28T08:28:08.127581Z","iopub.status.idle":"2022-07-28T08:28:09.251989Z","shell.execute_reply.started":"2022-07-28T08:28:08.127546Z","shell.execute_reply":"2022-07-28T08:28:09.250846Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# average predictions for final score\nfor num, data in enumerate(os.listdir(\"./predictions/\")):\n\n    p1 = pd.read_csv(f\"./predictions/{data}\")\n    del p1[\"Unnamed: 0\"]\n    sub[f\"{num}_prediction\"] = p1[\"prediction\"]\n\n    del p1\n    gc.collect()\n\nsub.to_csv(\"test_output.csv\")\nsub[\"prediction\"] = sub.iloc[:, 1:].mean(axis=1)\nsub = sub[[\"customer_ID\", \"prediction\"]]\nsub.to_csv(\"submission.csv\", index=False)","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:28:15.847796Z","iopub.execute_input":"2022-07-28T08:28:15.848187Z","iopub.status.idle":"2022-07-28T08:28:32.124568Z","shell.execute_reply.started":"2022-07-28T08:28:15.848153Z","shell.execute_reply":"2022-07-28T08:28:32.123457Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sub","metadata":{"execution":{"iopub.status.busy":"2022-07-28T08:28:32.126461Z","iopub.execute_input":"2022-07-28T08:28:32.127472Z","iopub.status.idle":"2022-07-28T08:28:32.14521Z","shell.execute_reply.started":"2022-07-28T08:28:32.127427Z","shell.execute_reply":"2022-07-28T08:28:32.144145Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}