Experiment 1 Solution to XOR problem using DNN

Date

AIM:
To solve XOR problem using DNN

CONCEPT:

The XOR problem is a classic problem in the field of machine learning and artificial intelligence.
XOR stands for "exclusive OR," which is a logical operation that takes two binary inputs (0 or 1)
and returns 1 only when exactly one of the inputs is 1. Otherwise, it returns 0. Here's the truth
table for the XOR operation:

Input 1 Input 2 Output

0 0 0
0 1 1
1 0 1
1 1 0

For solving the XOR problem, use a Deep Neural Network (DNN) implemented with
TensorFlow and Keras. The XOR problem is a classic binary classification problem that
cannot be linearly separated. A DNN with hidden layers can learn the non-linear patterns
required to solve this problem.
1. Training:
 Provide the input data (XOR inputs) and the corresponding labels (XOR outputs) to
the DNN.
 The DNN adjusts its internal weights through backpropagation to minimize the loss
function.
 The model learns to approximate the XOR function based on the provided
examples.
2. Epochs and Batch Size:
 Train the model for multiple epochs (iterations over the entire dataset) to allow the
DNN to adjust its weights and learn the XOR function.
 You can choose a suitable batch size for updating weights in each iteration.
3. Evaluation:
 After training, evaluate the model's performance using the same XOR data.
 Calculate metrics like accuracy to assess how well the model has learned the XOR
function.
4. Inference:
 Once trained, the DNN can be used to predict the XOR output for new input
combinations.

5
STEPS

1 Define the XOR X: Input data for the XOR problem, where each row represents an
input and output input sample.
data y: Corresponding target outputs for the XOR problem.
2 Define the DNN Input Layer:
architecture
The input layer specifies an input shape of (2,), indicating that
the model expects input data with two features.
Hidden Layer 1 (Dense):

This hidden layer has 8 units/neurons.

It uses the ReLU activation function ('relu'), which introduces non-
linearity to the network.
Hidden Layer 2 (Dense):

This hidden layer also has 8 units/neurons.

It also uses the ReLU activation function.
Output Layer (Dense):

The output layer has 1 unit/neuron, which corresponds to the

binary classification task.
It uses the sigmoid activation function ('sigmoid') to produce a
probability score between 0 and 1- indicating likelihood of
positive class
3 Compile the model [Link](loss='mean_squared_error', optimizer='adam'):
Configures the model for training. It specifies the loss function
('mean_squared_error') and the optimization algorithm ('adam').
4 Train the DNN [Link](X, y, epochs=10000, verbose=0): Trains the model on the
XOR dataset. The epochs parameter specifies the number of times
the dataset is iterated during training. verbose=0 means that no
progress updates will be printed during training.
5 Test the trained DNN  predictions = [Link](X): Uses the trained model to
make predictions on the same XOR dataset.
 print(predictions): Prints the predicted outputs for the XOR
inputs.

6
PROGRAM
import tensorflow as tf
import numpy as np

# Define the XOR input and output data

x_data = [Link]([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32)
y_data = [Link]([[0], [1], [1], [0]], dtype=np.float32)

# Define the DNN architecture

model = [Link]([
[Link](8, input_dim=2, activation='relu'),
[Link](8, activation='relu'),
[Link](1, activation='sigmoid')
])

# Compile the model

[Link](optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])

# Train the DNN

[Link](x_data, y_data, epochs=1000, verbose=0)

# Test the trained DNN

predictions = [Link](x_data)
rounded_predictions = [Link](predictions)
print("Predictions:", rounded_predictions)
OUTPUT
Predictions: [[0.]
[1.]
[1.]
[0.]]

RESULT
Thus XOR problem using DNN is solved.

7
Experiment 2 Character recognition using CNN
Date

AIM:
To implement character Recognition using CNN

CONCEPT:

Character recognition using Convolutional Neural Networks (CNNs) is a widely used

technique in the field of computer vision and machine learning. CNNs are particularly well-
suited for tasks like character recognition because they can automatically learn hierarchical
features from the input data, capturing both local and global patterns.
1. Data Preparation: Collect and preprocess a dataset of labeled character images. Each
image should be associated with a label indicating the corresponding character. You
may need to resize, normalize, and augment the images to improve the model's
performance and generalization.
2. Model Architecture: Design a CNN architecture for character recognition. A typical CNN
architecture consists of alternating convolutional and pooling layers, followed by one or
more fully connected layers. The convolutional layers extract features from the input
images, while the pooling layers downsample the feature maps to reduce dimensionality.
3. Convolutional and Pooling Layers: Convolutional layers consist of multiple filters that slide
over the input image, computing dot products between the filter weights and local
image patches. This process captures local patterns and features. Pooling layers (e.g.,
max pooling) reduce the spatial dimensions of the feature maps, retaining the most
salient information.
4. Fully Connected Layers: After the convolutional and pooling layers, flatten the feature
maps and feed them into one or more fully connected layers. These layers perform
classification based on the learned features. The output layer should have as many
neurons as there are classes (characters), and a suitable activation function (e.g.,
softmax) is applied to produce class probabilities.
5. Training: Initialize the CNN's weights randomly and use a labeled training dataset to
optimize these weights. Employ a loss function (e.g., categorical cross-entropy) to
measure the difference between predicted and actual labels. Backpropagate the error
and update the weights using an optimization algorithm (e.g., stochastic gradient
descent or Adam) to minimize the loss.
6. Validation and Testing: Split your dataset into training, validation, and testing sets. Monitor
the model's performance on the validation set during training to prevent overfitting.
Once training is complete, evaluate the model's accuracy on the testing set to assess its
real-world performance.
7. Hyperparameter Tuning: Experiment with various hyperparameters such as learning rate,
batch size, number of layers, filter sizes, and pooling strategies to optimize the model's
performance.
8. Deployment: Once satisfied with the model's performance, deploy it to recognize
characters in new, unseen images. You can integrate the trained CNN into applications
8
 such as optical character recognition (OCR) systems, document processing pipelines, or
