EXERCISE - 1

Aim: Build a Convolution Neural Network for Image Recognition.

Source Code:
import tensorflow as tf
from [Link] import layers, models

# Step 1: Load and preprocess the dataset (e.g., CIFAR-10)

# Replace this with your dataset loading and preprocessing code
# For example, with CIFAR-10:
from [Link] import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# Step 2: Define the CNN model

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

# Step 3: Flatten the 3D output to 1D and add Dense layers for classification
[Link]([Link]())
[Link]([Link](64, activation='relu'))
[Link]([Link](10, activation='softmax')) # Assuming 10 classes for CIFAR-10

# Step 4: Compile the model

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

# Step 5: Train the model

# Replace the placeholders with your training data and labels

1
[Link](x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))

# Step 6: Evaluate the model

# Replace the placeholders with your test data and labels
test_loss, test_acc = [Link](x_test, y_test)
print("Test accuracy:", test_acc)

Result:
Downloading data from [Link]
170498071/170498071 [==============================] - 7s 0us/step
Epoch 1/10
1563/1563 [==============================] - 56s 34ms/step - loss: 1.7659 -
accuracy: 0.3827 - val_loss: 1.4559 - val_accuracy: 0.4655
Epoch 2/10
1563/1563 [==============================] - 52s 33ms/step - loss: 1.3744 -
accuracy: 0.5078 - val_loss: 1.3300 - val_accuracy: 0.5203
Epoch 3/10
1563/1563 [==============================] - 52s 33ms/step - loss: 1.2385 -
accuracy: 0.5607 - val_loss: 1.2420 - val_accuracy: 0.5709
Epoch 4/10
1563/1563 [==============================] - 50s 32ms/step - loss: 1.1355 -
accuracy: 0.6019 - val_loss: 1.1483 - val_accuracy: 0.5969
Epoch 5/10
1563/1563 [==============================] - 51s 33ms/step - loss: 1.0459 -
accuracy: 0.6322 - val_loss: 1.0826 - val_accuracy: 0.6224
Epoch 6/10
1563/1563 [==============================] - 52s 33ms/step - loss: 0.9758 -
accuracy: 0.6607 - val_loss: 1.1183 - val_accuracy: 0.6212
Epoch 7/10
1563/1563 [==============================] - 60s 38ms/step - loss: 0.9119 -
accuracy: 0.6821 - val_loss: 1.0722 - val_accuracy: 0.6469
Epoch 8/10
1563/1563 [==============================] - 57s 37ms/step - loss: 0.8683 -
accuracy: 0.6982 - val_loss: 1.0293 - val_accuracy: 0.6566

2
Epoch 9/10
1563/1563 [==============================] - 60s 38ms/step - loss: 0.8196 -
accuracy: 0.7165 - val_loss: 1.0136 - val_accuracy: 0.6623
Epoch 10/10
1563/1563 [==============================] - 59s 38ms/step - loss: 0.7767 -
accuracy: 0.7316 - val_loss: 1.0620 - val_accuracy: 0.6629
313/313 [==============================] - 3s 10ms/step - loss: 1.0620 - accuracy:
0.6629
Test accuracy: 0.6628999710083008

3
 EXERCISE - 2

Aim: Design Artificial Neural Networks for Identifying and Classifying an actor using
Kaggle Dataset.

Source Code:
# Importing necessary libraries
import os
import numpy as np
import pandas as pd
import [Link] as plt
%matplotlib inline
from [Link] import LabelEncoder
from [Link] import utils
from [Link] import Sequential
from [Link] import Dense, Flatten, InputLayer
import keras
from [Link] import np_utils
import imageio # To read images
from PIL import Image # For image resizing

#upload zip train and test datasets in content folder. After uploading the folders unzip the
datasets as shown below
!unzip /content/[Link]
!unzip /content/[Link]
# Reading the data
train = pd.read_csv('/content/[Link]')
test = pd.read_csv('/content/[Link]')

# Image resizing of train data into single numpy array

temp = []
for img_name in [Link]:
img_path = [Link]('/content/Train', img_name)
img = [Link](img_path)

4
 img = [Link]([Link](img).resize((32, 32))).astype('float32')
[Link](img)

train_x = [Link](temp)

# Image resizing of test data into single numpy array

temp = []
for img_name in [Link]:
img_path = [Link]('/content/Test', img_name)
img = [Link](img_path)
img = [Link]([Link](img).resize((32,32))).astype('float32')
[Link](img)

test_x = [Link](temp)

# Normalizing the images

train_x = train_x / 255.
test_x = test_x / 255.

# Encoding the categorical variable to numeric

lb = LabelEncoder()
train_y = lb.fit_transform([Link])
train_y = [Link].np_utils.to_categorical(train_y)

# Specifying all the parameters we will be using in our network

input_num_units = (32, 32, 3)
hidden_num_units = 500
output_num_units = 3

epochs = 5
batch_size = 128

# Defining the network

5
model = Sequential([
InputLayer(input_shape=input_num_units),
Flatten(),
Dense(units=hidden_num_units, activation='relu'),
Dense(units=output_num_units, activation='softmax'),
])

# Printing model summary

[Link]()

# Compiling and Training Network

[Link](optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
[Link](train_x, train_y, batch_size=batch_size,epochs=epochs,verbose=1)

# Training model along with validation data

[Link](train_x, train_y, batch_size=batch_size,epochs=epochs,verbose=1,
validation_split=0.2)

# Predicting and importing the result in a csv file

pred = [Link]([Link](test_x),axis=1)
pred = lb.inverse_transform(pred)

test['Class'] = pred
test.to_csv('[Link]', index=False)

# Visual Inspection of predictions

idx = 2481
img_name = [Link][idx]

img = [Link]([Link]('/content/Test', img_name))

[Link]([Link]([Link](img).resize((128, 128))))
pred = [Link]([Link](test_x),axis=1)
print('Original:', [Link][idx])
print( 'Predicted:', lb.inverse_transform([pred[idx]]))

6
Result:
<ipython-input-1-b5e04c5b5b2f>:27: DeprecationWarning: Starting with ImageIO v3 the
behavior of this function will switch to that of [Link]. To keep the current behavior
(and make this warning disappear) use `import imageio.v2 as imageio` or call
`[Link]` directly.
img = [Link](img_path)
<ipython-input-1-b5e04c5b5b2f>:37: DeprecationWarning: Starting with ImageIO v3 the
behavior of this function will switch to that of [Link]. To keep the current behavior
(and make this warning disappear) use `import imageio.v2 as imageio` or call
`[Link]` directly.
img = [Link](img_path)
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
flatten (Flatten) (None, 3072) 0

dense (Dense) (None, 500) 1536500

dense_1 (Dense) (None, 3) 1503

=================================================================
Total params: 1,538,003
Trainable params: 1,538,003
Non-trainable params: 0
_________________________________________________________________
Epoch 1/5
156/156 [==============================] - 4s 24ms/step - loss: 0.8982 - accuracy:
0.5728
Epoch 2/5
156/156 [==============================] - 4s 24ms/step - loss: 0.8481 - accuracy:
0.6041
Epoch 3/5

7
156/156 [==============================] - 5s 31ms/step - loss: 0.8273 - accuracy:
0.6135
Epoch 4/5
156/156 [==============================] - 4s 23ms/step - loss: 0.8143 - accuracy:
0.6223
Epoch 5/5
156/156 [==============================] - 4s 23ms/step - loss: 0.8069 - accuracy:
0.6277
Epoch 1/5
125/125 [==============================] - 5s 38ms/step - loss: 0.8016 - accuracy:
0.6314 - val_loss: 0.8577 - val_accuracy: 0.5881
Epoch 2/5
125/125 [==============================] - 4s 29ms/step - loss: 0.7955 - accuracy:
0.6341 - val_loss: 0.7877 - val_accuracy: 0.6459
Epoch 3/5
125/125 [==============================] - 4s 29ms/step - loss: 0.7909 - accuracy:
0.6393 - val_loss: 0.7802 - val_accuracy: 0.6429
Epoch 4/5
125/125 [==============================] - 4s 31ms/step - loss: 0.7857 - accuracy:
0.6436 - val_loss: 0.7741 - val_accuracy: 0.6509
Epoch 5/5
125/125 [==============================] - 4s 35ms/step - loss: 0.7860 - accuracy:
0.6410 - val_loss: 0.7810 - val_accuracy: 0.6494
208/208 [==============================] - 1s 6ms/step
1/208 [..............................] - ETA: 4s<ipython-input-1-b5e04c5b5b2f>:90:
DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to
that of [Link]. To keep the current behavior (and make this warning disappear) use
`import imageio.v2 as imageio` or call `[Link]` directly.
img = [Link]([Link]('/content/Test', img_name))
208/208 [==============================] - 1s 6ms/step
Original: MIDDLE
Predicted: ['YOUNG']

8
9
 EXERCISE - 3

Aim: Design a CNN for Image Recognition which includes hyper parameter tuning.

Source Code:
import numpy as np
import tensorflow as tf
from [Link] import mnist
from [Link] import Sequential
from [Link] import Conv2D, MaxPooling2D, Flatten, Dense
from [Link].scikit_learn import KerasClassifier
from sklearn.model_selection import RandomizedSearchCV
from [Link] import accuracy_score

# Load and preprocess the MNIST dataset

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1).astype(np.float32) / 255.0

#In this case, -1 is used in the first dimension to indicate that the size of that dimension
should be automatically calculated based on the other dimensions. The resulting shape will be
(num_samples, 28, 28, 1).
x_test = x_test.reshape(-1, 28, 28, 1).astype(np.float32) / 255.0
y_train = [Link].to_categorical(y_train, num_classes=10)
y_test = [Link].to_categorical(y_test, num_classes=10)

# Define the function to create a CNN model

def create_model(filters=32, kernel_size=(3, 3), pool_size=(2, 2), dense_units=128):
model = Sequential([
Conv2D(filters, kernel_size, activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D(pool_size=pool_size),
Flatten(),
Dense(dense_units, activation='relu'),
Dense(10, activation='softmax')
])

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

# Create a Keras wrapper for scikit-learn API

#The KerasClassifier is a wrapper class that takes a function that creates a Keras model as an
[Link] function is typically referred to as the build_fn.

model = KerasClassifier(build_fn=create_model, verbose=0)

# Define hyperparameters and their possible values for tuning

param_dist = {
'filters': [16, 32, 64],
'kernel_size': [(3, 3), (5, 5)],
'pool_size': [(2, 2), (3, 3)],
'dense_units': [64, 128, 256]
}

# Perform randomized search cross-validation for hyperparameter tuning

random_search = RandomizedSearchCV(estimator=model, param_distributions=param_dist,
n_iter=10, cv=3, verbose=2)
# verbose=2 means more detailed output during the search process.
random_search_result = random_search.fit(x_train, y_train)
# cv=3 means 3-fold cross-validation (3 sub sets).

# Print the best parameters and accuracy

print("Best Parameters:", random_search_result.best_params_)
best_model = random_search_result.best_estimator_
y_pred = best_model.predict(x_test)
accuracy = accuracy_score([Link](y_test, axis=1), y_pred)
print("Test Accuracy:", accuracy)

Result:
Downloading data from [Link]
11490434/11490434 [==============================] - 0s 0us/step

11
<ipython-input-1-cb2fd6eb48c0>:36: DeprecationWarning: KerasClassifier is deprecated,
use Sci-Keras ([Link] instead. See
[Link] for help migrating.
model = KerasClassifier(build_fn=create_model, verbose=0)
Fitting 3 folds for each of 10 candidates, totalling 30 fits
[CV] END dense_units=128, filters=64, kernel_size=(3, 3), pool_size=(2, 2); total time=
1.2min
[CV] END dense_units=128, filters=64, kernel_size=(3, 3), pool_size=(2, 2); total time=
1.5min
[CV] END dense_units=128, filters=64, kernel_size=(3, 3), pool_size=(2, 2); total time=
1.5min
[CV] END dense_units=64, filters=64, kernel_size=(3, 3), pool_size=(2, 2); total time=
53.2s
[CV] END dense_units=64, filters=64, kernel_size=(3, 3), pool_size=(2, 2); total time=
53.2s
[CV] END dense_units=64, filters=64, kernel_size=(3, 3), pool_size=(2, 2); total time=
43.1s
[CV] END dense_units=128, filters=64, kernel_size=(3, 3), pool_size=(3, 3); total time=
46.6s
[CV] END dense_units=128, filters=64, kernel_size=(3, 3), pool_size=(3, 3); total time=
47.6s
[CV] END dense_units=128, filters=64, kernel_size=(3, 3), pool_size=(3, 3); total time=
37.8s
[CV] END dense_units=128, filters=16, kernel_size=(5, 5), pool_size=(3, 3); total time=
27.1s
[CV] END dense_units=128, filters=16, kernel_size=(5, 5), pool_size=(3, 3); total time=
27.3s
[CV] END dense_units=128, filters=16, kernel_size=(5, 5), pool_size=(3, 3); total time=
27.3s
[CV] END dense_units=256, filters=16, kernel_size=(3, 3), pool_size=(2, 2); total time=
47.8s
[CV] END dense_units=256, filters=16, kernel_size=(3, 3), pool_size=(2, 2); total time=
46.0s

12
[CV] END dense_units=256, filters=16, kernel_size=(3, 3), pool_size=(2, 2); total time=
31.1s
[CV] END dense_units=64, filters=16, kernel_size=(5, 5), pool_size=(2, 2); total time=
26.9s
[CV] END dense_units=64, filters=16, kernel_size=(5, 5), pool_size=(2, 2); total time=
25.0s
[CV] END dense_units=64, filters=16, kernel_size=(5, 5), pool_size=(2, 2); total time=
23.8s
[CV] END dense_units=256, filters=32, kernel_size=(3, 3), pool_size=(3, 3); total time=
46.1s
[CV] END dense_units=256, filters=32, kernel_size=(3, 3), pool_size=(3, 3); total time=
46.5s
[CV] END dense_units=256, filters=32, kernel_size=(3, 3), pool_size=(3, 3); total time=
46.6s
[CV] END dense_units=64, filters=64, kernel_size=(5, 5), pool_size=(3, 3); total time=
48.2s
[CV] END dense_units=64, filters=64, kernel_size=(5, 5), pool_size=(3, 3); total time=
53.3s
[CV] END dense_units=64, filters=64, kernel_size=(5, 5), pool_size=(3, 3); total time=
40.0s
[CV] END dense_units=64, filters=64, kernel_size=(3, 3), pool_size=(3, 3); total time=
47.8s
[CV] END dense_units=64, filters=64, kernel_size=(3, 3), pool_size=(3, 3); total time=
47.8s
[CV] END dense_units=64, filters=64, kernel_size=(3, 3), pool_size=(3, 3); total time=
47.9s
[CV] END dense_units=64, filters=16, kernel_size=(3, 3), pool_size=(2, 2); total time=
21.0s
[CV] END dense_units=64, filters=16, kernel_size=(3, 3), pool_size=(2, 2); total time=
25.2s
[CV] END dense_units=64, filters=16, kernel_size=(3, 3), pool_size=(2, 2); total time=
25.0s
Best Parameters: {'pool_size': (3, 3), 'kernel_size': (5, 5), 'filters': 64, 'dense_units': 64}
313/313 [==============================] - 2s 7ms/step

13
Test Accuracy: 0.9834

14
 EXERCISE - 4

Aim: Implement a Recurrence Neural Network for Predicting Sequential Data.

Source Code:
import numpy as np
import pandas as pd
import [Link] as plt
import keras
from [Link] import Sequential
from [Link] import LSTM
from [Link] import Dense, Activation, Dropout
from [Link] import MinMaxScaler

# Loading data
data = pd.read_csv('/content/[Link]')
#[Link]() # information about Dataset

# Selecting three columns as input

data = data[['Last Price', 'Average Price', 'Open Price']].values

[Link](figsize=(10, 6))
[Link](data[:,0]+500, '--g', label='Last Price')
[Link](data[:,1], '--r', label='Average Price')
[Link](data[:,2]-500, '--b', label='Open Price')
[Link]('Days', fontsize=15)
[Link]('Price', fontsize=15)
[Link]('Plot of Last, Average and Open price', fontsize=18, weight='bold')
[Link]('with added noise to prevent overlapping')
[Link]()
[Link]()

# Scaling the values in the range of 0 to 1

scaler = MinMaxScaler(feature_range=(0,1))

15
scaled_data = scaler.fit_transform(data[:,:])

# Splitting dataset in the ratio of 75:25 for training and test

train_size = int(scaled_data.shape[0] * 0.75)
train, test = scaled_data[0:train_size, :], scaled_data[train_size:scaled_data.shape[0], :]
print("Number of entries (training set, test set): " + str((len(train), len(test))))

def create_dataset(ser, window_size=1):

data_X, data_Y = [], []
for i in range(len(ser) - window_size - 1):
a = []
for j in range(0, window_size):
[Link](ser[[(i+j)], :])
data_X.append(a)
data_Y.append(ser[i + window_size, 1])
return([Link](data_X), [Link](data_Y))
window_size = 50
train_X, train_Y = create_dataset(train, window_size)
test_X, test_Y = create_dataset(test, window_size)
print("Original training data shape:")
print(train_X.shape, test_X.shape)

# Reshape the input data into appropriate form for Keras.

train_X = [Link](train_X, (train_X.shape[0], train_X.shape[1], 3))
test_X = [Link](test_X, (test_X.shape[0], test_X.shape[1], 3))
print("New training data shape:")
print(train_X.shape, test_X.shape)

# Designing the LSTM model

model = Sequential()
[Link](LSTM(4, input_shape = (window_size, 3)))
[Link](Dense(1))

# Compiling the model

16
[Link](loss = "mean_squared_error", optimizer = "adam")

# Training the model

[Link](train_X, train_Y, epochs=3, batch_size=1)

# Visualization
[Link](figsize = (15, 5))
[Link]([Link]((train[:,1], test[:,1])), '--b', label='True value')

[Link](range(window_size, len(train_X) + window_size), [Link](train_X), '-r',

label='Training set prediction')
[Link](range(window_size + len(train), len(train) + len(test) - 1), [Link](test_X), '-g',
label='Test set prediction')

[Link]("Days")
[Link]("Average Price")
[Link]("Comparison true vs. predicted training / test", fontsize=16)
[Link]()
[Link](-5, 2500)
[Link]()

Result:

17
Number of entries (training set, test set): (1872, 624)
Original training data shape:
(1821, 50, 1, 3) (573, 50, 1, 3)
New training data shape:
(1821, 50, 3) (573, 50, 3)
Epoch 1/3
1821/1821 [==============================] - 25s 13ms/step - loss: 0.0018
Epoch 2/3
1821/1821 [==============================] - 19s 10ms/step - loss: 4.4835e-04
Epoch 3/3
1821/1821 [==============================] - 18s 10ms/step - loss: 3.4780e-04
57/57 [==============================] - 1s 5ms/step
18/18 [==============================] - 0s 4ms/step

EXERCISE - 5
18
Aim: Implement Multi-Layer Perceptron algorithm for Image denoising hyperparameter
tuning.

Source Code:
import numpy as np
import tensorflow as tf
from [Link] import Dense, Flatten
from [Link] import Sequential
from [Link] import Adam
from [Link] import mnist
from [Link] import MeanSquaredError
# Load the MNIST dataset
(x_train, _), (x_test, _) = mnist.load_data()

# Normalize and flatten the images

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

# Add Gaussian noise to the images for creating noisy data

noise_factor = 0.4
x_train_noisy = x_train + noise_factor * [Link](size=x_train.shape)
x_test_noisy = x_test + noise_factor * [Link](size=x_test.shape)
x_train_noisy = [Link](x_train_noisy, 0., 1.)
x_test_noisy = [Link](x_test_noisy, 0., 1.)
def build_mlp(input_shape):
model = Sequential([
Dense(128, activation='relu', input_shape=input_shape),
Dense(64, activation='relu'),
Dense(128, activation='relu'),
Dense(784, activation='sigmoid')
])

19
 return model

input_shape = (784,)
model = build_mlp(input_shape)
[Link](optimizer=Adam(learning_rate=0.001), loss=MeanSquaredError())
batch_size = 128
epochs = 20

# Train the model

[Link](x_train_noisy, x_train, batch_size=batch_size, epochs=epochs,
validation_split=0.1)

# Evaluate the denoising performance on test data

decoded_images = [Link](x_test_noisy)

# Visualize some noisy images, denoised images, and original images

import [Link] as plt

num_images = 10
[Link](figsize=(18, 4))

for i in range(num_images):
# Noisy image
ax = [Link](3, num_images, i + 1)
[Link](x_test_noisy[i].reshape(28, 28))
[Link]()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)

# Denoised image
ax = [Link](3, num_images, i + 1 + num_images)
[Link](decoded_images[i].reshape(28, 28))
[Link]()
ax.get_xaxis().set_visible(False)

20
 ax.get_yaxis().set_visible(False)

# Original image
ax = [Link](3, num_images, i + 1 + 2*num_images)
[Link](x_test[i].reshape(28, 28))
[Link]()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)

[Link]()

Result:
Downloading data from [Link]
11490434/11490434 [==============================] - 0s 0us/step
Epoch 1/20
422/422 [==============================] - 5s 10ms/step - loss: 0.0479 - val_loss:
0.0292
Epoch 2/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0253 - val_loss:
0.0225
Epoch 3/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0211 - val_loss:
0.0197
Epoch 4/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0189 - val_loss:
0.0183
Epoch 5/20
422/422 [==============================] - 4s 9ms/step - loss: 0.0177 - val_loss:
0.0173
Epoch 6/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0167 - val_loss:
0.0167
Epoch 7/20

21
422/422 [==============================] - 3s 7ms/step - loss: 0.0160 - val_loss:
0.0160
Epoch 8/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0155 - val_loss:
0.0155
Epoch 9/20
422/422 [==============================] - 4s 9ms/step - loss: 0.0151 - val_loss:
0.0153
Epoch 10/20
422/422 [==============================] - 4s 9ms/step - loss: 0.0148 - val_loss:
0.0149
Epoch 11/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0144 - val_loss:
0.0146
Epoch 12/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0142 - val_loss:
0.0143
Epoch 13/20
422/422 [==============================] - 4s 9ms/step - loss: 0.0139 - val_loss:
0.0144
Epoch 14/20
422/422 [==============================] - 4s 9ms/step - loss: 0.0137 - val_loss:
0.0139
Epoch 15/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0135 - val_loss:
0.0138
Epoch 16/20
422/422 [==============================] - 4s 10ms/step - loss: 0.0133 - val_loss:
0.0136
Epoch 17/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0132 - val_loss:
0.0135
Epoch 18/20

22
422/422 [==============================] - 3s 7ms/step - loss: 0.0130 - val_loss:
0.0134
Epoch 19/20
422/422 [==============================] - 3s 7ms/step - loss: 0.0129 - val_loss:
0.0132
Epoch 20/20
422/422 [==============================] - 4s 9ms/step - loss: 0.0128 - val_loss:
0.0132
313/313 [==============================] - 1s 2ms/step

23
 EXERCISE - 6

Aim: Implement Object Detection Using YOLO.

Source Code:

Result:

EXERCISE - 7

24
Aim: Design a Deep learning Network for Robust Bi-Tempered Logistic Loss.

Source Code:
import numpy as np
import tensorflow as tf
from [Link] import Sequential
from [Link] import Dense
import [Link] as plt

# Define the Robust Bi-Tempered Logistic Loss function with fixed t1 and t2
def create_robust_bi_tempered_loss(t1, t2, label_smoothing=0.0):
#The @[Link] decorator is used in TensorFlow to convert a regular Python function
into a TensorFlow computation graph.
@[Link]
def loss(y_true, y_pred):
y_pred = tf.clip_by_value(y_pred, 1e-7, 1.0 - 1e-7)
y_true = [Link](y_true, y_pred.dtype)
term1 = (1 - y_true) * ([Link](1 - y_pred, t2 - 1))
term2 = y_true * ([Link](y_pred, t1 - 1))
loss_value = -(term1 + term2)
if label_smoothing > 0.0:
loss_value += label_smoothing * y_true * [Link](y_true / y_pred)
return tf.reduce_mean(loss_value)
return loss

# Create a Binary Classification Model

input_dim = 20 # Example input dimension
num_classes = 1 # Binary classification
model = Sequential([
Dense(128, activation='relu', input_dim=input_dim),
Dense(num_classes, activation='sigmoid')
])

25
# Compile the Model with RBL Loss
t1 = 0.8 # Temperature parameter 1
t2 = 1.2 # Temperature parameter 2
label_smoothing = 0.1 # Optional label smoothing
rbl_loss = create_robust_bi_tempered_loss(t1, t2, label_smoothing)
[Link](optimizer='adam', loss=rbl_loss, metrics=['accuracy'])

# Save the model

[Link]('trained_model.h5')

# Load the Trained Model for Prediction

loaded_model = [Link].load_model('trained_model.h5', custom_objects={'loss':
rbl_loss})

# Preprocess New Data for Prediction

new_data = [Link](5, input_dim) # Replace with your new data

# Make Predictions
predictions = loaded_model.predict(new_data)
predicted_classes = (predictions > 0.5).astype(int)
print(predictions)
print("Predicted Classes:", predicted_classes)

Result:
1/1 [==============================] - 0s 175ms/step
[[0.63754183]
[0.6558753 ]
[0.6071969 ]
[0.5628828 ]
[0.67136395]]
Predicted Classes: [[1]
[1]
[1]
[1]

26
[1]]

EXERCISE - 8

27
Aim: Build AlexNet using Advanced CNN.
Source Code:
import tensorflow as tf
from [Link] import Input, Conv2D, MaxPooling2D, BatchNormalization,
Flatten, Dense, Dropout

# Define the AlexNet-inspired architecture for CIFAR-10

def create_alexnet_cifar(input_shape, num_classes):
input_layer = Input(shape=input_shape)

# First convolutional layer

conv1 = Conv2D(64, (3, 3), padding='same', activation='relu')(input_layer)
pool1 = MaxPooling2D((2, 2))(conv1)
norm1 = BatchNormalization()(pool1)

# Second convolutional layer

conv2 = Conv2D(128, (3, 3), padding='same', activation='relu')(norm1)
pool2 = MaxPooling2D((2, 2))(conv2)
norm2 = BatchNormalization()(pool2)

# Three convolutional layers

conv3 = Conv2D(256, (3, 3), padding='same', activation='relu')(norm2)
conv4 = Conv2D(256, (3, 3), padding='same', activation='relu')(conv3)
conv5 = Conv2D(128, (3, 3), padding='same', activation='relu')(conv4)
pool3 = MaxPooling2D((2, 2))(conv5)
norm3 = BatchNormalization()(pool3)

# Flatten and fully connected layers

flatten = Flatten()(norm3)
fc1 = Dense(512, activation='relu')(flatten)
dropout1 = Dropout(0.5)(fc1)
fc2 = Dense(256, activation='relu')(dropout1)
dropout2 = Dropout(0.5)(fc2)

28
 output_layer = Dense(num_classes, activation='softmax')(dropout2)
model = [Link](inputs=input_layer, outputs=output_layer)
return model

# Set hyperparameters
input_shape = (32, 32, 3) # Input shape for CIFAR-10
num_classes = 10 # Number of classes in CIFAR-10 dataset

# Create the model

model = create_alexnet_cifar(input_shape, num_classes)

# Display the model summary

[Link]()

Result:
Model: "model"
_________________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) [(None, 32, 32, 3)] 0

conv2d (Conv2D) (None, 32, 32, 64) 1792

max_pooling2d (MaxPooling2D) (None, 16, 16, 64) 0

batch_normalization (BatchNormalization) (None, 16, 16, 64) 256

conv2d_1 (Conv2D) (None, 16, 16, 128) 73856

max_pooling2d_1 (MaxPooling2D) (None, 8, 8, 128) 0

batch_normalization_1 (BatchNormalization) (None, 8, 8, 128) 512

29
conv2d_2 (Conv2D) (None, 8, 8, 256) 295168

conv2d_3 (Conv2D) (None, 8, 8, 256) 590080

conv2d_4 (Conv2D) (None, 8, 8, 128) 295040

max_pooling2d_2 (MaxPooling 2D) (None, 4, 4, 128) 0

batch_normalization_2 (BatchNormalization) (None, 4, 4, 128) 512

flatten (Flatten) (None, 2048) 0

dense (Dense) (None, 512) 1049088

dropout (Dropout) (None, 512) 0

dense_1 (Dense) (None, 256) 131328

dropout_1 (Dropout) (None, 256) 0

dense_2 (Dense) (None, 10) 2570

=================================================================
Total params: 2,440,202
Trainable params: 2,439,562
Non-trainable params: 640
_________________________________________________________________________

EXERCISE - 9

30
Aim: Demonstration of Application of Autoencoders.

Source Code:
import numpy as np
import [Link] as plt
import tensorflow as tf
from [Link] import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D
from [Link] import Model

# Load and preprocess the dataset (MNIST)

(x_train, _), (x_test, _) = [Link].load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Add noise to the images

noise_factor = 0.5
x_train_noisy = x_train + noise_factor * [Link](loc=0.0, scale=1.0,
size=x_train.shape)
x_test_noisy = x_test + noise_factor * [Link](loc=0.0, scale=1.0,
size=x_test.shape)
x_train_noisy = [Link](x_train_noisy, 0.0, 1.0)
x_test_noisy = [Link](x_test_noisy, 0.0, 1.0)

# Define the autoencoder architecture

input_img = Input(shape=(28, 28, 1))
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)

31
autoencoder = Model(input_img, decoded)
[Link](optimizer='adam', loss='binary_crossentropy')

# Train the autoencoder

[Link](x_train_noisy, x_train,
epochs=10,
batch_size=128,
shuffle=True,
validation_data=(x_test_noisy, x_test))

# Denoise images using the trained autoencoder

decoded_imgs = [Link](x_test_noisy)

# Display original, noisy, and denoised images

n = 10
[Link](figsize=(20, 6))
for i in range(n):
# Original image
ax = [Link](3, n, i + 1)
[Link](x_test[i].reshape(28, 28))
[Link]()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)

# Noisy image
ax = [Link](3, n, i + 1 + n)
[Link](x_test_noisy[i].reshape(28, 28))
[Link]()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)

# Denoised image
ax = [Link](3, n, i + 1 + 2*n)
[Link](decoded_imgs[i].reshape(28, 28))

32
 [Link]()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
[Link]()

Result:
Downloading data from [Link]
11490434/11490434 [==============================] - 0s 0us/step
Epoch 1/10
469/469 [==============================] - 181s 383ms/step - loss: 0.1718 -
val_loss: 0.1195
Epoch 2/10
469/469 [==============================] - 172s 367ms/step - loss: 0.1150 -
val_loss: 0.1101
Epoch 3/10
469/469 [==============================] - 172s 366ms/step - loss: 0.1089 -
val_loss: 0.1061
Epoch 4/10
469/469 [==============================] - 173s 369ms/step - loss: 0.1058 -
val_loss: 0.1035
Epoch 5/10
469/469 [==============================] - 173s 369ms/step - loss: 0.1036 -
val_loss: 0.1018
Epoch 6/10
469/469 [==============================] - 175s 372ms/step - loss: 0.1020 -
val_loss: 0.1005
Epoch 7/10
469/469 [==============================] - 172s 366ms/step - loss: 0.1009 -
val_loss: 0.0995
Epoch 8/10
469/469 [==============================] - 172s 367ms/step - loss: 0.1000 -
val_loss: 0.0987
Epoch 9/10

33
469/469 [==============================] - 175s 374ms/step - loss: 0.0993 -
val_loss: 0.0980
Epoch 10/10
469/469 [==============================] - 171s 365ms/step - loss: 0.0988 -
val_loss: 0.0983
313/313 [==============================] - 8s 25ms/step

EXERCISE - 10

34
Aim: Demonstration of GAN (Generative Adversarial Network).

Source Code:
import numpy as np
import [Link] as plt
import tensorflow as tf
from [Link] import Dense
from [Link] import Sequential

# Generator model
generator = Sequential([
Dense(128, input_shape=(100,), activation='relu'),
Dense(784, activation='sigmoid')
])

# Discriminator model
discriminator = Sequential([
Dense(128, input_shape=(784,), activation='relu'),
Dense(1, activation='sigmoid')
])

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

# Combined model (stacked generator and discriminator)

[Link] = False
combined = Sequential([generator, discriminator])
[Link](optimizer='adam', loss='binary_crossentropy')

# Load MNIST dataset

(x_train, _), (_, _) = [Link].load_data()
x_train = x_train.reshape(-1, 784) / 255.0

35
# Training loop
epochs = 10000
batch_size = 64

for epoch in range(epochs):

# Train discriminator
real_images = x_train[[Link](0, x_train.shape[0], batch_size)]
fake_images = [Link]([Link](batch_size, 100))
discriminator_loss_real = discriminator.train_on_batch(real_images, [Link]((batch_size,
1)))
discriminator_loss_fake = discriminator.train_on_batch(fake_images,
[Link]((batch_size, 1)))
discriminator_loss = 0.5 * [Link](discriminator_loss_real, discriminator_loss_fake)

# Train generator
noise = [Link](batch_size, 100)
generator_loss = combined.train_on_batch(noise, [Link]((batch_size, 1)))

if epoch % 1000 == 0:
print(f"Epoch: {epoch}, D Loss: {discriminator_loss[0]}, G Loss: {generator_loss}")

# Generate and plot images

generated_images = [Link]([Link](10, 100))
[Link](figsize=(7, 7))
for i in range(10):
[Link](1, 10, i+1)
[Link](generated_images[i].reshape(28, 28), cmap='gray')
[Link]('off')
[Link]()

Result:

36
Downloading data from [Link]
11490434/11490434 [==============================] - 0s 0us/step
2/2 [==============================] - 0s 5ms/step
Epoch: 0, D Loss: 1.15574049949646, G Loss: 0.865715503692627
1/1 [==============================] - 0s 35ms/step

Epoch: 1000, D Loss: 0.005416138679720461, G Loss: 8.305022239685059

1/1 [==============================] - 0s 17ms/step

Epoch: 2000, D Loss: 0.0018298850336577743, G Loss: 13.786312103271484

1/1 [==============================] - 0s 14ms/step

Epoch: 3000, D Loss: 0.0035641974536702037, G Loss: 8.086578369140625

1/1 [==============================] - 0s 14ms/step

Epoch: 4000, D Loss: 0.013586459215730429, G Loss: 6.605484962463379

1/1 [==============================] - 0s 17ms/step

Epoch: 5000, D Loss: 0.042879847809672356, G Loss: 5.631101608276367

1/1 [==============================] - 0s 17ms/step

Epoch: 6000, D Loss: 0.13714924454689026, G Loss: 4.428217887878418

1/1 [==============================] - 0s 17ms/step

37
Epoch: 7000, D Loss: 0.356029212474823, G Loss: 3.2198615074157715
1/1 [==============================] - 0s 15ms/step

Epoch: 8000, D Loss: 0.28962957859039307, G Loss: 2.318570613861084

1/1 [==============================] - 0s 21ms/step

Epoch: 9000, D Loss: 0.21806973218917847, G Loss: 2.7780983448028564

1/1 [==============================] - 0s 15ms/step

38