7.rnn分类文字sst2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6547c14a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "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>x</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>101,5342,2047,3595,8496,2013,1996,18643,3197,1...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>101,3397,2053,15966,1010,2069,4450,2098,18201,...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>101,2008,7459,2049,3494,1998,10639,2015,2242,2...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>101,3464,12580,8510,2000,3961,1996,2168,2802,1...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>101,2006,1996,5409,7195,1011,1997,1011,1996,10...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64995</th>\n",
       "      <td>101,1996,2569,3896,2024,1036,2446,1011,3670,29...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64996</th>\n",
       "      <td>101,8552,3494,102,0,0,0,0,0,0,0,0,0,0,0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64997</th>\n",
       "      <td>101,15299,102,0,0,0,0,0,0,0,0,0,0,0,0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64998</th>\n",
       "      <td>101,2000,4608,1996,6510,1997,2010,13805,2015,1...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64999</th>\n",
       "      <td>101,2087,5810,1010,4895,9581,20876,6024,6298,2...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>65000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                       x  y\n",
       "0      101,5342,2047,3595,8496,2013,1996,18643,3197,1...  0\n",
       "1      101,3397,2053,15966,1010,2069,4450,2098,18201,...  0\n",
       "2      101,2008,7459,2049,3494,1998,10639,2015,2242,2...  1\n",
       "3      101,3464,12580,8510,2000,3961,1996,2168,2802,1...  0\n",
       "4      101,2006,1996,5409,7195,1011,1997,1011,1996,10...  0\n",
       "...                                                  ... ..\n",
       "64995  101,1996,2569,3896,2024,1036,2446,1011,3670,29...  0\n",
       "64996            101,8552,3494,102,0,0,0,0,0,0,0,0,0,0,0  1\n",
       "64997              101,15299,102,0,0,0,0,0,0,0,0,0,0,0,0  1\n",
       "64998  101,2000,4608,1996,6510,1997,2010,13805,2015,1...  1\n",
       "64999  101,2087,5810,1010,4895,9581,20876,6024,6298,2...  0\n",
       "\n",
       "[65000 rows x 2 columns]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "#加载处理好的数据集,每句话是15个词,y是2分类,字典在data/sst2/vocab.txt\n",
    "data = pd.read_csv('data/sst2/data.csv')\n",
    "\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b855903",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(65000,\n",
       " (tensor([  101,  5342,  2047,  3595,  8496,  2013,  1996, 18643,  3197,   102,\n",
       "              0,     0,     0,     0,     0]),\n",
       "  0))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "\n",
    "#定义数据集\n",
    "class Dataset(torch.utils.data.Dataset):\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(data)\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        #取数据\n",
    "        x, y = data.iloc[i]\n",
    "\n",
    "        #以逗号分割x数据,转换为向量\n",
    "        x = [int(i) for i in x.split(',')]\n",
    "        x = torch.LongTensor(x)\n",
    "        \n",
    "        #y不需要太特别的处理\n",
    "        y = int(y)\n",
    "\n",
    "        return x, y\n",
    "\n",
    "\n",
    "dataset = Dataset()\n",
    "\n",
    "len(dataset), dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b5fd0e99",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8125,\n",
       " [tensor([[  101,  1045,  2293,  2009,  1012,  1012,  1012,  3109,  1010,  1045,\n",
       "           14145,  2080,  1012,   102,     0],\n",
       "          [  101,  2064,  3191,  1996,  4942, 27430,  1006,  1996,  3850,  2003,\n",
       "            7042,  1999,  3059,  1007,   102],\n",
       "          [  101,  7093, 11450,  2055,  2028,  2518,  1010,  2005,  2035,  2049,\n",
       "           26161,  1998, 27451,  1010,   102],\n",
       "          [  101,  5019,  1997, 21014, 15401,   102,     0,     0,     0,     0,\n",
       "               0,     0,     0,     0,     0],\n",
       "          [  101, 15594, 20957,   102,     0,     0,     0,     0,     0,     0,\n",
       "               0,     0,     0,     0,     0],\n",
       "          [  101,  1045,  1005,  1049,  3497,  2000,  2156,  2035,  2095,   102,\n",
       "               0,     0,     0,     0,     0],\n",
       "          [  101,  2878, 14045,  1998,   102,     0,     0,     0,     0,     0,\n",
       "               0,     0,     0,     0,     0],\n",
       "          [  101,  1999,  8489,  1997,  2293,  1005,  2003,  1996,  2472,  1005,\n",
       "            1055,  4958,  6590,  8458,   102]]),\n",
       "  tensor([1, 1, 1, 1, 1, 1, 1, 1])])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#数据集加载器\n",
    "loader = torch.utils.data.DataLoader(dataset=dataset,\n",
    "                                     batch_size=8,\n",
    "                                     shuffle=True,\n",
    "                                     drop_last=True)\n",
    "\n",
    "len(loader), next(iter(loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "42a20247",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 2])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#全连接神经网络\n",
    "class Model(torch.nn.Module):\n",
    "\n",
    "    #模型初始化部分\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        #词编码层,30522是词的数量,每个词会被编码为100维的向量\n",
    "        self.embed = torch.nn.Embedding(num_embeddings=30522,\n",
    "                                        embedding_dim=100)\n",
    "\n",
    "        #RNN单元\n",
    "        self.cell = torch.nn.GRUCell(input_size=100, hidden_size=512)\n",
    "\n",
    "        #线性输出\n",
    "        self.fc = torch.nn.Linear(in_features=512, out_features=2)\n",
    "\n",
    "    #定义神经网络计算过程\n",
    "    def forward(self, x):\n",
    "\n",
    "        #每个词编码为100维的向量\n",
    "        #[8, 15] -> [8, 15, 100]\n",
    "        x = self.embed(x)\n",
    "\n",
    "        #初始记忆为空\n",
    "        h = None\n",
    "\n",
    "        #从前向后读句子中的每一个词\n",
    "        for i in range(x.shape[1]):\n",
    "            #[8, 100],[8, 512] -> [8, 512]\n",
    "            h = self.cell(x[:, i], h)\n",
    "\n",
    "        #根据最后一个词的记忆,分类整句话\n",
    "        #[8, 512] -> [8, 2]\n",
    "        return self.fc(h)\n",
    "\n",
    "\n",
    "model = Model()\n",
    "\n",
    "model(torch.ones(8, 15).long()).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "233d2672",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0.6832275986671448 0.625\n",
      "0 2000 0.9678245186805725 0.5\n",
      "0 4000 0.5564815998077393 0.625\n",
      "0 6000 0.3704407811164856 0.875\n",
      "0 8000 0.7264536619186401 0.75\n",
      "1 0 0.5351651310920715 0.625\n",
      "1 2000 0.7487736940383911 0.625\n",
      "1 4000 0.4652150869369507 0.75\n",
      "1 6000 0.3317089378833771 0.875\n",
      "1 8000 0.12732546031475067 1.0\n"
     ]
    }
   ],
   "source": [
    "#训练\n",
    "def train():\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
    "    loss_fun = torch.nn.CrossEntropyLoss()\n",
    "    model.train()\n",
    "\n",
    "    for epoch in range(2):\n",
    "        for i, (x, y) in enumerate(loader):\n",
    "            out = model(x)\n",
    "            loss = loss_fun(out, y)\n",
    "\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            if i % 2000 == 0:\n",
    "                acc = (out.argmax(dim=1) == y).sum().item() / len(y)\n",
    "                print(epoch, i, loss.item(), acc)\n",
    "\n",
    "    torch.save(model, 'model/7.model')\n",
    "\n",
    "\n",
    "train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4a1135ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8325\n"
     ]
    }
   ],
   "source": [
    "#测试\n",
    "@torch.no_grad()\n",
    "def test():\n",
    "    model = torch.load('model/7.model')\n",
    "    model.eval()\n",
    "\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for i in range(100):\n",
    "        x, y = next(iter(loader))\n",
    "\n",
    "        out = model(x).argmax(dim=1)\n",
    "\n",
    "        correct += (out == y).sum().item()\n",
    "        total += len(y)\n",
    "\n",
    "    print(correct / total)\n",
    "\n",
    "\n",
    "test()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pt2]",
   "language": "python",
   "name": "conda-env-pt2-py"
  },
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}