other relevant projects.
Keep in mind that the success of your character recognition system will depend on
factors like the quality and quantity of your dataset, the architecture of your CNN, and
the effectiveness of your training process. Additionally, there are pre-trained CNN
architectures, such as VGG, ResNet, and Inception, which you can fine-tune for
character recognition tasks to potentially achieve better performance.

STEPS

1 Load the MNIST dataset

2 Preprocess the data
3 Define the CNN architecture
4 Compile, train and evaluate the model

PROGRAM
import tensorflow as tf
from [Link] import mnist
from [Link] import Sequential
from [Link] import Conv2D, MaxPooling2D, Flatten, Dense

# Load the MNIST dataset

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Preprocess the data

x_train = x_train.reshape(-1, 28, 28, 1).astype('float32') / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0

# Define the CNN architecture

model = Sequential()
[Link](Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
[Link](MaxPooling2D((2, 2)))
[Link](Conv2D(64, (3, 3), activation='relu'))
[Link](MaxPooling2D((2, 2)))
[Link](Flatten())
[Link](Dense(64, activation='relu'))
[Link](Dense(10, activation='softmax'))

# Compile the model

[Link](optimizer='adam', loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

# Train the CNN

[Link](x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test,
y_test))
9
 # Evaluate the model
loss, accuracy = [Link](x_test, y_test)
print('Test Loss:', loss)
print('Test Accuracy:', accuracy)
OUTPUT
Epoch 1/5
938/938 [==============================] - 21s 21ms/step - loss: 0.1687 - accuracy: 0.
9493 - val_loss: 0.0792 - val_accuracy: 0.9755
Epoch 2/5
938/938 [==============================] - 19s 21ms/step - loss: 0.0511 - accuracy: 0.
9847 - val_loss: 0.0426 - val_accuracy: 0.9855
Epoch 3/5
938/938 [==============================] - 20s 21ms/step - loss: 0.0365 - accuracy: 0.
9884 - val_loss: 0.0308 - val_accuracy: 0.9900
Epoch 4/5
938/938 [==============================] - 20s 21ms/step - loss: 0.0274 - accuracy: 0.
9915 - val_loss: 0.0319 - val_accuracy: 0.9889
Epoch 5/5
938/938 [==============================] - 20s 21ms/step - loss: 0.0230 - accuracy: 0.
9927 - val_loss: 0.0353 - val_accuracy: 0.9901
313/313 [==============================] - 1s 4ms/step - loss: 0.0353 - accuracy: 0.99
01
Test Loss: 0.03527578338980675
Test Accuracy: 0.9901000261306763
RESULT
Thus character Recognition using CNN is implemented.

10
Experiment 3 Face recognition using CNN

Date

AIM:
To Implement Face recognition using CNN

CONCEPT:
Face recognition using Convolutional Neural Networks (CNNs) is a popular application of deep
learning in computer vision. CNNs are well-suited for image recognition tasks like face
recognition because they can automatically learn hierarchical features from images, which
are essential for discriminating between different faces.
Here's an overview of how to approach face recognition using CNNs:
1. Data Collection and Preprocessing:
 Collect a dataset of labeled face images. You need images of individuals you
want the model to recognize.
 Preprocess the images: Resize them to a common size (e.g., 224x224 pixels),
normalize pixel values to a certain range (usually [0, 1] or [-1, 1]), and perform data
augmentation (e.g., random cropping, flipping) to increase model robustness.
2. CNN Architecture:
 Choose a CNN architecture: Common choices include variants of VGG, ResNet,
Inception, or MobileNet. These architectures are available in libraries like
TensorFlow and PyTorch.
 Pretrained Models: Consider using a pretrained CNN model on a large dataset like
ImageNet. Transfer learning allows you to leverage learned features and fine-tune
the model for face recognition.
3. Model Training:
 Modify the architecture: Replace the classification head of the pretrained model
with a new one suitable for face recognition. Typically, the new head consists of a
few fully connected layers.
 Data Input: Feed the preprocessed face images into the model and train it using
a suitable loss function. Common choices include triplet loss or contrastive loss,
which encourage the network to learn embeddings that make similar faces close
and dissimilar faces far apart in the embedding space.
 Optimization: Use an optimizer like Adam or SGD to update the model's
parameters during training.
4. Testing and Verification:
 Embedding Extraction: After training, remove the classification head and use the
model to extract embeddings (feature vectors) from face images.
 Face Verification: To verify whether two face images belong to the same person,
calculate the similarity (e.g., cosine similarity) between their embeddings. Define a
threshold to decide whether the faces are a match or not.
 Face Identification: For identification, compare the embeddings of a query face
against embeddings of all known faces in the database and find the closest
11
 match.
5. Deployment and Testing:
 Deploy the trained model to your desired platform (web application, mobile app,
etc.).
 Test the model's accuracy and performance on real-world data. Tweak
hyperparameters or augment the dataset as needed to improve accuracy.
Remember that face recognition involves privacy concerns, and ethical considerations should
be taken into account, especially when working with sensitive data.

STEPS
1 Set the path to the directory containing the face images
2 Load the face images and labels & Iterate over the face image directory and
load the images
3 Convert the data to numpy arrays, Preprocess labels to extract numeric part
And Convert labels to one-hot encoded vectors
4 Split the data into training and validation sets
5 Compile, Train the CNN model and Save the trained model

PROGRAM
import os
import numpy as np
import tensorflow as tf
from [Link] import load_img, img_to_array
from sklearn.model_selection import train_test_split

# Set the path to the directory containing the face images

faces_dir = "D:/R2021 DL LAB/Faces/Faces"

# Load the face images and labels

x_data = []
y_data = []

# Iterate over the face image directory and load the images
for filename in [Link](faces_dir):
if [Link](".jpg"):
img_path = [Link](faces_dir, filename)
img = load_img(img_path, target_size=(64, 64)) # Resize images to
64x64 pixels
img_array = img_to_array(img)
x_data.append(img_array)
label = [Link](".")[0]
# Assuming the filename format is [Link]
y_data.append(label)

# Convert the data to numpy arrays

12
 x_data = [Link](x_data)
y_data = [Link](y_data)

# Preprocess labels to extract numeric part

y_data_numeric = [Link]([int([Link]("_")[1]) for label in y_data])

# Convert labels to one-hot encoded vectors

num_classes = len([Link](y_data_numeric))
y_data_encoded = [Link].to_categorical(y_data_numeric, num_classes)

# Split the data into training and validation sets

x_train, x_val, y_train, y_val = train_test_split(x_data, y_data_encoded,
test_size=0.2, random_state=42)

# Define the CNN architecture for face recognition

model = [Link]([
[Link].Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64,
3)),
[Link].MaxPooling2D((2, 2)),
[Link](),
[Link](128, activation='relu'),
[Link](num_classes, activation='softmax')
])

