This is about RNN - Rebuild Model. I used below Model in Google Collab

 

LOADING THE IMDB DATASET:

from tensorflow.keras.datasets import imdb

(train_data, train_labels), (test_data, test_labels) = imdb.load_data(

    num_words=10000)

 

train_data[0]

 

train_labels[0]

 

max([max(sequence) for sequence in train_data])

 

Decoding reviews back to text

word_index = imdb.get_word_index()

reverse_word_index = dict(

    [(value, key) for (key, value) in word_index.items()])

decoded_review = " ".join(

    [reverse_word_index.get(i - 3, "?") for i in train_data[0]

 

PREPARING THE DATA:
Encoding the integer sequences via multi-hot encoding

import numpy as np

def vectorize_sequences(sequences, dimension=10000):

    results = np.zeros((len(sequences), dimension))

    for i, sequence in enumerate(sequences):

        for j in sequence:

            results[i, j] = 1.

    return results

x_train = vectorize_sequences(train_data)

x_test = vectorize_sequences(test_data)

 

x_train[0]

 

y_train = np.asarray(train_labels).astype("float32")

y_test = np.asarray(test_labels).astype("float32")

BUILDING THE MODEL:

Model Definition

from tensorflow import keras

from tensorflow.keras import layers

 

model = keras.Sequential([

    layers.Dense(16, activation="relu"),

    layers.Dense(16, activation="relu"),

    layers.Dense(1, activation="sigmoid")

])

 

Compiling the model

model.compile(optimizer="rmsprop",

              loss="binary_crossentropy",

              metrics=["accuracy"])

 

VALIDATING THE MODEL:

 

Setting aside a validation set

x_val = x_train[:10000]

partial_x_train = x_train[10000:]

y_val = y_train[:10000]

partial_y_train = y_train[10000:]

 

Training your model

history = model.fit(partial_x_train,

                    partial_y_train,

                    epochs=20,

                    batch_size=512,

                    validation_data=(x_val, y_val))

 

history_dict = history.history

history_dict.keys()

 

Plotting the training and validation loss

import matplotlib.pyplot as plt

history_dict = history.history

loss_values = history_dict["loss"]

val_loss_values = history_dict["val_loss"]

epochs = range(1, len(loss_values) + 1)

plt.plot(epochs, loss_values, "bo", label="Training loss")

plt.plot(epochs, val_loss_values, "b", label="Validation loss")

plt.title("Training and validation loss")

plt.xlabel("Epochs")

plt.ylabel("Loss")

plt.legend()

plt.show()

 

Plotting the training and validation accuracy

plt.clf()

acc = history_dict["accuracy"]

val_acc = history_dict["val_accuracy"]

plt.plot(epochs, acc, "bo", label="Training acc")

plt.plot(epochs, val_acc, "b", label="Validation acc")

plt.title("Training and validation accuracy")

plt.xlabel("Epochs")

plt.ylabel("Accuracy")

plt.legend()

plt.show()

 

Retraining the model from scratch

model = keras.Sequential([

    layers.Dense(16, activation="relu"),

    layers.Dense(16, activation="relu"),

    layers.Dense(1, activation="sigmoid")

])

model.compile(optimizer="rmsprop",

              loss="binary_crossentropy",

              metrics=["accuracy"])

model.fit(x_train, y_train, epochs=4, batch_size=512)

results = model.evaluate(x_test, y_test)

 

results

 

USING A TRAINED MODEL TO GENERATE PREDICTIONS ON NEW DATA

model.predict(x_test)

 

-------------------------

 

After using above model, I modified my model using below codes:

 

LOADING THE IMDB DATASET

# Increasing the number of words

from tensorflow.keras.datasets import imdb

(train_data, train_labels), (test_data, test_labels) = imdb.load_data(

    num_words=11000)

 

# Decoding reviews back to text

word_index = imdb.get_word_index()

reverse_word_index = dict(

    [(value, key) for (key, value) in word_index.items()])

decoded_review = " ".join(

    [reverse_word_index.get(i - 3, "?") for i in train_data[0]])

 

decoded_review

 

DATA PREPARATION

Encoding the integer sequences via multi-hot encoding

import numpy as np

def vectorize_sequences(sequences, dimension=11000):

    results = np.zeros((len(sequences), dimension))

    for i, sequence in enumerate(sequences):

        for j in sequence:

            results[i, j] = 1.

    return results

x_train = vectorize_sequences(train_data)

x_test = vectorize_sequences(test_data)

 

y_train = np.asarray(train_labels).astype("float32")

y_test = np.asarray(test_labels).astype("float32")

 

BUILDING THE MODEL

# Changing activation function from relu to tanh and changing the number of dense layers to 3 and its units from 32 to 64

from tensorflow import keras

from tensorflow.keras import layers

 

model = keras.Sequential([

    layers.Dense(64, activation="tanh"),

    layers.Dense(64, activation="tanh"),

    layers.Dense(64, activation="tanh"),

    layers.Dense(1, activation="sigmoid")

])

 

# Changed loss function to mean_squared_error

model.compile(optimizer="rmsprop",

              loss="mean_squared_error",

              metrics=["accuracy"])

 

VALIDATING THE MODEL

x_val = x_train[:11000]

partial_x_train = x_train[11000:]

y_val = y_train[:11000]

partial_y_train = y_train[11000:]

 

# Keeping number of epochs at 10

history = model.fit(partial_x_train,

                    partial_y_train,

                    epochs=10,

                    batch_size=512,

                    validation_data=(x_val, y_val))

history_dict = history.history

history_dict.keys()

 

Plotting the training and validation loss

import matplotlib.pyplot as plt

history_dict = history.history

loss_values = history_dict["loss"]

val_loss_values = history_dict["val_loss"]

epochs = range(1, len(loss_values) + 1)

plt.plot(epochs, loss_values, "bo", label="Training loss")

plt.plot(epochs, val_loss_values, "b", label="Validation loss")

plt.title("Training and validation loss")

plt.xlabel("Epochs")

plt.ylabel("Loss")

plt.legend()

plt.show()

 

plt.clf()

acc = history_dict["accuracy"]

val_acc = history_dict["val_accuracy"]

plt.plot(epochs, acc, "bo", label="Training acc")

plt.plot(epochs, val_acc, "b", label="Validation acc")

plt.title("Training and validation accuracy")

plt.xlabel("Epochs")

plt.ylabel("Accuracy")

plt.legend()

plt.show()

 

RETRAINING THE MODEL

# Changing the number of epochs to 2 where the val_loss is minimum and val_acc is second maximum

model = keras.Sequential([

    layers.Dense(64, activation="tanh"),

    layers.Dense(64, activation="tanh"),

    layers.Dense(64, activation="tanh"),

    layers.Dense(1, activation="sigmoid")

])

model.compile(optimizer="rmsprop",

              loss="mean_squared_error",

              metrics=["accuracy"])

model.fit(x_train, y_train, epochs=2, batch_size=512)

results = model.evaluate(x_test, y_test)

 

results

 

PREDICTING USING THE MODEL

model.predict(x_test)

 

------------------------------

 

QUESTION:

 

1. Is there any problem with my codes and or can you suggest anything we can add to make it better? Please provide code and explanation

 

Then answer the following questions:

• What modification(s) did you make?
• How did this impact accuracy?