IMPLEMENTSIMPLEVECTORADDITIONINTENSORFLOW

Aim

To implement a Simple Vector Addition using TensorFlow in Python.

Algorithm

Algorithm

Step 1 - Import the library

Step 2 – Initialize two vectors as x any y using constant function

Step 3 – Add both the vectors using add function

Step 4 – Display the output

Program

import numpy as np

import tensorflow as tf

x = [Link]([1, 2, 3, 4, 5])

y = [Link]([1, 2, 3, 4, 5])

z=[Link](x, y)

print(z)

Output

[Link]([ 2 4 6 8 10], shape=(5,), dtype=int32)

Aim

To implement a simple regression model using Keras in Python.

Algorithm

Step 1 - Import the library

Step 2 - Loading the Dataset

Step 3 - Creating Regression Model

Step 4 - Compiling the model

Step 5 - Fitting the model

Step 6 - Evaluating the model

Step 7 - Predicting the output

Program

from keras import models

from [Link] import Dense, Dropout

from [Link] import to_categorical

from [Link] import mnist

from [Link].vis_utils import model_to_dot

from [Link] import SVG

# Load data

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape((X_train.shape[0], 28*28))

X_train = X_train.astype('float32') / 255

X_test = X_test.reshape((X_test.shape[0],28*28))

X_test = X_test.astype('float32') / 255

y_train = to_categorical(y_train,10)

y_test = to_categorical(y_test,10)

# Build neural network

model = [Link]()

[Link](Dense(512, activation='relu'))
[Link](Dropout(0.5))

[Link](Dense(256, activation='relu'))

[Link](Dropout(0.25))

[Link](Dense(10))

# Compile model

[Link](optimizer='rmsprop',

loss='categorical_crossentropy',

metrics=['accuracy'])

# Train model

[Link](X_train, y_train,

batch_size=128,

epochs=2,

verbose=1,

validation_data=(X_test, y_test))

[Link]()

#Evaluating model

score = [Link](X_test, y_test, verbose=0)

print('Test loss:', score[0])

print('Test accuracy:', score[1])

#Predicting

y_pred = [Link](X_test)

print()

print(y_pred)

Output

Epoch 1/2

469/469 [==============================] - 3s 6ms/step - loss: 9.5282 - accuracy:

0.1621 - val_loss: 11.0893 - val_accuracy: 0.2014

469/469 [==============================] - 3s 6ms/step - loss: 9.7238 - accuracy:

0.1655 - val_loss: 7.7625 - val_accuracy: 0.2367

Model: "sequential_1"

_________________________________________________________________

Layer (type) Output Shape Param #

=================================================================

dense_3 (Dense) (None, 512) 401920

dropout_2 (Dropout) (None, 512) 0

dense_4 (Dense) (None, 256) 131328

dropout_3 (Dropout) (None, 256) 0

dense_5 (Dense) (None, 10) 2570

=================================================================

Total params: 535,818

Trainable params: 535,818

Non-trainable params: 0

_________________________________________________________________

Test loss: 7.762475967407227

Test accuracy: 0.23669999837875366

313/313 [==============================] - 0s 917us/step