# Compile the model

[Link](optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])

# Train the CNN model

[Link](x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val,
y_val))

# Save the trained model

[Link]("face_recognition_model.keras")

OUTPUT
Epoch 1/10
65/65 [==============================] - 5s 68ms/step - loss: 215.6209 - accuracy: 0.0
098 - val_loss: 4.7830 - val_accuracy: 0.0039
Epoch 2/10
65/65 [==============================] - 4s 66ms/step - loss: 4.7793 - accuracy: 0.011
2 - val_loss: 4.7757 - val_accuracy: 0.0039
Epoch 3/10
65/65 [==============================] - 4s 66ms/step - loss: 4.7717 - accuracy: 0.012
2 - val_loss: 4.7694 - val_accuracy: 0.0039
Epoch 4/10
65/65 [==============================] - 4s 66ms/step - loss: 4.7646 - accuracy: 0.010
7 - val_loss: 4.7634 - val_accuracy: 0.0039
Epoch 5/10
13
65/65 [==============================] - 4s 68ms/step - loss: 4.7579 - accuracy: 0.010
2 - val_loss: 4.7577 - val_accuracy: 0.0039
Epoch 6/10
65/65 [==============================] - 5s 70ms/step - loss: 4.7516 - accuracy: 0.010
7 - val_loss: 4.7525 - val_accuracy: 0.0039
Epoch 7/10
65/65 [==============================] - 4s 66ms/step - loss: 4.7457 - accuracy: 0.009
8 - val_loss: 4.7476 - val_accuracy: 0.0039
Epoch 8/10
65/65 [==============================] - 4s 67ms/step - loss: 4.7402 - accuracy: 0.010
7 - val_loss: 4.7432 - val_accuracy: 0.0039
Epoch 9/10
65/65 [==============================] - 4s 66ms/step - loss: 4.7349 - accuracy: 0.013
2 - val_loss: 4.7392 - val_accuracy: 0.0078
Epoch 10/10
65/65 [==============================] - 4s 65ms/step - loss: 4.7300 - accuracy: 0.010
2 - val_loss: 4.7354 - val_accuracy: 0.0078

CHECK OUTPUT AS IMAGES IN MENTIONED FOLDER

RESULT
Face recognition using CNN is analysed and implemented.

14
Experiment 4 Language modeling using RNN
Date

AIM:
To implement Language modeling using RNN

CONCEPT:

Language modeling is a fundamental task in natural language processing (NLP) that

involves predicting the next word or character in a sequence of text. Recurrent Neural
Networks (RNNs) are a class of neural networks commonly used for language modeling due
to their ability to capture sequential dependencies in data.
1. Data Preparation: Language modeling requires a large dataset of text. This could be a
collection of sentences, paragraphs, or entire documents. The text is usually tokenized
into words or characters, and each token is assigned a unique integer ID.
2. Creating Input-Output Pairs: The next step is to create input-output pairs for training. For
each token in the dataset, the input will be the previous sequence of tokens, and the
output will be the token that follows. For example, given the sentence "I love to eat ice,"
the pairs would be: ("I love to eat", "ice"), ("love to eat ice", "cream"), and so on.
3. Embedding Layer: Each token ID is typically transformed into a dense vector
representation using an embedding layer. This helps the network learn meaningful
representations of words or characters.
4. RNN Architecture: The core of the language model is the RNN layer. At each time step,
the RNN takes in the current token's embedding and the previous hidden state, and
produces a new hidden state. This hidden state captures the context of the previous
tokens in the sequence.
5. Output Layer: The output of the RNN at each time step is used to predict the probability
distribution over the vocabulary (i.e., all possible tokens). This is typically done using a
softmax activation function. The token with the highest predicted probability is the
predicted next token.
6. Training: The model is trained to minimize the cross-entropy loss between the predicted
probability distribution and the actual next token. This involves adjusting the model's
weights using backpropagation through time (BPTT).
7. Sampling: Once the model is trained, you can use it to generate new text. To do this, you
provide an initial seed sequence, and then repeatedly sample from the predicted
probability distribution to generate the next token. This token is then fed back into the
model as input for the next time step, and the process continues to generate a sequence
of desired length.
8. Hyperparameter Tuning: There are several hyperparameters to tune, such as the number
of hidden units in the RNN, the type of RNN cell (e.g., LSTM, GRU), the sequence length,
learning rate, and more. Tuning these hyperparameters can significantly impact the
performance of the language model.
It's worth noting that while RNNs were popular for language modeling, more advanced
architectures like LSTM (Long Short-Term Memory) and GRU (Gated Recurrent Unit) have been
15
developed to address some of the limitations of traditional RNNs, such as the vanishing gradient
problem.
Additionally, modern language models like GPT (Generative Pre-trained Transformer) have
largely surpassed the performance of traditional RNN-based models by utilizing attention
mechanisms and larger-scale architectures.

STEPS

1 Create a set of unique characters in the text

2 Convert text to a sequence of character indices
3 Create input-output pairs for training
4 Convert sequences and next_char to numpy arrays
5 Train the model and Generate text using the trained model

PROGRAM

import numpy as np
import tensorflow as tf
from [Link] import Sequential
from [Link] import Embedding, SimpleRNN, Dense

# Sample text data

text = "This is a sample text for language modeling using RNN."

# Create a set of unique characters in the text

chars = sorted(set(text))
char_to_index = {char: index for index, char in enumerate(chars)}
index_to_char = {index: char for index, char in enumerate(chars)}

# Convert text to a sequence of character indices

text_indices = [char_to_index[char] for char in text]

