Datasets:

JunyuLu
/

ToxiCN

+# Facilitating Fine-grained Detection of Chinese Toxic Language: Hierarchical Taxonomy, Resources, and Benchmark
+🎉**2024.9 Our related study, titled "Towards Comprehensive Detection of Chinese Harmful Meme", has been accepted to NeurIPS 2024! In this paper, we present ToxiCN_MM, the first Chinese harmful meme dataset. Here is the link: [https://github.com/DUT-lujunyu/ToxiCN_MM](https://github.com/DUT-lujunyu/ToxiCN_MM). Welcome to star or fork it!**
+🎉**2024.9 Our related study, titled "PclGPT: A Large Language Model for Patronizing and Condescending Language Detection", has been accepted to EMNLP 2024! In this paper, we focus on a specific type of implicit toxicity, patronizing, and condescending language. [link](https://github.com/dut-laowang/emnlp24-PclGPT/tree/main) [paper](https://arxiv.org/abs/2410.00361)**
+🎉**2024.5 Our proposed dataset, ToxiCN, has been adopted by the international evaluation [CLEF 2024: Multilingual Text Detoxification](https://pan.webis.de/clef24/pan24-web/text-detoxification.html) as the sole Chinese data source. [Report](https://ceur-ws.org/Vol-3740/paper-223.pdf)**
+___
+**The paper has been accepted in ACL 2023 (main conference, long paper).** [Paper](https://aclanthology.org/2023.acl-long.898/)
+☠️ ***Warning: The samples presented by this paper may be considered offensive or vulgar.***
+## ❗️ Ethics Statement
+The opinions and findings contained in the samples of our presented dataset should not be interpreted as representing the views expressed or implied by the authors. We acknowledge the risk of malicious actors attempting to reverse-engineer comments. **We sincerely hope that users will employ the dataset responsibly and appropriately, avoiding misuse or abuse.** We believe the benefits of our proposed resources outweigh the associated risks. **All resources are intended solely for scientific research and are prohibited from commercial use.**
+## 📜 Monitor Toxic Frame
+we introduce a hierarchical taxonomy **Monitor Toxic Frame**. Based on the taxonomy, the posts are progressively divided into diverse granularities as follows: **_(I) Whether Toxic_**, ***(II) Toxic Type*** (general offensive language or hate speech), ***(III) Targeted Group***, ***(IV) Expression Category*** (explicitness, implicitness, or reporting).
+## 📜 ToxiCN
+We conduct a fine-grained annotation of posts crawled from _Zhihu_ and _Tieba_, including both direct and indirect toxic samples. And ToxiCN dataset is presented, which has 12k comments containing **_Sexism_**, **_Racism_**, **_Regional Bias_**, **_Anti-LGBTQ_**, and **_Others_**. The dataset is presented in ***ToxiCN_1.0.csv***. Here we simply describe each fine-grain label.
+| Label             | Description                                                  |
+| ----------------- | ------------------------------------------------------------ |
+| toxic             | Identify if a comment is toxic (1) or non-toxic (0).         |
+| toxic_type        | non-toxic: 0, general offensive language: 1, hate speech: 2  |
+| expression        | non-hate: 0, explicit hate speech: 1, implicit hate speech: 2, reporting: 3|
+| target (a list)   | LGBTQ: Index 0, Region: Index 1, Sexism: Index 2, Racism: Index 3,  others: Index 4, non-hate: Index 5 |
+## 📜 Insult Lexicon
+See https://github.com/DUT-lujunyu/ToxiCN/tree/main/ToxiCN_ex/ToxiCN/lexicon
+## 📜 Benchmark
+We present a migratable benchmark of **Toxic Knowledge Enhancement** (**TKE**), enriching the text representation. The code is shown in **_modeling_bert.py_**, which is based on **transformers 3.1.0**.
+## ❗️ Licenses
+This work is licensed under a Creative Commons Attribution- NonCommercial-NoDerivatives 4.0 International License (CC BY-NC-ND 4.0).
+## Poster
+![CCAC_2](https://github.com/DUT-lujunyu/ToxiCN/assets/53985277/8e26c649-0952-4d04-a562-b971f441df07)
+## Cite
+If you want to use the resources, please cite the following paper:
+~~~
+@inproceedings{lu-etal-2023-facilitating,
+    title = "Facilitating Fine-grained Detection of {C}hinese Toxic Language: Hierarchical Taxonomy, Resources, and Benchmarks",
+    author = "Lu, Junyu  and
+      Xu, Bo  and
+      Zhang, Xiaokun  and
+      Min, Changrong  and
+      Yang, Liang  and
+      Lin, Hongfei",
+    booktitle = "Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = jul,
+    year = "2023",
+    address = "Toronto, Canada",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2023.acl-long.898",
+    doi = "10.18653/v1/2023.acl-long.898",
+    pages = "16235--16250",
+}
+~~~

ToxiCN_1.0.csv ADDED Viewed

The diff for this file is too large to render. See raw diff

ToxiCN_ex/ToxiCN/data/test.json ADDED Viewed

The diff for this file is too large to render. See raw diff

ToxiCN_ex/ToxiCN/data/train.json ADDED Viewed

The diff for this file is too large to render. See raw diff

ToxiCN_ex/ToxiCN/lexicon/LGBT.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"基佬": [1825, 878], "炼铜": [4159, 7198], "txl": [162, 8206, 8178], "基蛆": [1825, 6025], "男同": [4511, 1398], "反同": [1353, 1398], "恐同": [2607, 1398], "同志": [1398, 2562], "gay": [149, 143, 167], "通讯录": [6858, 6380, 2497], "撑同": [3053, 1398], "鸡老": [7883, 5439], "直佬": [4684, 878], "反铜": [1353, 7198], "艾基": [5687, 1825], "艾兹佬": [5687, 1074, 878], "男铜": [4511, 7198], "鸡佬": [7883, 878], "ltp": [10413, 8187], "屠同": [2248, 1398], "繁殖批": [5246, 3658, 2821], "染艾": [3381, 5687], "同杏恋": [1398, 3331, 2605], "断袖": [3171, 6153], "龙阳之好": [7987, 7345, 722, 1962], "击佬": [1140, 878], "男童": [4511, 4997]}

ToxiCN_ex/ToxiCN/lexicon/general.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"神经": [4868, 5307], "神经病": [4868, 5307, 4567], "垃圾": [1796, 1769], "艹": [5685], "草": [5770], "辣鸡": [6793, 7883], "傻逼": [1004, 6873], "萨比": [5855, 3683], "煞笔": [4208, 5011], "沙软": [3763, 6763], "沙軟": [3763, 6727], "法西斯": [3791, 6205, 3172], "几把": [1126, 2828], "肥猪": [5503, 4343], "尼玛": [2225, 4377], "傻X": [1004, 166], "舔狗": [5654, 4318], "狗": [4318], "猪": [4343], "废物": [2426, 4289], "儒猴": [1027, 4347], "他妈": [800, 1968], "鬼话": [7787, 6413], "脑瘫": [5554, 4611], "巨婴": [2342, 2048], "驴": [7723], "蠢驴": [6111, 7723], "特么": [4294, 720], "捏麻麻的": [2934, 7937, 7937, 4638], "绿毛龟": [5344, 3688, 7991], "不得house": [679, 2533, 150, 157, 163, 161, 147], "你妈妈的": [872, 1968, 1968, 4638], "捏妈妈的": [2934, 1968, 1968, 4638], "小屁孩": [2207, 2230, 2111], "弱智": [2483, 3255], "批": [2821], "贵物": [6586, 4289], "畜生": [4523, 4495], "蛆": [6025], "屎": [2241], "货色": [6573, 5682], "勾八": [1256, 1061], "妈的": [1968, 4638], "傻卵": [1004, 1317], "啥卵": [1567, 1317], "放屁": [3123, 2230], "牛鬼蛇神": [4281, 7787, 6026, 4868], "精神病": [5125, 4868, 4567], "狗屁": [4318, 2230], "猪精": [4343, 5125], "沸物": [3778, 4289], "伞兵": [835, 1070], "乞丐": [737, 681], "疯狗": [4556, 4318], "嘴炮": [1673, 4152], "鬼母": [7787, 3678], "智障": [3255, 7397], "变态": [1359, 2578], "他妈的": [800, 1968, 4638], "你妈的": [872, 1968, 4638], "你他妈的": [872, 800, 1968, 4638], "鸟事": [7881, 752], "活该": [3833, 6421], "操蛋": [3082, 6028], "烂裤裆": [4162, 6175, 6164], "孝子": [2105, 2094], "奴隶": [1958, 7405], "死一死": [3647, 671, 3647], "傻B": [1004, 144], "爆杀": [4255, 3324], "下头": [678, 1928], "鲨bee": [7835, 8815, 8154], "牲口": [4291, 1366], "吸血虫": [1429, 6117, 6001], "吸血鬼": [1429, 6117, 7787], "吊": [1396], "网曝": [5381, 3284], "网暴": [5381, 3274], "畜牲": [4523, 4291], "孽": [2121], "寄生虫": [2164, 4495, 6001], "弱指": [2483, 2900], "坦克": [1788, 1046], "鲨鼻": [7835, 7965], "捧杀": [2942, 3324], "寄吧": [2164, 1416], "p事": [158, 752], "贱": [6583], "蠢": [6111], "傻子": [1004, 2094], "粪": [5116], "崽子": [2312, 2094], "苟": [5732], "穷b": [4956, 144], "魔怔": [7795, 2585], "牛头人": [4281, 1928, 782], "牛马": [4281, 7716], "乐子人": [727, 2094, 782], "鸵鸟": [7893, 7881], "呆子": [1438, 2094], "歪皮": [3639, 4649], "憨憨": [2736, 2736], "矮子": [4765, 2094], "蒻痣": [5894, 4582], "撒币": [3054, 2355], "小丑": [2207, 682], "你妈": [872, 1968], "菊花": [5825, 5709], "喷子": [1613, 2094], "傻*": [1004, 115], "给爷爬": [5314, 4267, 4260], "狗腿子": [4318, 5597, 2094], "÷剩": [193, 1197], "恶熏": [2626, 4221], "鼠鼠": [7962, 7962], "僵尸": [1018, 2221], "暴毙": [3274, 3687], "孙杂": [2101, 3325], "杂皮": [3325, 4649], "有大病": [3300, 1920, 4567], "你是个什么东西": [872, 3221, 702, 784, 720, 691, 6205], "沙币": [3763, 2355], "白莲": [4635, 5813], "沙峦": [3763, 2287], "熊孩子": [4220, 2111, 2094], "嘿涩蕙": [1678, 3886, 5936], "瘪三": [4610, 676], "老鼠": [5439, 7962], "二极管": [753, 3353, 5052], "恶心": [2626, 2552], "下三滥": [678, 676, 4010], "双标": [1352, 3403], "口区": [1366, 1277], "蛀虫": [6024, 6001], "搅屎棍": [3009, 2241, 3471], "蛆丝": [6025, 692], "傻呗": [1004, 1446], "强奸犯": [2487, 1960, 4306], "吃枣药丸": [1391, 3365, 5790, 709], "呸": [1459], "这b": [6821, 144], "铁花生": [7188, 5709, 4495], "牠": [4284], "吉拔": [1395, 2869], "屌逼": [2239, 6873], "冲爆": [1103, 4255], "孽畜": [2121, 4523], "眼瞎": [4706, 4735], "小鬼": [2207, 7787], "淦死": [3911, 3647], "淦": [3911], "瘠薄": [4603, 5946], "跪舔": [6661, 5654], "塌马": [1847, 7716], "跪族": [6661, 3184], "粪蛋": [5116, 6028], "乐色": [727, 5682], "渣子": [3942, 2094], "杂毛": [3325, 3688], "色狼": [5682, 4331], "杂碎": [3325, 4810], "杂种": [3325, 4905], "沙口": [3763, 1366], "瞎": [4735], "鬼子": [7787, 2094], "奴才": [1958, 2798], "走狗": [6624, 4318], "爪牙": [4259, 4280], "败类": [6571, 5102], "憨批": [2736, 2821], "狗东西": [4318, 691, 6205], "街溜子": [6125, 3977, 2094], "诡雷": [6417, 7440], "烂裤子": [4162, 6175, 2094], "色胚": [5682, 5524], "狗贼": [4318, 6592], "丁丁": [672, 672], "强奸": [2487, 1960], "造孽": [6863, 2121], "pussy": [11227, 8565, 8179], "一棒子打死": [671, 3472, 2094, 2802, 3647], "杠精": [3339, 5125], "tm": [9908], "jb": [13063], "sj": [161, 8334], "sb": [12359], "nm": [156, 8175], "der": [9157], "nt": [8495], "tmd": [9908, 8168], "qj": [159, 8334], "md": [11399], "fw": [148, 8220], "j8": [152, 8156], "ntr": [8495, 8180], "zz": [168, 8253], "lkd": [154, 8197, 8168], "ex": [9577], "pua": [11227, 8139], "qs": [11974], "loser": [12264, 9520]}

ToxiCN_ex/ToxiCN/lexicon/racism.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"黑叔叔": [7946, 1356, 1356], "原": [1333], "洋大人": [3817, 1920, 782], "洋爹": [3817, 4269], "默": [7949], "白楠": [4635, 3507], "n哥": [156, 1520], "ni哥": [10560, 1520], "歪果仁": [3639, 3362, 785], "歪果": [3639, 3362], "泥娃娃": [3799, 2015, 2015], "尼哥": [2225, 1520], "泥哥": [3799, 1520], "尼葛": [2225, 5867], "黒鬼": [7946, 7787], "昆仑奴": [3204, 796, 1958], "泥鸽": [3799, 7894], "嘿鬼": [1678, 7787], "黑蛆": [7946, 6025], "跪虫族": [6661, 6001, 3184], "虫族": [6001, 3184], "黒杂": [7947, 3325], "黑杂种": [7946, 3325, 4905], "黑混": [7946, 3921], "黑砸": [7946, 4790], "混黑": [3921, 7946], "嘿砸": [1678, 4790], "黑泥鳅": [7946, 3799, 7844], "嘿蛆": [1678, 6025], "嘿爹": [1678, 4269], "黑爹": [7946, 4269], "黑哥": [7946, 1520], "嘿哥": [1678, 1520], "猩猩": [4342, 4342], "命贵": [1462, 6586], "黑命贵": [7946, 1462, 6586], "nigger": [10560, 9949, 8196], "黑狗": [7946, 4318], "泥革": [3799, 7484], "嘿狗": [1678, 4318], "倪格": [960, 3419], "嘿虫": [1678, 6001], "黑虫": [7946, 6001], "嗨人": [1635, 782], "黑比": [7946, 3683], "嘿比": [1678, 3683], "黑逼": [7946, 6873], "嘿逼": [1678, 6873], "嘿砸肿": [1678, 4790, 5514], "犹太狗": [4310, 1922, 4318], "黑杂碎": [7946, 3325, 4810], "黑犬": [7946, 4305], "嘿嘿": [1678, 1678], "黑黑": [7946, 7946], "倪哥": [960, 1520], "反三非": [1353, 676, 7478], "三非": [676, 7478], "反黑": [1353, 7946], "小黑": [2207, 7946], "黑枸": [7946, 3375], "嘿枸": [1678, 3375], "黑猴子": [7946, 4347, 2094], "洋垃圾": [3817, 1796, 1769], "黑吹": [7946, 1430], "黑小子": [7946, 2207, 2094], "黑玩意": [7946, 4381, 2692], "嘿玩意": [1678, 4381, 2692], "嘿杂碎": [1678, 3325, 4810], "嘿杂种": [1678, 3325, 4905], "人妖": [782, 1973], "白皮猪": [4635, 4649, 4343], "串串": [706, 706], "嘿畜": [1678, 4523], "黑畜": [7946, 4523], "小二黑": [2207, 753, 7946], "小二嘿": [2207, 753, 1678], "黑贵": [7946, 6586], "嘿贵": [1678, 6586], "黑粪": [7946, 5116], "类人猿": [5102, 782, 4351], "人猿": [782, 4351], "舔黑": [5654, 7946], "黑皮": [7946, 4649], "嘿皮": [1678, 4649], "黑乐色": [7946, 727, 5682], "嘿乐色": [1678, 727, 5682], "黑沙口": [7946, 3763, 1366], "嘿沙口": [1678, 3763, 1366], "墨": [1874], "默人": [7949, 782], "墨人": [1874, 782], "黑醋": [7946, 7005], "黑杂": [7946, 3325], "默妖": [7949, 1973], "黑猩猩": [7946, 4342, 4342], "嘿猩猩": [1678, 4342, 4342], "媚黑": [2055, 7946], "飞周人": [7607, 1453, 782], "鬼子虫类": [7787, 2094, 6001, 5102], "虫混": [6001, 3921], "黑非洲": [7946, 7478, 3828], "媚白": [2055, 4635], "非洲佬": [7478, 3828, 878], "嘿硅": [1678, 4795], "黑硅": [7946, 4795], "黑不溜秋": [7946, 679, 3977, 4904], "黑子哥": [7946, 2094, 1520], "灭默": [4127, 7949], "屠默": [2248, 7949], "猎默": [4333, 7949], "杀默": [3324, 7949], "反默": [1353, 7949], "虫类": [6001, 5102], "国际鬼子虫类": [1744, 7354, 7787, 2094, 6001, 5102], "屠嘿": [2248, 1678], "屠黑": [2248, 7946], "媚嘿": [2055, 1678], "凯乐奇": [1132, 727, 1936], "hr": [8967], "凯乐奇计划": [1132, 727, 1936, 6369, 1153], "凯勒奇": [1132, 1239, 1936], "凯勒奇计划": [1132, 1239, 1936, 6369, 1153], "红毛鬼子": [5273, 3688, 7787, 2094], "煤精": [4209, 5125], "类人": [5102, 782], "黑哥哥": [7946, 1520, 1520], "黑妹妹": [7946, 1987, 1987], "黑族": [7946, 3184], "黑娃娃": [7946, 2015, 2015], "反白": [1353, 4635], "跪洋": [6661, 3817], "白皮": [4635, 4649], "哥布林": [1520, 2357, 3360], "肖万": [5494, 674], "h人": [150, 782], "黑北鼻": [7946, 1266, 7965], "羊大人": [5399, 1920, 782], "泥搁": [3799, 3007], "魄": [7790], "白腩": [4635, 5583], "黑男": [7946, 4511], "黑女": [7946, 1957], "崇洋媚外": [2300, 3817, 2055, 1912], "黑淫": [7946, 3915]}

ToxiCN_ex/ToxiCN/lexicon/region.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"南满": [1298, 4007], "南蛮": [1298, 6037], "蛮子": [6037, 2094], "棒子": [3472, 2094], "小日本": [2207, 3189, 3315], "漂亮国": [4023, 778, 1744], "南大人": [1298, 1920, 782], "弯弯": [2482, 2482], "湾湾": [3968, 3968], "西八": [6205, 1061], "棒男": [3472, 4511], "棒女": [3472, 1957], "山东葱": [2255, 691, 5876], "蛮": [6037], "满子": [4007, 2094], "蛮夷": [6037, 1929], "喃蛮": [1586, 6037], "南宋人": [1298, 2129, 782], "西戎": [6205, 2766], "北狄": [1266, 4313], "东夷": [691, 1929], "北佬": [1266, 878], "偷井盖": [982, 759, 4667], "山越猴": [2255, 6632, 4347], "京巴": [776, 2349], "九头鸟": [736, 1928, 7881], "东百": [691, 4636], "白完": [4635, 2130], "胡建": [5529, 2456], "陕蛋蛋": [7362, 6028, 6028], "百越": [4636, 6632], "狗日的": [4318, 3189, 4638], "红脖子": [5273, 5556, 2094], "巴铁": [2349, 7188], "三哥": [676, 1520], "阿三": [7350, 676], "小鬼子": [2207, 7787, 2094], "小日子": [2207, 3189, 2094], "倭狗": [963, 4318], "倭": [963], "倭寇": [963, 2167], "日杂": [3189, 3325], "飞周": [7607, 1453], "飞舟": [7607, 5660], "高卢乌鸡": [7770, 1306, 723, 7883], "美国佬": [5401, 1744, 878], "乡巴佬": [740, 2349, 878]}

ToxiCN_ex/ToxiCN/lexicon/sexism.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"婊": [2040], "婊子": [2040, 2094], "拳师": [2891, 2360], "开苞": [2458, 5731], "骚": [7746], "绝育": [5318, 5509], "奇趣蛋": [1936, 6637, 6028], "母狗": [3678, 4318], "牧狗": [4288, 4318], "幕刃": [2391, 1145], "慕刃": [2710, 1145], "亩人": [774, 782], "鸡": [7883], "龟男": [7991, 4511], "龟楠": [7991, 3507], "普信男": [3249, 928, 4511], "普信": [3249, 928], "女拳": [1957, 2891], "男拳": [4511, 2891], "仙女": [803, 1957], "小仙女": [2207, 803, 1957], "小藓女": [2207, 5968, 1957], "女厕所": [1957, 1329, 2792], "幕人": [2391, 782], "慕人": [2710, 782], "幕勾": [2391, 1256], "慕勾": [2710, 1256], "国铝": [1744, 7199], "亩狗": [774, 4318], "亩勾": [774, 1256], "亩篝": [774, 5068], "亩刃": [774, 1145], "亩": [774], "龟仙人": [7991, 803, 782], "姆蛆": [1990, 6025], "阿娜": [7350, 2025], "easygirl": [9935, 9375], "eg": [147, 8181], "÷女": [193, 1957], "姆搐": [1990, 3012], "蝈女": [6067, 1957], "木勾": [3312, 1256], "鲍鱼": [7828, 7824], "妓女": [1972, 1957], "母拳": [3678, 2891], "普信女": [3249, 928, 1957], "绿帽": [5344, 2384], "穆狗": [4946, 4318], "母猪": [3678, 4343], "厌女": [1328, 1957], "硅南": [4795, 1298], "粿": [5126], "公狗": [1062, 4318], "犬男": [4305, 4511], "沐勾": [3759, 1256], "拳畜": [2891, 4523], "母畜": [3678, 4523], "牧人": [4288, 782], "钼刃": [7184, 1145], "娘炮": [2023, 4152], "慕√": [2710, 380], "烧鸡": [4173, 7883], "女醛": [1957, 7010], "姆坦": [1990, 1788], "墓垢": [1867, 1803], "薇安妇": [5948, 2128, 1967], "慰安妇": [2720, 2128, 1967], "女犬": [1957, 4305], "妈宝女": [1968, 2140, 1957], "妈宝男": [1968, 2140, 4511], "腐女": [5576, 1957], "母坦": [3678, 1788], "肉便器": [5489, 912, 1690], "直男癌": [4684, 4511, 4617], "郭女": [6958, 1957], "田园女拳": [4506, 1736, 1957, 2891], "田园女权": [4506, 1736, 1957, 3326], "绿茶": [5344, 5763], "绿茶婊": [5344, 5763, 2040], "男淫": [4511, 3915], "烂货": [4162, 6573], "腩人": [5583, 782], "蝈腩": [6067, 5583], "女贼": [1957, 6592], "七尺大儒": [673, 2223, 1920, 1027], "拳虱": [2891, 6003], "圣母": [1760, 3678], "织女": [5302, 1957], "母朱": [3678, 3319], "腐癌": [5576, 4617], "站街女": [4991, 6125, 1957], "龟奴": [7991, 1958], "乌龟精": [723, 7991, 5125], "娘们": [2023, 812], "脑残女": [5554, 3655, 1957], "窑姐": [4965, 1995], "郭南": [6958, 1298], "ezg": [147, 8253, 8181], "田园表": [4506, 1736, 6134], "田园婊": [4506, 1736, 2040], "表子": [6134, 2094], "xdz": [8444, 8253], "小吊子": [2207, 1396, 2094], "金针菇": [7032, 7151, 5823], "田园女": [4506, 1736, 1957], "中华田园犬": [704, 1290, 4506, 1736, 4305], "国楠": [1744, 3507], "子宫战": [2094, 2151, 2773], "人造子宫": [782, 6863, 2094, 2151], "母沟": [3678, 3765], "锅女": [7222, 1957], "打拳": [2802, 2891], "姆的": [1990, 4638], "八婆": [1061, 2038], "sao": [3221, 12053], "骚女": [7746, 1957], "sao女": [3221, 12053, 1957], "幕√": [2391, 380]}

