kaggle-competitions/competitions/identify-age-related-conditions/train_models/submission.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "from sklearn.metrics import accuracy_score\n",
    "from xgboost import XGBClassifier\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.feature_selection import mutual_info_regression\n",
    "from sklearn.discriminant_analysis import StandardScaler\n",
    "import numpy as np\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split, ParameterGrid\n",
    "from keras.callbacks import TensorBoard, EarlyStopping, LearningRateScheduler\n",
    "from keras.models import Model\n",
    "from keras.layers import Activation, Dense, LSTM, Input\n",
    "from keras.optimizers import Adam, RMSprop, SGD\n",
    "from scikeras.wrappers import KerasClassifier\n",
    "import tensorflow as tf\n",
    "from os import path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method to load the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset(columns_drop) -> tuple([pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame]):\n",
    "    train = pd.read_csv(\"C:\\\\Projects\\\\kaggle\\\\competitions\\\\identify-age-related-conditions\\\\data\\\\train.csv\")\n",
    "    greeks = pd.read_csv(\"C:\\\\Projects\\\\kaggle\\\\competitions\\\\identify-age-related-conditions\\\\data\\\\greeks.csv\")\n",
    "    test = pd.read_csv(\"C:\\\\Projects\\\\kaggle\\\\competitions\\\\identify-age-related-conditions\\\\data\\\\test.csv\")\n",
    "    \"\"\"\n",
    "    train = pd.read_csv(\"/kaggle/input/icr-identify-age-related-conditions/train.csv\")\n",
    "    greeks = pd.read_csv(\"/kaggle/input/icr-identify-age-related-conditions/greeks.csv\")\n",
    "    test = pd.read_csv(\"/kaggle/input/icr-identify-age-related-conditions/test.csv\")\n",
    "    \"\"\"\n",
    "    columns_drop = ['Id'] + columns_drop\n",
    "    id_list = test[\"Id\"]\n",
    "    train.drop(columns_drop, inplace=True, axis=1)\n",
    "    test.drop(columns_drop, inplace=True, axis=1)\n",
    "    print(len(train.columns))\n",
    "    return (train, greeks, test, id_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method to split the data in validation and train set randomly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_data(df: pd.DataFrame, split)->tuple([pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame]):\n",
    "    X = df.loc[:, df.columns != \"Class\"]\n",
    "    y = df.loc[:, \"Class\"]\n",
    "    return train_test_split(X, y, test_size=split, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method to build a Tensorflow model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_tensorflow_model(input_shape:int, output_shape:int, units1: int, units2: int, units3: int, units4: int, activation1: str, \n",
    "                activation2: str, activation3: str, activation4: str, optimizer: tf.keras.optimizers.Optimizer, learning_rate: float) -> Model:\n",
    "    input = Input(shape=input_shape)\n",
    "    x = Dense(units=units1, activation=activation1)(input)\n",
    "    x = Dense(units=units2, activation=activation2)(x)\n",
    "    x = Dense(units=units3, activation=activation3)(x)\n",
    "    x = Dense(units=units4, activation=activation4)(x)\n",
    "    output = Dense(units=output_shape, activation=\"softmax\")(x)\n",
    "    model = Model(inputs=[input], outputs=[output])\n",
    "    \n",
    "    model.compile(loss=\"categorical_crossentropy\",\n",
    "              optimizer=optimizer(learning_rate=learning_rate),\n",
    "              metrics=[\"accuracy\"])   \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method to plot the accuracy of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_acc_tf_model(history:Model):\n",
    "    # summarize history for accuracy\n",
    "    plt.plot(history.history['accuracy'])\n",
    "    plt.plot(history.history['val_accuracy'])\n",
    "    plt.title('model accuracy')\n",
    "    plt.ylabel('accuracy')\n",
    "    plt.xlabel('epoch')\n",
    "    plt.legend(['Train', 'Validation'], loc='upper left')\n",
    "    plt.show()\n",
    "    \n",
    "    # summarize history for loss\n",
    "    plt.plot(history.history['loss'])\n",
    "    plt.plot(history.history['val_loss'])\n",
    "    plt.title('model loss')\n",
    "    plt.ylabel('loss')\n",
    "    plt.xlabel('epoch')\n",
    "    plt.legend(['Train', 'Validation'], loc='upper left')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method to fit the Tensorflow model with ES Callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "es_callback = EarlyStopping(\n",
    "        monitor=\"val_accuracy\",\n",
    "        patience=5,\n",
    "        verbose=1,\n",
    "        restore_best_weights=True,\n",
    "        min_delta=0.005\n",
    "    )\n",
    " \n",
    "def fit_model(model: Model, x: np.ndarray, y: np.ndarray, epochs: int, split: float) -> Model:\n",
    "    #split train and validation\n",
    "    x_train, x_val, y_train, y_val = train_test_split(x, y, test_size=split, random_state=42)\n",
    "    #fit the model\n",
    "    history = model.fit(x_train, y_train, epochs=epochs, validation_data=(x_val,y_val), callbacks=[es_callback])\n",
    "    return history "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method to build a preprocessing pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_preprocessing_pipeline(df: pd.DataFrame) -> ColumnTransformer:\n",
    "    # Preprocessing for numerical data    \n",
    "    numerical_transformer = Pipeline(steps=[\n",
    "        ('imputer',SimpleImputer(strategy='constant')),\n",
    "        ('scaler', StandardScaler())])\n",
    "    \n",
    "    # Preprocessing for categorical data\n",
    "    categorical_transformer = Pipeline(steps=[\n",
    "        ('imputer', SimpleImputer(strategy='most_frequent')),\n",
    "        ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
    "    ])\n",
    "\n",
    "    # Bundle preprocessing for numerical and categorical data\n",
    "    numerical_cols = [cname for cname in df.columns if df[cname].dtype in [\"int64\", \"float64\"]]\n",
    "    categorical_cols = [cname for cname in df.columns if df[cname].nunique() < 10]\n",
    "    preprocessor = ColumnTransformer(\n",
    "        transformers=[\n",
    "            ('num', numerical_transformer, numerical_cols),\n",
    "            ('cat', categorical_transformer, categorical_cols)\n",
    "        ])\n",
    "    print(f\"Number of columns: {len(df.columns)}\")\n",
    "    return preprocessor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a model and preprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36\n",
      "dataset shape: (617, 36)\n",
      "Number of columns: 35\n",
      "Epoch 1/100\n",
      "11/11 [==============================] - 1s 17ms/step - loss: 0.6332 - accuracy: 0.7616 - val_loss: 0.5207 - val_accuracy: 0.8391\n",
      "Epoch 2/100\n",
      "11/11 [==============================] - 0s 4ms/step - loss: 0.5131 - accuracy: 0.8372 - val_loss: 0.4679 - val_accuracy: 0.8391\n",
      "Epoch 3/100\n",
      "11/11 [==============================] - 0s 4ms/step - loss: 0.4392 - accuracy: 0.8372 - val_loss: 0.4429 - val_accuracy: 0.8391\n",
      "Epoch 4/100\n",
      "11/11 [==============================] - 0s 4ms/step - loss: 0.3799 - accuracy: 0.8459 - val_loss: 0.4251 - val_accuracy: 0.8391\n",
      "Epoch 5/100\n",
      "11/11 [==============================] - 0s 4ms/step - loss: 0.3300 - accuracy: 0.8808 - val_loss: 0.4181 - val_accuracy: 0.8391\n",
      "Epoch 6/100\n",
      " 1/11 [=>............................] - ETA: 0s - loss: 0.1903 - accuracy: 0.9375Restoring model weights from the end of the best epoch: 1.\n",
      "11/11 [==============================] - 0s 4ms/step - loss: 0.2810 - accuracy: 0.8924 - val_loss: 0.4152 - val_accuracy: 0.8391\n",
      "Epoch 6: early stopping\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Newly load the dataset with columns drop and create preprocessing pipeline\n",
    "bad_col = ['CH', 'CC', 'DN', 'CW ', 'EG', 'CU', 'CF', 'CB', 'DV', 'AH', 'AY', 'GB', 'FS', 'AZ', 'DE', 'DY', 'BD ', 'FD ', 'CD ', 'BZ', 'EL']\n",
    "train, greeks, test, id_list = load_dataset(columns_drop=bad_col)\n",
    "print(f\"dataset shape: {train.shape}\")\n",
    "X_train, X_valid, y_train, y_valid = split_data(train, 0.3)\n",
    "preprocessor = build_preprocessing_pipeline(X_train)\n",
    "\n",
    "\n",
    "# Define models for the pipeline\n",
    "preprocessor.fit(X_train)\n",
    "X_preprocessed = preprocessor.transform(X_train)\n",
    "y_train_ohe = pd.get_dummies(y_train, columns = ['Class'])\n",
    "y_valid_ohe = pd.get_dummies(y_valid, columns = ['Class'])\n",
    "model_keras = build_tensorflow_model(input_shape=len(X_preprocessed[1]), output_shape=2, units1=16, units2=32, units3=64, units4=128,activation1=\"relu\",\n",
    "                                     activation2=\"relu\", activation3=\"relu\", activation4=\"relu\", optimizer=Adam, learning_rate=0.001)\n",
    "history = fit_model(model_keras, X_preprocessed, y_train_ohe, 100, 0.2)\n",
    "plot_acc_tf_model(history)\n",
    "model_keras = KerasClassifier(model=model_keras, epochs=0)\n",
    "model_rf = RandomForestClassifier(n_estimators=100, random_state=22)\n",
    "model_xgb = XGBClassifier(n_estimators=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build the final pipeline with preprocessor and model, fit it and display accuracy score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Building Pipeline\n",
    "def fit_pipeline(X_train: pd.DataFrame, y_train: pd.DataFrame, preprocessor, model) -> Pipeline:\n",
    "    pipeline = Pipeline(steps=[('preprocessor', preprocessor),\n",
    "                            ('model', model)\n",
    "                            ])\n",
    "    #Fit the Model and make preds\n",
    "    pipeline.fit(X_train, y_train)\n",
    "    preds = pipeline.predict(X_valid)\n",
    "    \"\"\" score = cross_val_score(pipeline, X_valid, y_valid, cv=5, scoring='accuracy')\n",
    "    print(f\"Accuracy of {score}\") \"\"\"\n",
    "    correct_answers = 0\n",
    "    for y_pred,y_true in zip(preds,y_valid_ohe.to_numpy()):\n",
    "        if(y_pred[0] == y_true[0]):correct_answers+=1\n",
    "    print(correct_answers/len(preds))\n",
    "    return pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print results of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6/6 [==============================] - 0s 998us/step\n",
      "0.7956989247311828\n",
      "0.9354838709677419\n",
      "0.946236559139785\n"
     ]
    }
   ],
   "source": [
    "pipeline_keras = fit_pipeline(X_train, y_train_ohe, preprocessor, model_keras)\n",
    "pipeline_rf = fit_pipeline(X_train, y_train_ohe, preprocessor, model_rf)\n",
    "pipeline_xgb = fit_pipeline(X_train, y_train_ohe, preprocessor, model_xgb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combine the fitted models to look if the accuracy improves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 24ms/step\n"
     ]
    }
   ],
   "source": [
    "preds1 = pipeline_keras.predict(test)\n",
    "preds2 = pipeline_rf.predict(test)\n",
    "preds3 = pipeline_xgb.predict(test)\n",
    "submission = [[0,0] for _ in range(len(preds1))]\n",
    "for y_pred1,y_pred2,y_pred3, i in zip(preds1,preds2,preds3, range(len(preds1))):\n",
    "    count_class1 = y_pred1[0] + y_pred2[0] + y_pred3[0]\n",
    "    count_class2 = y_pred1[1] + y_pred2[1] + y_pred3[1]\n",
    "    submission[i][0] = round(count_class1/(count_class1 + count_class2),2)\n",
    "    submission[i][1] = round(count_class2/(count_class1 + count_class2),2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "submission_df = pd.DataFrame()\n",
    "submission_df.insert(0, \"Id\", id_list, False)\n",
    "submission_df.insert(1, \"class_0\", [i[0] for i in submission], True)\n",
    "submission_df.insert(2, \"class_1\", [i[1] for i in submission], True)\n",
    "submission_df.to_csv(\"C:\\Projects\\kaggle\\competitions\\identify-age-related-conditions\\submissions\\submission.csv\",index = False)\n",
    "#submission_df.to_csv(\"/kaggle/working/submission.csv\",index = False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}