{"cells":[{"metadata":{},"cell_type":"markdown","source":"<center><h2>Import Libraries</h2><center>"},{"metadata":{"trusted":true,"_kg_hide-output":true},"cell_type":"code","source":"!pip install -q pyicu\n!pip install -q pycld2\n!pip install -q polyglot\n!pip install -q textstat\n!pip install -q googletrans","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true,"_kg_hide-input":true,"_kg_hide-output":true},"cell_type":"code","source":"import warnings\nwarnings.filterwarnings('ignore')\n\nimport os\nimport numpy as np\nimport pandas as pd\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport plotly.offline as plty\nimport plotly.express as px\nimport plotly.graph_objects as go\nfrom plotly.subplots import make_subplots\nimport plotly.figure_factory as ff\n\nfrom colorama import Fore, Back, Style, init\n\nimport spacy\nfrom wordcloud import WordCloud\n\nfrom polyglot.detect import Detector\nimport pycountry\n\nimport nltk\nfrom nltk.sentiment.vader import SentimentIntensityAnalyzer\n\nfrom googletrans import Translator\nimport textstat\n\nimport re\n\nfrom tqdm import tqdm, tqdm_notebook\ntqdm_notebook().pandas()\n\nfrom kaggle_datasets import KaggleDatasets\nimport transformers\nimport tensorflow as tf\nfrom tokenizers import BertWordPieceTokenizer\n\nfrom tensorflow.keras.callbacks import Callback\nfrom sklearn.metrics import accuracy_score, roc_auc_score\nfrom tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, CSVLogger\n\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.layers import Dense, Input, Dropout, Embedding\nfrom tensorflow.keras.layers import LSTM, GRU, Conv1D, SpatialDropout1D\n\nfrom tensorflow.keras import layers\nfrom tensorflow.keras import optimizers\nfrom tensorflow.keras import activations\nfrom tensorflow.keras import constraints\nfrom tensorflow.keras import initializers\nfrom tensorflow.keras import regularizers\n\nimport tensorflow.keras.backend as K\nfrom tensorflow.keras.layers import *\nfrom tensorflow.keras.optimizers import *\nfrom tensorflow.keras.activations import *\nfrom tensorflow.keras.constraints import *\nfrom tensorflow.keras.initializers import *\nfrom tensorflow.keras.regularizers import *\n\n# to set a style to all graphs\nplt.style.use('fivethirtyeight')\nsns.set_style(\"whitegrid\")\nsns.set_context(\"paper\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<center><h2>Load Data</h2></center>"},{"metadata":{"trusted":true},"cell_type":"code","source":"INPUT_DIR = '../input/jigsaw-multilingual-toxic-comment-classification/'\n\nTRAIN_PATH = INPUT_DIR + 'jigsaw-toxic-comment-train.csv'\nTEST_PATH = INPUT_DIR + 'test.csv'\nVAL_PATH = INPUT_DIR + 'validation.csv'\n\ntrain_df = pd.read_csv(TRAIN_PATH)\ntest_df = pd.read_csv(TEST_PATH)\nval_df = pd.read_csv(VAL_PATH)\n\ndisplay('TRAINING DATA')\ndisplay(train_df.head(5))\n\ndisplay('TEST DATA')\ndisplay(test_df.head(5))\n\ndisplay('VALIDATION DATA')\ndisplay(val_df.head(5))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<center><h2>Looking at the comments from Train data</h2></center>"},{"metadata":{"trusted":true},"cell_type":"code","source":"nlp = spacy.load('en_core_web_sm')\nstop_words = spacy.lang.en.stop_words.STOP_WORDS\n\n'''\ndef preprocess_text(text):\n    doc = nlp(text, disable=['ner','parser'])\n    lemmas = [token.lemma_ for token in doc]\n    a_lemmas = [lemma for lemma in lemmas if lemma.isalpha() and lemma not in stop_words]\n    return ' '.join(a_lemmas)\n\ntrain_comments = train_df['comment_text'].progress_apply(preprocess_text)\n'''\n#Create an o/p file for reading directly if session expires or new session\n#train_comments.to_csv('comments.csv')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_comments = pd.read_csv('../input/comments/comments.csv')\ntrain_comments.drop(train_comments.columns[0], axis=1, inplace=True)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"string = ' '.join(train_comments['comment_text'].dropna())\n\nwordcloud = WordCloud(max_font_size=None, background_color='black', collocations=False,\n                      width=1200, height=1000).generate(string.lower())\nfig = px.imshow(wordcloud)\nfig.update_layout(title_text='Common words in comments')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<b>\n    As of now we don't seen any toxic words in the above Word Cloud.<br> It seems those words have not been used frequently in the comments.</b>"},{"metadata":{},"cell_type":"markdown","source":"<h2>Let's Detect Languages and Countries</h2>\n\n![image.png](attachment:image.png)\n<br>\nWe will be using pycountry to get Full Language names and also the Country names","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"# This will return language code, eg: 'en' for English\ndef detect_language(text):\n    return Detector(\"\".join(x for x in text if x.isprintable()), quiet=True).languages[0].name\n\n\n#This function will Fetch Full Language Name by passing Language code\ndef get_full_name(lang_code):\n    try:\n        Name = pycountry.languages.get(alpha_2=lang_code).name\n    except:\n        Name = None\n    return Name\n\n\ntrain_df['lang_code'] = train_df['comment_text'].progress_apply(detect_language)\ntrain_df['lang'] = train_df['lang_code'].progress_apply(get_full_name)","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"_kg_hide-output":true,"trusted":true},"cell_type":"code","source":"def get_country(language):\n    if language == \"German\":\n        return \"Germany\"\n    if language == \"Scots\":\n        return \"Scotland\"\n    if language == \"Danish\":\n        return \"Denmark\"\n    if language == \"Arabic\":\n        return \"Saudi Arabia\"\n    if language == \"Spanish\":\n        return \"Spain\"\n    if language == \"Persian\":\n        return \"Iran\"\n    if language == \"Greek\":\n        return \"Greece\"\n    if language == \"Portuguese\":\n        return \"Portugal\"\n    if language == \"English\":\n        return \"United Kingdom\"\n    if language == \"Hindi\":\n        return \"India\"\n    if language == \"Albanian\":\n        return \"Albania\"\n    if language == \"Bosnian\":\n        return \"Bosnia and Herzegovina\"\n    if language == \"Croatian\":\n        return \"Croatia\"\n    if language == \"Dutch\":\n        return \"Netherlands\"\n    if language == \"Russian\":\n        return \"Russia\"\n    if language == \"Vietnamese\":\n        return \"Vietnam\"\n    if language == \"Somali\":\n        return \"Somalia\"\n    if language == \"Turkish\":\n        return \"Turkey\"\n    if language == \"Serbian\":\n        return \"Serbia\"\n    if language == \"Indonesian\":\n        return \"Indonesia\"\n    if language == \"Manx\":\n        return \"Ireland\"\n    if language == \"Scots\":\n        return \"Scotland\"\n    if language == \"Latin\":\n        return \"Holy See (Vatican City State)\"\n    if language == \"Afrikaans\":\n        return \"South Africa\"\n    return \"None\"","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_df['lang'].value_counts()[:10]","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"total_comments = train_df['lang_code'].count()\nenglish_comments = train_df['lang_code'].value_counts().loc['en']\nlanguages = ['English','Non-English']\ncount = [english_comments, total_comments-english_comments]\n\nfig = make_subplots(rows=1, cols=2, specs=[[{\"type\": \"bar\"}, {\"type\": \"pie\"}]])\nfig.add_trace(go.Bar(x=languages,y=count,text=count, marker_color=['#64D9D1','#D9636B']),\n             row=1, col=1)\nfig.add_trace(go.Pie(labels=languages, values=count, domain=dict(x=[0.5, 1.0]), marker_colors=['#64D9D1','#D9636B']), \n              row=1, col=2)\n\nfig.update_layout(height=600, width=800, title_text=\"English vs Non-English\", template='plotly_white')\n\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"It is clear that the comment section is mostly in English with more than 98% usage."},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"df = train_df['lang'].value_counts()[1:6].reset_index()\ndf.columns = ['Language','Count']\n\nfig = px.bar(df,\n             y=\"Language\", x=\"Count\", title=\"Non-English comments\", template=\"plotly_white\", \n             color=\"Language\", text=\"Count\", orientation=\"h\")\nfig.update_traces(marker=dict(line=dict(width=0.75,\n                                        color='black')),  textposition=\"outside\")\nfig.update_layout(showlegend=False)\nfig","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"df = train_df['lang'].value_counts().reset_index()\ndf.columns = ['Language','Count']\ndf[\"country\"] = df[\"Language\"].progress_apply(get_country)\n \n\nfig = px.choropleth(df.query(\"Language != 'English' and Language != 'un' and country != 'None'\").query(\"Count >= 5\"), locations=\"country\", hover_name=\"country\",\n                     projection=\"natural earth\", locationmode=\"country names\", title=\"Countries of non-English languages\", color=\"Count\",\n                     template=\"plotly\", color_continuous_scale=\"agsunset\")\n# fig.data[0].marker.line.color = 'rgb(0, 0, 0)'\n# fig.data[0].marker.line.width = 0.2\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"fig = px.choropleth(df.query(\"Language != 'English' and Language != 'un' and country != 'None'\"), locations=\"country\", hover_name=\"country\",\n                     projection=\"natural earth\", locationmode=\"country names\", title=\"Non-English European countries\", color=\"Count\",\n                     template=\"plotly\", color_continuous_scale=\"aggrnyl\", scope=\"europe\")\n# fig.data[0].marker.line.color = 'rgb(0, 0, 0)'\n# fig.data[0].marker.line.width = 0.2\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"fig = px.choropleth(df.query(\"Language != 'English' and Language != 'un' and country != 'None'\"), locations=\"country\", hover_name=\"country\",\n                     projection=\"natural earth\", locationmode=\"country names\", title=\"Asian countries\", color=\"Count\",\n                     template=\"plotly\", color_continuous_scale=\"spectral\", scope=\"asia\")\n# fig.data[0].marker.line.color = 'rgb(0, 0, 0)'\n# fig.data[0].marker.line.width = 0.2\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"fig = px.choropleth(df.query(\"Language != 'English' and Language != 'un' and country != 'None'\").query(\"Count >= 5\"), locations=\"country\", hover_name=\"country\",\n                     projection=\"natural earth\", locationmode=\"country names\", title=\"African countries\", color=\"Count\",\n                     template=\"plotly\", color_continuous_scale=\"agsunset\", scope=\"africa\")\n# fig.data[0].marker.line.color = 'rgb(0, 0, 0)'\n# fig.data[0].marker.line.width = 0.2\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Distribution of Comment Words"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Counting no of words in each comment\ntrain_df['word_count'] = train_df['comment_text'].progress_apply(lambda x : len([word for word in x.split() if type(word) is str]))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Top 3 most verbose comments"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_df.sort_values(by='word_count', ascending=False)[['comment_text','word_count']].head(3)","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"fig = plt.figure(figsize=(20,10))\nplt.suptitle('Distribuition of Word count', fontsize=30)\n\nax1 = fig.add_subplot(121)\n_ = sns.distplot(train_df['word_count'], bins=200,color='#e56b6f', ax=ax1)\n_ = ax1.set_ylabel('Distribution', fontsize=20)\n_ = ax1.set_xlabel('Word count', fontsize=20)\n\n\nax2 = fig.add_subplot(122)\n_ = plt.scatter(range(train_df.shape[0]), np.sort(train_df['word_count'].values), color='#2a9d8f')\n_ = ax2.set_ylabel('Word count', fontsize=20)\n_ = ax2.set_xlabel('Comments', fontsize=20)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Majority of the comments are having average number of words around 100.\nAlso from the scatter plot on the right we can see that more than 2 lakh comments have word count less than 100"},{"metadata":{},"cell_type":"markdown","source":"### Average Word count per Language"},{"metadata":{"trusted":true},"cell_type":"code","source":"top_15 = train_df.groupby('lang')['word_count'].mean().rename('Mean').reset_index().\\\n                                    sort_values(by='Mean', ascending=False)[:15]\nbottom_15 = train_df.groupby('lang')['word_count'].mean().rename('Mean').reset_index().\\\n                                    sort_values(by='Mean')[:15]","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"fig = make_subplots(rows=2, cols=1,subplot_titles=['Top 15', 'Bottom 15'])\n\nfig.add_trace(go.Bar(x=top_15['lang'], y=top_15['Mean']), row=1, col=1)\n\nfig.add_trace(go.Bar(x=bottom_15['lang'], y=bottom_15['Mean']), row=2, col=1)\n\nfig.update_layout(height=900, width=800,yaxis_title=\"Average comment words\", title_text=\"Average comment words vs. language\", template=\"plotly_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Translate comments"},{"metadata":{"trusted":true},"cell_type":"code","source":"translator = Translator()\n\ndef translate_text(comment_lang):\n    comment, lang = comment_lang[0], comment_lang[1]\n    try:\n        if (lang == 'English' or lang == None):\n            return comment\n        else:\n            return translator.translate(comment).text\n    except:\n        return None\n\ntrain_df['translated_comment'] = train_df[['comment_text','lang']].progress_apply(lambda x: translate_text(x), axis=1)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Sentiment Analysis\n![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"def polarity(text):\n    if type(text) == str:\n        return SIA.polarity_scores(text)\n    else:\n        return 1000\n    \nSIA = SentimentIntensityAnalyzer()\ntrain_df[\"polarity\"] = train_df[\"translated_comment\"].progress_apply(polarity)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Negative Sentiment\nNegative sentiment refers to negative or pessimistic emotions. It is a score between 0 and 1; the greater the score, the more negative the abstract is."},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"neg_pol = [pols['neg'] for pols in train_df[\"polarity\"] if type(pols) is dict]\nneg_pol = list(filter((0.0).__ne__, neg_pol))\n\nfig = go.Figure(go.Histogram(x=neg_pol, marker=dict(\n            color='seagreen')\n    ))\n\nfig.update_layout(xaxis_title=\"Negativity sentiment\", title_text=\"Negativity sentiment\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"From the above plot, we can see that negative sentiment has a strong rightward (positive) skew, indicating that negativity is usually on the lower side. This suggests that most comments are not toxic or negative. In fact, the most common negativity value is around 0.04. Virtually no comments have a negativity greater than 0.8."},{"metadata":{},"cell_type":"markdown","source":"### Negativity of Toxic vs Non-Toxic Comments"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"toxic = [x['neg'] for x in train_df.sample(frac=0.1).query(\"toxic == 1\")['polarity'] if type(x) == dict]\nnon_toxic = [x['neg'] for x in train_df.sample(frac=0.1).query(\"toxic == 0\")['polarity'] if type(x) == dict]\n\nfig = ff.create_distplot(hist_data=[toxic, non_toxic],\n                         group_labels=[\"Toxic\", \"Non-toxic\"],\n                         colors=[\"darkorange\", \"dodgerblue\"], show_hist=False)\n\nfig.update_layout(title_text=\"Negativity of Toxic vs Non-toxic\", xaxis_title=\"Negativity\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We can clearly see that toxic comments have a significantly greater negative sentiment than toxic comments (on average). The probability density of negativity peaks at around 0 for non-toxic comments, while the negativity for toxic comments are minimum at this point. This suggests that a comment is very likely to be non-toxic if it has a negativity of 0."},{"metadata":{},"cell_type":"markdown","source":"### Positive Sentiment\nPositive sentiment refers to positive or optimistic emotions. It is a score between 0 and 1; the greater the score, the more positive the abstract is."},{"metadata":{"trusted":true},"cell_type":"code","source":"pos_pol = [pols['pos'] for pols in train_df[\"polarity\"] if type(pols) is dict]\npos_pol = list(filter((0.0).__ne__, pos_pol))\n\nfig = go.Figure(go.Histogram(x=pos_pol, marker=dict(\n            color='seagreen')\n    ))\n\nfig.update_layout(xaxis_title=\"Positive sentiment\", title_text=\"Positive sentiment\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Neutral Sentiment\nNeutrality sentiment refers to the level of bias or opinion in the text. It is a score between 0 and 1; the greater the score, the more neutral/unbiased the abstract is."},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"neu_pol = [pols['neu'] for pols in train_df[\"polarity\"] if type(pols) is dict]\nneu_pol = list(filter((1.0).__ne__, neu_pol))\n\nfig = go.Figure(go.Histogram(x=neu_pol, marker=dict(\n            color='seagreen')\n    ))\n\nfig.update_layout(xaxis_title=\"Neutral sentiment\", title_text=\"Neutral sentiment\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"From the above plot, we can see that the neutrality sentiment distribution has a strong leftward (negative) skew, which is in constrast to the negativity and positivity sentiment distributions. This indicates that the comments tend to be very neutral and unbiased in general. This also suggests that most comments are not highly opinionated and polarizing, meaning that most comments are non-toxic."},{"metadata":{},"cell_type":"markdown","source":"### Compound sentiment\nCompoundness sentiment refers to the total level of sentiment in the sentence. It is a score between -1 and 1; the greater the score, the more emotional the abstract is."},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"neu_pol = [pols['compound'] for pols in train_df[\"polarity\"] if type(pols) is dict]\nneu_pol = list(filter((0.0).__ne__, neu_pol))\n\nfig = go.Figure(go.Histogram(x=neu_pol, marker=dict(\n            color='seagreen')\n    ))\n\nfig.update_layout(xaxis_title=\"Compound sentiment\", title_text=\"Compund sentiment\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"toxic = [x['compound'] for x in train_df.sample(frac=0.1).query(\"toxic == 1\")['polarity'] if type(x) == dict]\nnon_toxic = [x['compound'] for x in train_df.sample(frac=0.1).query(\"toxic == 0\")['polarity'] if type(x) == dict]\n\nfig = ff.create_distplot(hist_data=[toxic, non_toxic],\n                         group_labels=[\"Toxic\", \"Non-toxic\"],\n                         colors=[\"darkorange\", \"dodgerblue\"], show_hist=False)\n\nfig.update_layout(title_text=\"Compoundedness of Toxic vs Non-toxic\", xaxis_title=\"Compound\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We can see that compound sentiment tends to be higher for non-toxic comments as compared to toxic comments. The non-toxic distribution has a leftward (negative) skew, while the toxic distribution has a positive (rightward) skew. This indicates that non-toxic comments tend to have a higher compound sentiment than toxic comments on average."},{"metadata":{},"cell_type":"markdown","source":"### Readability \nReadability is an indication of how \"easy\" it is to read some text. There are several metrics that can be used to measure the readability of a piece of text, including Flesch reading ease, automated readability, and Dale-Chall readability."},{"metadata":{"trusted":true},"cell_type":"code","source":"train_df[\"flesch_reading_ease\"] = train_df[\"comment_text\"].progress_apply(textstat.flesch_reading_ease)\ntrain_df[\"automated_readability\"] = train_df[\"comment_text\"].progress_apply(textstat.automated_readability_index)\ntrain_df[\"dale_chall_readability\"] = train_df[\"comment_text\"].progress_apply(textstat.dale_chall_readability_score)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{},"cell_type":"markdown","source":"![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"fig = go.Figure(go.Histogram(x=train_df.query(\"flesch_reading_ease > 0\")[\"flesch_reading_ease\"], marker=dict(\n            color='darkorange')\n    ))\n\nfig.update_layout(xaxis_title=\"Flesch reading ease\", title_text=\"Flesch reading ease\", template=\"simple_white\")\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Target Variables"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Count of Different Negative categories of comments\ntrain_df[train_df.columns[2:8]].sum(axis=0).rename('Count').sort_values(ascending=False).reset_index()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Most toxic comments used in a Language"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_df.groupby(['lang'])[train_df.columns[2:8]].sum().sum(axis=1).rename('Toxic_count').sort_values(ascending=False)[:10].reset_index()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Word cloud of Negative Comments"},{"metadata":{},"cell_type":"markdown","source":"### Toxic"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"string = ' '.join(train_df.query('toxic == 1')['translated_comment'])\n\nwordcloud = WordCloud(max_font_size=None, background_color='black', collocations=False,\n                      width=1200, height=1000).generate(string.lower())\nfig = px.imshow(wordcloud)\nfig.update_layout(title_text='Toxic comments')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Obscene"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"string = ' '.join(train_df.query('obscene == 1')['translated_comment'])\n\nwordcloud = WordCloud(max_font_size=None, background_color='black', collocations=False,\n                      width=1200, height=1000).generate(string.lower())\nfig = px.imshow(wordcloud)\nfig.update_layout(title_text='Obscene comments')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Identity hate"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"string = ' '.join(train_df.query('identity_hate == 1')['translated_comment'])\n\nwordcloud = WordCloud(max_font_size=None, background_color='black', collocations=False,\n                      width=1200, height=1000).generate(string.lower())\nfig = px.imshow(wordcloud)\nfig.update_layout(title_text='Identity hate comments')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Threat"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"string = ' '.join(train_df.query('threat == 1')['translated_comment'])\n\nwordcloud = WordCloud(max_font_size=None, background_color='black', collocations=False,\n                      width=1200, height=1000).generate(string.lower())\nfig = px.imshow(wordcloud)\nfig.update_layout(title_text='Identity hate comments')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Modelling"},{"metadata":{},"cell_type":"markdown","source":"### Cleaning Comments"},{"metadata":{"trusted":true},"cell_type":"code","source":"val = val_df\ntrain = train_df\n\ndef clean(text):\n    text = text.fillna(\"fillna\").str.lower()\n    text = text.map(lambda x: re.sub('\\\\n',' ',str(x)))\n    text = text.map(lambda x: re.sub(\"\\[\\[User.*\",'',str(x)))\n    text = text.map(lambda x: re.sub(\"\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\",'',str(x)))\n    text = text.map(lambda x: re.sub(\"\\(http://.*?\\s\\(http://.*\\)\",'',str(x)))\n    return text\n\ntrain['comment_text'] = clean(train['comment_text'])\ntest_df['content'] = clean(test_df['content'])\nval['comment_text'] = clean(val['comment_text'])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Building Roc Auc evaluation metric"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Inheriting tf.keras.Callback\nclass RocAucEvaluation(Callback):\n    def __init__(self, validation_data=(), interval=1):\n        super(Callback, self).__init__()\n\n        self.interval = interval\n        self.X_val, self.y_val = validation_data\n\n    def on_epoch_end(self, epoch, logs={}):\n        if epoch % self.interval == 0:\n            y_pred = self.model.predict(self.X_val, verbose=0)\n            score = roc_auc_score(self.y_val, y_pred)\n            print(\"\\n ROC-AUC - epoch: {:d} - score: {:.6f}\".format(epoch+1, score))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Setting up function for Encoding comments"},{"metadata":{"trusted":true},"cell_type":"code","source":"def fast_encode(texts, tokenizer, chunk_size=240, maxlen=512):\n    tokenizer.enable_truncation(max_length=maxlen)\n    tokenizer.enable_padding(max_length=maxlen)\n    all_ids = []\n    \n    for i in range(0, len(texts), chunk_size):\n        text_chunk = texts[i:i+chunk_size].tolist()\n        encs = tokenizer.encode_batch(text_chunk)\n        all_ids.extend([enc.ids for enc in encs])\n    \n    return np.array(all_ids)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Setup TPU config"},{"metadata":{"trusted":true},"cell_type":"code","source":"AUTO = tf.data.experimental.AUTOTUNE\n\ntpu = tf.distribute.cluster_resolver.TPUClusterResolver()\ntf.config.experimental_connect_to_cluster(tpu)\ntf.tpu.experimental.initialize_tpu_system(tpu)\nstrategy = tf.distribute.experimental.TPUStrategy(tpu)\n\nGCS_DS_PATH = KaggleDatasets().get_gcs_path('jigsaw-multilingual-toxic-comment-classification')\n\nEPOCHS = 2\nBATCH_SIZE = 32 * strategy.num_replicas_in_sync","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Bert Tokenizer"},{"metadata":{"trusted":true},"cell_type":"code","source":"tokenizer = transformers.DistilBertTokenizer.from_pretrained('distilbert-base-multilingual-cased')\n\nsave_path = '/kaggle/working/distilbert_base_uncased/'\nif not os.path.exists(save_path):\n    os.makedirs(save_path)\ntokenizer.save_pretrained(save_path)\n\nfast_tokenizer = BertWordPieceTokenizer('distilbert_base_uncased/vocab.txt', \n                                        lowercase=True)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Encoding comments and generating token ids"},{"metadata":{"trusted":true},"cell_type":"code","source":"x_train_token_ids = fast_encode(train.comment_text.astype(str), \n                      fast_tokenizer, maxlen=512)\nx_valid_token_ids = fast_encode(val.comment_text.astype(str).values, \n                      fast_tokenizer, maxlen=512)\nx_test_token_ids = fast_encode(test_df.content.astype(str).values, \n                     fast_tokenizer, maxlen=512)\n\ny_valid = val.toxic.values\ny_train = train.toxic.values","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"## Token Ids for 1st comment tokens padded with 0s (max len = 512)\nx_train_token_ids[0][:100]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Define training, validation, and testing datasets"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_train_token_ids, y_train))\n    .repeat()\n    .shuffle(2048)\n    .batch(BATCH_SIZE)\n    .prefetch(AUTO)\n)\n\nvalid_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices((x_valid_token_ids, y_valid))\n    .batch(BATCH_SIZE)\n    .cache()\n    .prefetch(AUTO)\n)\n\ntest_dataset = (\n    tf.data.Dataset\n    .from_tensor_slices(x_test_token_ids)\n    .batch(BATCH_SIZE)\n)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Vanilla neural network\n\nVanilla neural network refers to the classic neural network architecture."},{"metadata":{},"cell_type":"markdown","source":"<center><img src=\"https://i.imgur.com/ReZ9Ppl.png\" width=\"500px\"></center>"},{"metadata":{},"cell_type":"markdown","source":"Vanilla neural networks consist of sequential layers that perform simple matrix multiplications and vector additions, until we reach the output layer. The propagation of values in a VNN can be represented with the following equation:\n\n<center><img src=\"https://i.imgur.com/xbtn9ex.png\" width=\"200px\"></center>\n\nwhere *W* is the weight matrix and *b* is the bias vector in layer *n*."},{"metadata":{},"cell_type":"markdown","source":"We will be using the pretrained BERT embeddings as input, add the word vectors, and pass it through a VNN and get the probability of the comment being toxic. The approach can be summarized using the flowchart below:\n\n<center><img src=\"https://i.imgur.com/ORDcivv.png\" width=\"315px\"></center>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def build_vnn_model(transformer, max_len):\n    input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"input_word_ids\")\n    \n    embed = transformer.weights[0].numpy()\n    embedding = Embedding(np.shape(embed)[0], np.shape(embed)[1],\n                          input_length=max_len, weights=[embed],\n                          trainable=False)(input_word_ids)\n    \n    conc = K.sum(embedding, axis=2)\n    conc = Dense(128, activation='relu')(conc)\n    conc = Dense(1, activation='sigmoid')(conc)\n    \n    model = Model(inputs=input_word_ids, outputs=conc)\n    \n    model.compile(Adam(lr=0.01), \n                  loss='binary_crossentropy', \n                  metrics=['accuracy'])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    transformer_layer = transformers.TFDistilBertModel.\\\n    from_pretrained('distilbert-base-multilingual-cased')\n    model_vnn = build_vnn_model(transformer_layer, max_len=512)\n\nmodel_vnn.summary()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Callbacks"},{"metadata":{"trusted":true},"cell_type":"code","source":"## Callback #1 - Reduce LR on Plateau\ndef callback():\n    cb = []\n\n    reduceLROnPlat = ReduceLROnPlateau(monitor='val_loss',  \n                                    factor=0.3, patience=3, \n                                    verbose=1, mode='auto', \n                                    epsilon=0.0001, cooldown=1, min_lr=0.000001)\n    cb.append(reduceLROnPlat)\n    log = CSVLogger('log.csv')\n    cb.append(log)\n\n    RocAuc = RocAucEvaluation(validation_data=(x_valid_token_ids, y_valid), interval=1)\n    cb.append(RocAuc)\n    \n    return cb\ncalls = callback()\n\n## Callback #2 - Simply decay learning rate after each step\n\"\"\"\ndef step_decay(epoch):\n    initial_lrate = 0.1\n    drop = 0.5\n    epochs_drop = 10.0\n    lrate = initial_lrate * math.pow(drop, math.floor((1+epoch)/epochs_drop))\n    return lrate\n\"\"\"\n\n## Callback #3 - learning rate scheduler\n\ndef build_lrfn(lr_start=0.00001, lr_max=0.00005, \n               lr_min=0.00001, lr_rampup_epochs=5, \n               lr_sustain_epochs=0, lr_exp_decay=.8):\n    lr_max = lr_max * strategy.num_replicas_in_sync\n\n    def lrfn(epoch):\n        if epoch < lr_rampup_epochs:\n            lr = (lr_max - lr_start) / lr_rampup_epochs * epoch + lr_start\n        elif epoch < lr_rampup_epochs + lr_sustain_epochs:\n            lr = lr_max\n        else:\n            lr = (lr_max - lr_min) *\\\n                 lr_exp_decay**(epoch - lr_rampup_epochs\\\n                                - lr_sustain_epochs) + lr_min\n        return lr\n    return lrfn\n\nlrfn = build_lrfn()\nlr_schedule = tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=1)\ncallbacks_list = [lr_schedule]","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Train the model"},{"metadata":{"trusted":true},"cell_type":"code","source":"STEPS_PER_EPOCH = x_train_token_ids.shape[0] // BATCH_SIZE\n\ntrain_history = model_vnn.fit(\n    train_dataset,\n    steps_per_epoch=STEPS_PER_EPOCH,\n    validation_data=valid_dataset,\n    \n    ## Using learning rate scheduler, tried running with all three callback methods, \n    ## Learning rate sceduler was considerably slower than LRonPlateau but the results were \n    ## more accurate\n    \n    callbacks = callbacks_list,  \n    epochs=10\n)","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"translator = Translator()\n\ndef visualize_model_preds(model, indices=[0, 17, 1, 24]):\n    comments = val_df.comment_text.loc[indices].values.tolist()\n    preds = model.predict(x_valid_token_ids[indices].reshape(len(indices), -1))\n\n    for idx, i in enumerate(indices):\n        if y_valid[i] == 0:\n            label = \"Non-toxic\"\n            color = f'{Fore.GREEN}'\n            symbol = '\\u2714'\n        else:\n            label = \"Toxic\"\n            color = f'{Fore.RED}'\n            symbol = '\\u2716'\n\n        print('{}{} {}'.format(color, str(idx+1) + \". \" + label, symbol))\n        print(f'{Style.RESET_ALL}')\n        print(\"ORIGINAL\")\n        print(comments[idx]); print(\"\")\n        print(\"TRANSLATED\")\n        print(translator.translate(comments[idx]).text)\n        fig = go.Figure()\n        if y_valid[i] == 1:\n            yl = [preds[idx][0], 1 - preds[idx][0]]\n        else:\n            yl = [1 - preds[idx][0], preds[idx][0]]\n        fig.add_trace(go.Bar(x=['Non-Toxic', 'Toxic'], y=yl, marker=dict(color=[\"seagreen\", \"indianred\"])))\n        fig.update_traces(name=comments[idx])\n        fig.update_layout(xaxis_title=\"Labels\", yaxis_title=\"Probability\", template=\"plotly_white\", title_text=\"Predictions for validation comment #{}\".format(idx+1))\n        fig.show()\n        \nvisualize_model_preds(model_vnn)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Vanilla Network Summary-\nValidation Accuracy - 84.61\n\n4 out 4 above validation samples predicted coorectly"},{"metadata":{},"cell_type":"markdown","source":"## Convolutional neural network \nConvolutional neural networks are a type of neural netork generally used for image recognition problems. But, the 1D version of CNNs can also be used for text-related problems (natural language processing). Convolution involves a process called convolution.\n\n**In text classification, a 1D variant of convolution is used where the kernel moves in only one dimension.**\n\nwe wil use the pretrained BERT embeddings as input, pass the embeddings through convolutional layers, and get the probability of the comment being toxic. The approach can be summarized using the flowchart below:\n\n<center><img src=\"https://i.imgur.com/7hsdV9T.png\" width=\"315px\"></center>"},{"metadata":{},"cell_type":"markdown","source":"### Convolution Neural Networks"},{"metadata":{"trusted":true},"cell_type":"code","source":"def build_cnn_model(transformer, max_len):\n    input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"input_word_ids\")\n    \n    embed = transformer.weights[0].numpy()\n    embedding = Embedding(np.shape(embed)[0], np.shape(embed)[1],\n                          input_length=max_len, weights=[embed],\n                          trainable=False)(input_word_ids)\n    \n    embedding = SpatialDropout1D(0.3)(embedding)\n    conv_1 = Conv1D(64, 2)(embedding)\n    conv_2 = Conv1D(64, 3)(embedding)\n    conv_3 = Conv1D(64, 4)(embedding)\n    conv_4 = Conv1D(64, 5)(embedding)\n    \n    maxpool_1 = GlobalAveragePooling1D()(conv_1)\n    maxpool_2 = GlobalAveragePooling1D()(conv_2)\n    maxpool_3 = GlobalAveragePooling1D()(conv_3)\n    maxpool_4 = GlobalAveragePooling1D()(conv_4)\n    conc = concatenate([maxpool_1, maxpool_2, maxpool_3, maxpool_4], axis=1)\n\n    conc = Dense(64, activation='relu')(conc)\n    conc = Dense(1, activation='sigmoid')(conc)\n    \n    model = Model(inputs=input_word_ids, outputs=conc)\n    \n    model.compile(Adam(lr=0.01), \n                  loss='binary_crossentropy', \n                  metrics=['accuracy'])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    model_cnn = build_cnn_model(transformer_layer, max_len=512)","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"from PIL import Image\nfrom IPython.display import SVG\nfrom keras.utils import model_to_dot\nSVG(tf.keras.utils.model_to_dot(model_cnn, dpi=70).create(prog='dot', format='svg'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_history = model_cnn.fit(\n    train_dataset,\n    steps_per_epoch=STEPS_PER_EPOCH,\n    validation_data=valid_dataset,\n    callbacks = callbacks_list,\n    epochs=10\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"visualize_model_preds(model_cnn)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Convolution Neural Network Summary-\nValidation Accuracy - 84.61\n\n4 out 4 above validation samples predicted correctly, however the probability of prediction for some samples are not extreme"},{"metadata":{},"cell_type":"markdown","source":"## LSTM with Attention\n \n\n### LSTM\n\nLSTMs are a type of neural network specifically made for NLP (text-related) tasks. In fact, LSTMs are a specific type of RNN. An RNN is a type of neural network that has a sense of direction (sequence). Classic neural networks look at all inputs at the same level, but RNNs look at inputs in a sequential order, which works well for text, as it is a sequential form of input.\n\nBut, RNNs have a problem called \"vanishing gradients\", which makes it difficult for it to understand long-term dependencies in text. Below is a depiction of the LSTM architecture which solves the problem of long-term dependencies:\n\n<center><img src=\"https://i.imgur.com/gmijcvr.png\" width=\"650px\"></center>\n\n### Attention\n\nAttention is a mathematical mechanism that allows a neural network to select its main areas of focus ina sequence. Understanding which part of the comment to focus on (based on mathematics and probabilities) can be crucial in predicting whether it is toxic or not. The Attention mechanism can be combined with LSTMs to produce excellent NLP models.\n\nThe approach can be summarized with flowchart below:\n\n\n<center><img src=\"https://i.imgur.com/SbFlht3.png\" width=\"315px\"></center>"},{"metadata":{},"cell_type":"markdown","source":"### Define the Attention Layer"},{"metadata":{"trusted":true},"cell_type":"code","source":"class AttentionWeightedAverage(Layer):\n\n    def __init__(self, return_attention=False, **kwargs):\n        self.init = initializers.get('uniform')\n        self.supports_masking = True\n        self.return_attention = return_attention\n        super(AttentionWeightedAverage, self).__init__(** kwargs)\n\n    def build(self, input_shape):\n        self.input_spec = [InputSpec(ndim=3)]\n        assert len(input_shape) == 3\n\n        self.W = self.add_weight(shape=(input_shape[2], 1),\n                                 name='{}_W'.format(self.name),\n                                 initializer=self.init)\n        super(AttentionWeightedAverage, self).build(input_shape)\n\n    def call(self, x, mask=None):\n        logits = K.dot(x, self.W)\n        x_shape = K.shape(x)\n        logits = K.reshape(logits, (x_shape[0], x_shape[1]))\n        ai = K.exp(logits - K.max(logits, axis=-1, keepdims=True))\n\n        if mask is not None:\n            mask = K.cast(mask, K.floatx())\n            ai = ai * mask\n        att_weights = ai / (K.sum(ai, axis=1, keepdims=True) + K.epsilon())\n        weighted_input = x * K.expand_dims(att_weights)\n        result = K.sum(weighted_input, axis=1)\n        if self.return_attention:\n            return [result, att_weights]\n        return result\n\n    def get_output_shape_for(self, input_shape):\n        return self.compute_output_shape(input_shape)\n\n    def compute_output_shape(self, input_shape):\n        output_len = input_shape[2]\n        if self.return_attention:\n            return [(input_shape[0], output_len), (input_shape[0], input_shape[1])]\n        return (input_shape[0], output_len)\n\n    def compute_mask(self, input, input_mask=None):\n        if isinstance(input_mask, list):\n            return [None] * len(input_mask)\n        else:\n            return None","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Define LSTM model"},{"metadata":{"trusted":true},"cell_type":"code","source":"def build_lstm_model(transformer, max_len):\n    input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"input_word_ids\")\n    \n    embed = transformer.weights[0].numpy()\n    embedding = Embedding(np.shape(embed)[0], np.shape(embed)[1],\n                          input_length=max_len, weights=[embed],\n                          trainable=False)(input_word_ids)\n    \n    embedding = SpatialDropout1D(0.3)(embedding)\n    lstm_1 = LSTM(128, return_sequences=True)(embedding)\n    lstm_2 = LSTM(128, return_sequences=True)(lstm_1)\n    \n    attention = AttentionWeightedAverage()(lstm_2)\n    conc = Dense(64, activation='relu')(attention)\n    conc = Dense(1, activation='sigmoid')(conc)\n    \n    model = Model(inputs=input_word_ids, outputs=conc)\n    \n    model.compile(Adam(lr=0.01), \n                  loss='binary_crossentropy', \n                  metrics=['accuracy'])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    model_lstm = build_lstm_model(transformer_layer, max_len=512)","execution_count":null,"outputs":[]},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"SVG(tf.keras.utils.model_to_dot(model_lstm, dpi=70).create(prog='dot', format='svg'))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Train LSTM model"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_history = model_lstm.fit(\n    train_dataset,\n    steps_per_epoch=STEPS_PER_EPOCH,\n    validation_data=valid_dataset,\n    callbacks = callbacks_list,\n    epochs=10\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"visualize_model_preds(model_lstm)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### LSTM summary-\n\nPretty better results till now"},{"metadata":{},"cell_type":"markdown","source":"## DistilBERT\n\n### BERT\n\nBERT (Bidirectional Encoder Representations from Transformers) was a paper published by researchers at Google AI Language, which caused a great stir in the NLP community as it became the SOTA on several NLP tasks.\n\nBERT’s key technical innovation is applying the bidirectional training of Transformer, a popular attention model, to language modelling. This is in contrast to previous efforts which looked at a text sequence either from left to right or combined left-to-right and right-to-left training (such as LSTMs). \n\nThe paper’s results show that a language model which is bidirectionally trained can have a deeper sense of language context and flow than single-direction language models. In the paper, the researchers detail a novel technique named Masked LM (MLM) which allows bidirectional training in models in which it was previously impossible.\n\n### DistilBERT\n\nDistilBERT is a lighter version of BERT (a very complex model) which uses fewer weights and achieves similar accuracies on several tasks with much lower training times. For this notebook, I will be using DistilBERT as it is easier to train in less time. The approach can be summarized with the flowchart below:\n\n<center><img src=\"https://i.imgur.com/6AGu9a4.png\" width=\"315px\"></center>"},{"metadata":{},"cell_type":"markdown","source":"### Define the model"},{"metadata":{"trusted":true},"cell_type":"code","source":"def build_distilbert_model(transformer, max_len=512):\n    input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"input_word_ids\")\n    sequence_output = transformer(input_word_ids)[0]\n    cls_token = sequence_output[:, 0, :]\n    cls_token = Dense(500, activation=\"elu\")(cls_token)\n    cls_token = Dropout(0.1)(cls_token)\n    out = Dense(1, activation='sigmoid')(cls_token)\n    \n    model = Model(inputs=input_word_ids, outputs=out)\n    \n    model.compile(Adam(lr=1.5e-5), \n                  loss='binary_crossentropy', \n                  metrics=['accuracy'])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    model_distilbert = build_distilbert_model(transformer_layer, max_len=512)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_history = model_distilbert.fit(\n    train_dataset,\n    steps_per_epoch=STEPS_PER_EPOCH,\n    validation_data=valid_dataset,\n    callbacks = callbacks_list,\n    epochs=2\n)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"visualize_model_preds(model_distilbert)","execution_count":null,"outputs":[]}],"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}