# Create input-output pairs for training

seq_length = 20
sequences = []
next_char = []
for i in range(0, len(text_indices) - seq_length):
[Link](text_indices[i : i + seq_length])
next_char.append(text_indices[i + seq_length])

# Convert sequences and next_char to numpy arrays

X = [Link](sequences)
y = [Link](next_char)

# Build the RNN model

16
model = Sequential([
Embedding(input_dim=len(chars), output_dim=50, input_length=seq_length),
SimpleRNN(100, return_sequences=False),
Dense(len(chars), activation="softmax")
])

[Link](loss="sparse_categorical_crossentropy", optimizer="adam")

# Train the model

[Link](X, y, batch_size=64, epochs=50)

# Generate text using the trained model

seed_text = "This is a sample te"
generated_text = seed_text
num_chars_to_generate = 100

for _ in range(num_chars_to_generate):
seed_indices = [char_to_index[char] for char in seed_text]

# Check if the seed sequence length matches the model's input length
if len(seed_indices) < seq_length:
diff = seq_length - len(seed_indices)
seed_indices = [0] * diff + seed_indices

seed_indices = [Link](seed_indices).reshape(1, -1)

next_index = [Link](seed_indices).argmax()
next_char = index_to_char[next_index]
generated_text += next_char
seed_text = seed_text[1:] + next_char
print(generated_text)
OUTPUT
Epoch 1/50
1/1 [==============================] - 1s 1s/step - loss: 3.0885
Epoch 2/50
1/1 [==============================] - 0s 8ms/step - loss: 3.0053
Epoch 3/50
1/1 [==============================] - 0s 14ms/step - loss: 2.9234
Epoch 4/50
1/1 [==============================] - 0s 0s/step - loss: 2.8392
Epoch 5/50
1/1 [==============================] - 0s 17ms/step - loss: 2.7501
Epoch 6/50
1/1 [==============================] - 0s 0s/step - loss: 2.6545
Epoch 7/50
1/1 [==============================] - 0s 4ms/step - loss: 2.5519
Epoch 8/50

17
1/1 [==============================] - 0s 14ms/step - loss: 2.4425
Epoch 9/50
1/1 [==============================] - 0s 0s/step - loss: 2.3266
Epoch 10/50
1/1 [==============================] - 0s 18ms/step - loss: 2.2063
Epoch 11/50
1/1 [==============================] - 0s 8ms/step - loss: 2.0865
Epoch 12/50
1/1 [==============================] - 0s 5ms/step - loss: 1.9717
Epoch 13/50
1/1 [==============================] - 0s 0s/step - loss: 1.8622
Epoch 14/50
1/1 [==============================] - 0s 4ms/step - loss: 1.7552
Epoch 15/50
1/1 [==============================] - 0s 13ms/step - loss: 1.6493
Epoch 16/50
1/1 [==============================] - 0s 0s/step - loss: 1.5457
Epoch 17/50
1/1 [==============================] - 0s 17ms/step - loss: 1.4472
Epoch 18/50
1/1 [==============================] - 0s 0s/step - loss: 1.3554
Epoch 19/50
1/1 [==============================] - 0s 17ms/step - loss: 1.2678
Epoch 20/50
1/1 [==============================] - 0s 0s/step - loss: 1.1810
Epoch 21/50
1/1 [==============================] - 0s 17ms/step - loss: 1.0964
Epoch 22/50
1/1 [==============================] - 0s 14ms/step - loss: 1.0179
Epoch 23/50
1/1 [==============================] - 0s 1ms/step - loss: 0.9459
Epoch 24/50
1/1 [==============================] - 0s 16ms/step - loss: 0.8773
Epoch 25/50
1/1 [==============================] - 0s 0s/step - loss: 0.8107
Epoch 26/50
1/1 [==============================] - 0s 17ms/step - loss: 0.7473
Epoch 27/50
1/1 [==============================] - 0s 0s/step - loss: 0.6884
Epoch 28/50
1/1 [==============================] - 0s 17ms/step - loss: 0.6333
Epoch 29/50
1/1 [==============================] - 0s 0s/step - loss: 0.5809
Epoch 30/50
1/1 [==============================] - 0s 2ms/step - loss: 0.5318

18
Epoch 31/50
1/1 [==============================] - 0s 17ms/step - loss: 0.4871
Epoch 32/50
1/1 [==============================] - 0s 0s/step - loss: 0.4469
Epoch 33/50
1/1 [==============================] - 0s 18ms/step - loss: 0.4099
Epoch 34/50
1/1 [==============================] - 0s 0s/step - loss: 0.3753
Epoch 35/50
1/1 [==============================] - 0s 18ms/step - loss: 0.3430
Epoch 36/50
1/1 [==============================] - 0s 0s/step - loss: 0.3134
Epoch 37/50
1/1 [==============================] - 0s 15ms/step - loss: 0.2865
Epoch 38/50
1/1 [==============================] - 0s 0s/step - loss: 0.2621
Epoch 39/50
1/1 [==============================] - 0s 2ms/step - loss: 0.2399
Epoch 40/50
1/1 [==============================] - 0s 15ms/step - loss: 0.2200
Epoch 41/50
1/1 [==============================] - 0s 1ms/step - loss: 0.2021
Epoch 42/50
1/1 [==============================] - 0s 18ms/step - loss: 0.1860
Epoch 43/50
1/1 [==============================] - 0s 0s/step - loss: 0.1714
Epoch 44/50
1/1 [==============================] - 0s 16ms/step - loss: 0.1580
Epoch 45/50
1/1 [==============================] - 0s 0s/step - loss: 0.1460
Epoch 46/50
1/1 [==============================] - 0s 4ms/step - loss: 0.1353
Epoch 47/50
1/1 [==============================] - 0s 12ms/step - loss: 0.1257
Epoch 48/50
1/1 [==============================] - 0s 933us/step - loss: 0.1170
Epoch 49/50
1/1 [==============================] - 0s 17ms/step - loss: 0.1090
Epoch 50/50
1/1 [==============================] - 0s 0s/step - loss: 0.1017
This is a sample tentrfornlanguags modnging nsing [Link] nsingrnging
ndgg nsinorng ngrngadgsinorng

