To run this:

- `pip3 install -r requirements.txt`

- For training, since we're using transfer learning, you first need to download, extract [GloVe](http://nlp.stanford.edu/data/glove.6B.zip) and put to `data` folder, this is a pre trained embedding vectors that map each word to its vector, two words that have similar meanings tend to have very close vectors, and so on.

```

from keras.preprocessing.text import Tokenizer

from keras.preprocessing.sequence import pad_sequences

from keras.utils import to_categorical

from keras.callbacks import ModelCheckpoint, TensorBoard

from sklearn.model_selection import train_test_split

import time

import numpy as np

import pickle

from utils import get_embedding_vectors, get_model, SEQUENCE_LENGTH, EMBEDDING_SIZE, TEST_SIZE

from utils import BATCH_SIZE, EPOCHS, int2label, label2int

def load_data():

"""

texts, labels = [], []

with open("data/SMSSpamCollection") as f:

for line in f:

split = line.split()

labels.append(split[0].strip())

texts.append(' '.join(split[1:]).strip())

return texts, labels

X, y = load_data()

tokenizer = Tokenizer()

tokenizer.fit_on_texts(X)

pickle.dump(tokenizer, open("results/tokenizer.pickle", "wb"))

X = tokenizer.texts_to_sequences(X)

print(X[0])

X = np.array(X)

y = np.array(y)

X = pad_sequences(X, maxlen=SEQUENCE_LENGTH)

print(X[0])

y = [ label2int[label] for label in y ]

y = to_categorical(y)

print(y[0])

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=7)

model = get_model(tokenizer=tokenizer, lstm_units=128)

model_checkpoint = ModelCheckpoint("results/spam_classifier_{val_loss:.2f}", save_best_only=True,

verbose=1)

tensorboard = TensorBoard(f"logs/spam_classifier_{time.time()}")

print("X_train.shape:", X_train.shape)

print("X_test.shape:", X_test.shape)

print("y_train.shape:", y_train.shape)

print("y_test.shape:", y_test.shape)

model.fit(X_train, y_train, validation_data=(X_test, y_test),

batch_size=BATCH_SIZE, epochs=EPOCHS,

callbacks=[tensorboard, model_checkpoint],

verbose=1)

result = model.evaluate(X_test, y_test)

loss = result[0]

accuracy = result[1]

precision = result[2]

recall = result[3]

print(f"[+] Accuracy: {accuracy*100:.2f}%")

print(f"[+] Precision: {precision*100:.2f}%")

print(f"[+] Recall: {recall*100:.2f}%")

import os

from utils import get_model, int2label, label2int

from keras.preprocessing.sequence import pad_sequences

import pickle

import numpy as np

SEQUENCE_LENGTH = 100

tokenizer = pickle.load(open("results/tokenizer.pickle", "rb"))

model = get_model(tokenizer, 128)

model.load_weights("results/spam_classifier_0.05")

def get_predictions(text):

sequence = tokenizer.texts_to_sequences([text])

# pad the sequence

sequence = pad_sequences(sequence, maxlen=SEQUENCE_LENGTH)

# get the prediction

prediction = model.predict(sequence)[0]

# one-hot encoded vector, revert using np.argmax

return int2label[np.argmax(prediction)]

while True:

text = input("Enter the mail:")

# convert to sequences

print(get_predictions(text))

import tqdm

import numpy as np

from keras.preprocessing.sequence import pad_sequences

from keras.layers import Embedding, LSTM, Dropout, Dense

from keras.models import Sequential

import keras_metrics

SEQUENCE_LENGTH = 100 # the length of all sequences (number of words per sample)

EMBEDDING_SIZE = 100 # Using 100-Dimensional GloVe embedding vectors

TEST_SIZE = 0.25 # ratio of testing set

BATCH_SIZE = 64

EPOCHS = 20 # number of epochs

label2int = {"ham": 0, "spam": 1}

int2label = {0: "ham", 1: "spam"}

def get_embedding_vectors(tokenizer, dim=100):

embedding_index = {}

with open(f"data/glove.6B.{dim}d.txt", encoding='utf8') as f:

for line in tqdm.tqdm(f, "Reading GloVe"):

values = line.split()

word = values[0]

vectors = np.asarray(values[1:], dtype='float32')

embedding_index[word] = vectors

word_index = tokenizer.word_index

# we do +1 because Tokenizer() starts from 1

embedding_matrix = np.zeros((len(word_index)+1, dim))

for word, i in word_index.items():

embedding_vector = embedding_index.get(word)

if embedding_vector is not None:

# words not found will be 0s

embedding_matrix[i] = embedding_vector

return embedding_matrix

def get_model(tokenizer, lstm_units):

"""

# get the GloVe embedding vectors

embedding_matrix = get_embedding_vectors(tokenizer)

model = Sequential()

model.add(Embedding(len(tokenizer.word_index)+1,

EMBEDDING_SIZE,

weights=[embedding_matrix],

trainable=False,

input_length=SEQUENCE_LENGTH))

model.add(LSTM(lstm_units, recurrent_dropout=0.2))

model.add(Dropout(0.3))

model.add(Dense(2, activation="softmax"))

# compile as rmsprop optimizer

# aswell as with recall metric

model.compile(optimizer="rmsprop", loss="categorical_crossentropy",

metrics=["accuracy", keras_metrics.precision(), keras_metrics.recall()])

model.summary()

return model