ToxiCN_ex/model/Config_base.py ADDED Viewed

	@@ -0,0 +1,70 @@

+# coding: UTF-8
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import os
+from os import path
+# 2022.7.27 config基类
+class Config_base(object):
+    """配置参数"""
+    def __init__(self, model_name, dataset):
+        # path
+        self.model_name = model_name
+        self.train_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/data/train.json'                                # 训练集
+        self.dev_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/data/test.json'                                    # 验证集
+        self.test_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/data/test.json'                                  # 测试集
+        self.vocab_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/data/vocab.pkl'
+        self.lexicon_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/lexicon/'        # 数据集、模型训练结果                               # 词表
+        self.result_path = path.dirname(path.dirname(__file__))+'/' + dataset + '/result'
+        self.checkpoint_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/saved_dict'        # 数据集、模型训练结果
+        self.data_path = self.checkpoint_path + '/data.tar'
+        # self.log_path = path.dirname(path.dirname(__file__))+'/'+ dataset + '/log/' + self.model_name
+        # self.embedding_pretrained = torch.tensor(
+        #     np.load(path.dirname(path.dirname(__file__))+'/'+ 'THUCNews' + '/data/' + embedding)["embeddings"].astype('float32'))\
+        #     if embedding != 'random' else None                                       # 预训练词向量
+        self.word2vec_path = path.dirname(path.dirname(path.dirname(__file__)))+"/glove/source/glove.6B.300d.bin"
+        # self.plm = "roberta-base"  # 预训练模型
+        # self.plm = "bert-base-chinese"
+        # dataset
+        self.seed = 1
+        # self.require_improvement = 1000                                 # 若超过1000batch效果还没提升，则提前结束训练 transformer:2000
+        self.num_classes = 2                                             # 类别数
+        # self.n_vocab = 0                                                # 词表大小，在运行时赋值
+        self.pad_size = 80                                              # 每句话处理成的长度(短填长切)
+        # model
+        self.dropout = 0.5                                              # 随机失活
+        self.vocab_dim = 768
+        self.fc_hidden_dim = 256
+        # train
+        self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')   # 设备
+        self.learning_rate = 1e-5                                       # 学习率  transformer:5e-4
+        self.scheduler = False                                          # 是否学习率衰减
+        self.adversarial = False  # 是否对抗训练
+        self.num_warm = 0                                               # 开始验证的epoch数
+        self.num_epochs = 5                                            # epoch数
+        self.batch_size = 32                                           # mini-batch大小
+        # loss
+        self.alpha1 = 0.5
+        self.gamma1 = 4
+        # evaluate
+        self.threshold = 0.5                                            # 二分类阈值
+        self.score_key = "F1"      # 评价指标
+if __name__ == '__main__':
+    config = Config_base("BERT", "SWSR")
+    print(config.vocab_path)
+    print(config.word2vec_path)
+    print(path.dirname(__file__))
+    print(path.dirname(path.dirname(__file__)))