RESULT
Thus Language modeling using RNN is implemented.

19
Experiment 5 Sentiment analysis using LSTM
Date

AIM:
To implement Sentiment analysis using LSTM

CONCEPT:

Sentiment analysis using LSTM (Long Short-Term Memory) is a common task in natural language
processing where you aim to determine the sentiment or emotional tone expressed in a given
text. LSTM is a type of recurrent neural network that can capture long-range dependencies in
sequences, making it well-suited for sequence-based tasks like sentiment analysis.
1. Text Representation: In sentiment analysis, text data needs to be converted into a
numerical format that can be processed by neural networks. This is typically done using
techniques like tokenization and word embedding. Tokenization splits the text into
individual words or subwords, while word embedding maps each token to a dense
vector representation in a continuous vector space.
2. Sequence Padding: In order to train LSTM networks efficiently, sequences (sentences or
documents) need to have a consistent length. Since text data can have varying lengths,
padding is applied to make all sequences of the same length. Shorter sequences are
padded with zeros at the beginning or end.
3. LSTM Architecture: An LSTM is a type of recurrent neural network designed to handle
sequential data. It has memory cells and gates that allow it to capture long-term
dependencies in sequences. LSTMs can remember important information over extended
periods, which is crucial for sentiment analysis since sentiments in text can span across
multiple words.
4. Embedding Layer: The input text tokens are passed through an embedding layer, which
converts the discrete token indices into dense vector representations. This layer is
responsible for capturing semantic relationships between words.
5. LSTM Layer: The LSTM layer processes the embedded sequences, updating its internal
state based on the input tokens and previous state. The LSTM's ability to maintain and
update context over time enables it to capture sequential patterns and dependencies
within the text.
6. Classification Layer: After processing the sequence through the LSTM layer, the final
hidden state is passed through a fully connected (dense) layer. This layer performs the
sentiment classification by producing a probability score indicating the likelihood of a
particular sentiment class.
7. Training and Backpropagation: During training, the model's predictions are compared to
the actual sentiment labels using a loss function (such as binary cross-entropy for binary
sentiment classification). The gradients of the loss are propagated back through the
network using backpropagation through time (BPTT), and the model's parameters are
updated using an optimization algorithm (e.g., Adam, SGD).
8. Inference and Prediction: Once the LSTM model is trained, it can be used to predict
sentiment labels for new, unseen text data. The input text is processed through the trained
20
 model, and the final classification layer's output provides the predicted sentiment.

Sentiment analysis using LSTM is a powerful application of deep learning in natural language
processing. It allows the model to learn and capture complex patterns in textual data, making
it capable of understanding and classifying sentiments expressed in various contexts.

STEPS

1 Load the IMDB dataset, which consists of movie reviews labeled with positive or
negative sentiment.
2 Preprocess the data by padding sequences to a fixed length (max_review_length)
and limiting the vocabulary size to the most frequent words (num_words).

3 Build an LSTM-based model. The Embedding layer is used to map word indices to
dense vectors, the LSTM layer captures sequence dependencies, and the Dense layer
produces a binary sentiment prediction.

4 The model is compiled with binary cross-entropy loss and the Adam optimizer.

5 Train the model using the training data. Finally, we evaluate the model on the test
data and print the test accuracy.

PROGRAM
import numpy as np
import tensorflow as tf
from [Link] import imdb
from [Link] import sequence
from [Link] import Sequential
from [Link] import Embedding, LSTM, Dense

# Load the IMDb movie review dataset

max_features = 5000 # Number of words to consider as features
max_len = 500 # Maximum length of each review (pad shorter reviews, truncate
longer reviews)
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
x_train = sequence.pad_sequences(x_train, maxlen=max_len)
x_test = sequence.pad_sequences(x_test, maxlen=max_len)

# Define the LSTM model

embedding_size = 32 # Dimensionality of the word embeddings

model = Sequential()
[Link](Embedding(max_features, embedding_size, input_length=max_len))
[Link](LSTM(100)) # LSTM layer with 100 units
[Link](Dense(1, activation='sigmoid'))

21
# Compile the model
[Link](loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train the model

batch_size = 64
epochs = 5

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

validation_data=(x_test, y_test))

# Evaluate the model

loss, accuracy = [Link](x_test, y_test)
print("Loss:", loss)
print("Accuracy:", accuracy)

OUTPUT
Downloading data from [Link]
.npz
17464789/17464789 [==============================] - 7s 0us/step
Epoch 1/5
391/391 [==============================] - 286s 727ms/step - loss: 0.4991 - accuracy:
0.7626 - val_loss: 0.3712 - val_accuracy: 0.8412
Epoch 2/5
391/391 [==============================] - 296s 757ms/step - loss: 0.3381 - accuracy:
0.8587 - val_loss: 0.3609 - val_accuracy: 0.8532
Epoch 3/5
391/391 [==============================] - 313s 801ms/step - loss: 0.2642 - accuracy:
0.8945 - val_loss: 0.3168 - val_accuracy: 0.8678
Epoch 4/5
391/391 [==============================] - 433s 1s/step - loss: 0.2263 - accuracy: 0.9
142 - val_loss: 0.3119 - val_accuracy: 0.8738
Epoch 5/5
391/391 [==============================] - 302s 774ms/step - loss: 0.1982 - accuracy:
0.9247 - val_loss: 0.3114 - val_accuracy: 0.8745
782/782 [==============================] - 74s 95ms/step - loss: 0.3114 - accuracy: 0.
8745
Loss: 0.3113741874694824
Accuracy: 0.8745200037956238

RESULT
Thus Sentiment analysis using LSTM is implemented.

22
Experiment 6 Parts of speech tagging using Sequence to Sequence architecture
Date

AIM:
To implement Parts of speech tagging using Sequence to Sequence architecture

CONCEPT:

Parts of speech (POS) tagging is a natural language processing task where each word in a
sentence is assigned a specific grammatical category, such as noun, verb, adjective, etc.
Sequence-to-Sequence (Seq2Seq) architecture, which was originally designed for machine
translation tasks, can also be adapted for POS tagging. The Seq2Seq architecture consists of
two main components: an encoder and a decoder. Here's how you can use Seq2Seq for POS
tagging:
1. Encoder-Decoder Setup: In the context of POS tagging, the encoder takes in the input
sentence (sequence of words) and encodes it into a fixed-size context vector. The
decoder then generates the POS tags based on this context vector.
2. Encoder Component: The encoder can be implemented using a recurrent neural
network (RNN) such as LSTM or GRU. The input sequence of words (tokens) is passed
through the encoder RNN, and the final hidden state of the encoder captures the
contextual information of the entire sentence.
3. Decoder Component: The decoder is another RNN that takes the encoder's final hidden
state as an initial hidden state and generates POS tags one at a time. At each step, the
decoder produces a probability distribution over possible POS tags for the current word.
4. Training: During training, the model is given pairs of input sentences and corresponding
POS tag sequences. The encoder generates the context vector, which is then used as
the initial state of the decoder. The decoder generates the predicted POS tags. The
model is trained to minimize the cross-entropy loss between the predicted and actual
POS tags.
5. Inference: During inference (testing or prediction), the model is given an input sentence,
and the encoder generates the context vector. The decoder then generates POS tags
one by one, using the context vector and the previously generated tag. This process
continues until an end-of-sentence token is generated or a maximum sequence length
is reached.

STEPS

1 Define the input and output sequences.

2 Create a set of all unique words and POS tags in the dataset
3 Add <sos> and <eos> tokens to target_words.
4 Create dictionaries to map words and POS tags to integers.
5 Define the maximum sequence lengths, Prepare the encoder input data
And Prepare the decoder input and target data
23
6 Define the encoder input and LSTM layers
Define the decoder input and LSTM layers
7 Define, Compile and train the model
8 Define the encoder model to get the encoder states and
Define the decoder model with encoder states as initial state
9 Define a function to perform inference and generate POS tags,
Test the model.

PROGRAM
import numpy as np
import tensorflow as tf
from [Link] import Model
from [Link] import Input, LSTM, Dense
from [Link] import pad_sequences

# Define the input and output sequences

input_texts = ['I love coding', 'This is a pen', 'She sings well']
target_texts = ['PRP VB NNP', 'DT VBZ DT NN', 'PRP VBZ RB']

# Create a set of all unique words and POS tags in the dataset
input_words = set()
target_words = set()
for input_text, target_text in zip(input_texts, target_texts):
input_words.update(input_text.split())
target_words.update(target_text.split())

# Add <sos> and <eos> tokens to target_words

target_words.add('<sos>')
target_words.add('<eos>')

# Create dictionaries to map words and POS tags to integers

input_word2idx = {word: idx for idx, word in enumerate(input_words)}
input_idx2word = {idx: word for idx, word in enumerate(input_words)}
target_word2idx = {word: idx for idx, word in enumerate(target_words)}
target_idx2word = {idx: word for idx, word in enumerate(target_words)}

# Define the maximum sequence lengths

max_encoder_seq_length = max([len([Link]()) for text in input_texts])
max_decoder_seq_length = max([len([Link]()) for text in target_texts])

# Prepare the encoder input data

encoder_input_data = [Link]((len(input_texts), max_encoder_seq_length),
dtype='float32')
for i, input_text in enumerate(input_texts):
for t, word in enumerate(input_text.split()):
encoder_input_data[i, t] = input_word2idx[word]
24
# Prepare the decoder input and target data
decoder_input_data = [Link]((len(input_texts), max_decoder_seq_length),
dtype='float32')
decoder_target_data = [Link]((len(input_texts), max_decoder_seq_length,
len(target_words)), dtype='float32')
for i, target_text in enumerate(target_texts):
for t, word in enumerate(target_text.split()):
decoder_input_data[i, t] = target_word2idx[word]
if t > 0:
decoder_target_data[i, t - 1, target_word2idx[word]] = 1.0

# Define the encoder input and LSTM layers

encoder_inputs = Input(shape=(None,))
encoder_embedding = [Link](len(input_words),
256)(encoder_inputs)
encoder_lstm = LSTM(256, return_state=True)
encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
encoder_states = [state_h, state_c]

# Define the decoder input and LSTM layers

decoder_inputs = Input(shape=(None,))
decoder_embedding = [Link](len(target_words),
256)(decoder_inputs)
decoder_lstm = LSTM(256, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_embedding,
initial_state=encoder_states)
decoder_dense = Dense(len(target_words), activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

# Define the model

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

# Compile and train the model

[Link](optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
[Link]([encoder_input_data, decoder_input_data], decoder_target_data,
batch_size=64, epochs=50, validation_split=0.2)

# Define the encoder model to get the encoder states

encoder_model = Model(encoder_inputs, encoder_states)

# Define the decoder model with encoder states as initial state

decoder_state_input_h = Input(shape=(256,))
decoder_state_input_c = Input(shape=(256,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = decoder_lstm(decoder_embedding,
25
initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs)
decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs]
+ decoder_states)

# Define a function to perform inference and generate POS tags

def generate_pos_tags(input_sequence):
states_value = encoder_model.predict(input_sequence)
target_sequence = [Link]((1, 1))
target_sequence[0, 0] = target_word2idx['<sos>']
stop_condition = False
pos_tags = []
while not stop_condition:
output_tokens, h, c = decoder_model.predict([target_sequence] +
states_value)
sampled_token_index = [Link](output_tokens[0, -1, :])
sampled_word = target_idx2word[sampled_token_index]
pos_tags.append(sampled_word)
if sampled_word == '<eos>' or len(pos_tags) > max_decoder_seq_length:
stop_condition = True
target_sequence = [Link]((1, 1))
target_sequence[0, 0] = sampled_token_index
states_value = [h, c]
return ' '.join(pos_tags)

# Test the model

for input_text in input_texts:
input_seq = pad_sequences([[input_word2idx[word] for word in
input_text.split()]], maxlen=max_encoder_seq_length)
predicted_pos_tags = generate_pos_tags(input_seq)
print('Input:', input_text)
print('Predicted POS Tags:', predicted_pos_tags)
print()

OUTPUT
Epoch 1/50
1/1 [==============================] - 7s 7s/step - loss: 1.3736 - accuracy: 0.0000e+0
0 - val_loss: 1.1017 - val_accuracy: 0.0000e+00
Epoch 2/50
1/1 [==============================] - 0s 63ms/step - loss: 1.3470 - accuracy: 0.7500
- val_loss: 1.1068 - val_accuracy: 0.0000e+00
Epoch 3/50
1/1 [==============================] - 0s 65ms/step - loss: 1.3199 - accuracy: 0.7500
- val_loss: 1.1123 - val_accuracy: 0.0000e+00
Epoch 4/50
Epoch 44/50
1/1 [==============================] - 0s 58ms/step - loss: 0.0882 - accuracy: 0.7500
:
26
:
:
Epoch 50/50
1/1 [==============================] - 0s 60ms/step - loss: 0.0751 - accuracy: 0.7500
- val_loss: 2.2554 - val_accuracy: 0.0000e+00

Input: I love coding

Predicted POS Tags: VB NNP NNP DT DT

Input: This is a pen

Predicted POS Tags: VBZ DT NN NN DT

Input: She sings well

Predicted POS Tags: VB NNP NNP DT DT

RESULT

Thus Parts of speech tagging using Sequence to Sequence architecture is implemented.

27
Experiment 7 Machine Translation using Encoder-Decoder model
Date

AIM:
To implement Machine Translation using Encoder-Decoder model

CONCEPT:

Machine translation using an Encoder-Decoder model is a popular approach in natural

language processing (NLP) for automatically translating text from one language to another.
1. Encoder: The encoder is responsible for processing the input text in the source language
and transforming it into a fixed-length representation called a "context vector" or
"thought vector." This context vector is a condensed representation of the input text that
captures its essential information..
2. Decoder: The decoder takes the context vector generated by the encoder and
generates the translated text in the target language. Like the encoder, the decoder is
usually implemented using an RNN, LSTM, or transformer architecture.
3. Training: he model is trained on a parallel corpus of source and target language pairs.
During training, it learns to minimize the translation error by adjusting the model's
parameters. This is typically done using techniques like maximum likelihood estimation
(MLE) or more advanced methods like teacher forcing.
4. Inference: During inference or translation, the model takes an input sentence in the
source language, encodes it to obtain the context vector, and then decodes to
generate the translated sentence in the target language.

STEPS

1 Define the input and output sequences.

2 Create a set of all unique words in the input and target sequences.
3 Add <sos> and <eos> tokens to target_words.
4 Define the maximum sequence lengths
Create dictionaries to map words to integers.
Define the maximum sequence lengths
5 Prepare the encoder input data
Prepare the decoder input and target data
6 Define the encoder input and LSTM layers
Define the decoder input and LSTM layers
7 Define, Compile and train the model
8 Define the encoder model to get the encoder states
Define the decoder model with encoder states as initial state

28
9 Define a function to perform inference and generate translations
Test the model

PROGRAM
import numpy as np
import tensorflow as tf
from [Link] import Model
from [Link] import Input, LSTM, Dense
from [Link] import pad_sequences

# Define the input and output sequences

input_texts = ['I love coding', 'This is a pen', 'She sings well']
target_texts = ['Ich liebe das Coden', 'Das ist ein Stift', 'Sie singt gut']

# Create a set of all unique words in the input and target sequences
input_words = set()
target_words = set()
for input_text, target_text in zip(input_texts, target_texts):
input_words.update(input_text.split())
target_words.update(target_text.split())

# Add <sos> and <eos> tokens to target_words

target_words.add('<sos>')
target_words.add('<eos>')

# Create dictionaries to map words to integers

input_word2idx = {word: idx for idx, word in enumerate(input_words)}
input_idx2word = {idx: word for idx, word in enumerate(input_words)}
target_word2idx = {word: idx for idx, word in enumerate(target_words)}
target_idx2word = {idx: word for idx, word in enumerate(target_words)}

# Define the maximum sequence lengths

max_encoder_seq_length = max([len([Link]()) for text in input_texts])
max_decoder_seq_length = max([len([Link]()) for text in target_texts])

# Prepare the encoder input data

encoder_input_data = [Link]((len(input_texts), max_encoder_seq_length),
dtype='float32')
for i, input_text in enumerate(input_texts):
for t, word in enumerate(input_text.split()):
encoder_input_data[i, t] = input_word2idx[word]

# Prepare the decoder input and target data

decoder_input_data = [Link]((len(input_texts), max_decoder_seq_length),
dtype='float32')

29
decoder_target_data = [Link]((len(input_texts), max_decoder_seq_length,
len(target_words)), dtype='float32')
for i, target_text in enumerate(target_texts):
for t, word in enumerate(target_text.split()):
decoder_input_data[i, t] = target_word2idx[word]
if t > 0:
decoder_target_data[i, t - 1, target_word2idx[word]] = 1.0

# Define the encoder input and LSTM layers

encoder_inputs = Input(shape=(None,))
encoder_embedding = [Link](len(input_words),
256)(encoder_inputs)
encoder_lstm = LSTM(256, return_state=True)
encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
encoder_states = [state_h, state_c]

# Define the decoder input and LSTM layers

decoder_inputs = Input(shape=(None,))
decoder_embedding = [Link](len(target_words),
256)(decoder_inputs)
decoder_lstm = LSTM(256, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_embedding,
initial_state=encoder_states)
decoder_dense = Dense(len(target_words), activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

# Define the model

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

# Compile and train the model

[Link](optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
[Link]([encoder_input_data, decoder_input_data], decoder_target_data,
batch_size=64, epochs=50, validation_split=0.2)

# Define the encoder model to get the encoder states

encoder_model = Model(encoder_inputs, encoder_states)

# Define the decoder model with encoder states as initial state

decoder_state_input_h = Input(shape=(256,))
decoder_state_input_c = Input(shape=(256,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = decoder_lstm(decoder_embedding,
initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs)

30
decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs]
+ decoder_states)

# Define a function to perform inference and generate translations

def translate(input_sequence):
states_value = encoder_model.predict(input_sequence)
target_sequence = [Link]((1, 1))
target_sequence[0, 0] = target_word2idx['<sos>']
stop_condition = False
translation = []
while not stop_condition:
output_tokens, h, c = decoder_model.predict([target_sequence] +
states_value)
sampled_token_index = [Link](output_tokens[0, -1, :])
sampled_word = target_idx2word[sampled_token_index]
[Link](sampled_word)
if sampled_word == '<eos>' or len(translation) > max_decoder_seq_length:
stop_condition = True
target_sequence = [Link]((1, 1))
target_sequence[0, 0] = sampled_token_index
states_value = [h, c]
return ' '.join(translation)

# Test the model

for input_text in input_texts:
input_seq = pad_sequences([[input_word2idx[word] for word in
input_text.split()]], maxlen=max_encoder_seq_length)
translated_text = translate(input_seq)
print('Input:', input_text)
print('Translated Text:', translated_text)
print()

OUTPUT
Input: This is a pen
Translated Text: ist ein Stift Coden ein

RESULT
Thus Machine Translation using Encoder-Decoder model is implemented.

31
Experiment 8 Image augmentation using GANs
Date

AIM:
To implement Image augmentation using GANs

CONCEPT:

Image augmentation using Generative Adversarial Networks (GANs) is a technique that

leverages the power of GANs to generate new, realistic images that are variations of existing
images. This approach is commonly used in computer vision tasks, such as image classification
and object detection, to increase the diversity and size of training datasets.
1. Generative Adversarial Networks (GANs):GANs consist of two neural networks: a
generator and a [Link] generator network takes random noise as input and
generates synthetic [Link] discriminator network tries to distinguish between real
and synthetic images. During training, the generator aims to produce images that are
indistinguishable from real ones, while the discriminator tries to get better at telling them
apart.
2. Image Augmentation with GANs: You train a GAN on this dataset, where the generator
learns to generate images similar to those in the dataset, and the discriminator learns to
distinguish real images from generated ones.
3. Generating Augmented Images: Once the GAN is trained, you can use the generator to
create new, synthetic images. To augment an image from your dataset, you feed it to
the generator, and the generator produces a new image. These generated images are
typically variations of the original images, introducing changes in aspects like style,
lighting, perspective, or other factors that the GAN has learned from the training data.

STEPS

1 Load the MNIST dataset

Normalize and reshape the images
Define the generator network

2 Define the discriminator network

Compile the discriminator
Combine the generator and discriminator into a single GAN model

32
3 Train the hyperparameters and the Training loop has the following steps:
 Generate a batch of fake images
 Train the discriminator
 Train the generator
 Print the progress and save samples

PROGRAM
import numpy as np
import [Link] as plt
from [Link] import mnist
from [Link] import Input, Dense, Reshape, Flatten
from [Link] import BatchNormalization, Dropout
from [Link] import Conv2D, Conv2DTranspose
from [Link] import Sequential, Model
from [Link] import Adam

# Load the MNIST dataset

(x_train, _), (_, _) = mnist.load_data()

# Normalize and reshape the images

x_train = (x_train.astype('float32') - 127.5) / 127.5
x_train = np.expand_dims(x_train, axis=-1)

# Define the generator network

generator = Sequential()
[Link](Dense(7 * 7 * 256, input_dim=100))
[Link](Reshape((7, 7, 256)))
[Link](BatchNormalization())
[Link](Conv2DTranspose(128, kernel_size=5, strides=1, padding='same',
activation='relu'))
[Link](BatchNormalization())
[Link](Conv2DTranspose(64, kernel_size=5, strides=2, padding='same',
activation='relu'))
[Link](BatchNormalization())
[Link](Conv2DTranspose(1, kernel_size=5, strides=2, padding='same',
activation='tanh'))

# Define the discriminator network

discriminator = Sequential()
[Link](Conv2D(64, kernel_size=5, strides=2, padding='same',
input_shape=(28, 28, 1), activation='relu'))
[Link](Dropout(0.3))
[Link](Conv2D(128, kernel_size=5, strides=2, padding='same',
activation='relu'))
[Link](Dropout(0.3))
33
[Link](Flatten())
[Link](Dense(1, activation='sigmoid'))

# Compile the discriminator

[Link](loss='binary_crossentropy',
optimizer=Adam(learning_rate=0.0002, beta_1=0.5), metrics=['accuracy'])

# Combine the generator and discriminator into a single GAN model

gan_input = Input(shape=(100,))
gan_output = discriminator(generator(gan_input))
gan = Model(gan_input, gan_output)
[Link](loss='binary_crossentropy', optimizer=Adam(learning_rate=0.0002,
beta_1=0.5))

# Training hyperparameters
epochs = 100
batch_size = 128
sample_interval = 10

# Training loop
for epoch in range(epochs):
# Randomly select a batch of real images
idx = [Link](0, x_train.shape[0], batch_size)
real_images = x_train[idx]

# Generate a batch of fake images

noise = [Link](0, 1, (batch_size, 100))
fake_images = [Link](noise)

# Train the discriminator

x = [Link]((real_images, fake_images))
y = [Link](([Link]((batch_size, 1)), [Link]((batch_size, 1))))
d_loss = discriminator.train_on_batch(x, y)

# Train the generator

noise = [Link](0, 1, (batch_size, 100))
g_loss = gan.train_on_batch(noise, [Link]((batch_size, 1)))

# Print the progress and save samples

if epoch % sample_interval == 0:
print(f'Epoch: {epoch} Discriminator Loss: {d_loss[0]} Generator
Loss: {g_loss}')
samples = [Link]([Link](0, 1, (16, 100)))
samples = (samples * 127.5) + 127.5
samples = [Link](16, 28, 28)
fig, axs = [Link](4, 4)

34
 count = 0
for i in range(4):
for j in range(4):
axs[i, j].imshow(samples[count, :, :], cmap='gray')
axs[i, j].axis('off')
count += 1
[Link]()

OUTPUT
Epoch: 90 Discriminator Loss: 0.03508808836340904
Generator Loss: 1.736445483402349e-06

RESULT
Thus Image augmentation using GANs is implemented.

35