UNITED INSTITUTE OF TECHNOLOGY

Periyanaickenpalayam,Coimbatore-641020.

AD3511
DEEP LEARNING LABORATORY

DEPARTMENT OF

ARTIFICIAL INTELLIGENCE AND DATA SCIENCE

 UNITED INSTITUTE OF TECHNOLOGY
Periyanaickenpalayam,Coimbatore-641020.

BONAFIDECERTIFICATE

This is to certify that the record work entitled

AD3511 DEEP LEARNING LABORATORY

Is the bonafide record of practical work done by

Name :

Register No :

In V semester of B. Tech Artificial Intelligence and Data Science

during the academic year 2023-2024

Staff-in-charge Head of the Department

Submitted for the University Practical Examination held on ------------------------

Internal Examiner External Examiner

 UNITEDINSTITUTEOFTECHNOLOGY
Periyanaickenpalayam,Coimbatore-641020.

TABLE OF CONTENTS

EX FACULTY
DATE NAME OF THE EXPERIMENT MARKS
NO. SIGNATURE

1. 07.08.2023 Solving XOR problem using DNN

2. 21.08.2023 Character Recognition using CNN

3. 04.09.2023 Face recognition using RNN

4. 11.09.2023 Language Modelling using CNN

5. Sentiment Analysis using LSTM

18.09.2023

Parts of speech tagging using Sequence to

6. 25.09.2023
Sequence Architecture

Machine Translation using Encoder

7. 09.10.2023
-Decoder Model

8. 09.10.2023 Image Augumentation using GANs

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.
STEPS

1 Define the XOR X: Input data for the XOR problem, where each row represents
input and output an 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.
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.
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
 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.

STEP
S
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))
 # 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.
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
 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

 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
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.
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
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

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
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
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.
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
 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'))
# 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.
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
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]
# 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,
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
:
:
:
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.

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
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')
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)
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.
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
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))
[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)
 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.