ToxiCN_ex/requirements.txt ADDED Viewed

	@@ -0,0 +1,10 @@

+gensim==3.8.3
+jieba==0.42.1
+nltk==3.7
+numpy==1.21.2
+ray==1.13.0
+scikit_learn==1.1.2
+tensorboardX==2.5.1
+torch==1.7.0
+tqdm==4.64.0
+transformers==3.4.0

ToxiCN_ex/run.py ADDED Viewed

	@@ -0,0 +1,123 @@

+from importlib import import_module
+from src.datasets import *
+import os
+from os import path
+import numpy as np
+from train_eval import train, eval
+import argparse
+from src.Models import *
+from ray import tune
+from ray.tune.schedulers import ASHAScheduler
+parser = argparse.ArgumentParser(description='Chinese Toxic Classification')
+parser.add_argument('--mode', default="train", type=str, help='train/test')
+# 是否微调超参数
+parser.add_argument('--tune_param', default=False, type=bool, help='True for param tuning')
+parser.add_argument('--tune_samples', default=1, type=int, help='Number of tuning experiments to run')
+parser.add_argument('--tune_asha', default=False, type=bool, help='If use ASHA scheduler for early stopping')
+parser.add_argument('--tune_file', default='RoBERTa', type=str, help='Suffix of filename for parameter tuning results')
+parser.add_argument('--tune_gpu', default=True, type=bool, help='Use GPU to tune parameters')
+args = parser.parse_args()
+# TOC
+# search_space = {
+#     'learning_rate': tune.choice([1e-5, 5e-5]),
+#     'num_epochs': tune.choice([5]),
+#     'batch_size': tune.choice([32, 64]),
+#     'dropout': tune.choice([0.2, 0.5]),
+#     'seed': tune.choice([1]),
+#     "pad_size" : tune.choice([50, 100])
+# }
+# THUCnews
+search_space = {
+    'learning_rate': tune.choice([1e-5]),
+    'num_epochs': tune.choice([5]),
+    'batch_size': tune.choice([32]),
+    # 'dropout': tune.choice([0.2, 0.3, 0.5]),
+    'seed': tune.choice([1]),
+    "pad_size" : tune.choice([80]),
+    "alpha1" : tune.choice([0.5])
+}
+def convert_label(preds):
+    final_pred = []
+    for pred in preds:
+        if pred == [1, 0]:
+            final_pred.append("offensive")
+        else:
+            final_pred.append("non-offensive")
+    return final_pred
+if __name__ == '__main__':
+    # dataset = 'TOC'  # 数据集
+    dataset = "ToxiCN"
+    # model_name = "bert-base-chinese"
+    model_name = "hfl/chinese-roberta-wwm-ext"
+    # model_name = "junnyu/ChineseBERT-base"
+    np.random.seed(1)
+    torch.manual_seed(1)
+    torch.cuda.manual_seed_all(1)
+    torch.backends.cudnn.deterministic = True  # 保证每次结果一样
+    start_time = time.time()
+    print("Loading data...")
+    x = import_module('model.' + "Config_base")
+    config = x.Config_base(model_name, dataset)  # 引入Config参数，包括Config_base和各私有Config
+    if not os.path.exists(config.data_path):
+        trn_data = Datasets(config, config.train_path)
+        dev_data = Datasets(config, config.dev_path)
+        test_data = Datasets(config, config.test_path)
+        torch.save({
+            'trn_data' : trn_data,
+            'dev_data' : dev_data,
+            'test_data' : test_data,
+            }, config.data_path)
+    else:
+        checkpoint = torch.load(config.data_path)
+        trn_data = checkpoint['trn_data']
+        dev_data = checkpoint['dev_data']
+        test_data = checkpoint['test_data']
+        print('The size of the Training dataset: {}'.format(len(trn_data)))
+        print('The size of the Validation dataset: {}'.format(len(dev_data)))
+        print('The size of the Test dataset: {}'.format(len(test_data)))
+    train_iter = Dataloader(trn_data,  batch_size=int(config.batch_size), SEED=config.seed)
+    dev_iter = Dataloader(dev_data,  batch_size=int(config.batch_size), shuffle=False)
+    test_iter = Dataloader(test_data,  batch_size=int(config.batch_size), shuffle=False)
+    time_dif = get_time_dif(start_time)
+    print("Time usage:", time_dif)
+    def experiment(tune_config):
+        if tune_config:
+            for param in tune_config:
+                setattr(config, param, tune_config[param])
+        train(config, train_iter, dev_iter, test_iter)
+    if args.mode == "train":
+        if args.tune_param:
+            scheduler = ASHAScheduler(metric='metric', mode="max") if args.tune_asha else None
+            analysis = tune.run(experiment, num_samples=args.tune_samples, config=search_space, resources_per_trial={'gpu':int(args.tune_gpu)},
+                scheduler=scheduler,
+                verbose=3)
+            analysis.results_df.to_csv('tune_results_'+args.tune_file+'.csv')
+        # if not tune parameters
+        else:
+            experiment(tune_config=None)
+    else:
+        embed_model = Bert_Layer(config).to(config.device)
+        model = TwoLayerFFNNLayer(config).to(config.device)
+        # model_name = "ckp-bert-base-chinese-NN_ML-100_D-0.2_B-64_E-5_Lr-1e-05-BEST.tar"
+        model_name = "ckp-bert-base-chinese-NN_ML-150_D-0.5_B-32_E-2_Lr-1e-05-BEST.tar"
+        path = '{}/{}'.format(config.checkpoint_path, model_name)
+        checkpoint = torch.load(path)
+        embed_model.load_state_dict(checkpoint['embed_model_state_dict'])
+        model.load_state_dict(checkpoint['model_state_dict'])
+        loss_fn = nn.BCEWithLogitsLoss()
+        dev_scores, preds = eval(config, embed_model, model, loss_fn, dev_iter, data_name='TEST')
+        print(convert_label(preds))

ToxiCN_ex/src/BERT.py ADDED Viewed

	@@ -0,0 +1,507 @@

