Train on the Kaggle dataset using the pretrained model¶
Download the Kaggle API¶
In [7]:
!pip install -q kaggle
Import Packages¶
In [8]:
from google.colab import drive, files
import tensorflow as tf
import tensorflow_hub as hub
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import zipfile
from sklearn import model_selection
drive.mount('/content/gdrive')
Import the Secret Key in order to download the data from kaggle¶
In [9]:
import os
import pathlib
# Upload the API token.
def get_kaggle():
try:
import kaggle
return kaggle
except OSError:
pass
token_file = pathlib.Path("~/.kaggle/kaggle.json").expanduser()
token_file.parent.mkdir(exist_ok=True, parents=True)
try:
from google.colab import files
except ImportError:
raise ValueError("Could not find kaggle token.")
uploaded = files.upload()
token_content = uploaded.get('kaggle.json', None)
if token_content:
token_file.write_bytes(token_content)
token_file.chmod(0o600)
else:
raise ValueError('Need a file named "kaggle.json"')
import kaggle
return kaggle
kaggle = get_kaggle()
Download the data from Kaggle and import as Dataframe object¶
- The data we download from Kaggle need to be unzip.
- We will split the training data into 2 part (validation and train).
In [10]:
# Download data from Kaggle and create a DataFrame.
def load_data_from_zip(path):
with zipfile.ZipFile(path, "r") as zip_ref:
name = zip_ref.namelist()[0]
with zip_ref.open(name) as zf:
return pd.read_csv(zf)
# The data does not come with a validation set so we'll create one from the
# training set.
def get_data(competition, train_file, test_file, validation_set_ratio=0.1):
data_path = pathlib.Path("data")
kaggle.api.competition_download_files(competition, data_path)
competition_path = (data_path/competition)
competition_path.mkdir(exist_ok=True, parents=True)
competition_zip_path = competition_path.with_suffix(".zip")
with zipfile.ZipFile(competition_zip_path, "r") as zip_ref:
zip_ref.extractall(competition_path)
train_df = load_data_from_zip(competition_path/train_file)
test_df = load_data_from_zip(competition_path/test_file)
# We split by sentence ids, because we don't want to have phrases belonging
# to the same sentence in both training and validation set.
train_df, validation_df = model_selection.train_test_split(
train_df,
test_size=0.3,
random_state=0)
print("Split the training data into %d training and %d validation examples." %
(len(train_df), len(validation_df)))
return train_df, validation_df, test_df
train_df, validation_df, test_df = get_data(
"jigsaw-toxic-comment-classification-challenge",
"train.csv.zip", "test.csv.zip")
In [11]:
test_df.head(5)
Out[11]:
In [12]:
train_df.head(5)
Out[12]:
Show the distribution of Result data¶
In [13]:
graph_df = train_df['toxic'].value_counts().to_frame()\
.join(train_df['severe_toxic'].value_counts().to_frame())\
.join(train_df['obscene'].value_counts().to_frame())\
.join(train_df['threat'].value_counts().to_frame())\
.join(train_df['insult'].value_counts().to_frame())\
.join(train_df['identity_hate'].value_counts().to_frame())\
graph_df.plot(kind='bar',figsize=(12, 6))
Out[13]:
Extract Label from data¶
- X -> The data we would like to train
- y -> The result we would like to predict
In [14]:
x_train = train_df['comment_text']
y_train = train_df.iloc[:, 2:]
x_val = validation_df['comment_text']
y_val = validation_df.iloc[:, 2:]
In [15]:
x_train.head()
Out[15]:
In [16]:
y_train.head()
Out[16]:
Use the pretrained model from tensorflow¶
- Train our model based on the universal sentence encoder.
- Set the output layer, must correspond to y_train's shape.
- Set some training information. Because the output is multi-label. We will use the loss function
tf.keras.losses.BinaryCrossentropy.
What is universal sentence encoder?¶
The Universal Sentence Encoder encodes text into high dimensional vectors that can be used for text classification, semantic similarity, clustering, and other natural language tasks. The pre-trained Universal Sentence Encoder is publicly available in Tensorflow-hub.
Application:¶
- Skip-thought: use the current sentence to predict the previous and next sentence.
- Response Prediction
- Natural Language Inference
In [17]:
class MyModel(tf.keras.Model):
def __init__(self, hub_url):
super().__init__()
self.hub_url = hub_url
self.embed = hub.load(self.hub_url)
self.sequential = tf.keras.Sequential([
tf.keras.layers.Dense(500),
tf.keras.layers.Dense(100),
tf.keras.layers.Dense(6),
tf.keras.layers.Activation('sigmoid')
])
def call(self, inputs):
inputs = tf.reshape(inputs, shape=[-1])
embedding = 6 * self.embed(inputs)
return self.sequential(embedding)
def get_config(self):
return {"hub_url":self.hub_url}
In [18]:
model = MyModel("https://tfhub.dev/google/nnlm-en-dim128/2")
model.compile(
loss = tf.keras.losses.BinaryCrossentropy(from_logits=True),
optimizer=tf.optimizers.Adam(),
metrics = [tf.keras.metrics.BinaryCrossentropy()])
In [19]:
history = model.fit(x=x_train, y=y_train,
validation_data=(x_val, y_val),
epochs = 25)
Use the trained Model to predict the test data.¶
- predict a probability for each of the six possible types of comment toxicity (toxic, severetoxic, obscene, threat, insult, identityhate).
- Export result to csv file.
In [25]:
test_df['comment_text'][1]
Out[25]:
In [22]:
test_df['comment_text']
Out[22]:
In [23]:
y_test = model.predict(test_df['comment_text'])
In [24]:
y_test
Out[24]:
In [28]:
result_df = pd.DataFrame(y_test, columns=y_train.columns)
result_df
Out[28]:
In [26]:
test_df['id']
Out[26]:
In [29]:
result_df.insert(0, 'id', test_df['id'])
In [30]:
result_df
Out[30]:
In [31]:
result_df.to_csv("submission.csv", index=False)
In [32]:
len(y_test)
Out[32]:
In [33]:
model.predict(["Mother fucker"])
Out[33]:
In [34]:
model.predict(["Starting a new AI project there are lots of things to consider, and getting a proof-of-concept going with whatever-bunch-of-tools-you-come-across is, probably, the way to go. But once this phase of the project is over you’ll need to think engineering!"])
Out[34]:
In [40]:
model.save_weights('my_model.h5')
In [ ]: