examples/FTTransformer多分类.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c6a2bd60",
   "metadata": {},
   "source": [
    "# FTTransformer，一个很能打的模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "382eb806",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "FTTransformer是一个可以用于结构化(tabular)数据的分类和回归任务的模型。\n",
    "\n",
    "FT 即 Feature Tokenizer的意思，把结构化数据中的离散特征和连续特征都像单词一样编码成一个向量。\n",
    "\n",
    "从而可以像对text数据那样 应用 Transformer对 Tabular数据进行特征抽取。\n",
    "\n",
    "值得注意的是，它对Transformer作了一些微妙的改动以适应 Tabular数据。\n",
    "\n",
    "例如：去除第一个Transformer输入的LayerNorm层，仿照BERT的设计增加了output token(CLS token) 与features token 一起进行进入Transformer参与注意力计算。\n",
    "\n",
    "参考: https://paperswithcode.com/method/ft-transformer\n",
    "\n",
    "本范例我们使用Covertype数据集，它的目标是预测植被覆盖类型，是一个七分类问题。\n",
    "\n",
    "公众号**算法美食屋**后台回复关键词：torchkeras，获取本文notebook源码和所用Covertype数据集下载链接。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "79c9440c-4e00-4d27-93d6-3f73c40ae149",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('..')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81c4a29a",
   "metadata": {},
   "source": [
    "## 一，准备数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "18d1cca2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dfdata.shape =  (581012, 13)\n",
      "target_col =  Cover_Type\n",
      "cat_cols =  ['Wilderness_Area', 'Soil_Type']\n",
      "num_cols =  ['Elevation', 'Aspect', 'Slope', '...']\n",
      "len(dftrain) =  371847\n",
      "len(dfval) =  92962\n",
      "len(dftest) =  116203\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import pandas as pd \n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "file_path = \"covertype.parquet\"\n",
    "dfdata = pd.read_parquet(file_path)\n",
    "\n",
    "cat_cols = ['Wilderness_Area', 'Soil_Type']\n",
    "num_cols = ['Elevation','Aspect','Slope','Horizontal_Distance_To_Hydrology',\n",
    " 'Vertical_Distance_To_Hydrology','Horizontal_Distance_To_Roadways',\n",
    " 'Hillshade_9am','Hillshade_Noon','Hillshade_3pm','Horizontal_Distance_To_Fire_Points']\n",
    "target_col = 'Cover_Type'\n",
    "\n",
    "print(\"dfdata.shape = \",dfdata.shape)\n",
    "print(\"target_col = \", target_col)\n",
    "print('cat_cols = ', cat_cols)  \n",
    "print('num_cols = ', num_cols[:3]+['...'])\n",
    "\n",
    "dftmp, dftest_raw = train_test_split(dfdata, random_state=42, test_size=0.2)\n",
    "dftrain_raw, dfval_raw = train_test_split(dftmp, random_state=42, test_size=0.2)\n",
    "\n",
    "print(\"len(dftrain) = \",len(dftrain_raw))\n",
    "print(\"len(dfval) = \",len(dfval_raw))\n",
    "print(\"len(dftest) = \",len(dftest_raw))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "169703c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3d974b6e58f34a01adb2829200624f1e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torchkeras.tabular import TabularPreprocessor\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "\n",
    "#特征工程\n",
    "pipe = TabularPreprocessor(cat_features = cat_cols, \n",
    "                           embedding_features=cat_cols)\n",
    "encoder = OrdinalEncoder()\n",
    "\n",
    "dftrain = pipe.fit_transform(dftrain_raw.drop(target_col,axis=1))\n",
    "dftrain[target_col] = encoder.fit_transform(\n",
    "    dftrain_raw[target_col].values.reshape(-1,1)).astype(np.int32)\n",
    "\n",
    "dfval = pipe.transform(dfval_raw.drop(target_col,axis=1))\n",
    "dfval[target_col] = encoder.transform(\n",
    "    dfval_raw[target_col].values.reshape(-1,1)).astype(np.int32)\n",
    "\n",
    "dftest = pipe.transform(dftest_raw.drop(target_col,axis=1))\n",
    "dftest[target_col] = encoder.transform(\n",
    "    dftest_raw[target_col].values.reshape(-1,1)).astype(np.int32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7768b968",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchkeras.tabular import TabularDataset\n",
    "from torch.utils.data import Dataset,DataLoader \n",
    "\n",
    "def get_dataset(dfdata):\n",
    "    return TabularDataset(\n",
    "                data = dfdata,\n",
    "                task = 'multiclass', #regression, binary, multiclass\n",
    "                target = [target_col],\n",
    "                continuous_cols = pipe.get_numeric_features(),\n",
    "                categorical_cols = pipe.get_embedding_features()\n",
    "        )\n",
    "\n",
    "def get_dataloader(ds,batch_size=1024,num_workers=0,shuffle=False):\n",
    "    dl = DataLoader(\n",
    "            ds,\n",
    "            batch_size=batch_size,\n",
    "            shuffle=shuffle,\n",
    "            num_workers=num_workers,\n",
    "            pin_memory=False,\n",
    "        )\n",
    "    return dl \n",
    "    \n",
    "ds_train = get_dataset(dftrain)\n",
    "ds_val = get_dataset(dfval)\n",
    "ds_test = get_dataset(dftest)\n",
    "\n",
    "dl_train = get_dataloader(ds_train,shuffle=True)\n",
    "dl_val = get_dataloader(ds_val,shuffle=False)\n",
    "dl_test = get_dataloader(ds_test,shuffle=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ec009434",
   "metadata": {},
   "outputs": [],
   "source": [
    "for batch in dl_train:\n",
    "    break\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb2f0170",
   "metadata": {},
   "source": [
    "## 二，定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "767468ab",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "from torchkeras.tabular.models import FTTransformerConfig,FTTransformerModel\n",
    "\n",
    "model_config = FTTransformerConfig(\n",
    "    task=\"multiclass\",  #regression, binary, multiclass\n",
    "    num_attn_blocks=3\n",
    ")\n",
    "\n",
    "config = model_config.merge_dataset_config(ds_train)\n",
    "net = FTTransformerModel(config = config)\n",
    "\n",
    "#初始化参数\n",
    "net.reset_weights()\n",
    "net.data_aware_initialization(dl_train)\n",
    "\n",
    "print(net.backbone.output_dim)\n",
    "print(net.hparams.output_dim)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7e312c76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.8597, grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "output = net.forward(batch)\n",
    "loss = net.compute_loss(output,batch['target'])\n",
    "print(loss)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22001eaf",
   "metadata": {},
   "source": [
    "## 三，训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "14bb01e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchkeras import KerasModel \n",
    "from torchkeras.tabular import StepRunner \n",
    "KerasModel.StepRunner = StepRunner \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "780167c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch \n",
    "from torch import nn \n",
    "class Accuracy(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.correct = nn.Parameter(torch.tensor(0.0),requires_grad=False)\n",
    "        self.total = nn.Parameter(torch.tensor(0.0),requires_grad=False)\n",
    "\n",
    "    def forward(self, preds: torch.Tensor, targets: torch.Tensor):\n",
    "        preds = preds.argmax(dim=-1)\n",
    "        targets = targets.reshape(-1)\n",
    "        m = (preds == targets).sum()\n",
    "        n = targets.shape[0] \n",
    "        self.correct += m \n",
    "        self.total += n\n",
    "        \n",
    "        return m/n\n",
    "\n",
    "    def compute(self):\n",
    "        return self.correct.float() / self.total \n",
    "    \n",
    "    def reset(self):\n",
    "        self.correct -= self.correct\n",
    "        self.total -= self.total\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d3c69f48",
   "metadata": {},
   "outputs": [],
   "source": [
    "keras_model = KerasModel(net,\n",
    "                   loss_fn=None,\n",
    "                   optimizer = torch.optim.AdamW(net.parameters(),lr = 1e-3),\n",
    "                   metrics_dict = {\"acc\":Accuracy()}\n",
    "                   )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08f4ad31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31m<<<<<< 🚀 mps is used >>>>>>\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* background: */\n",
       "    progress::-webkit-progress-bar {background-color: #CDCDCD; width: 100%;}\n",
       "    progress {background-color: #CDCDCD;}\n",
       "\n",
       "    /* value: */\n",
       "    progress::-webkit-progress-value {background-color: #00BFFF  !important;}\n",
       "    progress::-moz-progress-bar {background-color: #00BFFF  !important;}\n",
       "    progress {color: #00BFFF ;}\n",
       "\n",
       "    /* optional */\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #000000;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      <progress value='10' class='' max='20' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      50.00% [10/20] [05:06<05:06]\n",
       "      <br>\n",
       "      █████████████████▌  87.91% [320/364] [train_loss=0.3224, train_acc=0.8613, lr=0.0010]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "keras_model.fit(\n",
    "    train_data = dl_train,\n",
    "    val_data= dl_val,\n",
    "    ckpt_path='checkpoint',\n",
    "    epochs=20,\n",
    "    patience=10,\n",
    "    monitor=\"val_acc\", \n",
    "    mode=\"max\",\n",
    "    plot = True,\n",
    "    wandb = False\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "092528f3",
   "metadata": {},
   "source": [
    "## 四，评估模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15693dba",
   "metadata": {},
   "outputs": [],
   "source": [
    "keras_model.evaluate(dl_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f52f49a",
   "metadata": {},
   "outputs": [],
   "source": [
    "keras_model.evaluate(dl_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6050f49a",
   "metadata": {},
   "outputs": [],
   "source": [
    "keras_model.evaluate(dl_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced7f651",
   "metadata": {},
   "source": [
    "## 五，使用模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c3f0dd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm \n",
    "net = net.cpu()\n",
    "net.eval()\n",
    "preds = []\n",
    "with torch.no_grad():\n",
    "    for batch in tqdm(dl_test):\n",
    "        preds.append(net.predict(batch))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e330d9f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_list = [yd.argmax(dim=-1).tolist() for yd in preds]\n",
    "yhat = []\n",
    "for yd in yhat_list:\n",
    "    yhat.extend(yd)\n",
    "yhat = encoder.inverse_transform(np.array(yhat).reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac0b9cad",
   "metadata": {},
   "outputs": [],
   "source": [
    "dftest_raw = dftest_raw.rename(columns = {target_col: 'y'})\n",
    "dftest_raw['yhat'] = yhat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cd623c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_true = dftest_raw['y'],y_pred = dftest_raw['yhat']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75b5f2ee",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "\n",
    "# 计算混淆矩阵\n",
    "cm = confusion_matrix(dftest_raw['y'], dftest_raw['yhat'])\n",
    "\n",
    "# 将混淆矩阵转换为DataFrame\n",
    "df_cm = pd.DataFrame(cm, index=['Actual {}'.format(i) for i in range(cm.shape[0])],\n",
    "                     columns=['Predicted {}'.format(i) for i in range(cm.shape[1])])\n",
    "\n",
    "# 使用seaborn绘制混淆矩阵\n",
    "plt.figure(figsize=(10,7))\n",
    "sns.heatmap(df_cm, annot=True, fmt='d', cmap='Blues', cbar=False)\n",
    "plt.title('Confusion Matrix')\n",
    "plt.xlabel('Predicted labels')\n",
    "plt.ylabel('True labels')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd458bc",
   "metadata": {},
   "source": [
    "## 六，保存模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84fd68e5",
   "metadata": {},
   "source": [
    "最佳模型权重已经保存在ckpt_path = 'checkpoint'位置了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "039d1fd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "net.load_state_dict(torch.load('checkpoint',weights_only=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af119bc",
   "metadata": {},
   "source": [
    "## 七，与LightGBM对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a217aa4",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import lightgbm as lgb\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "from sklearn.metrics import accuracy_score \n",
    "\n",
    "\n",
    "dftmp, dftest_raw = train_test_split(dfdata, random_state=42, test_size=0.2)\n",
    "dftrain_raw, dfval_raw = train_test_split(dftmp, random_state=42, test_size=0.2)\n",
    "\n",
    "dftrain = dftrain_raw.copy()\n",
    "dfval = dfval_raw.copy()\n",
    "dftest = dftest_raw.copy()\n",
    "\n",
    "target_col = 'Cover_Type'\n",
    "cat_cols = ['Wilderness_Area', 'Soil_Type']\n",
    "\n",
    "encoder = OrdinalEncoder()\n",
    "\n",
    "dftrain[target_col] = encoder.fit_transform(dftrain[target_col].values.reshape(-1,1)) \n",
    "dfval[target_col] = encoder.transform(dfval[target_col].values.reshape(-1,1))\n",
    "dftest[target_col] = encoder.transform(dftest[target_col].values.reshape(-1,1))\n",
    "\n",
    "for col in cat_cols:\n",
    "    dftrain[col] = dftrain[col].astype(int)\n",
    "    dfval[col] = dfval[col].astype(int)\n",
    "    dftest[col] = dftest[col].astype(int)\n",
    "\n",
    "ds_train = lgb.Dataset(dftrain.drop(columns=[target_col]), label=dftrain[target_col],categorical_feature=cat_cols)\n",
    "ds_val = lgb.Dataset(dfval.drop(columns=[target_col]), label=dfval[target_col],categorical_feature=cat_cols)\n",
    "ds_test = lgb.Dataset(dftest.drop(columns=[target_col]), label=dftest[target_col],categorical_feature=cat_cols)\n",
    "\n",
    "\n",
    "import lightgbm as lgb\n",
    "\n",
    "params = {\n",
    "    'n_estimators':500,\n",
    "    'boosting_type': 'gbdt',\n",
    "    'objective':'multiclass',\n",
    "    'num_class': 7,  # 类别数量\n",
    "    'metric': 'multi_logloss', \n",
    "    'learning_rate': 0.01,\n",
    "    'verbose': 1,\n",
    "    'early_stopping_round':50\n",
    "}\n",
    "model = lgb.train(params, ds_train, \n",
    "        valid_sets=[ds_val], \n",
    "        valid_names=['validate']\n",
    "        )\n",
    "\n",
    "y_pred_val = model.predict(dfval.drop(target_col,axis = 1), num_iteration=model.best_iteration)\n",
    "y_pred_val = np.argmax(y_pred_val, axis=1)\n",
    "\n",
    "y_pred_test = model.predict(dftest.drop(target_col,axis = 1), num_iteration=model.best_iteration)\n",
    "y_pred_test = np.argmax(y_pred_test, axis=1)\n",
    "\n",
    "val_score = accuracy_score(dfval[target_col], y_pred_val)\n",
    "test_score = accuracy_score(dftest[target_col], y_pred_test) \n",
    "\n",
    "print('val_score = ',val_score)\n",
    "print('test_score = ' , test_score)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [],
   "dockerImageVersionId": 30747,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}