+"""PyTorch BERT model. """
+import logging
+import math
+import os
+import warnings
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import CrossEntropyLoss, MSELoss
+from transformers.activations import gelu, gelu_new, swish
+from transformers.configuration_bert import BertConfig
+from transformers.file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_callable
+from transformers.modeling_utils import PreTrainedModel, find_pruneable_heads_and_indices, prune_linear_layer
+logger = logging.getLogger(__name__)
+BERT_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "bert-base-uncased",
+    "bert-large-uncased",
+    "bert-base-cased",
+    "bert-large-cased",
+    "bert-base-multilingual-uncased",
+    "bert-base-multilingual-cased",
+    "bert-base-chinese",
+    "bert-base-german-cased",
+    "bert-large-uncased-whole-word-masking",
+    "bert-large-cased-whole-word-masking",
+    "bert-large-uncased-whole-word-masking-finetuned-squad",
+    "bert-large-cased-whole-word-masking-finetuned-squad",
+    "bert-base-cased-finetuned-mrpc",
+    "bert-base-german-dbmdz-cased",
+    "bert-base-german-dbmdz-uncased",
+    "cl-tohoku/bert-base-japanese",
+    "cl-tohoku/bert-base-japanese-whole-word-masking",
+    "cl-tohoku/bert-base-japanese-char",
+    "cl-tohoku/bert-base-japanese-char-whole-word-masking",
+    "TurkuNLP/bert-base-finnish-cased-v1",
+    "TurkuNLP/bert-base-finnish-uncased-v1",
+    "wietsedv/bert-base-dutch-cased",
+    # See all BERT models at https://huggingface.co/models?filter=bert
+]
+def mish(x):
+    return x * torch.tanh(nn.functional.softplus(x))
+ACT2FN = {"gelu": gelu, "relu": torch.nn.functional.relu, "swish": swish, "gelu_new": gelu_new, "mish": mish}
+BertLayerNorm = torch.nn.LayerNorm
+class BertEmbeddings(nn.Module):
+    """Construct the embeddings from word, position and token_type embeddings.
+    """
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
+        # 2022.10.8 toxic_embeddings: non-toxic + 5 kinds of toxic
+        self.toxic_embeddings = nn.Embedding(6, config.hidden_size)
+        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
+        # any TensorFlow checkpoint file
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    # 2022.05.02 test token_tags
+    def forward(self, input_ids=None, token_type_ids=None, position_ids=None, token_tags=None, toxic_ids=None, inputs_embeds=None):
+        if input_ids is not None:
+            input_shape = input_ids.size()
+        else:
+            input_shape = inputs_embeds.size()[:-1]
+        seq_length = input_shape[1]
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+        if position_ids is None:
+            position_ids = torch.arange(seq_length, dtype=torch.long, device=device)
+            position_ids = position_ids.unsqueeze(0).expand(input_shape)
+        if token_type_ids is None:
+            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+        position_embeddings = self.position_embeddings(position_ids)
+        token_type_embeddings = self.token_type_embeddings(token_type_ids)
+        embeddings = inputs_embeds + position_embeddings + token_type_embeddings
+        # 2022.10.8 toxic_embeddings
+        if toxic_ids is not None:
+            toxic_embeddings = self.toxic_embeddings(toxic_ids)
+            embeddings += toxic_embeddings
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+class BertSelfAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention "
+                "heads (%d)" % (config.hidden_size, config.num_attention_heads)
+            )
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+    ):
+        mixed_query_layer = self.query(hidden_states)
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        if encoder_hidden_states is not None:
+            mixed_key_layer = self.key(encoder_hidden_states)
+            mixed_value_layer = self.value(encoder_hidden_states)
+            attention_mask = encoder_attention_mask
+        else:
+            mixed_key_layer = self.key(hidden_states)
+            mixed_value_layer = self.value(hidden_states)
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+        key_layer = self.transpose_for_scores(mixed_key_layer)
+        value_layer = self.transpose_for_scores(mixed_value_layer)
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        if attention_mask is not None:
+            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
+            attention_scores = attention_scores + attention_mask
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+        context_layer = torch.matmul(attention_probs, value_layer)
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+        return outputs
+class BertSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+class BertAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.self = BertSelfAttention(config)
+        self.output = BertSelfOutput(config)
+        self.pruned_heads = set()
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
+        )
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+    ):
+        self_outputs = self.self(
+            hidden_states, attention_mask, head_mask, encoder_hidden_states, encoder_attention_mask, output_attentions,
+        )
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+class BertIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+class BertOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+class BertLayer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.attention = BertAttention(config)
+        self.is_decoder = config.is_decoder
+        if self.is_decoder:
+            self.crossattention = BertAttention(config)
+        self.intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+    ):
+        self_attention_outputs = self.attention(
+            hidden_states, attention_mask, head_mask, output_attentions=output_attentions,
+        )
+        attention_output = self_attention_outputs[0]
+        outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights
+        if self.is_decoder and encoder_hidden_states is not None:
+            cross_attention_outputs = self.crossattention(
+                attention_output,
+                attention_mask,
+                head_mask,
+                encoder_hidden_states,
+                encoder_attention_mask,
+                output_attentions,
+            )
+            attention_output = cross_attention_outputs[0]
+            outputs = outputs + cross_attention_outputs[1:]  # add cross attentions if we output attention weights
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        outputs = (layer_output,) + outputs
+        return outputs
+class BertEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([BertLayer(config) for _ in range(config.num_hidden_layers)])
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+        output_hidden_states=False,
+    ):
+        all_hidden_states = ()
+        all_attentions = ()
+        for i, layer_module in enumerate(self.layer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+            if getattr(self.config, "gradient_checkpointing", False):
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        return module(*inputs, output_attentions)
+                    return custom_forward
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(layer_module),
+                    hidden_states,
+                    attention_mask,
+                    head_mask[i],
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    head_mask[i],
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    output_attentions,
+                )
+            hidden_states = layer_outputs[0]
+            if output_attentions:
+                all_attentions = all_attentions + (layer_outputs[1],)
+        # Add last layer
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+        outputs = (hidden_states,)
+        if output_hidden_states:
+            outputs = outputs + (all_hidden_states,)
+        if output_attentions:
+            outputs = outputs + (all_attentions,)
+        return outputs  # last-layer hidden state, (all hidden states), (all attentions)
+class BertPooler(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.activation = nn.Tanh()
+    def forward(self, hidden_states):
+        # We "pool" the model by simply taking the hidden state corresponding
+        # to the first token.
+        first_token_tensor = hidden_states[:, 0]
+        pooled_output = self.dense(first_token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+class BertPreTrainedModel(PreTrainedModel):
+    config_class = BertConfig
+    base_model_prefix = "bert"
+    def _init_weights(self, module):
+        """ Initialize the weights """
+        if isinstance(module, (nn.Linear, nn.Embedding)):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif isinstance(module, BertLayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        if isinstance(module, nn.Linear) and module.bias is not None:
+            module.bias.data.zero_()
+class BertModel(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        self.embeddings = BertEmbeddings(config)
+        self.encoder = BertEncoder(config)
+        self.pooler = BertPooler(config)
+        self.init_weights()
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+    def _prune_heads(self, heads_to_prune):
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        toxic_ids=None,
+    ):
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+        if token_type_ids is None:
+            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, device)
+        # If a 2D ou 3D attention mask is provided for the cross-attention
+        # we need to make broadcastabe to [batch_size, num_heads, seq_length, seq_length]
+        if self.config.is_decoder and encoder_hidden_states is not None:
+            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            if encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_extended_attention_mask = None
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+        embedding_output = self.embeddings(
+            input_ids=input_ids, position_ids=position_ids, token_type_ids=token_type_ids, inputs_embeds=inputs_embeds
+        )
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_mask=extended_attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_extended_attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+        )
+        sequence_output = encoder_outputs[0]
+        pooled_output = self.pooler(sequence_output)
+        outputs = (sequence_output, pooled_output,) + encoder_outputs[
+            1:
+        ]  # add hidden_states and attentions if they are here
+        return outputs  # sequence_output, pooled_output, (hidden_states), (attentions)

ToxiCN_ex/src/Models.py ADDED Viewed

	@@ -0,0 +1,69 @@

+from transformers import BertModel
+# from chinesebert import ChineseBertForMaskedLM, ChineseBertTokenizerFast, ChineseBertConfig
+from src.BERT import BertModel
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import numpy as np
+# 2022.4.28 Glove + LSTM
+class BiLSTM(nn.Module):
+    def __init__(self, config, embedding_weight):
+        super(BiLSTM, self).__init__()
+        self.device = config.device
+        self.vocab_size = embedding_weight.shape[0]
+        self.embed_dim = embedding_weight.shape[1]
+        # Embedding Layer
+        embedding_weight = torch.from_numpy(embedding_weight).float()
+        embedding_weight = Variable(embedding_weight, requires_grad=config.if_grad)
+        self.embedding = nn.Embedding(self.vocab_size, self.embed_dim, _weight=embedding_weight)
+        # Encoder layer
+        self.bi_lstm = nn.LSTM(self.embed_dim, config.lstm_hidden_dim, bidirectional=True, batch_first=True)
+    def forward(self, **kwargs):
+        emb = self.embedding(kwargs["title_text_token_ids"].to(self.device)) # [batch, len] --> [batch, len, embed_dim]
+        lstm_out, _ = self.bi_lstm(emb)  # [batch, len, embed_dim] --> [batch, len, lstm_hidden_dim*2]
+        lstm_out_pool = torch.mean(lstm_out, dim=1)  # [batch, lstm_hidden_dim*2]
+        return lstm_out, lstm_out_pool
+class Bert_Layer(torch.nn.Module):
+    def __init__(self, config):
+        super(Bert_Layer, self).__init__()
+        # self.use_cuda = kwargs['use_cuda']
+        self.device = config.device
+        # BERT/Roberta
+        self.bert_layer = BertModel.from_pretrained(config.model_name)
+        # ChineseBERT
+        # self.config = ChineseBertConfig.from_pretrained(config.model_name)
+        # self.bert_layer = ChineseBertForMaskedLM.from_pretrained("ShannonAI/ChineseBERT-base", config=self.config)
+        self.dim = config.vocab_dim
+    def forward(self, **kwargs):
+        bert_output = self.bert_layer(input_ids=kwargs['text_idx'].to(self.device),
+                                 token_type_ids=kwargs['text_ids'].to(self.device),
+                                 attention_mask=kwargs['text_mask'].to(self.device),
+                                 toxic_ids=kwargs["toxic_ids"].to(self.device))
+        return bert_output[0], bert_output[1]
+class TwoLayerFFNNLayer(torch.nn.Module):
+    '''
+    2-layer FFNN with specified nonlinear function
+    must be followed with some kind of prediction layer for actual prediction
+    '''
+    def __init__(self, config):
+        super(TwoLayerFFNNLayer, self).__init__()
+        self.output = config.dropout
+        self.input_dim = config.vocab_dim
+        self.hidden_dim = config.fc_hidden_dim
+        self.out_dim = config.num_classes
+        self.dropout = nn.Dropout(config.dropout)
+        self.model = nn.Sequential(nn.Linear(self.input_dim, self.hidden_dim),
+                                   nn.Tanh(),
+                                   nn.Linear(self.hidden_dim, self.out_dim))
+    def forward(self, att_input, pooled_emb):
+        att_input = self.dropout(att_input)
+        pooled_emb = self.dropout(pooled_emb)
+        return self.model(pooled_emb)

ToxiCN_ex/src/datasets.py ADDED Viewed

	@@ -0,0 +1,238 @@

+import re
+import json, time, random, torch
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertTokenizer, AutoTokenizer
+# from chinesebert import ChineseBertForMaskedLM, ChineseBertTokenizerFast, ChineseBertConfig
+from tqdm import tqdm
+import jieba
+# from nltk.corpus import stopwords
+# from src.helper import *
+from importlib import import_module
+import pickle as pkl
+import time
+from datetime import timedelta
+MAX_VOCAB_SIZE = 10000
+UNK, PAD = '<UNK>', '<PAD>'
+def token_to_index(token, config):
+    vocab = pkl.load(open(config.vocab_path, 'rb'))
+    # print(f"Vocab size: {len(vocab)}")
+    words_line = []
+    if len(token) < config.pad_size:
+        token.extend([PAD] * (config.pad_size - len(token)))
+    else:
+        token = token[:config.pad_size]
+    # word to id
+    for word in token:
+        words_line.append(vocab.get(word, vocab.get(UNK)))
+    return words_line
+# 获取dirty_word的索引
+def get_dirty_words(path):
+    with open(path, 'r') as f:
+        data = json.load(f)
+    dirty_words = list(data.values())
+    return dirty_words
+def get_all_dirty_words(base_path):
+    all_dirty_words = []
+    paths = ["general.json", "LGBT.json", "region.json", "sexism.json", "racism.json"]
+    for i in paths:
+        all_dirty_words.append(get_dirty_words(base_path + i))
+    return all_dirty_words
+def get_toxic_id(text_idx, toxic_ids, dirty_words, toxic_index):
+    for dirty_word in dirty_words:
+        for index, token in enumerate(text_idx):
+            if token == 0:
+                break
+            if token != dirty_word[0]:  # 第一个字符不是dirty_word的词首
+                continue
+            else:
+                flag = 1
+                start_index = index
+                end_index = index+1
+                for i in range(len(dirty_word[1:])):
+                    if end_index >= len(text_idx):  # 越界
+                        flag = 0
+                        break
+                    if text_idx[end_index] != dirty_word[1+i]:  # 后续单词非dirty词
+                        flag = 0
+                        break
+                    end_index += 1
+            if flag:
+                for dirty_index in range(start_index, end_index):  # 对含脏词的span打上类别label
+                    toxic_ids[dirty_index] = toxic_index
+    # print(toxic_ids)
+    return toxic_ids
+def get_all_toxic_id(pad_size, text_idx, all_dirty_words):
+    toxic_ids = [0 for i in range(pad_size)]
+    for toxic_index, dirty_words in enumerate(all_dirty_words):
+        toxic_ids = get_toxic_id(text_idx, toxic_ids, dirty_words, toxic_index+1)
+    return toxic_ids
+class Datasets(Dataset):
+    '''
+    The dataset based on Bert.
+    '''
+    def __init__(self, kwargs, data_name, add_special_tokens=True, not_test=True):
+        self.kwargs = kwargs
+        self.not_test = not_test
+        self.data_name = data_name
+        self.lexicon_base_path = kwargs.lexicon_path
+        self.max_tok_len = kwargs.pad_size
+        self.add_special_tokens = add_special_tokens
+        # self.tokenizer = BertTokenizer.from_pretrained('resources/scibert_scivocab_cased')
+        # self.tokenizer = BertTokenizer.from_pretrained(kwargs.model_name)
+        # BERT/Roberta
+        self.tokenizer = AutoTokenizer.from_pretrained(kwargs.model_name)
+        # ChineseBERT
+        # self.tokenizer = ChineseBertTokenizerFast.from_pretrained(kwargs.model_name)
+        # self.word2vec_path = kwargs.word2vec_path
+        with open(data_name, 'r') as f:
+            self.data_file = json.load(f)
+        self.preprocess_data()
+    def preprocess_data(self):
+        print('Preprocessing Data {} ...'.format(self.data_name))
+        # word2idx, embedding_matrix = load_word2vec_matrix(self.word2vec_path)
+        data_time_start=time.time()
+        all_dirty_words = get_all_dirty_words(self.lexicon_base_path)
+        for row in tqdm(self.data_file):
+            ori_text = row['content']
+            text = self.tokenizer(ori_text, add_special_tokens=self.add_special_tokens,
+                                  max_length=int(self.max_tok_len), padding='max_length', truncation=True)
+            # For BERT
+            row['text_idx'] = text['input_ids']
+            row['text_ids'] = text['token_type_ids']
+            row['text_mask'] = text['attention_mask']
+            row['toxic_ids'] = get_all_toxic_id(self.max_tok_len, row['text_idx'], all_dirty_words)
+            # for glove
+            # sub_text = re.sub(u"([^\u0030-\u0039\u0041-\u005a\u0061-\u007a])"," ",ori_text)
+            # text_token = [w for w in ori_text]
+            # row["text_token_ids"] = token_to_index(text_token, self.kwargs)
+            # row["text_token_len"] = len(row["text_token_ids"])
+            # row["text_token_ids"] = pad_token_seq(row["text_token_ids"], self.max_tok_len)
+        data_time_end = time.time()
+        print("... finished preprocessing cost {} ".format(data_time_end-data_time_start))
+    # def get_key(self, index):
+    #     path = "data/label/level_" + str(index) + '.json'
+    #     with open(path, 'r+') as file:
+    #         content=file.read()
+    #     key = json.loads(content)
+    #     return key
+    # def convert_one_hot(self, data, one_hot, length):
+    #     data_ = [0 for i in range(length)]
+    #     for i in data:
+    #         data_[one_hot[i]] = 1
+    #     return data_
+    def __len__(self):
+        return len(self.data_file)
+    def __getitem__(self, idx, corpus=None):
+        row = self.data_file[idx]
+        sample = {
+                    # For BERT
+                    'text_idx': row['text_idx'], 'text_ids': row['text_ids'], 'text_mask': row['text_mask'], 'toxic_ids': row['toxic_ids'],
+                    # For GloVe
+                    # 'text_token_ids': row["text_token_ids"]
+                    'toxic': row["toxic_one_hot"], 'toxic_type': row["toxic_type_one_hot"], 'expression': row["expression_one_hot"], 'target': row["target"]
+                }
+        # For label
+        # sample['label'] = row['label']
+        return sample
+class Dataloader(DataLoader):
+    '''
+    A batch sampler of a dataset.
+    '''
+    def __init__(self, data, batch_size, shuffle=True, SEED=0):
+        self.data = data
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.SEED = SEED
+        random.seed(self.SEED)
+        self.indices = list(range(len(data)))
+        if shuffle:
+            random.shuffle(self.indices)
+        self.batch_num = 0
+    def __len__(self):
+        return int(len(self.data) / float(self.batch_size))
+    def num_batches(self):
+        return len(self.data) / float(self.batch_size)
+    def __iter__(self):
+        self.indices = list(range(len(self.data)))
+        if self.shuffle:
+            random.shuffle(self.indices)
+        return self
+    def __next__(self):
+        if self.indices != []:
+            idxs = self.indices[:self.batch_size]
+            batch = [self.data.__getitem__(i) for i in idxs]
+            self.indices = self.indices[self.batch_size:]
+            return batch
+        else:
+            raise StopIteration
+    def get(self):
+        self.reset()
+        return self.__next__()
+    def reset(self):
+        self.indices = list(range(len(self.data)))
+        if self.shuffle: random.shuffle(self.indices)
+def to_tensor(batch):
+    '''
+    Convert a batch data into tensor
+    '''
+    args = {}
+    # For label
+    # args["label"] = torch.tensor([b['label'] for b in batch])
+    # For BERT
+    args['text_idx'] = torch.tensor([b['text_idx'] for b in batch])
+    args['text_ids'] = torch.tensor([b['text_ids'] for b in batch])
+    args['text_mask'] = torch.tensor([b['text_mask'] for b in batch])
+    args['toxic_ids'] = torch.tensor([b['toxic_ids'] for b in batch])
+    # For GloVe
+    # args['text_token_len'] = torch.tensor([b['text_token_len'] for b in batch])
+    # args['text_token_ids'] = torch.tensor([b['text_token_ids'] for b in batch])
+    args['toxic'] = torch.tensor([b['toxic'] for b in batch])
+    args['toxic_type'] = torch.tensor([b['toxic_type'] for b in batch])
+    args['expression'] = torch.tensor([b['expression'] for b in batch])
+    args['target'] = torch.tensor([b['target'] for b in batch])
+    return args
+def get_time_dif(start_time):
+    """获取已使用时间"""
+    end_time = time.time()
+    time_dif = end_time - start_time
+    return timedelta(seconds=int(round(time_dif)))
+def convert_onehot(config, label):
+    onehot_label = [0 for i in range(config.num_classes)]
+    onehot_label[int(label)] = 1
+    return onehot_label

ToxiCN_ex/train_eval.py ADDED Viewed

	@@ -0,0 +1,202 @@

+import numpy as np
+from sklearn import metrics
+from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from tqdm import tqdm
+import time
+import json
+import copy
+from src.datasets import get_time_dif, to_tensor, convert_onehot
+from src.Models import *
+# from src.losses import *
+# from tensorboardX import SummaryWriter
+from ray import tune
+def train(config, train_iter, dev_iter, test_iter, task=1):
+    embed_model = Bert_Layer(config).to(config.device)
+    model = TwoLayerFFNNLayer(config).to(config.device)
+    model_name = '{}-NN_ML-{}_D-{}_B-{}_E-{}_Lr-{}_aplha-{}'.format(config.model_name, config.pad_size, config.dropout,
+                                            config.batch_size, config.num_epochs, config.learning_rate, config.alpha1)
+    embed_optimizer = optim.AdamW(embed_model.parameters(), lr=config.learning_rate)
+    model_optimizer = optim.AdamW(model.parameters(), lr=config.learning_rate)
+    # fgm = FGM(embed_model, epsilon=1, emb_name='word_embeddings.')
+    loss_fn = nn.BCEWithLogitsLoss()
+    # loss_fn = get_loss_func("FL", [0.4, 0.6], config.num_classes, config.alpha1)
+    max_score = 0
+    for epoch in range(config.num_epochs):
+        embed_model.train()
+        model.train()
+        start_time = time.time()
+        print("Model is training in epoch {}".format(epoch))
+        loss_all = 0.
+        preds = []
+        labels = []
+        for batch in tqdm(train_iter, desc='Training', colour = 'MAGENTA'):
+            embed_model.zero_grad()
+            model.zero_grad()
+            args = to_tensor(batch)
+            att_input, pooled_emb = embed_model(**args)
+            logit = model(att_input, pooled_emb).cpu()
+            label = args['toxic']
+            # label = args['toxic_type']
+            # label = args['expression']
+            # label = args['target']
+            loss = loss_fn(logit, label.float())
+            pred = get_preds(config, logit)
+            # pred = get_preds_task2_4(config, logit)
+            # pred = get_preds_task3(config, logit)
+            preds.extend(pred)
+            labels.extend(label.detach().numpy())
+            loss_all += loss.item()
+            embed_optimizer.zero_grad()
+            model_optimizer.zero_grad()
+            loss.backward()
+            embed_optimizer.step()
+            model_optimizer.step()
+        end_time = time.time()
+        print(" took: {:.1f} min".format((end_time - start_time)/60.))
+        print("TRAINED for {} epochs".format(epoch))
+        # 验证
+        if epoch >= config.num_warm:
+            # print("training loss: loss={}".format(loss_all/len(data)))
+            trn_scores = get_scores(preds, labels, loss_all, len(train_iter), data_name="TRAIN")
+            dev_scores, _ = eval(config, embed_model, model, loss_fn, dev_iter, data_name='DEV')
+            f = open('{}/{}.all_scores.txt'.format(config.result_path, model_name), 'a')
+            f.write(' ==================================================  Epoch: {}  ==================================================\n'.format(epoch))
+            f.write('TrainScore: \n{}\nEvalScore: \n{}\n'.format(json.dumps(trn_scores), json.dumps(dev_scores)))
+            max_score = save_best(config, epoch, model_name, embed_model, model, dev_scores, max_score)
+        print("ALLTRAINED for {} epochs".format(epoch))
+    path = '{}/ckp-{}-{}.tar'.format(config.checkpoint_path, model_name, 'BEST')
+    checkpoint = torch.load(path)
+    embed_model.load_state_dict(checkpoint['embed_model_state_dict'])
+    model.load_state_dict(checkpoint['model_state_dict'])
+    test_scores, _ = eval(config, embed_model, model, loss_fn, test_iter, data_name='DEV')
+    f = open('{}/{}.all_scores.txt'.format(config.result_path, model_name), 'a')
+    f.write('Test: \n{}\n'.format(json.dumps(test_scores)))
+def eval(config, embed_model, model, loss_fn, dev_iter, data_name='DEV'):
+    loss_all = 0.
+    preds = []
+    labels = []
+    for batch in tqdm(dev_iter, desc='Evaling', colour = 'CYAN'):
+        with torch.no_grad():
+            args = to_tensor(batch)
+            att_input, pooled_emb = embed_model(**args)
+            logit = model(att_input, pooled_emb)
+            logit = logit.cpu()
+            label = args['toxic']
+            # label = args['toxic_type']
+            # label = args['expression']
+            # label = args['target']
+            loss = loss_fn(logit, label.float())
+            pred = get_preds(config, logit)
+            # pred = get_preds_task2_4(config, logit)
+            # pred = get_preds_task3(config, logit)
+            preds.extend(pred)
+            labels.extend(label.detach().numpy())
+            loss_all += loss.item()
+    dev_scores = get_scores(preds, labels, loss_all, len(dev_iter), data_name=data_name)
+    # if data_name != "TEST": # 2022.9.20 命令行输入为test模式时，不调用tune
+    # tune.report(metric=dev_scores)
+    return dev_scores, preds
+# For Multi Classfication
+def get_preds(config, logit):
+    results = torch.max(logit.data, 1)[1].cpu().numpy()
+    new_results = []
+    for result in results:
+        result = convert_onehot(config, result)
+        new_results.append(result)
+    return new_results
+# Task 2 and 4: 多分类 Toxic Type Discrimination and d Expression Type Detection
+def get_preds_task2_4(config, logit):
+    all_results = []
+    logit_ = torch.sigmoid(logit)
+    results_pred = torch.max(logit_.data, 1)[0].cpu().numpy()
+    results = torch.max(logit_.data, 1)[1].cpu().numpy() # index for maximum probability
+    for i in range(len(results)):
+        if results_pred[i] < 0.5:
+            result = [0 for i in range(config.num_classes)]
+        else:
+            result = convert_onehot(config, results[i])
+        all_results.append(result)
+    return all_results
+# Task 3: 多标签分类 Targeted Group Detection
+def get_preds_task3(config, logit):
+    all_results = []
+    logit_ = torch.sigmoid(logit)
+    results_pred = torch.max(logit_.data, 1)[0].cpu().numpy()
+    results = torch.max(logit_.data, 1)[1].cpu().numpy()
+    logit_ = logit_.detach().cpu().numpy()
+    for i in range(len(results)):
+        if results_pred[i] < 0.5:
+            result = [0 for i in range(config.num_classes)]
+        else:
+            result = get_pred_task3(logit_[i])
+        all_results.append(result)
+    return all_results
+def get_pred_task3(logit):
+    result = [0 for i in range(len(logit))]
+    for i in range(len(logit)):
+        if logit[i] >= 0.5:
+            result[i] = 1
+    return result
+def get_scores(all_preds, all_lebels, loss_all, len, data_name):
+    score_dict = dict()
+    f1 = f1_score(all_preds, all_lebels, average='weighted')
+    # acc = accuracy_score(all_preds, all_lebels)
+    all_f1 = f1_score(all_preds, all_lebels, average=None)
+    pre = precision_score(all_preds, all_lebels, average='weighted')
+    recall = recall_score(all_preds, all_lebels, average='weighted')
+    score_dict['F1'] = f1
+    # score_dict['accuracy'] = acc
+    score_dict['all_f1'] = all_f1.tolist()
+    score_dict['precision'] = pre
+    score_dict['recall'] = recall
+    score_dict['all_loss'] = loss_all/len
+    print("Evaling on \"{}\" data".format(data_name))
+    for s_name, s_val in score_dict.items():
+        print("{}: {}".format(s_name, s_val))
+    return score_dict
+def save_best(config, epoch, model_name, embed_model, model, score, max_score):
+    score_key = config.score_key
+    curr_score = score[score_key]
+    print('The epoch_{} {}: {}\nCurrent max {}: {}'.format(epoch, score_key, curr_score, score_key, max_score))
+    if curr_score > max_score or epoch == 0:
+        torch.save({
+        'epoch': config.num_epochs,
+        'embed_model_state_dict': embed_model.state_dict(),
+        'model_state_dict': model.state_dict(),
+        }, '{}/ckp-{}-{}.tar'.format(config.checkpoint_path, model_name, 'BEST'))
+        return curr_score
+    else:
+        return max_score

modeling_bert.py ADDED Viewed

	@@ -0,0 +1,1635 @@

+# coding=utf-8
+# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch BERT model. """
+import math
+import os
+import warnings
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import CrossEntropyLoss, MSELoss
+from .activations import gelu, gelu_new, swish
+from .configuration_bert import BertConfig
+from .file_utils import (
+    ModelOutput,
+    add_code_sample_docstrings,
+    add_start_docstrings,
+    add_start_docstrings_to_callable,
+    replace_return_docstrings,
+)
+from .modeling_outputs import (
+    BaseModelOutput,
+    BaseModelOutputWithPooling,
+    CausalLMOutput,
+    MaskedLMOutput,
+    MultipleChoiceModelOutput,
+    NextSentencePredictorOutput,
+    QuestionAnsweringModelOutput,
+    SequenceClassifierOutput,
+    TokenClassifierOutput,
+)
+from .modeling_utils import (
+    PreTrainedModel,
+    apply_chunking_to_forward,
+    find_pruneable_heads_and_indices,
+    prune_linear_layer,
+)
+from .utils import logging
+logger = logging.get_logger(__name__)
+_CONFIG_FOR_DOC = "BertConfig"
+_TOKENIZER_FOR_DOC = "BertTokenizer"
+BERT_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "bert-base-uncased",
+    "bert-large-uncased",
+    "bert-base-cased",
+    "bert-large-cased",
+    "bert-base-multilingual-uncased",
+    "bert-base-multilingual-cased",
+    "bert-base-chinese",
+    "bert-base-german-cased",
+    "bert-large-uncased-whole-word-masking",
+    "bert-large-cased-whole-word-masking",
+    "bert-large-uncased-whole-word-masking-finetuned-squad",
+    "bert-large-cased-whole-word-masking-finetuned-squad",
+    "bert-base-cased-finetuned-mrpc",
+    "bert-base-german-dbmdz-cased",
+    "bert-base-german-dbmdz-uncased",
+    "cl-tohoku/bert-base-japanese",
+    "cl-tohoku/bert-base-japanese-whole-word-masking",
+    "cl-tohoku/bert-base-japanese-char",
+    "cl-tohoku/bert-base-japanese-char-whole-word-masking",
+    "TurkuNLP/bert-base-finnish-cased-v1",
+    "TurkuNLP/bert-base-finnish-uncased-v1",
+    "wietsedv/bert-base-dutch-cased",
+    # See all BERT models at https://huggingface.co/models?filter=bert
+]
+def load_tf_weights_in_bert(model, config, tf_checkpoint_path):
+    """Load tf checkpoints in a pytorch model."""
+    try:
+        import re
+        import numpy as np
+        import tensorflow as tf
+    except ImportError:
+        logger.error(
+            "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
+            "https://www.tensorflow.org/install/ for installation instructions."
+        )
+        raise
+    tf_path = os.path.abspath(tf_checkpoint_path)
+    logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
+    # Load weights from TF model
+    init_vars = tf.train.list_variables(tf_path)
+    names = []
+    arrays = []
+    for name, shape in init_vars:
+        logger.info("Loading TF weight {} with shape {}".format(name, shape))
+        array = tf.train.load_variable(tf_path, name)
+        names.append(name)
+        arrays.append(array)
+    for name, array in zip(names, arrays):
+        name = name.split("/")
+        # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
+        # which are not required for using pretrained model
+        if any(
+            n in ["adam_v", "adam_m", "AdamWeightDecayOptimizer", "AdamWeightDecayOptimizer_1", "global_step"]
+            for n in name
+        ):
+            logger.info("Skipping {}".format("/".join(name)))
+            continue
+        pointer = model
+        for m_name in name:
+            if re.fullmatch(r"[A-Za-z]+_\d+", m_name):
+                scope_names = re.split(r"_(\d+)", m_name)
+            else:
+                scope_names = [m_name]
+            if scope_names[0] == "kernel" or scope_names[0] == "gamma":
+                pointer = getattr(pointer, "weight")
+            elif scope_names[0] == "output_bias" or scope_names[0] == "beta":
+                pointer = getattr(pointer, "bias")
+            elif scope_names[0] == "output_weights":
+                pointer = getattr(pointer, "weight")
+            elif scope_names[0] == "squad":
+                pointer = getattr(pointer, "classifier")
+            else:
+                try:
+                    pointer = getattr(pointer, scope_names[0])
+                except AttributeError:
+                    logger.info("Skipping {}".format("/".join(name)))
+                    continue
+            if len(scope_names) >= 2:
+                num = int(scope_names[1])
+                pointer = pointer[num]
+        if m_name[-11:] == "_embeddings":
+            pointer = getattr(pointer, "weight")
+        elif m_name == "kernel":
+            array = np.transpose(array)
+        try:
+            assert (
+                pointer.shape == array.shape
+            ), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
+        except AssertionError as e:
+            e.args += (pointer.shape, array.shape)
+            raise
+        logger.info("Initialize PyTorch weight {}".format(name))
+        pointer.data = torch.from_numpy(array)
+    return model
+def mish(x):
+    return x * torch.tanh(nn.functional.softplus(x))
+ACT2FN = {"gelu": gelu, "relu": torch.nn.functional.relu, "swish": swish, "gelu_new": gelu_new, "mish": mish}
+BertLayerNorm = torch.nn.LayerNorm
+class BertEmbeddings(nn.Module):
+    """Construct the embeddings from word, position and token_type embeddings."""
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
+        # 2022.10.8 toxic_embeddings: non-toxic + 5 kinds of toxic
+        self.toxic_embeddings = nn.Embedding(6, config.hidden_size)
+        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
+        # any TensorFlow checkpoint file
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+    def forward(self, input_ids=None, token_type_ids=None, position_ids=None, toxic_ids=None, inputs_embeds=None):
+        if input_ids is not None:
+            input_shape = input_ids.size()
+        else:
+            input_shape = inputs_embeds.size()[:-1]
+        seq_length = input_shape[1]
+        if position_ids is None:
+            position_ids = self.position_ids[:, :seq_length]
+        if token_type_ids is None:
+            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=self.position_ids.device)
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+        position_embeddings = self.position_embeddings(position_ids)
+        token_type_embeddings = self.token_type_embeddings(token_type_ids)
+        embeddings = inputs_embeds + position_embeddings + token_type_embeddings
+        # 2022.10.8 toxic_embeddings
+        if toxic_ids is not None:
+            toxic_embeddings = self.toxic_embeddings(toxic_ids)
+            embeddings += toxic_embeddings
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+class BertSelfAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention "
+                "heads (%d)" % (config.hidden_size, config.num_attention_heads)
+            )
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+    ):
+        mixed_query_layer = self.query(hidden_states)
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        if encoder_hidden_states is not None:
+            mixed_key_layer = self.key(encoder_hidden_states)
+            mixed_value_layer = self.value(encoder_hidden_states)
+            attention_mask = encoder_attention_mask
+        else:
+            mixed_key_layer = self.key(hidden_states)
+            mixed_value_layer = self.value(hidden_states)
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+        key_layer = self.transpose_for_scores(mixed_key_layer)
+        value_layer = self.transpose_for_scores(mixed_value_layer)
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        if attention_mask is not None:
+            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
+            attention_scores = attention_scores + attention_mask
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+        context_layer = torch.matmul(attention_probs, value_layer)
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+        return outputs
+class BertSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+class BertAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.self = BertSelfAttention(config)
+        self.output = BertSelfOutput(config)
+        self.pruned_heads = set()
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
+        )
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+    ):
+        self_outputs = self.self(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            encoder_hidden_states,
+            encoder_attention_mask,
+            output_attentions,
+        )
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+class BertIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+class BertOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+class BertLayer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = BertAttention(config)
+        self.is_decoder = config.is_decoder
+        self.add_cross_attention = config.add_cross_attention
+        if self.add_cross_attention:
+            assert self.is_decoder, f"{self} should be used as a decoder model if cross attention is added"
+            self.crossattention = BertAttention(config)
+        self.intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+    ):
+        self_attention_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            output_attentions=output_attentions,
+        )
+        attention_output = self_attention_outputs[0]
+        outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights
+        if self.is_decoder and encoder_hidden_states is not None:
+            assert hasattr(
+                self, "crossattention"
+            ), f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers by setting `config.add_cross_attention=True`"
+            cross_attention_outputs = self.crossattention(
+                attention_output,
+                attention_mask,
+                head_mask,
+                encoder_hidden_states,
+                encoder_attention_mask,
+                output_attentions,
+            )
+            attention_output = cross_attention_outputs[0]
+            outputs = outputs + cross_attention_outputs[1:]  # add cross attentions if we output attention weights
+        layer_output = apply_chunking_to_forward(
+            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
+        )
+        outputs = (layer_output,) + outputs
+        return outputs
+    def feed_forward_chunk(self, attention_output):
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+class BertEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([BertLayer(config) for _ in range(config.num_hidden_layers)])
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=False,
+        output_hidden_states=False,
+        return_dict=False,
+    ):
+        all_hidden_states = () if output_hidden_states else None
+        all_attentions = () if output_attentions else None
+        for i, layer_module in enumerate(self.layer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+            if getattr(self.config, "gradient_checkpointing", False):
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        return module(*inputs, output_attentions)
+                    return custom_forward
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(layer_module),
+                    hidden_states,
+                    attention_mask,
+                    head_mask[i],
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    head_mask[i],
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    output_attentions,
+                )
+            hidden_states = layer_outputs[0]
+            if output_attentions:
+                all_attentions = all_attentions + (layer_outputs[1],)
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+        if not return_dict:
+            return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
+        return BaseModelOutput(
+            last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions
+        )
+class BertPooler(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.activation = nn.Tanh()
+    def forward(self, hidden_states):
+        # We "pool" the model by simply taking the hidden state corresponding
+        # to the first token.
+        first_token_tensor = hidden_states[:, 0]
+        pooled_output = self.dense(first_token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+class BertPredictionHeadTransform(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        if isinstance(config.hidden_act, str):
+            self.transform_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.transform_act_fn = config.hidden_act
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.transform_act_fn(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states)
+        return hidden_states
+class BertLMPredictionHead(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.transform = BertPredictionHeadTransform(config)
+        # The output weights are the same as the input embeddings, but there is
+        # an output-only bias for each token.
+        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
+        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
+        self.decoder.bias = self.bias
+    def forward(self, hidden_states):
+        hidden_states = self.transform(hidden_states)
+        hidden_states = self.decoder(hidden_states)
+        return hidden_states
+class BertOnlyMLMHead(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.predictions = BertLMPredictionHead(config)
+    def forward(self, sequence_output):
+        prediction_scores = self.predictions(sequence_output)
+        return prediction_scores
+class BertOnlyNSPHead(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.seq_relationship = nn.Linear(config.hidden_size, 2)
+    def forward(self, pooled_output):
+        seq_relationship_score = self.seq_relationship(pooled_output)
+        return seq_relationship_score
+class BertPreTrainingHeads(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.predictions = BertLMPredictionHead(config)
+        self.seq_relationship = nn.Linear(config.hidden_size, 2)
+    def forward(self, sequence_output, pooled_output):
+        prediction_scores = self.predictions(sequence_output)
+        seq_relationship_score = self.seq_relationship(pooled_output)
+        return prediction_scores, seq_relationship_score
+class BertPreTrainedModel(PreTrainedModel):
+    """An abstract class to handle weights initialization and
+    a simple interface for downloading and loading pretrained models.
+    """
+    config_class = BertConfig
+    load_tf_weights = load_tf_weights_in_bert
+    base_model_prefix = "bert"
+    authorized_missing_keys = [r"position_ids"]
+    def _init_weights(self, module):
+        """ Initialize the weights """
+        if isinstance(module, (nn.Linear, nn.Embedding)):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif isinstance(module, BertLayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        if isinstance(module, nn.Linear) and module.bias is not None:
+            module.bias.data.zero_()
+@dataclass
+class BertForPreTrainingOutput(ModelOutput):
+    """
+    Output type of :class:`~transformers.BertForPreTrainingModel`.
+    Args:
+        loss (`optional`, returned when ``labels`` is provided, ``torch.FloatTensor`` of shape :obj:`(1,)`):
+            Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss.
+        prediction_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`):
+            Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+        seq_relationship_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, 2)`):
+            Prediction scores of the next sequence prediction (classification) head (scores of True/False
+            continuation before SoftMax).
+        hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
+            Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
+            of shape :obj:`(batch_size, sequence_length, hidden_size)`.
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
+        attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
+            Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
+            :obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+    """
+    loss: Optional[torch.FloatTensor] = None
+    prediction_logits: torch.FloatTensor = None
+    seq_relationship_logits: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+BERT_START_DOCSTRING = r"""
+    This model is a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`_ sub-class.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general
+    usage and behavior.
+    Parameters:
+        config (:class:`~transformers.BertConfig`): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the configuration.
+            Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
+"""
+BERT_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`):
+            Indices of input sequence tokens in the vocabulary.
+            Indices can be obtained using :class:`transformers.BertTokenizer`.
+            See :func:`transformers.PreTrainedTokenizer.encode` and
+            :func:`transformers.PreTrainedTokenizer.__call__` for details.
+            `What are input IDs? <../glossary.html#input-ids>`__
+        attention_mask (:obj:`torch.FloatTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`):
+            Mask to avoid performing attention on padding token indices.
+            Mask values selected in ``[0, 1]``:
+            ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
+            `What are attention masks? <../glossary.html#attention-mask>`__
+        token_type_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`):
+            Segment token indices to indicate first and second portions of the inputs.
+            Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
+            corresponds to a `sentence B` token
+            `What are token type IDs? <../glossary.html#token-type-ids>`_
+        position_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`):
+            Indices of positions of each input sequence tokens in the position embeddings.
+            Selected in the range ``[0, config.max_position_embeddings - 1]``.
+            `What are position IDs? <../glossary.html#position-ids>`_
+        head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`):
+            Mask to nullify selected heads of the self-attention modules.
+            Mask values selected in ``[0, 1]``:
+            :obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
+        inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
+            Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
+            This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+            than the model's internal embedding lookup matrix.
+        output_attentions (:obj:`bool`, `optional`, defaults to :obj:`None`):
+            If set to ``True``, the attentions tensors of all attention layers are returned. See ``attentions`` under returned tensors for more detail.
+        output_hidden_states (:obj:`bool`, `optional`, defaults to :obj:`None`):
+            If set to ``True``, the hidden states of all layers are returned. See ``hidden_states`` under returned tensors for more detail.
+        return_dict (:obj:`bool`, `optional`, defaults to :obj:`None`):
+            If set to ``True``, the model will return a :class:`~transformers.file_utils.ModelOutput` instead of a
+            plain tuple.
+"""
+@add_start_docstrings(
+    "The bare Bert Model transformer outputting raw hidden-states without any specific head on top.",
+    BERT_START_DOCSTRING,
+)
+class BertModel(BertPreTrainedModel):
+    """
+    The model can behave as an encoder (with only self-attention) as well
+    as a decoder, in which case a layer of cross-attention is added between
+    the self-attention layers, following the architecture described in `Attention is all you need`_ by Ashish Vaswani,
+    Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
+    To behave as an decoder the model needs to be initialized with the
+    :obj:`is_decoder` argument of the configuration set to :obj:`True`.
+    To be used in a Seq2Seq model, the model needs to initialized with both :obj:`is_decoder`
+    argument and :obj:`add_cross_attention` set to :obj:`True`; an
+    :obj:`encoder_hidden_states` is then expected as an input to the forward pass.
+    .. _`Attention is all you need`:
+        https://arxiv.org/abs/1706.03762
+    """
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        self.embeddings = BertEmbeddings(config)
+        self.encoder = BertEncoder(config)
+        self.pooler = BertPooler(config)
+        self.init_weights()
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+    def _prune_heads(self, heads_to_prune):
+        """Prunes heads of the model.
+        heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
+        See base class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="bert-base-uncased",
+        output_type=BaseModelOutputWithPooling,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        toxic_ids=None
+    ):
+        r"""
+        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
+            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+            if the model is configured as a decoder.
+        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
+            Mask to avoid performing attention on the padding token indices of the encoder input. This mask
+            is used in the cross-attention if the model is configured as a decoder.
+            Mask values selected in ``[0, 1]``:
+            ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+        if token_type_ids is None:
+            token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, device)
+        # If a 2D ou 3D attention mask is provided for the cross-attention
+        # we need to make broadcastabe to [batch_size, num_heads, seq_length, seq_length]
+        if self.config.is_decoder and encoder_hidden_states is not None:
+            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            if encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_extended_attention_mask = None
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+        embedding_output = self.embeddings(
+            input_ids=input_ids, position_ids=position_ids, token_type_ids=token_type_ids, toxic_ids=toxic_ids, inputs_embeds=inputs_embeds
+        )
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_mask=extended_attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_extended_attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = encoder_outputs[0]
+        pooled_output = self.pooler(sequence_output)
+        if not return_dict:
+            return (sequence_output, pooled_output) + encoder_outputs[1:]
+        return BaseModelOutputWithPooling(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+@add_start_docstrings(
+    """Bert Model with two heads on top as done during the pre-training: a `masked language modeling` head and
+    a `next sentence prediction (classification)` head. """,
+    BERT_START_DOCSTRING,
+)
+class BertForPreTraining(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.bert = BertModel(config)
+        self.cls = BertPreTrainingHeads(config)
+        self.init_weights()
+    def get_output_embeddings(self):
+        return self.cls.predictions.decoder
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @replace_return_docstrings(output_type=BertForPreTrainingOutput, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        next_sentence_label=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs
+    ):
+        r"""
+            labels (``torch.LongTensor`` of shape ``(batch_size, sequence_length)``, `optional`, defaults to :obj:`None`):
+                Labels for computing the masked language modeling loss.
+                Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring)
+                Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels
+                in ``[0, ..., config.vocab_size]``
+            next_sentence_label (``torch.LongTensor`` of shape ``(batch_size,)``, `optional`, defaults to :obj:`None`):
+                Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair (see :obj:`input_ids` docstring)
+                Indices should be in ``[0, 1]``.
+                ``0`` indicates sequence B is a continuation of sequence A,
+                ``1`` indicates sequence B is a random sequence.
+            kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
+                Used to hide legacy arguments that have been deprecated.
+        Returns:
+        Examples::
+            >>> from transformers import BertTokenizer, BertForPreTraining
+            >>> import torch
+            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+            >>> model = BertForPreTraining.from_pretrained('bert-base-uncased', return_dict=True)
+            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+            >>> outputs = model(**inputs)
+            >>> prediction_logits = outptus.prediction_logits
+            >>> seq_relationship_logits = outputs.seq_relationship_logits
+        """
+        if "masked_lm_labels" in kwargs:
+            warnings.warn(
+                "The `masked_lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.",
+                FutureWarning,
+            )
+            labels = kwargs.pop("masked_lm_labels")
+        assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output, pooled_output = outputs[:2]
+        prediction_scores, seq_relationship_score = self.cls(sequence_output, pooled_output)
+        total_loss = None
+        if labels is not None and next_sentence_label is not None:
+            loss_fct = CrossEntropyLoss()
+            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
+            next_sentence_loss = loss_fct(seq_relationship_score.view(-1, 2), next_sentence_label.view(-1))
+            total_loss = masked_lm_loss + next_sentence_loss
+        if not return_dict:
+            output = (prediction_scores, seq_relationship_score) + outputs[2:]
+            return ((total_loss,) + output) if total_loss is not None else output
+        return BertForPreTrainingOutput(
+            loss=total_loss,
+            prediction_logits=prediction_scores,
+            seq_relationship_logits=seq_relationship_score,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+@add_start_docstrings(
+    """Bert Model with a `language modeling` head on top for CLM fine-tuning. """, BERT_START_DOCSTRING
+)
+class BertLMHeadModel(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        if not config.is_decoder:
+            logger.warning("If you want to use `BertLMHeadModel` as a standalone, add `is_decoder=True.`")
+        self.bert = BertModel(config)
+        self.cls = BertOnlyMLMHead(config)
+        self.init_weights()
+    def get_output_embeddings(self):
+        return self.cls.predictions.decoder
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @replace_return_docstrings(output_type=CausalLMOutput, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+            encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
+                Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
+                if the model is configured as a decoder.
+            encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
+                Mask to avoid performing attention on the padding token indices of the encoder input. This mask
+                is used in the cross-attention if the model is configured as a decoder.
+                Mask values selected in ``[0, 1]``:
+                ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
+            labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
+                Labels for computing the left-to-right language modeling loss (next word prediction).
+                Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring)
+                Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels
+                in ``[0, ..., config.vocab_size]``
+        Returns:
+        Example::
+            >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig
+            >>> import torch
+            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased')
+            >>> config = BertConfig.from_pretrained("bert-base-cased")
+            >>> config.is_decoder = True
+            >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config, return_dict=True)
+            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+            >>> outputs = model(**inputs)
+            >>> prediction_logits = outputs.logits
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = outputs[0]
+        prediction_scores = self.cls(sequence_output)
+        lm_loss = None
+        if labels is not None:
+            # we are doing next-token prediction; shift prediction scores and input ids by one
+            shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous()
+            labels = labels[:, 1:].contiguous()
+            loss_fct = CrossEntropyLoss()
+            lm_loss = loss_fct(shifted_prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
+        if not return_dict:
+            output = (prediction_scores,) + outputs[2:]
+            return ((lm_loss,) + output) if lm_loss is not None else output
+        return CausalLMOutput(
+            loss=lm_loss,
+            logits=prediction_scores,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+    def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **model_kwargs):
+        input_shape = input_ids.shape
+        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
+        if attention_mask is None:
+            attention_mask = input_ids.new_ones(input_shape)
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+@add_start_docstrings("""Bert Model with a `language modeling` head on top. """, BERT_START_DOCSTRING)
+class BertForMaskedLM(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        if config.is_decoder:
+            logger.warning(
+                "If you want to use `BertForMaskedLM` make sure `config.is_decoder=False` for "
+                "bi-directional self-attention."
+            )
+        self.bert = BertModel(config)
+        self.cls = BertOnlyMLMHead(config)
+        self.init_weights()
+    def get_output_embeddings(self):
+        return self.cls.predictions.decoder
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="bert-base-uncased",
+        output_type=MaskedLMOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
+            Labels for computing the masked language modeling loss.
+            Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring)
+            Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels
+            in ``[0, ..., config.vocab_size]``
+        kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
+            Used to hide legacy arguments that have been deprecated.
+        """
+        if "masked_lm_labels" in kwargs:
+            warnings.warn(
+                "The `masked_lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.",
+                FutureWarning,
+            )
+            labels = kwargs.pop("masked_lm_labels")
+        assert "lm_labels" not in kwargs, "Use `BertWithLMHead` for autoregressive language modeling task."
+        assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = outputs[0]
+        prediction_scores = self.cls(sequence_output)
+        masked_lm_loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()  # -100 index = padding token
+            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
+        if not return_dict:
+            output = (prediction_scores,) + outputs[2:]
+            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
+        return MaskedLMOutput(
+            loss=masked_lm_loss,
+            logits=prediction_scores,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+    def prepare_inputs_for_generation(self, input_ids, attention_mask=None, **model_kwargs):
+        input_shape = input_ids.shape
+        effective_batch_size = input_shape[0]
+        #  add a dummy token
+        assert self.config.pad_token_id is not None, "The PAD token should be defined for generation"
+        attention_mask = torch.cat([attention_mask, attention_mask.new_zeros((attention_mask.shape[0], 1))], dim=-1)
+        dummy_token = torch.full(
+            (effective_batch_size, 1), self.config.pad_token_id, dtype=torch.long, device=input_ids.device
+        )
+        input_ids = torch.cat([input_ids, dummy_token], dim=1)
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+@add_start_docstrings(
+    """Bert Model with a `next sentence prediction (classification)` head on top. """,
+    BERT_START_DOCSTRING,
+)
+class BertForNextSentencePrediction(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.bert = BertModel(config)
+        self.cls = BertOnlyNSPHead(config)
+        self.init_weights()
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @replace_return_docstrings(output_type=NextSentencePredictorOutput, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        next_sentence_label=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+            next_sentence_label (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
+                Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair (see ``input_ids`` docstring)
+                Indices should be in ``[0, 1]``.
+                ``0`` indicates sequence B is a continuation of sequence A,
+                ``1`` indicates sequence B is a random sequence.
+        Returns:
+        Example::
+            >>> from transformers import BertTokenizer, BertForNextSentencePrediction
+            >>> import torch
+            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+            >>> model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased', return_dict=True)
+            >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
+            >>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
+            >>> encoding = tokenizer(prompt, next_sentence, return_tensors='pt')
+            >>> outputs = model(**encoding, next_sentence_label=torch.LongTensor([1]))
+            >>> logits = outputs.logits
+            >>> assert logits[0, 0] < logits[0, 1] # next sentence was random
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        pooled_output = outputs[1]
+        seq_relationship_scores = self.cls(pooled_output)
+        next_sentence_loss = None
+        if next_sentence_label is not None:
+            loss_fct = CrossEntropyLoss()
+            next_sentence_loss = loss_fct(seq_relationship_scores.view(-1, 2), next_sentence_label.view(-1))
+        if not return_dict:
+            output = (seq_relationship_scores,) + outputs[2:]
+            return ((next_sentence_loss,) + output) if next_sentence_loss is not None else output
+        return NextSentencePredictorOutput(
+            loss=next_sentence_loss,
+            logits=seq_relationship_scores,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+@add_start_docstrings(
+    """Bert Model transformer with a sequence classification/regression head on top (a linear layer on top of
+    the pooled output) e.g. for GLUE tasks. """,
+    BERT_START_DOCSTRING,
+)
+class BertForSequenceClassification(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.bert = BertModel(config)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+        self.init_weights()
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="bert-base-uncased",
+        output_type=SequenceClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
+            Labels for computing the sequence classification/regression loss.
+            Indices should be in :obj:`[0, ..., config.num_labels - 1]`.
+            If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
+            If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        pooled_output = outputs[1]
+        pooled_output = self.dropout(pooled_output)
+        logits = self.classifier(pooled_output)
+        loss = None
+        if labels is not None:
+            if self.num_labels == 1:
+                #  We are doing regression
+                loss_fct = MSELoss()
+                loss = loss_fct(logits.view(-1), labels.view(-1))
+            else:
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+@add_start_docstrings(
+    """Bert Model with a multiple choice classification head on top (a linear layer on top of
+    the pooled output and a softmax) e.g. for RocStories/SWAG tasks. """,
+    BERT_START_DOCSTRING,
+)
+class BertForMultipleChoice(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.bert = BertModel(config)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = nn.Linear(config.hidden_size, 1)
+        self.init_weights()
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, num_choices, sequence_length)"))
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="bert-base-uncased",
+        output_type=MultipleChoiceModelOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
+            Labels for computing the multiple choice classification loss.
+            Indices should be in ``[0, ..., num_choices-1]`` where `num_choices` is the size of the second dimension
+            of the input tensors. (see `input_ids` above)
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
+        input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
+        attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
+        token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
+        position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
+        inputs_embeds = (
+            inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
+            if inputs_embeds is not None
+            else None
+        )
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        pooled_output = outputs[1]
+        pooled_output = self.dropout(pooled_output)
+        logits = self.classifier(pooled_output)
+        reshaped_logits = logits.view(-1, num_choices)
+        loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(reshaped_logits, labels)
+        if not return_dict:
+            output = (reshaped_logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+        return MultipleChoiceModelOutput(
+            loss=loss,
+            logits=reshaped_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+@add_start_docstrings(
+    """Bert Model with a token classification head on top (a linear layer on top of
+    the hidden-states output) e.g. for Named-Entity-Recognition (NER) tasks. """,
+    BERT_START_DOCSTRING,
+)
+class BertForTokenClassification(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.bert = BertModel(config)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+        self.init_weights()
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="bert-base-uncased",
+        output_type=TokenClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
+            Labels for computing the token classification loss.
+            Indices should be in ``[0, ..., config.num_labels - 1]``.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = outputs[0]
+        sequence_output = self.dropout(sequence_output)
+        logits = self.classifier(sequence_output)
+        loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+            # Only keep active parts of the loss
+            if attention_mask is not None:
+                active_loss = attention_mask.view(-1) == 1
+                active_logits = logits.view(-1, self.num_labels)
+                active_labels = torch.where(
+                    active_loss, labels.view(-1), torch.tensor(loss_fct.ignore_index).type_as(labels)
+                )
+                loss = loss_fct(active_logits, active_labels)
+            else:
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+        return TokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+@add_start_docstrings(
+    """Bert Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
+    layers on top of the hidden-states output to compute `span start logits` and `span end logits`). """,
+    BERT_START_DOCSTRING,
+)
+class BertForQuestionAnswering(BertPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.bert = BertModel(config)
+        self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
+        self.init_weights()
+    @add_start_docstrings_to_callable(BERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="bert-base-uncased",
+        output_type=QuestionAnsweringModelOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        start_positions=None,
+        end_positions=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        start_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
+            Labels for position (index) of the start of the labelled span for computing the token classification loss.
+            Positions are clamped to the length of the sequence (`sequence_length`).
+            Position outside of the sequence are not taken into account for computing the loss.
+        end_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
+            Labels for position (index) of the end of the labelled span for computing the token classification loss.
+            Positions are clamped to the length of the sequence (`sequence_length`).
+            Position outside of the sequence are not taken into account for computing the loss.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = outputs[0]
+        logits = self.qa_outputs(sequence_output)
+        start_logits, end_logits = logits.split(1, dim=-1)
+        start_logits = start_logits.squeeze(-1)
+        end_logits = end_logits.squeeze(-1)
+        total_loss = None
+        if start_positions is not None and end_positions is not None:
+            # If we are on multi-GPU, split add a dimension
+            if len(start_positions.size()) > 1:
+                start_positions = start_positions.squeeze(-1)
+            if len(end_positions.size()) > 1:
+                end_positions = end_positions.squeeze(-1)
+            # sometimes the start/end positions are outside our model inputs, we ignore these terms
+            ignored_index = start_logits.size(1)
+            start_positions.clamp_(0, ignored_index)
+            end_positions.clamp_(0, ignored_index)
+            loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+            start_loss = loss_fct(start_logits, start_positions)
+            end_loss = loss_fct(end_logits, end_positions)
+            total_loss = (start_loss + end_loss) / 2
+        if not return_dict:
+            output = (start_logits, end_logits) + outputs[2:]
+            return ((total_loss,) + output) if total_loss is not None else output
+        return QuestionAnsweringModelOutput(
+            loss=total_loss,
+            start_logits=start_logits,
+            end_logits=end_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )