ANNA UNIVERSITY,CHENNAI .

GKM
COLLEGE OF ENGINEERING AND TECHNOLOGY
(SPONSPERED BY SUGANTHI EDUCATIONAL TRUST)
(AN ISO ISO: 9001 :2005 CERTIFIDE, APPROVED BY AICTE ,AFFLIATED TO ANNA UNIVERSITY)
G.K.M NAGAR,New Perungalathur(Near Tambaram) Chennai-600 063.

ESTD.1996

(BACHELOR OF TECHNOLOGY)
ARTIFICIAL INTELLIGENCE AND DATA SCIENCE
LABORATORY RECORD

NAME : …………………………………….

REGISTER NUMBER : …………………………………….

SEMESTER : …………………………………….

YEAR : …………………………………….

BRANCH : ……………………………………..
 GKM
COLLEGE OF ENGINEERING AND TECHNOLOGY

DEPARTMENT OF ARTIFICIAL INTELLIGENCE AND DATA SCIENCE

BONAFIDE CERTIFICATE

REG NO:

Name of the lab

Department of Certified that this is a bonafide record of

the work done by of Class in the

Laboratory during the Year

Signature of Staff-in-Charge Head of the Department

Internal Examiner External Examiner

Name of the Examination : ………………………….

Register No : …………………………..
Date of the Examination : ………………………….
 INDEX
Exp.No Date Name of the Experiment Page Marks Sign
No

Completed / Incomplete Staff-in-Charge Sign

 INDEX
Exp.No Date Name of the Experiment Page Marks Sign
No

Completed / Incomplete Staff-in-Charge Sign

Experiment 1 Solution to XOR problem using DNN

Date

AIM:

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.

1
 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 an input sample. y: Corresponding target outputs for the XOR
output data 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 model.compile(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 model.fit(X, y, epochs=1OOOO, verbose=O): Trains the model
on the XOR dataset. The epochs parameter specifies the number
of times the dataset is iterated during training. verbose=O
means that no progress updates will be printed during training.

2
5 Test the trained DNN • predictions = model.predict(X): Uses the trained model to
make predictions on the same XOR dataset.
• print(predictions): Prints the predicted outputs for the XOR
inputs.

3
 PROGRAM
import tensorflow as tf import
numpy as np

# Define the XOR input and output data

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

# Define the DNN architecture model = tf.keras.Sequential([

tf.keras.layers.Dense(8, input_dim=2, activation='relu'),
tf.keras.layers.Dense(8,activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid') ])

# Compile the model

model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy
'])

# Train the DNN

model.fit(x_data, y_data, epochs=1000, verbose=0)

# Test the trained DNN

predictions = model.predict(x_data)
rounded_predictions = np.round(predictions)
print("Predictions:", rounded_predictions)

OUTPUT
Predictions: [[0.]
[1.]
[1.]
[0.]]

RESULT

4
Experiment 2 Character recognition using CNN
Date

AIM:

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

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

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 tensorflow.keras.datasets import mnist from
tensorflow.keras.models import Sequential
from tensorflow.keras.layers 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()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))

6
 model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(64, activation='relu')) model.add(Dense(10,
activation='softmax'))

# Compile the model

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

# Train the CNN

model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test,
y_test))
# Evaluate the model
loss, accuracy = model.evaluate(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

7
Experiment 3 Face recognition using CNN

Date

AIM:

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.

8
 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 tensorflow.keras.preprocessing.image 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 = []

9
# Iterate over the face image directory and load the images for
filename in os.listdir(faces_dir):
if filename.endswith(".jpg"):
img_path = os.path.join(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 = filename.split(".")[0]
# Assuming the filename format is label.jpg y_data.append(label)

# Convert the data to numpy arrays

x_data = np.array(x_data)

y_data = np.array(y_data)

# Preprocess labels to extract numeric part

y_data_numeric = np.array([int(label.split("_")[1]) for label in y_data])

# Convert labels to one-hot encoded vectors

num_classes = len(np.unique(y_data_numeric))
y_data_encoded = tf.keras.utils.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 = tf.keras.models.Sequential([tf.keras.layers.Conv2D(32,(3,3),
activation='relu',input_shape=(64,64,3)),
tf.keras.layers.MaxPooling2D((2,2)), tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(num_classes, activation='softmax') ])

# Compile the model

model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['acc
uracy'])

# Train the CNN model

model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val,
y_val))

# Save the trained model model.save("face_recognition_model.keras")

10
 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

RESULT

11
 Experiment 4 Language modeling using RNN

Date

AIM:

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.
12
 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 tensorflow.keras.models import Sequential
from tensorflow.keras.layers 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):

13
 sequences.append(text_indices[i:i+seq_length])
next_char.append(text_indices[i + seq_length])

# Convert sequences and next_char to numpy arrays

X = np.array(sequences) y
= np.array(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")
])

model.compile(loss="sparse_categorical_crossentropy",optimizer="adam")

# Train the model

model.fit(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 = np.array(seed_indices).reshape(1, -1)

next_index = model.predict(seed_indices).argmax()
next_char = index_to_char[next_index] generated_text
+= next_char seed_text = seed_text[1:] + next_char
print(generated_text)

14
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

15
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
16
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 Rgn.rginsrngangrngangnoggrng nsingrnging ndgg
nsinorng ngrngadgsinorng

RESULT

17
 Experiment 5 Sentiment analysis using LSTM

Date

AIM:

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.

18
 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 tensorflow.keras.datasets import imdb from
tensorflow.keras.preprocessing import sequence from
tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense

# Load the IMDb movie review dataset

max_features = 5000 # Number of words to consider as features

19
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()
model.add(Embedding(max_features, embedding_size, input_length=max_len))
model.add(LSTM(100))

# LSTM layer with 100 units

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

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train the model

batch_size = 64
epochs = 5
model.fit(x_train, y_train)
batch_size=batch_size,epochs=epochs,validation_data=(x_test, y_test))

# Evaluate the model

loss, accuracy = model.evaluate(x_test, y_test)
print("Loss:", loss)
print("Accuracy:", accuracy)

OUTPUT
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb
.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:

20
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

21
 Experiment 6 Parts of speech tagging using Sequence to Sequence architecture

Date

AIM:

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

22
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 tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, LSTM, Dense
from tensorflow.keras.preprocessing.sequence 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

23
max_encoder_seq_length = max([len(text.split()) for text in input_texts])
max_decoder_seq_length = max([len(text.split()) for text in target_texts])

# Prepare the encoder input data

encoder_input_data = np.zeros((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 = np.zeros((len(input_texts), max_decoder_seq_length),
dtype='float32')
decoder_target_data = np.zeros((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=tf.keras.layers.Embedding(len(input_words),256)(encoder_input
s)
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 =
tf.keras.layers.Embedding(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)

24
# Compile and train the model
model.compile(optimizer='adam',loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit([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 = np.zeros((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 = np.argmax(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 = np.zeros((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]
25
 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

26
 Experiment 7 Machine Translation using Encoder-Decoder model

Date

AIM:

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.
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
27
 Define the decoder model with encoder states as initial state

9 Define afunction to perform inference and generate translations Test the model

PROGRAM
import numpy as np import
tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, LSTM, Dense
from tensorflow.keras.preprocessing.sequence 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(text.split()) for text in input_texts])
max_decoder_seq_length = max([len(text.split()) for text in target_texts])

# Prepare the encoder input data

encoder_input_data = np.zeros((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]
28
# Prepare the decoder input and target data
decoder_input_data = np.zeros((len(input_texts), max_decoder_seq_length),
dtype='float32')
decoder_target_data = np.zeros((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>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=tf.keras.layers.Embedding(len(input_words),256)(encoder_input)
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 = tf.keras.layers.Embedding(len(target_words),256)(decoder_input)
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
model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accura
cy'])
model.fit([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,))

29
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
= np.zeros((1, 1))
target_sequence[0, 0] = target_word2idx['<sos>']
stop_condition = False translation = [] while not
stop_condition:
sampled_word=target_idx2word[sampled_token_index]
translation.append(sampled_word)
if sampled_word == '<eos>' or len(translation) > max_decoder_seq_length:
stop_condition = True
target_sequence = np.zeros((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

30
 Experiment 8 Image augmentation using GANs

Date

AIM:

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 discriminator.The generator network takes random noise as input and
generates synthetic images.The 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

31
3 Train thehyperparameters 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 matplotlib.pyplot as plt from
tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Input, Dense, Reshape, Flatten
from tensorflow.keras.layers import BatchNormalization, Dropout
from tensorflow.keras.layers import Conv2D, Conv2DTranspose from
tensorflow.keras.models import Sequential, Model from
tensorflow.keras.optimizers 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()
generator.add(Dense(7 * 7 * 256, input_dim=100))
generator.add(Reshape((7,7,256)))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(128, kernel_size=5, strides=1, padding='same',
activation='relu'))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(64, kernel_size=5, strides=2, padding='same',
activation='relu'))
generator.add(BatchNormalization())
generator.add(Conv2DTranspose(1, kernel_size=5, strides=2, padding='same',
activation='tanh'))

# Define the discriminator network

discriminator = Sequential()
discriminator.add(Conv2D(64, kernel_size=5, strides=2, padding='same',
input_shape=(28, 28, 1), activation='relu'))
discriminator.add(Dropout(0.3))
32
discriminator.add(Conv2D(128, kernel_size=5, strides=2, padding='same',
activation='relu')) discriminator.add(Dropout(0.3))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))
# Compile the discriminator
discriminator.compile(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)
gan.compile(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 = np.random.randint(0, x_train.shape[0], batch_size) real_images =

x_train[idx]

# Generate a batch of fake images

noise = np.random.normal(0, 1, (batch_size, 100))
fake_images = generator.predict(noise)

# Train the discriminator

x = np.concatenate((real_images, fake_images))
y = np.concatenate((np.ones((batch_size, 1)), np.zeros((batch_size, 1))))
d_loss = discriminator.train_on_batch(x, y)

# Train the generator

noise = np.random.normal(0, 1, (batch_size, 100))
g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))

# Print the progress and save samples if

epoch % sample_interval == 0:
print(f'Epoch: {epoch}
33
 Discriminator Loss: {d_loss[0]}
Generator
Loss: {g_loss}') samples = generator.predict(np.random.normal(0, 1, (16,
100))) samples = (samples * 127.5) + 127.5
samples = samples.reshape(16, 28, 28) fig, axs = plt.subplots(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
plt.show()

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

RESULT

34