aiqiyi-baseline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1 导入包 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "# 常用包\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "# 导入torch\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from pylab import rcParams\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch import nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from tqdm import tqdm\n",
    "# 导入transformers\n",
    "from transformers import BertModel, BertTokenizer, AdamW, get_linear_schedule_with_warmup\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format='retina' # 主题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sns.set(style='whitegrid', palette='muted', font_scale=1.2)\n",
    "\n",
    "HAPPY_COLORS_PALETTE = [\"#01BEFE\", \"#FFDD00\", \"#FF7D00\", \"#FF006D\", \"#ADFF02\", \"#8F00FF\"]\n",
    "\n",
    "sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))\n",
    "\n",
    "rcParams['figure.figsize'] = 12, 8\n",
    "\n",
    "RANDOM_SEED = 42\n",
    "np.random.seed(RANDOM_SEED)\n",
    "torch.manual_seed(RANDOM_SEED)\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 42790/42790 [00:00<00:00, 1068986.42it/s]\n"
     ]
    }
   ],
   "source": [
    "with open('data/train_dataset_v2.tsv', 'r', encoding='utf-8') as handler:\n",
    "    lines = handler.read().split('\\n')[1:-1]\n",
    "\n",
    "    data = list()\n",
    "    for line in tqdm(lines):\n",
    "        sp = line.split('\\t')\n",
    "        if len(sp) != 4:\n",
    "            print(\"ERROR:\", sp)\n",
    "            continue\n",
    "        data.append(sp)\n",
    "\n",
    "train = pd.DataFrame(data)\n",
    "train.columns = ['id', 'content', 'character', 'emotions']\n",
    "\n",
    "test = pd.read_csv('data/test_dataset.tsv', sep='\\t')\n",
    "submit = pd.read_csv('data/submit_example.tsv', sep='\\t')\n",
    "train = train[train['emotions'] != '']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3 数据预处理处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 文本拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train['text'] = train[ 'content'].astype(str)  +'角色: ' + train['character'].astype(str)\n",
    "test['text'] = test['content'].astype(str) + ' 角色: ' + test['character'].astype(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2  标签转换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train['emotions'] = train['emotions'].apply(lambda x: [int(_i) for _i in x.split(',')])\n",
    "\n",
    "train[['love', 'joy', 'fright', 'anger', 'fear', 'sorrow']] = train['emotions'].values.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "test[['love', 'joy', 'fright', 'anger', 'fear', 'sorrow']] =[0,0,0,0,0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    35500\n",
       "1      527\n",
       "3      409\n",
       "2      346\n",
       "Name: love, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['love'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>id</th>\n",
       "      <th>content</th>\n",
       "      <th>character</th>\n",
       "      <th>emotions</th>\n",
       "      <th>text</th>\n",
       "      <th>love</th>\n",
       "      <th>joy</th>\n",
       "      <th>fright</th>\n",
       "      <th>anger</th>\n",
       "      <th>fear</th>\n",
       "      <th>sorrow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1171_0001_A_1</td>\n",
       "      <td>天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。</td>\n",
       "      <td>o2</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0]</td>\n",
       "      <td>内容: 天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1171_0001_A_2</td>\n",
       "      <td>天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。</td>\n",
       "      <td>c1</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0]</td>\n",
       "      <td>内容: 天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1171_0001_A_3</td>\n",
       "      <td>o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。</td>\n",
       "      <td>o2</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0]</td>\n",
       "      <td>内容: o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。角色: o2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1171_0001_A_4</td>\n",
       "      <td>o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。</td>\n",
       "      <td>c1</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0]</td>\n",
       "      <td>内容: o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。角色: c1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1171_0001_A_5</td>\n",
       "      <td>o2停下来接过c1手里的行李：你妈妈交待我了，等领了军装一定要照张相寄回去，让街坊邻居都知道...</td>\n",
       "      <td>o2</td>\n",
       "      <td>[0, 0, 0, 0, 0, 0]</td>\n",
       "      <td>内容: o2停下来接过c1手里的行李：你妈妈交待我了，等领了军装一定要照张相寄回去，让街坊...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              id                                            content character  \\\n",
       "0  1171_0001_A_1          天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。        o2   \n",
       "1  1171_0001_A_2          天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。        c1   \n",
       "2  1171_0001_A_3                       o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。        o2   \n",
       "3  1171_0001_A_4                       o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。        c1   \n",
       "4  1171_0001_A_5  o2停下来接过c1手里的行李：你妈妈交待我了，等领了军装一定要照张相寄回去，让街坊邻居都知道...        o2   \n",
       "\n",
       "             emotions                                               text  \\\n",
       "0  [0, 0, 0, 0, 0, 0]   内容: 天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。...   \n",
       "1  [0, 0, 0, 0, 0, 0]   内容: 天空下着暴雨，o2正在给c1穿雨衣，他自己却只穿着单薄的军装，完全暴露在大雨之中。...   \n",
       "2  [0, 0, 0, 0, 0, 0]             内容: o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。角色: o2   \n",
       "3  [0, 0, 0, 0, 0, 0]             内容: o2一手拿着一个行李，一路小跑着把c1带到了文工团门口。角色: c1   \n",
       "4  [0, 0, 0, 0, 0, 0]   内容: o2停下来接过c1手里的行李：你妈妈交待我了，等领了军装一定要照张相寄回去，让街坊...   \n",
       "\n",
       "   love  joy  fright  anger  fear  sorrow  \n",
       "0     0    0       0      0     0       0  \n",
       "1     0    0       0      0     0       0  \n",
       "2     0    0       0      0     0       0  \n",
       "3     0    0       0      0     0       0  \n",
       "4     0    0       0      0     0       0  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  4 加载Tokenizer\n",
    "> Byte Pair Encoding（BPE）/WordPiece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "PRE_TRAINED_MODEL_NAME = 'hfl/chinese-roberta-wwm-ext'\n",
    "tokenizer = BertTokenizer.from_pretrained(PRE_TRAINED_MODEL_NAME)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 选取文本最大长度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 36782/36782 [00:11<00:00, 3175.47it/s]\n"
     ]
    }
   ],
   "source": [
    "token_lens = []\n",
    "\n",
    "for txt in tqdm(train.text):\n",
    "    tokens = tokenizer.encode(txt, max_length=512)\n",
    "    token_lens.append(len(tokens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\ProgramData\\Anaconda3\\lib\\site-packages\\seaborn\\distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 487,
       "width": 743
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(token_lens)\n",
    "plt.xlim([0, 256]);\n",
    "plt.xlabel('Token count');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到大多数文本的ids长度在300我们设置最大长度为300"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    36782.000000\n",
       "mean        33.464194\n",
       "std         21.365152\n",
       "min         11.000000\n",
       "25%         21.000000\n",
       "50%         28.000000\n",
       "75%         39.000000\n",
       "max        417.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(token_lens).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_LEN=128 # 这里我们暂时选定128"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5 构建学术论文数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_cols=['love', 'joy', 'fright', 'anger', 'fear', 'sorrow']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 自定义数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RoleDataset(Dataset):\n",
    "    def __init__(self,texts,labels,tokenizer,max_len):\n",
    "        self.texts=texts\n",
    "        self.labels=labels\n",
    "        self.tokenizer=tokenizer\n",
    "        self.max_len=max_len\n",
    "    def __len__(self):\n",
    "        return len(self.texts)\n",
    "    \n",
    "    def __getitem__(self,item):\n",
    "        \"\"\"\n",
    "        item 为数据索引，迭代取第item条数据\n",
    "        \"\"\"\n",
    "        text=str(self.texts[item])\n",
    "        label=self.labels[item]\n",
    "        \n",
    "        encoding=self.tokenizer.encode_plus(\n",
    "            text,\n",
    "            add_special_tokens=True,\n",
    "            max_length=self.max_len,\n",
    "            return_token_type_ids=True,\n",
    "            pad_to_max_length=True,\n",
    "            return_attention_mask=True,\n",
    "            return_tensors='pt',\n",
    "        )\n",
    "        \n",
    "#         print(encoding['input_ids'])\n",
    "        sample = {\n",
    "            'texts': text,\n",
    "            'input_ids': encoding['input_ids'].flatten(),\n",
    "            'attention_mask': encoding['attention_mask'].flatten()\n",
    "        }\n",
    "        for label_col in target_cols:\n",
    "            sample[label_col] = torch.tensor(label[label_col], dtype=torch.float)\n",
    "        return sample\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 划分数据集并创建生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train, df_val = train_test_split(train, test_size=0.1, random_state=RANDOM_SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data_loader(df,tokenizer,max_len,batch_size):\n",
    "    ds=RoleDataset(\n",
    "        texts=df['text'].values,\n",
    "        labels=df[target_cols].to_dict('records'),\n",
    "        tokenizer=tokenizer,\n",
    "        max_len=max_len\n",
    "    )\n",
    "    \n",
    "    return DataLoader(\n",
    "        ds,\n",
    "        batch_size=batch_size,\n",
    "#         num_workers=4 # windows多线程\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 16\n",
    "\n",
    "train_data_loader = create_data_loader(df_train, tokenizer, MAX_LEN, BATCH_SIZE)\n",
    "val_data_loader = create_data_loader(df_val, tokenizer, MAX_LEN, BATCH_SIZE)\n",
    "# test_data_loader = create_data_loader(df_test, tokenizer, MAX_LEN, BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['texts', 'input_ids', 'attention_mask', 'love', 'joy', 'fright', 'anger', 'fear', 'sorrow'])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = next(iter(train_data_loader))\n",
    "data.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([16, 128])\n",
      "torch.Size([16, 128])\n",
      "torch.Size([16])\n"
     ]
    }
   ],
   "source": [
    "print(data['input_ids'].shape)\n",
    "print(data['attention_mask'].shape)\n",
    "print(data['love'].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 多目标回归模型构建"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at hfl/chinese-roberta-wwm-ext were not used when initializing BertModel: ['cls.predictions.decoder.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "bert_model = BertModel.from_pretrained(PRE_TRAINED_MODEL_NAME)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义分类模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EmotionClassifier(nn.Module):\n",
    "    def __init__(self, n_classes):\n",
    "        super(EmotionClassifier, self).__init__()\n",
    "        self.bert = BertModel.from_pretrained(PRE_TRAINED_MODEL_NAME)\n",
    "        self.out_love = nn.Linear(self.bert.config.hidden_size, n_classes)\n",
    "        self.out_joy = nn.Linear(self.bert.config.hidden_size, n_classes)\n",
    "        self.out_fright = nn.Linear(self.bert.config.hidden_size, n_classes)\n",
    "        self.out_anger = nn.Linear(self.bert.config.hidden_size, n_classes)\n",
    "        self.out_fear = nn.Linear(self.bert.config.hidden_size, n_classes)\n",
    "        self.out_sorrow = nn.Linear(self.bert.config.hidden_size, n_classes)\n",
    "    def forward(self, input_ids, attention_mask):\n",
    "        _, pooled_output = self.bert(\n",
    "            input_ids=input_ids,\n",
    "            attention_mask=attention_mask,\n",
    "            return_dict = False\n",
    "        )\n",
    "        love = self.out_love(pooled_output)\n",
    "        joy = self.out_joy(pooled_output)\n",
    "        fright = self.out_fright(pooled_output)\n",
    "        anger = self.out_anger(pooled_output)\n",
    "        fear = self.out_fear(pooled_output)\n",
    "        sorrow = self.out_sorrow(pooled_output)\n",
    "        return {\n",
    "            'love': love, 'joy': joy, 'fright': fright,\n",
    "            'anger': anger, 'fear': fear, 'sorrow': sorrow,\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class_names=train.love.unique()\n",
    "class_names=[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at hfl/chinese-roberta-wwm-ext were not used when initializing BertModel: ['cls.predictions.decoder.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "model = EmotionClassifier(len(class_names))\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7 模型训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCHS = 1 # 训练轮数\n",
    "\n",
    "optimizer = AdamW(model.parameters(), lr=3e-5, correct_bias=False)\n",
    "total_steps = len(train_data_loader) * EPOCHS\n",
    "\n",
    "scheduler = get_linear_schedule_with_warmup(\n",
    "  optimizer,\n",
    "  num_warmup_steps=0,\n",
    "  num_training_steps=total_steps\n",
    ")\n",
    "\n",
    "loss_fn = nn.MSELoss().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(\n",
    "  model, \n",
    "  data_loader, \n",
    "  criterion, \n",
    "  optimizer, \n",
    "  device, \n",
    "  scheduler, \n",
    "  n_examples\n",
    "):\n",
    "    model = model.train()\n",
    "    losses = []\n",
    "    correct_predictions = 0\n",
    "    for sample in tqdm(data_loader):\n",
    "        input_ids = sample[\"input_ids\"].to(device)\n",
    "        attention_mask = sample[\"attention_mask\"].to(device)\n",
    "        outputs = model(\n",
    "            input_ids=input_ids,\n",
    "            attention_mask=attention_mask\n",
    "        )\n",
    "        loss_love = criterion(outputs['love'], sample['love'].to(device))\n",
    "        loss_joy = criterion(outputs['joy'], sample['joy'].to(device))\n",
    "        loss_fright = criterion(outputs['fright'], sample['fright'].to(device))\n",
    "        loss_anger = criterion(outputs['anger'], sample['anger'].to(device))\n",
    "        loss_fear = criterion(outputs['fear'], sample['fear'].to(device))\n",
    "        loss_sorrow = criterion(outputs['sorrow'], sample['sorrow'].to(device))\n",
    "        loss = loss_love + loss_joy + loss_fright + loss_anger + loss_fear + loss_sorrow\n",
    "        \n",
    "        \n",
    "        losses.append(loss.item())\n",
    "        loss.backward()\n",
    "        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
    "        optimizer.step()\n",
    "        scheduler.step()\n",
    "        optimizer.zero_grad()\n",
    "#     return correct_predictions.double() / (n_examples*6), np.mean(losses)\n",
    "    return np.mean(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_model(model, data_loader, criterion, device, n_examples):\n",
    "    model = model.eval() # 验证预测模式\n",
    "\n",
    "    losses = []\n",
    "    correct_predictions = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for sample in tqdm(data_loader):\n",
    "            input_ids = sample[\"input_ids\"].to(device)\n",
    "            attention_mask = sample[\"attention_mask\"].to(device)\n",
    "            outputs = model(\n",
    "                input_ids=input_ids,\n",
    "                attention_mask=attention_mask\n",
    "            )\n",
    "            loss_love = criterion(outputs['love'], sample['love'].to(device))\n",
    "            loss_joy = criterion(outputs['joy'], sample['joy'].to(device))\n",
    "            loss_fright = criterion(outputs['fright'], sample['fright'].to(device))\n",
    "            loss_anger = criterion(outputs['anger'], sample['anger'].to(device))\n",
    "            loss_fear = criterion(outputs['fear'], sample['fear'].to(device))\n",
    "            loss_sorrow = criterion(outputs['sorrow'], sample['sorrow'].to(device))\n",
    "            loss = loss_love + loss_joy + loss_fright + loss_anger + loss_fear + loss_sorrow\n",
    "\n",
    "\n",
    "            losses.append(loss.item())\n",
    "    return  np.mean(losses)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                                                                                                                                                                                     | 0/230 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/1\n",
      "----------\n",
      "Train loss 1.464792532793216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:06<00:00, 33.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val   loss 1.528440403096054 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "history = defaultdict(list) # 记录10轮loss和acc\n",
    "best_loss = float('inf')\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "\n",
    "    print(f'Epoch {epoch + 1}/{EPOCHS}')\n",
    "    print('-' * 10)\n",
    "\n",
    "#     train_loss = train_epoch(\n",
    "#         model,\n",
    "#         train_data_loader,\n",
    "#         loss_fn,\n",
    "#         optimizer,\n",
    "#         device,\n",
    "#         scheduler,\n",
    "#         len(df_train)\n",
    "#     )\n",
    "\n",
    "    print(f'Train loss {train_loss}')\n",
    "\n",
    "    val_loss = eval_model(\n",
    "        model,\n",
    "        val_data_loader,\n",
    "        loss_fn,\n",
    "        device,\n",
    "        len(df_val)\n",
    "    )\n",
    "\n",
    "    print(f'Val   loss {val_loss} ')\n",
    "    print()\n",
    "\n",
    "    history['train_loss'].append(train_loss)\n",
    "    history['val_loss'].append(val_loss)\n",
    "\n",
    "    if val_loss < best_loss:\n",
    "        torch.save(model.state_dict(), 'best_model_state.bin')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8 模型预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data_loader = create_data_loader(test, tokenizer, MAX_LEN, BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at hfl/chinese-roberta-wwm-ext were not used when initializing BertModel: ['cls.predictions.decoder.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "0it [00:00, ?it/s]E:\\ProgramData\\Anaconda3\\lib\\site-packages\\transformers\\tokenization_utils_base.py:2184: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
      "  warnings.warn(\n",
      "1336it [00:38, 34.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21376\n",
      "21376\n",
      "21376\n",
      "21376\n",
      "21376\n",
      "21376\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "def predict(model):\n",
    "    val_loss = 0\n",
    "    test_pred = defaultdict(list)\n",
    "    model.eval()\n",
    "    for step, batch in tqdm(enumerate(test_data_loader)):\n",
    "        b_input_ids = batch['input_ids'].to(device)\n",
    "        b_attention_mask = batch['attention_mask'].to(device)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            logits = model(input_ids=b_input_ids, attention_mask=b_attention_mask)\n",
    "            for col in target_cols:\n",
    "                test_pred[col].append(logits[col].to('cpu').numpy())\n",
    "    preds = {}\n",
    "    for col in target_cols:\n",
    "        print(len(np.concatenate(test_pred[col])))\n",
    "        preds[col] = (np.concatenate(test_pred[col]))\n",
    "    return preds\n",
    "\n",
    "submit = pd.read_csv('data/submit_example.tsv', sep='\\t')\n",
    "\n",
    "best_model = EmotionClassifier(len(class_names))\n",
    "path = f'best_model_state.bin'\n",
    "best_model.load_state_dict(torch.load(path))\n",
    "best_model.to(device)\n",
    "test_pred = predict(best_model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "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>id</th>\n",
       "      <th>emotion</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>34170_0002_A_12</td>\n",
       "      <td>0.05773647874593735,0.08950565755367279,0.0876...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>34170_0002_A_14</td>\n",
       "      <td>0.056820206344127655,0.0903855413198471,0.0870...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>34170_0003_A_16</td>\n",
       "      <td>0.056235916912555695,0.0906827300786972,0.0863...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>34170_0003_A_17</td>\n",
       "      <td>0.060653604567050934,0.09047575294971466,0.087...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>34170_0003_A_18</td>\n",
       "      <td>0.06049662083387375,0.09141705930233002,0.0872...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                id                                            emotion\n",
       "0  34170_0002_A_12  0.05773647874593735,0.08950565755367279,0.0876...\n",
       "1  34170_0002_A_14  0.056820206344127655,0.0903855413198471,0.0870...\n",
       "2  34170_0003_A_16  0.056235916912555695,0.0906827300786972,0.0863...\n",
       "3  34170_0003_A_17  0.060653604567050934,0.09047575294971466,0.087...\n",
       "4  34170_0003_A_18  0.06049662083387375,0.09141705930233002,0.0872..."
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_preds = []\n",
    "for col in target_cols:\n",
    "    preds = test_pred[col]\n",
    "    label_preds.append(preds.flatten())\n",
    "sub = submit.copy()\n",
    "sub['emotion'] = np.stack(label_preds, axis=1).tolist()\n",
    "sub['emotion'] = sub['emotion'].apply(lambda x: ','.join([str(i) for i in x]))\n",
    "sub.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "sub.to_csv(f'baseline.tsv', sep='\\t', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0.67+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ChallengeHub\n",
    "\n",
    "分享人：致Great ChallengeHub成员 中国人民大学硕士\n",
    "\n",
    "![](https://img-blog.csdnimg.cn/fcef57e247724f02bf84533e13cfa523.jpg)\n",
    "\n",
    "关注回复**“爱奇艺”** 获取本notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}