{"cells":[{"metadata":{},"cell_type":"markdown","source":"### About this notebook\n#### Hi everyone! I'm a beginner in NLP and happy to win a medal in this comp. This notebook is one part of my single model notebooks before blending with others' results. I think this single model performs well(public lb 0.9448). The main highlight is the downstream structure of the model, which is more suitable for novices like me for reference.\n\nThe entire notebook is based on the [baseline](https://www.kaggle.com/xhlulu/jigsaw-tpu-xlm-roberta) provided by [@xhlulu](https://www.kaggle.com/xhlulu/).\n\nFor the model, I used the [MLM finetuned XLM-R large](https://www.kaggle.com/riblidezso/jigsaw-mlm-finetuned-xlm-r-large) provided by [@riblidezso](https://www.kaggle.com/riblidezso).\n\nAnd it trains on the different translated data in [translated data(Google API)](https://www.kaggle.com/miklgr500/jigsaw-train-multilingual-coments-google-api) provided by [@miklgr500](https://www.kaggle.com/miklgr500).\n\n### References\n* Original Author:  [@xhlulu](https://www.kaggle.com/xhlulu/)\n\n* Original notebook:  [Link](https://www.kaggle.com/xhlulu/jigsaw-tpu-distilbert-with-huggingface-and-keras)\n\n* some functions for cleaning data: [link](https://www.kaggle.com/shonenkov/tpu-inference-super-fast-xlmroberta) by [@shonenkov](https://www.kaggle.com/shonenkov)\n\n* model:  [Link](https://www.kaggle.com/riblidezso/jigsaw-mlm-finetuned-xlm-r-large) by [@riblidezso](https://www.kaggle.com/riblidezso)\n\n* dataset:  [Link](https://www.kaggle.com/miklgr500/jigsaw-train-multilingual-coments-google-api) by [@miklgr500](https://www.kaggle.com/miklgr500)\n\nMany Thanks for their nice work!","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## Import What We Need","execution_count":null},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import os\n\nimport re\nimport numpy as np\nimport pandas as pd\nimport nltk\nnltk.download('punkt')\nfrom nltk import sent_tokenize\nimport transformers\nimport tensorflow as tf\nfrom tensorflow.keras.layers import Dense, Input, concatenate, GlobalMaxPooling1D, GlobalAveragePooling1D, Dropout, Conv1D\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.callbacks import ModelCheckpoint\nfrom kaggle_datasets import KaggleDatasets\n\nfrom transformers import TFAutoModel, AutoTokenizer, AutoConfig\nfrom tqdm.notebook import tqdm\nfrom tokenizers import Tokenizer, models, pre_tokenizers, decoders, processors\n\ndef seed_everything(seed=0):\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    os.environ['TF_DETERMINISTIC_OPS'] = '1'\nSEED = 40\nseed_everything(SEED)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Helper Functions","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def regular_encode(texts, tokenizer, maxlen=512):\n    enc_di = tokenizer.batch_encode_plus(\n        texts, \n        return_attention_masks=True, \n        return_token_type_ids=True,\n        pad_to_max_length=True,\n        max_length=maxlen\n    )\n    return np.array(enc_di['input_ids'],dtype=np.int32),np.array(enc_di['attention_mask'],dtype=np.int32),np.array(enc_di['token_type_ids'],dtype=np.int32)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"LANGS = {\n    'en': 'english',\n    'it': 'italian', \n    'fr': 'french', \n    'es': 'spanish',\n    'tr': 'turkish', \n    'ru': 'russian',\n    'pt': 'portuguese'\n}\n\ndef get_sentences(text, lang='en'):\n    return sent_tokenize(text, LANGS.get(lang, 'english'))\n\ndef exclude_duplicate_sentences(text, lang='en'):\n    sentences = []\n    for sentence in get_sentences(text, lang):\n        sentence = sentence.strip()\n        if sentence not in sentences:\n            sentences.append(sentence)\n    return ' '.join(sentences)\n\ndef clean_text(text, lang='en'):\n    text = str(text)\n    text = re.sub(r'[0-9\"]', '', text)\n    text = re.sub(r'#[\\S]+\\b', '', text)\n    text = re.sub(r'@[\\S]+\\b', '', text)\n    text = re.sub(r'https?\\S+', '', text)\n    text = re.sub(r'\\s+', ' ', text)\n    text = exclude_duplicate_sentences(text, lang)\n    return text.strip()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Build model","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"#### I tried to combine various model structures in the downstream of xlm-roberta, and found that **stacking the last three layers and combining with CNN** brings the most outstanding effect (after parameter selection)","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"#last 3 layers\ndef build_model(transformer, max_len=512):\n    \"\"\"\n    https://www.kaggle.com/xhlulu/jigsaw-tpu-distilbert-with-huggingface-and-keras\n    \"\"\"\n    input_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"input_word_ids\")\n    input_mask = Input(shape=(max_len,), dtype=tf.int32, name=\"input_mask\")\n    segment_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"segment_ids\")\n\n#     sequence_output = transformer((input_ids,input_mask,segment_ids))[0] #the last layer [batch, seq_len, dim] dim=1024\n#     cls_token = sequence_output[:, 0, :]\n    _, _, hs = transformer((input_ids,input_mask,segment_ids)) #[batch, seq_len, dim]\n    x = tf.stack([hs[-1],hs[-2],hs[-3]])    #[3, batch, seq_len, dim]\n    sequence_output = tf.reduce_mean(x, axis = 0)         #[batch, seq_len, dim]\n    \n    pool_output = []\n    kernel_sizes = [3, 4, 5] \n    for kernel_size in kernel_sizes:\n        c = Conv1D(filters=64, kernel_size=kernel_size, padding='same',activation='relu',strides=1)(sequence_output) #[batch, seq_len, 2]\n        p = GlobalMaxPooling1D()(c) #[batch, 2]\n        pool_output.append(p)\n    pool_output = concatenate([p for p in pool_output])    #[batch, 8]\n    \n#     sequence_output = pool_output\n#     gp = GlobalMaxPooling1D()(sequence_output) #[batch,dim]\n#     gp = Dropout(0.3)(gp)\n#     ap = GlobalAveragePooling1D()(sequence_output) #[batch,dim]\n#     ap = Dropout(0.3)(ap)\n#     stack = concatenate([gp,ap],axis=1) #[batch,2*dim]\n#     out = Dropout(0.3)(stack)\n    out = pool_output\n    out = Dropout(0.3)(out)\n    out = Dense(64, activation='relu')(out) #[batch,1]\n    out = Dropout(0.3)(out)\n    out = Dense(1, activation='sigmoid')(out) #[batch,1]\n    \n    model = Model(inputs=[input_ids,input_mask,segment_ids], outputs=out)\n    model.compile(Adam(lr=0.2e-5), loss='binary_crossentropy', metrics=['accuracy',tf.keras.metrics.AUC()])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## TPU Configs","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Detect hardware, return appropriate distribution strategy\ntry:\n    # TPU detection. No parameters necessary if TPU_NAME environment variable is\n    # set: this is always the case on Kaggle.\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n    print('Running on TPU ', tpu.master())\nexcept ValueError:\n    tpu = None\n\nif tpu:\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nelse:\n    # Default distribution strategy in Tensorflow. Works on CPU and single GPU.\n    strategy = tf.distribute.get_strategy()\n\nprint(\"REPLICAS: \", strategy.num_replicas_in_sync)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"AUTO = tf.data.experimental.AUTOTUNE\n\n# Data access\n# GCS_DS_PATH = KaggleDatasets().get_gcs_path()\n\n# Configuration\nEPOCHS = 2\nBATCH_SIZE = 16 * strategy.num_replicas_in_sync\nMAX_LEN = 210\nMODEL = 'jplu/tf-xlm-roberta-large'\nPRETRAINED_MODEL = '/kaggle/input/jigsaw-mlm-finetuned-xlm-r-large'","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Create tokenizer","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# Load the real tokenizer\ntokenizer = AutoTokenizer.from_pretrained(MODEL)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Data Processing","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train1 = pd.read_csv(\"/kaggle/input/jigsaw-multilingual-toxic-comment-classification/jigsaw-toxic-comment-train.csv\")\ntrain2 = pd.read_csv(\"/kaggle/input/jigsaw-multilingual-toxic-comment-classification/jigsaw-unintended-bias-train.csv\")\ntrain2.toxic = train2.toxic.round().astype(int)\n\nvalid = pd.read_csv('/kaggle/input/jigsaw-multilingual-toxic-comment-classification/validation.csv')\ntest = pd.read_csv('/kaggle/input/jigsaw-multilingual-toxic-comment-classification/test.csv')\nsub = pd.read_csv('/kaggle/input/jigsaw-multilingual-toxic-comment-classification/sample_submission.csv')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train3 = pd.read_csv(\"/kaggle/input/jigsaw-train-multilingual-coments-google-api/jigsaw-toxic-comment-train-google-tr-cleaned.csv\")\ntrain4 = pd.read_csv(\"/kaggle/input/jigsaw-train-multilingual-coments-google-api/jigsaw-toxic-comment-train-google-it-cleaned.csv\")\ntrain5 = pd.read_csv(\"/kaggle/input/jigsaw-train-multilingual-coments-google-api/jigsaw-toxic-comment-train-google-pt-cleaned.csv\")\ntrain6 = pd.read_csv(\"/kaggle/input/jigsaw-train-multilingual-coments-google-api/jigsaw-toxic-comment-train-google-ru-cleaned.csv\")\ntrain7 = pd.read_csv(\"/kaggle/input/jigsaw-train-multilingual-coments-google-api/jigsaw-toxic-comment-train-google-fr-cleaned.csv\")\ntrain8 = pd.read_csv(\"/kaggle/input/jigsaw-train-multilingual-coments-google-api/jigsaw-toxic-comment-train-google-es-cleaned.csv\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import seaborn as sns\nsns.countplot(valid['lang'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.countplot(test['lang'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train1['toxic'].value_counts()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### We sample subsets from each datasets.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train = pd.concat([\n    train1[['comment_text', 'toxic']],\n    train2[['comment_text', 'toxic']].query('toxic==1').sample(n=60000, random_state=12312),\n    train2[['comment_text', 'toxic']].query('toxic==0').sample(n=60000, random_state=42323),\n    ])\ntrain_tr = pd.concat([\n    train3[['comment_text', 'toxic']].query('toxic==1'),\n    train3[['comment_text', 'toxic']].query('toxic==0').sample(n=50000, random_state=23412),\n])\ntrain_it = pd.concat([\n    train4[['comment_text', 'toxic']].query('toxic==1'),\n    train4[['comment_text', 'toxic']].query('toxic==0').sample(n=50000, random_state=23412),\n])\ntrain_pt = pd.concat([\n    train5[['comment_text', 'toxic']].query('toxic==1'),\n    train5[['comment_text', 'toxic']].query('toxic==0').sample(n=50000, random_state=75293),\n])\ntrain_ru = pd.concat([\n    train6[['comment_text', 'toxic']].query('toxic==1'),\n    train6[['comment_text', 'toxic']].query('toxic==0').sample(n=50000, random_state=17479),\n])\ntrain_fr = pd.concat([\n    train7[['comment_text', 'toxic']].query('toxic==1'),\n    train7[['comment_text', 'toxic']].query('toxic==0').sample(n=50000, random_state=56321),\n])\ntrain_es = pd.concat([\n    train8[['comment_text', 'toxic']].query('toxic==1'),\n    train8[['comment_text', 'toxic']].query('toxic==0').sample(n=50000, random_state=45874),\n])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train['comment_text'] = train['comment_text'].apply(lambda x : clean_text(x))\nvalid['comment_text'] = valid['comment_text'].apply(lambda x : clean_text(x))\n\ntrain_tr['comment_text'] = train_tr['comment_text'].apply(lambda x : clean_text(x,lang='tr'))\ntrain_pt['comment_text'] = train_pt['comment_text'].apply(lambda x : clean_text(x,lang='pt'))\ntrain_it['comment_text'] = train_it['comment_text'].apply(lambda x : clean_text(x,lang='it'))\ntrain_ru['comment_text'] = train_ru['comment_text'].apply(lambda x : clean_text(x,lang='ru'))\ntrain_fr['comment_text'] = train_fr['comment_text'].apply(lambda x : clean_text(x,lang='fr'))\ntrain_es['comment_text'] = train_es['comment_text'].apply(lambda x : clean_text(x,lang='es'))\ntest['content'] = test['content'].apply(lambda x : clean_text(x))\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time \n\nx_train = regular_encode(train.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_train_tr = regular_encode(train_tr.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_train_pt = regular_encode(train_pt.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_train_it = regular_encode(train_it.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_train_ru = regular_encode(train_ru.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_train_fr = regular_encode(train_fr.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_train_es = regular_encode(train_es.comment_text.values, tokenizer, maxlen=MAX_LEN)\n\nx_valid = regular_encode(valid.comment_text.values, tokenizer, maxlen=MAX_LEN)\nx_test = regular_encode(test.content.values, tokenizer, maxlen=MAX_LEN)\n\ny_train = train.toxic.values\ny_train_tr = train_tr.toxic.values\ny_train_pt = train_pt.toxic.values\ny_train_it = train_it.toxic.values\ny_train_ru = train_ru.toxic.values\ny_train_fr = train_fr.toxic.values\ny_train_es = train_es.toxic.values\n\ny_valid = valid.toxic.values","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Build datasets objects","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train, y_train))\n    .shuffle(len(train))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\ntrain_tr_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_tr, y_train_tr))\n    .shuffle(len(train_tr))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\ntrain_it_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_it, y_train_it))\n    .shuffle(len(train_it))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\ntrain_pt_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_pt, y_train_pt))\n    .shuffle(len(train_pt))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\ntrain_ru_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_ru, y_train_ru))\n    .shuffle(len(train_ru))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\ntrain_fr_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_fr, y_train_fr))\n    .shuffle(len(train_fr))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\ntrain_es_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_es, y_train_es))\n    .shuffle(len(train_es))\n    .batch(BATCH_SIZE)\n    .repeat()\n    .prefetch(AUTO)\n)\nvalid_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_valid, y_valid))\n    .batch(BATCH_SIZE)\n    .cache()\n    .prefetch(AUTO)\n)\n# test_dataset = (\n#     tf.data.Dataset\n#     .from_tensor_slices(x_test)\n#     .batch(BATCH_SIZE)\n# )","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Load model into the TPU","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\nwith strategy.scope():\n    config = AutoConfig.from_pretrained(PRETRAINED_MODEL)\n    config.output_hidden_states = True\n    transformer_layer = TFAutoModel.from_pretrained(PRETRAINED_MODEL,config=config)\n    model = build_model(transformer_layer, max_len=MAX_LEN)\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Train Model","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"#### We train on the different translated training set respectively.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"n_steps = train_tr.shape[0] // BATCH_SIZE\ntrain_history = model.fit(\n    train_tr_dataset,\n    steps_per_epoch=n_steps,\n    validation_data=valid_dataset,\n    epochs=EPOCHS+1,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"n_steps = train_it.shape[0] // BATCH_SIZE\ntrain_history = model.fit(\n    train_it_dataset,\n    steps_per_epoch=n_steps,\n    validation_data=valid_dataset,\n    epochs=EPOCHS,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"n_steps = train_pt.shape[0] // BATCH_SIZE\ntrain_history = model.fit(\n    train_pt_dataset,\n    steps_per_epoch=n_steps,\n    validation_data=valid_dataset,\n    epochs=EPOCHS,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"n_steps = train_ru.shape[0] // BATCH_SIZE\ntrain_history = model.fit(\n    train_ru_dataset,\n    steps_per_epoch=n_steps,\n    validation_data=valid_dataset,\n    epochs=EPOCHS,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"n_steps = train_fr.shape[0] // BATCH_SIZE\ntrain_history = model.fit(\n    train_fr_dataset,\n    steps_per_epoch=n_steps,\n    validation_data=valid_dataset,\n    epochs=EPOCHS,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"n_steps = train_es.shape[0] // BATCH_SIZE\ntrain_history = model.fit(\n    train_es_dataset,\n    steps_per_epoch=n_steps,\n    validation_data=valid_dataset,\n    epochs=EPOCHS,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#test dataset do not include Engish reviews\n# n_steps = train.shape[0] // BATCH_SIZE\n# train_history = model.fit(\n#     train_dataset,\n#     steps_per_epoch=n_steps,\n#     validation_data=valid_dataset,\n#     epochs=EPOCHS,\n#     shuffle=False,\n# )","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### We train it for five more epochs on the `validation` set, because the `validation` set seems to be similar to the `test` set.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\nn_steps = valid.shape[0] // BATCH_SIZE\ntrain_history_2 = model.fit(\n    valid_dataset.repeat(),\n    steps_per_epoch=n_steps,\n    epochs=5,\n    verbose=2,\n    shuffle=False,\n)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Submission","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"sub['toxic'] = model.predict(x_test, verbose=1)\nsub.to_csv('submission.csv', index=False)\nsub.head(10)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## What's more\n### My final result is blend of awesome kernels [notebooks](https://www.kaggle.com/c/jigsaw-multilingual-toxic-comment-classification/notebooks) and all my results. The flowing image shows how I change the model structure and use [single language dataset](https://www.kaggle.com/kashnitsky/jigsaw-multilingual-toxic-test-translated) and [multilingual dataset](https://www.kaggle.com/miklgr500/jigsaw-train-multilingual-coments-google-api) to get more single-model results.\n![%E8%B0%83%E5%8F%82%E8%AE%B0%E5%BD%95.png](attachment:%E8%B0%83%E5%8F%82%E8%AE%B0%E5%BD%95.png)","attachments":{"%E8%B0%83%E5%8F%82%E8%AE%B0%E5%BD%95.png":{"image/png":"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"}},"execution_count":null}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}