ljh.ipynb

{
 "metadata": {
  "kernelspec": {
   "language": "python",
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.13",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kaggle": {
   "accelerator": "nvidiaTeslaT4",
   "dataSources": [
    {
     "sourceId": 8845957,
     "sourceType": "datasetVersion",
     "datasetId": 5250097
    },
    {
     "sourceId": 8856983,
     "sourceType": "datasetVersion",
     "datasetId": 5331862
    }
   ],
   "dockerImageVersionId": 30733,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook",
   "isGpuEnabled": true
  }
 },
 "nbformat_minor": 4,
 "nbformat": 4,
 "cells": [
  {
   "cell_type": "code",
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, Dataset, Subset\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from sklearn.metrics import f1_score\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "from collections import Counter\n",
    "from torchtext.vocab import vocab\n",
    "from torch.cuda.amp import GradScaler, autocast"
   ],
   "metadata": {
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "execution": {
     "iopub.status.busy": "2024-07-04T04:06:26.977823Z",
     "iopub.execute_input": "2024-07-04T04:06:26.978461Z",
     "iopub.status.idle": "2024-07-04T04:06:31.125458Z",
     "shell.execute_reply.started": "2024-07-04T04:06:26.978408Z",
     "shell.execute_reply": "2024-07-04T04:06:31.124640Z"
    },
    "trusted": true
   },
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "train_df = pd.read_csv('/kaggle/input/newstextclassification/train_set.csv', sep='\\t')"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T04:10:41.135221Z",
     "iopub.execute_input": "2024-07-04T04:10:41.135610Z",
     "iopub.status.idle": "2024-07-04T04:11:00.045647Z",
     "shell.execute_reply.started": "2024-07-04T04:10:41.135556Z",
     "shell.execute_reply": "2024-07-04T04:11:00.044384Z"
    },
    "trusted": true
   },
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def tokenizer(text):\n",
    "    \"\"\"由于加密后的数据由空格隔开，所以此函数就是split()\"\"\"\n",
    "    return text.split()\n",
    "\n",
    "def build_vocab(train, min_freq):\n",
    "    all_text = ' '.join(train['text'])  # 将所有token组合在一起\n",
    "    c = Counter(tokenizer(all_text))  # 统计token频率\n",
    "    sorted_tokens = dict(c.most_common())  # vocab的输入需要是字典，most_common和sorted一样\n",
    "    # 创建vocab，设置最小频率，\n",
    "    v = vocab(sorted_tokens, min_freq=min_freq, specials=['<pad>','<unk>'])\n",
    "    v.set_default_index(v['<unk>'])  # 如果不在词汇表，则映射到<unk>\n",
    "    return v\n",
    "\n",
    "train_df = pd.read_csv('/kaggle/input/newstextclassification/train_set.csv', sep='\\t')\n",
    "min_freq = 5  # 忽略出现频率小于5的词\n",
    "my_vocab = build_vocab(train_df, min_freq)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:36:02.399649Z",
     "iopub.execute_input": "2024-07-03T23:36:02.399948Z",
     "iopub.status.idle": "2024-07-03T23:36:43.160278Z",
     "shell.execute_reply.started": "2024-07-03T23:36:02.399922Z",
     "shell.execute_reply": "2024-07-03T23:36:43.159290Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class MyDataset(Dataset):\n",
    "    def __init__(self, dataframe):\n",
    "        self.texts = dataframe['text'].tolist()\n",
    "        self.labels = dataframe['label'].tolist()\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        return my_vocab(tokenizer(self.texts[idx])), int(self.labels[idx])\n",
    "    \n",
    "def collate_batch(batch):\n",
    "    label_list, text_list, lengths = [], [], []\n",
    "    for _text, _label in batch:\n",
    "        label_list.append(_label)\n",
    "        processed_text = torch.tensor(_text, dtype=torch.int64)\n",
    "        text_list.append(processed_text)\n",
    "        lengths.append(processed_text.size(0))\n",
    "    label_list = torch.tensor(label_list, dtype=torch.float)\n",
    "    # 这里要写batch_first=True，表示按照batch进行填充，即一个text一个text填充\n",
    "    text_list = pad_sequence(text_list, padding_value=my_vocab[\"<pad>\"], batch_first=True)\n",
    "    lengths = torch.tensor(lengths, dtype=torch.int64)\n",
    "    return text_list, label_list, lengths"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:36:43.162867Z",
     "iopub.execute_input": "2024-07-03T23:36:43.163322Z",
     "iopub.status.idle": "2024-07-03T23:36:43.172099Z",
     "shell.execute_reply.started": "2024-07-03T23:36:43.163295Z",
     "shell.execute_reply": "2024-07-03T23:36:43.171271Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class BiLSTM(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout):\n",
    "        super(BiLSTM, self).__init__()\n",
    "        \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout, batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_dim * 2, output_dim)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, text, text_lengths):\n",
    "        embedded = self.dropout(self.embedding(text))\n",
    "        \n",
    "        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths.cpu(), batch_first=True, enforce_sorted=False)\n",
    "        packed_output, (hidden, cell) = self.lstm(packed_embedded)\n",
    "        output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)\n",
    "        \n",
    "        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1))\n",
    "        return self.fc(hidden)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:36:43.173166Z",
     "iopub.execute_input": "2024-07-03T23:36:43.173452Z",
     "iopub.status.idle": "2024-07-03T23:36:43.189105Z",
     "shell.execute_reply.started": "2024-07-03T23:36:43.173430Z",
     "shell.execute_reply": "2024-07-03T23:36:43.188352Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def train(model, dataloader, optimizer, criterion, device):\n",
    "    model.train()\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    scaler = GradScaler()\n",
    "    \n",
    "    for text, labels, lengths in tqdm(dataloader, desc=\"Train\", leave=False):\n",
    "#     for text, labels, lengths in dataloader:\n",
    "        text, labels, lengths = text.to(device), labels.to(device), lengths.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        with autocast(enabled=True, dtype=torch.float16):\n",
    "            predictions = model(text, lengths)\n",
    "            loss = criterion(predictions, labels.long())\n",
    "        \n",
    "        scaler.scale(loss).backward()\n",
    "        scaler.step(optimizer)\n",
    "        scaler.update()\n",
    "        \n",
    "        epoch_loss += loss.item()\n",
    "    return epoch_loss / len(dataloader)\n",
    "    \n",
    "    \n",
    "def evaluate(model, dataloader, criterion, device):\n",
    "    model.eval()\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    all_predictions = []\n",
    "    all_true_labels = []\n",
    "    with torch.no_grad():\n",
    "        for text, labels, lengths in dataloader:\n",
    "            text, labels, lengths = text.to(device), labels.to(device), lengths.to(device)\n",
    "            \n",
    "            predictions = model(text, lengths)\n",
    "            loss = criterion(predictions, labels.long())\n",
    "            \n",
    "            epoch_loss += loss.item()\n",
    "            \n",
    "            correct = torch.argmax(predictions, dim=1)\n",
    "            all_predictions.extend(correct.cpu().numpy())\n",
    "            all_true_labels.extend(labels.cpu().numpy())\n",
    "\n",
    "        f1 = f1_score(all_true_labels, all_predictions, average='macro')\n",
    "        print(f\"模型在未见数据集上的f1分数: {f1}\")\n",
    "    return epoch_loss / len(dataloader), f1"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:42:24.847064Z",
     "iopub.execute_input": "2024-07-03T23:42:24.847428Z",
     "iopub.status.idle": "2024-07-03T23:42:24.859364Z",
     "shell.execute_reply.started": "2024-07-03T23:42:24.847399Z",
     "shell.execute_reply": "2024-07-03T23:42:24.858437Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "seed = 123\n",
    "torch.manual_seed(seed)\n",
    "dataset = MyDataset(train_df)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:36:43.204589Z",
     "iopub.execute_input": "2024-07-03T23:36:43.204866Z",
     "iopub.status.idle": "2024-07-03T23:36:43.287213Z",
     "shell.execute_reply.started": "2024-07-03T23:36:43.204842Z",
     "shell.execute_reply": "2024-07-03T23:36:43.286347Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "seed = 123\n",
    "torch.manual_seed(seed)\n",
    "dataset = MyDataset(train_df)\n",
    "\n",
    "INPUT_DIM = len(my_vocab)\n",
    "EMBEDDING_DIM = 100\n",
    "HIDDEN_DIM = 256\n",
    "OUTPUT_DIM = 14\n",
    "N_LAYERS = 2\n",
    "BIDIRECTIONAL = True\n",
    "DROPOUT = 0.5\n",
    "lr = 0.0003\n",
    "\n",
    "sss = StratifiedShuffleSplit(n_splits=1, test_size=0.1, random_state=seed)\n",
    "epochs = 40\n",
    "batch_size = 32"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:40:23.774495Z",
     "iopub.execute_input": "2024-07-03T23:40:23.774842Z",
     "iopub.status.idle": "2024-07-03T23:40:23.780687Z",
     "shell.execute_reply.started": "2024-07-03T23:40:23.774816Z",
     "shell.execute_reply": "2024-07-03T23:40:23.779715Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "model = BiLSTM(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, BIDIRECTIONAL, DROPOUT)\n",
    "model = nn.DataParallel(model)\n",
    "model.to(device)\n",
    "optimizer = optim.Adam(model.parameters(), lr=lr)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "patience = 0\n",
    "best_loss = float('inf')\n",
    "best_f1 = float('0')\n",
    "stop_count = 15\n",
    "for train_index, test_index in sss.split(dataset.texts, dataset.labels):\n",
    "    train_loader = DataLoader(Subset(dataset, train_index), batch_size=batch_size, shuffle=True, collate_fn=collate_batch)\n",
    "    test_loader = DataLoader(Subset(dataset, test_index), batch_size=batch_size, shuffle=False, collate_fn=collate_batch)\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        train_loss = train(model, train_loader, optimizer, criterion, device)\n",
    "        valid_loss, f1 = evaluate(model, test_loader, criterion, device)\n",
    "        print(f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}, Val. Loss: {valid_loss:.3f}')\n",
    "\n",
    "        # 早停\n",
    "#         if valid_loss < best_loss:\n",
    "#             best_loss = valid_loss\n",
    "#             patience = 0\n",
    "# #             torch.save(model.module.state_dict(), f'BiLNoCut_256_{epoch+1}_{valid_loss:.3f}_{f1:.3f}.pth')\n",
    "#             torch.save(model.state_dict(), f'CBLA_256_{epoch+1}_{valid_loss:.3f}_{f1:.3f}.pth')\n",
    "        if f1 > best_f1:\n",
    "            best_f1 = f1\n",
    "            patience = 0\n",
    "            torch.save(model.module.state_dict(),  f'BiLSTM_{f1:.3f}_{valid_loss:.3f}.pth')\n",
    "#             torch.save(model.state_dict(), f'BiLSTM_{f1:.3f}_{valid_loss:.3f}.pth')\n",
    "        else:\n",
    "            patience += 1\n",
    "            if patience >= stop_count:\n",
    "                print(\"early stop!\")\n",
    "                break"
   ],
   "metadata": {
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "torch.cuda.empty_cache()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-03T23:40:32.537628Z",
     "iopub.execute_input": "2024-07-03T23:40:32.538288Z",
     "iopub.status.idle": "2024-07-03T23:40:32.606547Z",
     "shell.execute_reply.started": "2024-07-03T23:40:32.538257Z",
     "shell.execute_reply": "2024-07-03T23:40:32.605395Z"
    },
    "trusted": true
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "import pandas as pd\n",
    "from collections import Counter\n",
    "from torchtext.vocab import vocab\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import random_split, DataLoader, Dataset, Subset\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "from torch.cuda.amp import GradScaler, autocast\n",
    "from tqdm import tqdm\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from sklearn.metrics import f1_score\n",
    "import os\n",
    "import json"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:36:36.340148Z",
     "iopub.execute_input": "2024-07-04T10:36:36.340546Z",
     "iopub.status.idle": "2024-07-04T10:36:43.499035Z",
     "shell.execute_reply.started": "2024-07-04T10:36:36.340516Z",
     "shell.execute_reply": "2024-07-04T10:36:43.498230Z"
    },
    "trusted": true
   },
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def tokenizer(text):\n",
    "    \"\"\"由于加密后的数据由空格隔开，所以此函数就是split()\"\"\"\n",
    "    return text.split()\n",
    "\n",
    "def build_vocab(min_freq):\n",
    "    token_path = '/kaggle/input/newstextclassification/sorted_token.json'\n",
    "    train = None\n",
    "    if os.path.exists(token_path):\n",
    "        with open(token_path, 'r') as fp:\n",
    "            sorted_tokens = json.load(fp)\n",
    "    else:\n",
    "        all_text = ' '.join(train['text'])  # 将所有token组合在一起\n",
    "        c = Counter(tokenizer(all_text))  # 统计token频率\n",
    "        sorted_tokens = dict(c.most_common())  # vocab的输入需要是字典，most_common和sorted一样\n",
    "    # 创建vocab，设置最小频率，\n",
    "    v = vocab(sorted_tokens, min_freq=min_freq, specials=['<pad>','<unk>'])\n",
    "    v.set_default_index(v['<unk>'])  # 如果不在词汇表，则映射到<unk>\n",
    "    return v\n",
    "\n",
    "min_freq = 5  # 忽略出现次数低于此值的字\n",
    "my_vocab = build_vocab(min_freq)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:47:40.589314Z",
     "iopub.execute_input": "2024-07-04T10:47:40.590043Z",
     "iopub.status.idle": "2024-07-04T10:47:40.686549Z",
     "shell.execute_reply.started": "2024-07-04T10:47:40.590011Z",
     "shell.execute_reply": "2024-07-04T10:47:40.685729Z"
    },
    "trusted": true
   },
   "execution_count": 17,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "len(my_vocab)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:47:48.582574Z",
     "iopub.execute_input": "2024-07-04T10:47:48.582934Z",
     "iopub.status.idle": "2024-07-04T10:47:48.589645Z",
     "shell.execute_reply.started": "2024-07-04T10:47:48.582905Z",
     "shell.execute_reply": "2024-07-04T10:47:48.588639Z"
    },
    "trusted": true
   },
   "execution_count": 18,
   "outputs": [
    {
     "execution_count": 18,
     "output_type": "execute_result",
     "data": {
      "text/plain": "6038"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "class TestDataset(Dataset):\n",
    "    def __init__(self, dataframe):\n",
    "        self.texts = dataframe['text'].tolist()\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.texts)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        return my_vocab(tokenizer(self.texts[idx]))\n",
    "    \n",
    "def collate_batch(batch):\n",
    "    text_list, lengths = [], []\n",
    "    for _text in batch:\n",
    "        processed_text = torch.tensor(_text, dtype=torch.int64)\n",
    "        text_list.append(processed_text)\n",
    "        lengths.append(processed_text.size(0))\n",
    "    # 这里要写batch_first=True，表示按照batch进行填充，即一个text一个text填充\n",
    "    text_list = pad_sequence(text_list, padding_value=my_vocab[\"<pad>\"], batch_first=True)\n",
    "    lengths = torch.tensor(lengths, dtype=torch.int64)\n",
    "    return text_list, lengths"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:49:15.955569Z",
     "iopub.execute_input": "2024-07-04T10:49:15.956518Z",
     "iopub.status.idle": "2024-07-04T10:49:15.964785Z",
     "shell.execute_reply.started": "2024-07-04T10:49:15.956477Z",
     "shell.execute_reply": "2024-07-04T10:49:15.963840Z"
    },
    "trusted": true
   },
   "execution_count": 25,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class BiLSTM(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout):\n",
    "        super(BiLSTM, self).__init__()\n",
    "        \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout, batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_dim * 2, output_dim)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, text, text_lengths):\n",
    "        embedded = self.dropout(self.embedding(text))\n",
    "        \n",
    "        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths.cpu(), batch_first=True, enforce_sorted=False)\n",
    "        packed_output, (hidden, cell) = self.lstm(packed_embedded)\n",
    "        output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)\n",
    "        \n",
    "        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1))\n",
    "        return self.fc(hidden)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:47:53.054494Z",
     "iopub.execute_input": "2024-07-04T10:47:53.055133Z",
     "iopub.status.idle": "2024-07-04T10:47:53.063847Z",
     "shell.execute_reply.started": "2024-07-04T10:47:53.055101Z",
     "shell.execute_reply": "2024-07-04T10:47:53.062948Z"
    },
    "trusted": true
   },
   "execution_count": 20,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "INPUT_DIM = len(my_vocab)\n",
    "EMBEDDING_DIM = 100\n",
    "HIDDEN_DIM = 256\n",
    "OUTPUT_DIM = 14\n",
    "N_LAYERS = 2\n",
    "BIDIRECTIONAL = True\n",
    "DROPOUT = 0.5\n",
    "\n",
    "\n",
    "epochs = 40\n",
    "batch_size = 32"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:47:54.170532Z",
     "iopub.execute_input": "2024-07-04T10:47:54.171347Z",
     "iopub.status.idle": "2024-07-04T10:47:54.175917Z",
     "shell.execute_reply.started": "2024-07-04T10:47:54.171313Z",
     "shell.execute_reply": "2024-07-04T10:47:54.174954Z"
    },
    "trusted": true
   },
   "execution_count": 21,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "test_df = pd.read_csv('/kaggle/input/newstextclassification/test_a.csv', sep='\\t')\n",
    "device = torch.device('cuda')"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:47:56.089258Z",
     "iopub.execute_input": "2024-07-04T10:47:56.089954Z",
     "iopub.status.idle": "2024-07-04T10:47:58.235257Z",
     "shell.execute_reply.started": "2024-07-04T10:47:56.089927Z",
     "shell.execute_reply": "2024-07-04T10:47:58.234482Z"
    },
    "trusted": true
   },
   "execution_count": 22,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def test_a(path, dataset):\n",
    "    model = BiLSTM(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, BIDIRECTIONAL, DROPOUT)\n",
    "\n",
    "    \n",
    "    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_batch)\n",
    "    \n",
    "\n",
    "    model.load_state_dict(torch.load(path))\n",
    "    model = nn.DataParallel(model)\n",
    "\n",
    "    model.to(device)\n",
    "    model.eval()\n",
    "    \n",
    "    rest = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for text, lengths in tqdm(dataloader, desc=\"Train\", leave=False):\n",
    "\n",
    "            text, lengths = text.to(device), lengths.to(device)\n",
    "\n",
    "            predictions = model(text, lengths)\n",
    "\n",
    "            correct = predictions.argmax(dim=1, keepdim=True).squeeze(1)\n",
    "            rest.extend(correct.tolist())\n",
    "    return rest\n",
    "\n",
    "dataset = TestDataset(test_df)\n",
    "res = test_a('/kaggle/input/bimodel/BiLSTM_0.957_0.132.pth', dataset)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:50:31.635978Z",
     "iopub.execute_input": "2024-07-04T10:50:31.636602Z",
     "iopub.status.idle": "2024-07-04T10:54:55.290294Z",
     "shell.execute_reply.started": "2024-07-04T10:50:31.636569Z",
     "shell.execute_reply": "2024-07-04T10:54:55.289377Z"
    },
    "trusted": true
   },
   "execution_count": 28,
   "outputs": [
    {
     "name": "stderr",
     "text": "                                                          \r",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "sub = pd.DataFrame()\n",
    "sub['label'] = res\n",
    "sub.to_csv('sub.csv', index=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:55:02.221841Z",
     "iopub.execute_input": "2024-07-04T10:55:02.222502Z",
     "iopub.status.idle": "2024-07-04T10:55:02.308492Z",
     "shell.execute_reply.started": "2024-07-04T10:55:02.222469Z",
     "shell.execute_reply": "2024-07-04T10:55:02.307691Z"
    },
    "trusted": true
   },
   "execution_count": 29,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "sub.head()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-07-04T10:55:07.731716Z",
     "iopub.execute_input": "2024-07-04T10:55:07.732753Z",
     "iopub.status.idle": "2024-07-04T10:55:07.747558Z",
     "shell.execute_reply.started": "2024-07-04T10:55:07.732719Z",
     "shell.execute_reply": "2024-07-04T10:55:07.746741Z"
    },
    "trusted": true
   },
   "execution_count": 30,
   "outputs": [
    {
     "execution_count": 30,
     "output_type": "execute_result",
     "data": {
      "text/plain": "   label\n0      1\n1      2\n2      8\n3      5\n4      0",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>label</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>8</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "metadata": {}
    }
   ]
  }
 ]
}