[[ -4.273875 -4.0576115 -4.9126253 ... -5.84482 5.2502394

-4.8097253]

[ -4.555738 -5.793705 -6.7801566 ... -4.660957 4.9637175

-4.0144277]

[ -1.9521786 -3.6502404 -2.9680243 ... -2.8620088 2.7504675

...

[ -6.8836007 -6.544464 -8.085198 ... -8.431074 7.6601815

-8.05203 ]

[ -5.553829 -6.0648494 -6.8634663 ... -6.1897492 5.8377614

-5.449667 ]

[ -8.933447 -7.9666743 -10.311388 ... -7.3900075 8.031032

-7.837938 ]]
 2. A. Implement a multi-layer perceptron in TensorFlow Environment.

Aim

To implement a multi-layer perceptron using TensorFlow in Python.

Algorithm

Step 1: Import the necessary libraries.

Step 2: Download the dataset.

TensorFlow allows us to read the MNIST dataset and we can load it directly in the program

as a train and test dataset.

Step 3: Now we will convert the pixels into floating-point values.

Step 4: Understand the structure of the dataset

Step 5: Visualize the data.

Step 6: Form the Input, hidden, and output layers.

Step 7: Compile the model.

Step 8: Fit the model.

Step 9: Find Accuracy of the model.

Program

# importing modules

import tensorflow as tf

import numpy as np

from [Link] import Sequential

from [Link] import Flatten

from [Link] import Dense

from [Link] import Activation

import [Link] as plt

(x_train, y_train), (x_test, y_test) = [Link].load_data()

# Cast the records into float values

x_train = x_train.astype('float32')

x_test = x_test.astype('float32')
# normalize image pixel values by dividing

# by 255

gray_scale = 255

x_train /= gray_scale

x_test /= gray_scale

print("Feature matrix:", x_train.shape)

print("Target matrix:", x_test.shape)

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

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

fig, ax = [Link](10, 10)

k=0

for i in range(10):

for j in range(10):

ax[i][j].imshow(x_train[k].reshape(28, 28),

aspect='auto')

k += 1

[Link]()

model = Sequential([

# reshape 28 row * 28 column data to 28*28 rows

Flatten(input_shape=(28, 28)),

# dense layer 1

Dense(256, activation='sigmoid'),

# dense layer 2

Dense(128, activation='sigmoid'),

# output layer

Dense(10, activation='sigmoid'),

])
[Link](optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

[Link](x_train, y_train, epochs=10,

batch_size=2000,

validation_split=0.2)

results = [Link](x_test, y_test, verbose = 0)

print('test loss, test acc:', results)

Feature matrix: (60000, 28, 28)

Target matrix: (10000, 28, 28)

Feature matrix: (60000,)

Target matrix: (10000,)

Epoch 1/10

24/24 [==============================] - 1s 14ms/step - loss: 2.0874 - accuracy: 0.3941

- val_loss: 1.7334 - val_accuracy: 0.6237

Epoch 2/10

24/24 [==============================] - 0s 11ms/step - loss: 1.4023 - accuracy: 0.7329

- val_loss: 1.0575 - val_accuracy: 0.8115

Epoch 3/10

24/24 [==============================] - 0s 11ms/step - loss: 0.8895 - accuracy: 0.8204

- val_loss: 0.6979 - val_accuracy: 0.8616

Epoch 4/10

24/24 [==============================] - 0s 11ms/step - loss: 0.6294 - accuracy: 0.8618

- val_loss: 0.5178 - val_accuracy: 0.8853

Epoch 5/10

24/24 [==============================] - 0s 11ms/step - loss: 0.4909 - accuracy: 0.8842

- val_loss: 0.4190 - val_accuracy: 0.8982

Epoch 6/10

24/24 [==============================] - 0s 12ms/step - loss: 0.4119 - accuracy: 0.8965

- val_loss: 0.3614 - val_accuracy: 0.9068

Epoch 7/10
24/24 [==============================] - 0s 12ms/step - loss: 0.3638 - accuracy: 0.9047

- val_loss: 0.3260 - val_accuracy: 0.9130

Epoch 8/10

24/24 [==============================] - 0s 12ms/step - loss: 0.3310 - accuracy: 0.9106

- val_loss: 0.3002 - val_accuracy: 0.9193

Epoch 9/10

24/24 [==============================] - 0s 12ms/step - loss: 0.3070 - accuracy: 0.9155

- val_loss: 0.2815 - val_accuracy: 0.9242

Epoch 10/10

24/24 [==============================] - 0s 11ms/step - loss: 0.2878 - accuracy: 0.9195

- val_loss: 0.2668 - val_accuracy: 0.9253

test loss, test acc: [0.27316993474960327, 0.9235000014305115]

Aim

To implement a single-layer perceptron using TensorFlow in Python.

Algorithm

Step1: Import necessary libraries

Step 2: Now load the dataset using “Keras” from the imported version of tensor flow.

Step 3: Now display the shape and image of the single image in the dataset. The image size

contains a 28*28 matrix and length of the training set is 60,000 and the testing set is 10,000.

Step 4: Now normalize the dataset in order to compute the calculations in a fast and

accurate manner.

Step 5: Building a neural network with single-layer perception. Here we can observe as the

model is a single-layer perceptron that only contains one input layer and one output layer

there is no presence of the hidden layers.

Step 6: Output the accuracy of the model on the testing data.

Program

import numpy as np

import tensorflow as tf

from tensorflow import keras

import [Link] as plt

%matplotlib inline

(x_train, y_train),\

(x_test, y_test) = [Link].load_data()

len(x_train)

len(x_test)

x_train[0].shape

[Link](x_train[0])

# Normalizing the dataset

x_train = x_train/255

x_test = x_test/255

# Flatting the dataset in order

x_train_flatten = x_train.reshape(len(x_train), 28*28)

x_test_flatten = x_test.reshape(len(x_test), 28*28)

model = [Link]([

[Link](10, input_shape=(784,),

activation='sigmoid')

])

[Link](

optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

[Link](x_train_flatten, y_train, epochs=5)

[Link](x_test_flatten, y_test)

Output:

Epoch 1/5

1875/1875 [==============================] - 1s 679us/step - loss: 0.4709 - accuracy:

0.8760

Epoch 2/5

1875/1875 [==============================] - 1s 712us/step - loss: 0.3035 - accuracy:

0.9156

Epoch 3/5

1875/1875 [==============================] - 1s 635us/step - loss: 0.2834 - accuracy:

0.9210

Epoch 4/5

1875/1875 [==============================] - 1s 635us/step - loss: 0.2732 - accuracy:

0.9241

Epoch 5/5

1875/1875 [==============================] - 1s 616us/step - loss: 0.2666 - accuracy:

0.9256
313/313 [==============================] - 1s 661us/step - loss: 0.2677 - accuracy:

0.9246

[0.26773443818092346, 0.9246000051498413]
 3. Implement a Feed-Forward Network in TensorFlow/Keras.

Aim

To implement a Feed-Forward Network using TensorFlow in Python.

Algorithm

Step1: Import necessary libraries

Step 2: Now preparing training data (inputs-outputs).

Step 3: Preparing neural network parameters (weights and bias) using TensorFlow Variables

Step 4: Preparing inputs of the activation function

Step 5: Calculating the prediction error

Step 6: Minimizing the prediction error using gradient descent optimizer

Program

import tensorflow as tf

import numpy as np

# Preparing training data (inputs-outputs)

training_inputs_data = [[255, 0, 0],

[248, 80, 68],

[0, 0, 255],

[67, 15, 210]]

training_outputs_data = [[10], [20], [30], [40]]

# Preparing neural network parameters (weights and bias) using TensorFlow Variables

weights = [Link](initial_value=[[0.1], [0.2], [0.3]], dtype=tf.float32)

bias = [Link](initial_value=[[1]], dtype=tf.float32)

# Preparing inputs of the activation function

training_inputs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

training_outputs = [[10], [20], [30]] #Desired outputs for each input

af_input = [Link]([Link](training_inputs, tf.float32), weights) + bias

predictions = [Link](af_input)

# Calculating the prediction error

prediction_error = tf.reduce_sum(training_outputs - predictions)

# Minimizing the prediction error using gradient descent optimizer

learning_rate = 0.05

optimizer = [Link](learning_rate=learning_rate)

trainable_variables = [weights, bias] # List of variables to optimize

#train_op = [Link](prediction_error, var_list=trainable_variables)

#train_op =

[Link](learning_rate=0.05).minimize(prediction_error)

# Training loop of the neural network

for step in range(10000):

with [Link]() as tape:

af_input = [Link]([Link](training_inputs, tf.float32), weights) + bias

predictions = [Link](af_input)

prediction_error = tf.reduce_sum(training_outputs - predictions)

gradients = [Link](prediction_error, [weights, bias])

optimizer.apply_gradients(zip(gradients, [weights, bias]))

# Class scores of some testing data

test_inputs = [Link]([[255,0,0], [248,80,68],[0, 0, 255],[67,15,210]])

test_inputs_tensor = [Link](test_inputs, dtype=tf.float32)

test_predictions = [Link]([Link](test_inputs_tensor, weights) + bias)

print("Expected Scores: ", test_predictions.numpy())

Expected Scores: [[1.]

[1.]

[1.]

[1.]]
 4. Implement an Image Classifier using CNN in TensorFlow/Keras.

Aim

To implement an Image Classifier using CNN in TensorFlow using Python.

Algorithm

Step1: Import necessary libraries

Step 2: Download and prepare the CIFAR10 dataset

Step 3: Normalize pixel values to be between 0 and 1

Step 4: Create the convolutional base and Add Dense layers on top

Step 5: Compile and train the model

Step 6: Evaluate the model

Program

#Import TensorFlow

import tensorflow as tf

from [Link] import datasets, layers, models

import [Link] as plt

#Download and prepare the CIFAR10 dataset

(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# Normalize pixel values to be between 0 and 1

train_images, test_images = train_images / 255.0, test_images / 255.0

#Verify the data

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',

'dog', 'frog', 'horse', 'ship', 'truck']

[Link](figsize=(10,10))

for i in range(25):

[Link](5,5,i+1)

[Link]([])

[Link]([])

[Link](False)

[Link](train_images[i])
 # The CIFAR labels happen to be arrays,

# which is why you need the extra index

[Link](class_names[train_labels[i][0]])

[Link]()

#Create the convolutional base

model = [Link]()

[Link](layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))

[Link](layers.MaxPooling2D((2, 2)))

[Link](layers.Conv2D(64, (3, 3), activation='relu'))

[Link](layers.MaxPooling2D((2, 2)))

[Link](layers.Conv2D(64, (3, 3), activation='relu'))

[Link]()

#Add Dense layers on top

[Link]([Link]())

[Link]([Link](64, activation='relu'))

[Link]([Link](10))

[Link]()

#Compile and train the model

[Link](optimizer='adam',

loss=[Link](from_logits=True),

metrics=['accuracy'])

history = [Link](train_images, train_labels, epochs=10,

validation_data=(test_images, test_labels))

#Evaluate the model

[Link]([Link]['accuracy'], label='accuracy')

[Link]([Link]['val_accuracy'], label = 'val_accuracy')

[Link]('Epoch')

[Link]('Accuracy')

[Link]([0.5, 1])

[Link](loc='lower right')
test_loss, test_acc = [Link](test_images, test_labels, verbose=2)

print(test_acc)
Output

Downloading data from [Link]

170498071/170498071 [==============================] - 725s 4us/step

Model: "sequential"

_________________________________________________________________

Layer (type) Output Shape Param #

=================================================================

conv2d (Conv2D) (None, 30, 30, 32) 896

max_pooling2d (MaxPooling2D (None, 15, 15, 32) 0

conv2d_1 (Conv2D) (None, 13, 13, 64) 18496

max_pooling2d_1 (MaxPooling (None, 6, 6, 64) 0

2D)
conv2d_2 (Conv2D) (None, 4, 4, 64) 36928

=================================================================

Total params: 56,320

Trainable params: 56,320

Non-trainable params: 0

_________________________________________________________________

Model: "sequential"

_________________________________________________________________

Layer (type) Output Shape Param #

=================================================================

conv2d (Conv2D) (None, 30, 30, 32) 896

max_pooling2d (MaxPooling2D (None, 15, 15, 32) 0

conv2d_1 (Conv2D) (None, 13, 13, 64) 18496

max_pooling2d_1 (MaxPooling (None, 6, 6, 64) 0

2D)

conv2d_2 (Conv2D) (None, 4, 4, 64) 36928

flatten (Flatten) (None, 1024) 0

dense (Dense) (None, 64) 65600

dense_1 (Dense) (None, 10) 650

=================================================================

Total params: 122,570

Non-trainable params: 0

_________________________________________________________________

Epoch 1/10

1563/1563 [==============================] - 22s 13ms/step - loss: 1.5517 - accuracy:

0.4339 - val_loss: 1.2641 - val_accuracy: 0.5459

Epoch 2/10

1563/1563 [==============================] - 20s 13ms/step - loss: 1.1461 - accuracy:

0.5942 - val_loss: 1.0613 - val_accuracy: 0.6225

Epoch 3/10

1563/1563 [==============================] - 19s 12ms/step - loss: 0.9905 - accuracy:

0.6495 - val_loss: 1.0187 - val_accuracy: 0.6456

Epoch 4/10

1563/1563 [==============================] - 19s 12ms/step - loss: 0.8999 - accuracy:

0.6842 - val_loss: 0.9230 - val_accuracy: 0.6756

Epoch 5/10

1563/1563 [==============================] - 20s 13ms/step - loss: 0.8289 - accuracy:

0.7104 - val_loss: 0.9123 - val_accuracy: 0.6847

Epoch 6/10

1563/1563 [==============================] - 21s 13ms/step - loss: 0.7659 - accuracy:

0.7314 - val_loss: 0.8839 - val_accuracy: 0.6920

Epoch 7/10

1563/1563 [==============================] - 21s 13ms/step - loss: 0.7181 - accuracy:

0.7495 - val_loss: 0.8938 - val_accuracy: 0.6907

Epoch 8/10

1563/1563 [==============================] - 21s 13ms/step - loss: 0.6725 - accuracy:

0.7638 - val_loss: 0.9034 - val_accuracy: 0.6961

Epoch 9/10

1563/1563 [==============================] - 21s 13ms/step - loss: 0.6320 - accuracy:

0.7776 - val_loss: 0.9145 - val_accuracy: 0.6988

Epoch 10/10
1563/1563 [==============================] - 21s 14ms/step - loss: 0.5945 - accuracy:

0.7924 - val_loss: 0.8990 - val_accuracy: 0.7111

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

313/313 - 1s - loss: 0.8990 - accuracy: 0.7111 - 1s/epoch - 4ms/step

0.7110999822616577
 9. Perform Sentiment Analysis using RNN

Aim

To implement an Image Classifier using CNN in TensorFlow using Python.

Algorithm

Step1: Import necessary libraries

Step 2: Getting reviews with words that come under 5000 most occurring words in the entire

corpus of textual review data

Step 3: Getting all the words from word_index dictionary, again printing the review

Step 4: Get the minimum and the maximum length of reviews

Step 5: Keeping a fixed length of all reviews to max 400 words and fixing every word's

embedding size to be 32

Step 6: Creating a RNN model

Step 7: printing model summary

Step 8: Compiling model

Step 9: Training the model

Step 10: Printing model score on test data

Program

from [Link] import SimpleRNN, LSTM, GRU, Bidirectional, Dense, Embedding

from [Link] import imdb

from [Link] import Sequential

import numpy as np

# Getting reviews with words that come under 5000

# most occurring words in the entire

# corpus of textual review data

vocab_size = 5000

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)

print(x_train[0])

# Getting all the words from word_index dictionary

# Originally the index number of a value and not a key,

# hence converting the index as key and the words as values

word_idx = {i: word for word, i in word_idx.items()}

# again printing the review

print([word_idx[i] for i in x_train[0]])

# Get the minimum and the maximum length of reviews

print("Max length of a review:: ", len(max((x_train+x_test), key=len)))

print("Min length of a review:: ", len(min((x_train+x_test), key=len)))

from [Link] import sequence

# Keeping a fixed length of all reviews to max 400 words

max_words = 400

x_train = sequence.pad_sequences(x_train, maxlen=max_words)

x_test = sequence.pad_sequences(x_test, maxlen=max_words)

x_valid, y_valid = x_train[:64], y_train[:64]

x_train_, y_train_ = x_train[64:], y_train[64:]

# fixing every word's embedding size to be 32

embd_len = 32

# Creating a RNN model

RNN_model = Sequential(name="Simple_RNN")

RNN_model.add(Embedding(vocab_size,

embd_len,
 input_length=max_words))

# In case of a stacked(more than one layer of RNN)

# use return_sequences=True

RNN_model.add(SimpleRNN(128,

activation='tanh',

return_sequences=False))

RNN_model.add(Dense(1, activation='sigmoid'))

# printing model summary

print(RNN_model.summary())

# Compiling model

RNN_model.compile(

loss="binary_crossentropy",

optimizer='adam',

metrics=['accuracy']

# Training the model

history = RNN_model.fit(x_train_, y_train_,

batch_size=64,

epochs=5,

verbose=1,

validation_data=(x_valid, y_valid))

# Printing model score on test data

print()

print("Simple_RNN Score---> ", RNN_model.evaluate(x_test, y_test, verbose=0))

Downloading data from

[Link]

17464789/17464789 [==============================] - 0s 0us/step

[1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43,

838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111,

17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12,

16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8,

106, 5, 4, 2223, 2, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25,

1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 2, 15, 256, 4, 2, 7, 3766, 5,

723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32,

2071, 56, 26, 141, 6, 194, 2, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 2, 18, 51, 36, 28,

224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 2, 19,

178, 32]

Downloading data from

[Link]

1641221/1641221 [==============================] - 0s 0us/step

['the', 'as', 'you', 'with', 'out', 'themselves', 'powerful', 'lets', 'loves', 'their', 'becomes', 'reaching', 'had',

'journalist', 'of', 'lot', 'from', 'anyone', 'to', 'have', 'after', 'out', 'atmosphere', 'never', 'more', 'room',

'and', 'it', 'so', 'heart', 'shows', 'to', 'years', 'of', 'every', 'never', 'going', 'and', 'help', 'moments', 'or', 'of',

'every', 'chest', 'visual', 'movie', 'except', 'her', 'was', 'several', 'of', 'enough', 'more', 'with', 'is', 'now',

'current', 'film', 'as', 'you', 'of', 'mine', 'potentially', 'unfortunately', 'of', 'you', 'than', 'him', 'that', 'with',

'out', 'themselves', 'her', 'get', 'for', 'was', 'camp', 'of', 'you', 'movie', 'sometimes', 'movie', 'that', 'with',

'scary', 'but', 'and', 'to', 'story', 'wonderful', 'that', 'in', 'seeing', 'in', 'character', 'to', 'of', '70s', 'and',

'with', 'heart', 'had', 'shadows', 'they', 'of', 'here', 'that', 'with', 'her', 'serious', 'to', 'have', 'does', 'when',

'from', 'why', 'what', 'have', 'critics', 'they', 'is', 'you', 'that', "isn't", 'one', 'will', 'very', 'to', 'as', 'itself',

'with', 'other', 'and', 'in', 'of', 'seen', 'over', 'and', 'for', 'anyone', 'of', 'and', 'br', "show's", 'to', 'whether',

'from', 'than', 'out', 'themselves', 'history', 'he', 'name', 'half', 'some', 'br', 'of', 'and', 'odd', 'was', 'two',

'most', 'of', 'mean', 'for', '1', 'any', 'an', 'boat', 'she', 'he', 'should', 'is', 'thought', 'and', 'but', 'of', 'script',

'you', 'not', 'while', 'history', 'he', 'heart', 'to', 'real', 'at', 'and', 'but', 'when', 'from', 'one', 'bit', 'then',
'have', 'two', 'of', 'script', 'their', 'with', 'her', 'nobody', 'most', 'that', 'with', "wasn't", 'to', 'with', 'armed',

'acting', 'watch', 'an', 'for', 'with', 'and', 'film', 'want', 'an']

Max length of a review:: 2697

Min length of a review:: 70

Model: "Simple_RNN"

_________________________________________________________________

Layer (type) Output Shape Param #

=================================================================

embedding (Embedding) (None, 400, 32) 160000

simple_rnn (SimpleRNN) (None, 128) 20608

dense (Dense) (None, 1) 129

=================================================================

Total params: 180,737

Trainable params: 180,737

Non-trainable params: 0

_________________________________________________________________

None

Epoch 1/5

390/390 [==============================] - 82s 206ms/step - loss: 0.6776 - accuracy:

0.5587 - val_loss: 0.6771 - val_accuracy: 0.6094

Epoch 2/5

390/390 [==============================] - 82s 209ms/step - loss: 0.6412 - accuracy:

0.6250 - val_loss: 0.6056 - val_accuracy: 0.6406

Epoch 3/5

390/390 [==============================] - 80s 206ms/step - loss: 0.5382 - accuracy:

0.7320 - val_loss: 0.5407 - val_accuracy: 0.7500

390/390 [==============================] - 81s 207ms/step - loss: 0.5320 - accuracy:

0.7370 - val_loss: 0.6075 - val_accuracy: 0.6719

Epoch 5/5

390/390 [==============================] - 83s 213ms/step - loss: 0.4920 - accuracy:

0.7670 - val_loss: 0.6157 - val_accuracy: 0.6250

Simple_RNN Score--->[0.6009092330932617, 0.672760009765625]

CodeText