S.No.

Practical Name Signature

Train A Deep Learning Model to Classify A Given Image
1
Using Pre Trained Model

2 Implement Object Detection Using Convolution Neural

Network

3 Improve the Deep Learning Model by Tuning Hyper

Parameters

4 Implement Recommendation System from Sales Data

Using Deep Learning.

5 Perform Sentiment Analysis in Network Graph Using RNN

Implement The Image Generation Using GAN.

6 • Demonstration And Implementation of Shallow
Architecture, Using Python, Tensorflow And Keras
• Google Colaboratory Cloning Github Repository,
Upload Data, Importing Kaggle's Dataset, Basic File
Operations
• Implementing Perceptron.
• Digit Classification: Neural Network to Classify MNIST
Dataset
Implement Convolution Neural Network Application Using
7
Tensorflow and Keras,
• Classification Of MNIST Dataset Using CNN
• Face Recognition Using CNN

8 Implement Object Detection Using Transfer Learning of

CNN Architectures

Implement Hyper Parameter Tuning and Regularization

9
Practice -
• Multilayer Perceptron (BPN)
• Minibatch Gradient Descent
Practical 1: Train A Deep Learning Model to Classify A Given Image Using Pre
Trained Model

from keras.applications import VGG16

from keras.preprocessing.image import ImageDataGenerator

from keras import models

from keras import layers

from keras import optimizers

# Load the pre-trained model

conv_base = VGG16(weights='imagenet', include_top=False, input_shape=(150, 150, 3))

# Prepare the data

train_dir = 'data/train'

validation_dir = 'data/validation'

test_dir = 'data/test'

datagen = ImageDataGenerator(rescale=1./255)

batch_size = 20

train_features, train_labels = extract_features(train_dir, 2000, datagen, conv_base, batch_size)

validation_features, validation_labels = extract_features(validation_dir, 1000, datagen, conv_base,

batch_size)

test_features, test_labels = extract_features(test_dir, 1000, datagen, conv_base, batch_size)

# Define the new classifier

model = models.Sequential()

model.add(layers.Flatten(input_shape=train_features.shape[1:]))

model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dropout(0.5))

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

# Train the new classifier

model.compile(optimizer=optimizers.RMSprop(lr=2e-5), loss='binary_crossentropy', metrics=['acc'])

history = model.fit(train_features, train_labels, epochs=30, batch_size=20,

validation_data=(validation_features, validation_labels))

# Fine-tune the pre-trained model

conv_base.trainable = True

set_trainable = False

for layer in conv_base.layers:

if layer.name == 'block5_conv1':

set_trainable = True

if set_trainable:

layer.trainable = True

else:

layer.trainable = False

model.compile(optimizer=optimizers.RMSprop(lr=1e-5), loss='binary_crossentropy', metrics=['acc'])

history = model.fit(train_generator, steps_per_epoch=100, epochs=100,)

Practical 2: Implement Object Detection Using Convolution Neural Network:

import tensorflow as tf

from object_detection.utils import label_map_util

from object_detection.utils import visualization_utils as vis_util

# Load the model and label map

PATH_TO_MODEL = 'path/to/your/frozen_inference_graph.pb'

PATH_TO_LABELS = 'path/to/your/label_map.pbtxt'

NUM_CLASSES = 90

detection_graph = tf.Graph()

with detection_graph.as_default():

od_graph_def = tf.GraphDef()

with tf.gfile.GFile(PATH_TO_MODEL, 'rb') as fid:

serialized_graph = fid.read()

od_graph_def.ParseFromString(serialized_graph)

tf.import_graph_def(od_graph_def, name='')

label_map = label_map_util.load_labelmap(PATH_TO_LABELS)

categories = label_map_util.convert_label_map_to_categories(label_map,
max_num_classes=NUM_CLASSES, use_display_name=True)

category_index = label_map_util.create_category_index(categories)

# Define the input and output tensors

with detection_graph.as_default():

with tf.Session(graph=detection_graph) as sess:

image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')

detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
 detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')

detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')

num_detections = detection_graph.get_tensor_by_name('num_detections:0')

# Run object detection on an image

image = cv2.imread('path/to/your/image.jpg')

image_expanded = np.expand_dims(image, axis=0)

(boxes, scores, classes, num) = sess.run([detection_boxes, detection_scores, detection_classes,

num_detections], feed_dict={image_tensor: image_expanded})

# Draw bounding boxes and labels on the image

vis_util.visualize_boxes_and_labels_on_image_array(

image,

np.squeeze(boxes),)
Practical 3: Improve the Deep Learning Model by Tuning Hyper Parameters

from sklearn.model_selection import RandomizedSearchCV

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Dropout

from tensorflow.keras.optimizers import Adam

from tensorflow.keras.wrappers.scikit_learn import KerasClassifier

from sklearn.metrics import accuracy_score

from sklearn.model_selection import train_test_split

import numpy as np

# Load the data

X = np.load('X.npy')

y = np.load('y.npy')

# Split the data into training and validation sets

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2)

# Define the hyperparameter search space

params = {

'learning_rate': [0.001, 0.01, 0.1],

'batch_size': [32, 64, 128],

'num_hidden_layers': [1, 2, 3],

'num_neurons': [32, 64, 128],

'dropout_rate': [0.1, 0.2, 0.3]

# Define the model architecture

def create_model(learning_rate, num_hidden_layers, num_neurons, dropout_rate):

model = Sequential()

model.add(Dense(num_neurons, activation='relu', input_shape=(X_train.shape[1],)))

model.add(Dropout(dropout_rate))

for i in range(num_hidden_layers - 1):

model.add(Dense(num_neurons, activation='relu'))

model.add(Dropout(dropout_rate))

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

optimizer = Adam(learning_rate=learning_rate)

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

return model

# Create a KerasClassifier object

model = KerasClassifier(build_fn=create_model)

# Use RandomizedSearchCV to find the best hyperparameters

search = RandomizedSearchCV(model, param_distributions=params, n_iter=10, scoring='accuracy',

n_jobs=-1, cv=5)

search.fit(X_train, y_train)

# Print the best hyperparameters and accuracy

print("Best Parameters: ", search.best_params_)

y_pred = search.predict(X_val)

print("Validation Accuracy: ", accuracy_score(y_val, y_pred))

Practical 4: Implement Recommendation System from Sales Data Using Deep Learning.

import pandas as pd

sales_df = pd.read_csv('sales_data.csv')

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import train_test_split

user_encoder = LabelEncoder()

item_encoder = LabelEncoder()

sales_df['user_id'] = user_encoder.fit_transform(sales_df['user_id'])

sales_df['item_id'] = item_encoder.fit_transform(sales_df['item_id'])

X = sales_df[['user_id', 'item_id']].values

y = sales_df['sales_count'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from scipy.sparse import coo_matrix

from scipy.sparse.linalg import svds

# Convert the sales data to a sparse matrix

sales_matrix = coo_matrix((y_train, (X_train[:, 0], X_train[:, 1])))

# Perform singular value decomposition (SVD)

U, S, Vt = svds(sales_matrix, k=20)
# Construct the user and item embeddings

user_embeddings = U

item_embeddings = Vt.T

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Input, Dense, Concatenate, Dropout

user_input = Input(shape=(1,))

item_input = Input(shape=(1,))

user_embed = Dense(32, activation='relu')(user_input)

item_embed = Dense(32, activation='relu')(item_input)

concat = Concatenate()([user_embed, item_embed])

dense1 = Dense(64, activation='relu')(concat)

dropout1 = Dropout(0.5)(dense1)

dense2 = Dense(32, activation='relu')(dropout1)

dropout2 = Dropout(0.5)(dense2)

output = Dense(1, activation='linear')(dropout2)

model = Sequential([user_input, item_input, concat, dense1, dropout1, dense2, dropout2, output])

model.compile(loss='mse', optimizer='adam', metrics=['mae'])

model.fit([X_train[:, 0], X_train[:, 1]], y_train, batch_size=256, epochs=10, validation_data=([X_test[:, 0],

X_test[:, 1]], y_test))

import numpy as np

# Generate recommendations for each user

user_item_scores = np.dot(user_embeddings, item_embeddings.T)

user_item_scores_normalized = (user_item_scores - user_item_scores.min()) / (user_item_scores.max()
- user_item_scores.min())

user_items = sales_df[['user_id', 'item_id']].drop_duplicates()

user_items = user_items.set_index('user_id')

user_items['item_scores'] = user_item_scores_normalized

# Get top
Practical 5 Perform Sentiment Analysis in Network Graph Using RNN
from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Bidirectional, Dense, Embedding
from tensorflow.keras.datasets import imdb
from tensorflow.keras.models import Sequential
import numpy as np

# Getting reviews with words that come under 5000

# most occurring words in the entire
# corpus of textual review data
vocab_size = 5000
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)

print(x_train[0])

# Getting all the words from word_index dictionary

word_idx = imdb.get_word_index()

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

# hence converting the index as key and the words as values
word_idx = {i: word for word, i in word_idx.items()}

# again printing the review

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

# Get the minimum and the maximum length of reviews

print("Max length of a review:: ", len(max((x_train+x_test), key=len)))
print("Min length of a review:: ", len(min((x_train+x_test), key=len)))
from tensorflow.keras.preprocessing import sequence

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

max_words = 400

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

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

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

x_train_, y_train_ = x_train[64:], y_train[64:]
# fixing every word's embedding size to be 32
embd_len = 32

# Creating a RNN model

RNN_model = Sequential(name="Simple_RNN")
RNN_model.add(Embedding(vocab_size,
embd_len,
input_length=max_words))

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

# use return_sequences=True
RNN_model.add(SimpleRNN(128,
activation='tanh',
return_sequences=False))
RNN_model.add(Dense(1, activation='sigmoid'))

# printing model summary

print(RNN_model.summary())

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

# Training the model

history = RNN_model.fit(x_train_, y_train_,
 batch_size=64,
epochs=5,
verbose=1,
validation_data=(x_valid, y_valid))

# Printing model score on test data

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

# Defining GRU model

gru_model = Sequential(name="GRU_Model")
gru_model.add(Embedding(vocab_size,
embd_len,
input_length=max_words))
gru_model.add(GRU(128,
activation='tanh',
return_sequences=False))
gru_model.add(Dense(1, activation='sigmoid'))

# Printing the Summary

print(gru_model.summary())

# Compiling the model

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

# Training the GRU model

history2 = gru_model.fit(x_train_, y_train_,
batch_size=64,
epochs=5,
verbose=1,
validation_data=(x_valid, y_valid))

# Printing model score on test data

print()
print("GRU model Score---> ", gru_model.evaluate(x_test, y_test, verbose=0))
# Defining LSTM model
lstm_model = Sequential(name="LSTM_Model")
lstm_model.add(Embedding(vocab_size,
embd_len,
input_length=max_words))
lstm_model.add(LSTM(128,
activation='relu',
return_sequences=False))
lstm_model.add(Dense(1, activation='sigmoid'))
# Printing Model Summary
print(lstm_model.summary())
# Compiling the model
lstm_model.compile(
loss="binary_crossentropy",
optimizer='adam',
metrics=['accuracy']
)
# Training the model
history3 = lstm_model.fit(x_train_, y_train_,
 batch_size=64,
epochs=5,
verbose=2,
validation_data=(x_valid, y_valid))
# Displaying the model accuracy on test data
print()
print("LSTM model Score---> ", lstm_model.evaluate(x_test, y_test, verbose=0))

Practical 6 Implement The Image Generation Using GAN.

from numpy import zeros, ones, expand_dims, asarray

from numpy.random import randn, randint
from keras.datasets import fashion_mnist
from keras.optimizers import Adam
from keras.models import Model, load_model
from keras.layers import Input, Dense, Reshape, Flatten
from keras.layers import Conv2D, Conv2DTranspose, Concatenate
from keras.layers import LeakyReLU, Dropout, Embedding
from keras.layers import BatchNormalization, Activation
from keras import initializers
from keras.initializers import RandomNormal
from keras.optimizers import Adam, RMSprop, SGD
from matplotlib import pyplot
import numpy as np
from math import sqrt

(X_train, _), (_, _) = fashion_mnist.load_data()

X_train = X_train.astype(np.float32) / 127.5 - 1
X_train = np.expand_dims(X_train, axis=3)
print(X_train.shape)

def generate_latent_points(latent_dim, n_samples):

x_input = randn(latent_dim * n_samples)
z_input = x_input.reshape(n_samples, latent_dim)
return z_input

def generate_real_samples(X_train, n_samples):

ix = randint(0, X_train.shape[0], n_samples)
X = X_train[ix]
y = ones((n_samples, 1))
return X, y

def generate_fake_samples(generator, latent_dim, n_samples):

z_input = generate_latent_points(latent_dim, n_samples)
images = generator.predict(z_input)
y = zeros((n_samples, 1))
return images, y

def summarize_performance(step, g_model, latent_dim, n_samples=100):

X, _ = generate_fake_samples(g_model, latent_dim, n_samples)
X = (X + 1) / 2.0
for i in range(100):
pyplot.subplot(10, 10, 1 + i)
pyplot.axis('off')
pyplot.imshow(X[i, :, :, 0], cmap='gray_r')
filename2 = 'model_%04d.h5' % (step+1)
g_model.save(filename2)
print('>Saved: %s' % (filename2))
def save_plot(examples, n_examples):
for i in range(n_examples):
pyplot.subplot(sqrt(n_examples), sqrt(n_examples), 1 + i)
pyplot.axis('off')
pyplot.imshow(examples[i, :, :, 0], cmap='gray_r')
pyplot.show()

def define_discriminator(in_shape=(28, 28, 1)):

init = RandomNormal(stddev=0.02)
in_image = Input(shape=in_shape)
fe = Flatten()(in_image)
fe = Dense(1024)(fe)
fe = LeakyReLU(alpha=0.2)(fe)
fe = Dropout(0.3)(fe)
fe = Dense(512)(fe)
fe = LeakyReLU(alpha=0.2)(fe)
fe = Dropout(0.3)(fe)
fe = Dense(256)(fe)
fe = LeakyReLU(alpha=0.2)(fe)
fe = Dropout(0.3)(fe)
out = Dense(1, activation='sigmoid')(fe)
model = Model(in_image, out)
opt = Adam(lr=0.0002, beta_1=0.5)
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
return model
discriminator = define_discriminator()

def define_generator(latent_dim):
init = RandomNormal(stddev=0.02)
in_lat = Input(shape=(latent_dim,))
gen = Dense(256, kernel_initializer=init)(in_lat)
gen = LeakyReLU(alpha=0.2)(gen)
gen = Dense(512, kernel_initializer=init)(gen)
gen = LeakyReLU(alpha=0.2)(gen)
gen = Dense(1024, kernel_initializer=init)(gen)
gen = LeakyReLU(alpha=0.2)(gen)
gen = Dense(28 * 28 * 1, kernel_initializer=init)(gen)
out_layer = Activation('tanh')(gen)
out_layer = Reshape((28, 28, 1))(gen)
model = Model(in_lat, out_layer)
return model
generator = define_generator(100)

def define_gan(g_model, d_model):

d_model.trainable = False
gan_output = d_model(g_model.output)
model = Model(g_model.input, gan_output)
opt = Adam(lr=0.0002, beta_1=0.5)
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
return model
gan_model = define_gan(generator, discriminator)

def train(g_model, d_model, gan_model, X_train, latent_dim, n_epochs=100, n_batch=64):

bat_per_epo = int(X_train.shape[0] / n_batch)
n_steps = bat_per_epo * n_epochs
for i in range(n_steps):
X_real, y_real = generate_real_samples(X_train, n_batch)
d_loss_r, d_acc_r = d_model.train_on_batch(X_real, y_real)
X_fake, y_fake = generate_fake_samples(g_model, latent_dim, n_batch)
d_loss_f, d_acc_f = d_model.train_on_batch(X_fake, y_fake)
z_input = generate_latent_points(latent_dim, n_batch)
y_gan = ones((n_batch, 1))
g_loss, g_acc = gan_model.train_on_batch(z_input, y_gan)
print('>%d, dr[%.3f,%.3f], df[%.3f,%.3f], g[%.3f,%.3f]' % (i+1, d_loss_r,d_acc_r, d_loss_f,d_acc_f,
g_loss,g_acc))
if (i+1) % (bat_per_epo * 1) == 0:
summarize_performance(i, g_model, latent_dim)

latent_dim = 100
train(generator, discriminator, gan_model, X_train, latent_dim, n_epochs=20, n_batch=64)

import math
model = load_model('model_18740.h5')
latent_dim = 100
n_examples = 100
latent_points = generate_latent_points(latent_dim, n_examples)
X = model.predict(latent_points)
X = (X + 1) / 2.0
# Calculate the number of rows needed for the plot
n_rows = math.ceil(n_examples / 10)
save_plot(X, n_examples, )
Practical 7 Implement Convolution Neural Network Application Using Tensorflow and Keras,

• Classification Of MNIST Dataset Using CNN

import numpy as np
import pandas as pd
from numpy import unique, argmax
from tensorflow.keras.datasets.mnist import load_data
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dropout
from tensorflow.keras.utils import plot_model
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist

#loading the MNIST Dataset

(train_x, train_y), (test_x, test_y) = mnist.load_data()

#printing the shapes

print(train_x.shape, train_y.shape)

print(test_x.shape , test_y.shape)

#reshaping train and test sets

train_x = train_x.reshape((train_x.shape[0], train_x.shape[1], train_x.shape[2], 1))

test_x = test_x .reshape((test_x.shape[0], test_x.shape[1], test_x.shape[2], 1))
#printing the shapes
print(train_x.shape, train_y.shape)

print(test_x.shape , test_y.shape)

#normalizing the pixel values of images

train_x = train_x.astype('float32')/255.0

test_x = test_x.astype('float32')/255.0

#plotting images of dataset

fig = plt.figure(figsize = (10,3))

for i in range(20):

ax= fig.add_subplot(2, 10, i+1, xticks=[], yticks=[])

ax.imshow(np.squeeze(train_x[i]), cmap='gray')

ax.set_title(train_y[i])

shape = train_x.shape[1:]

shape
#CNN Model

model = Sequential()

#adding convolutional layer

model.add(Conv2D(32, (3,3), activation='relu', input_shape= shape))

model.add(Conv2D(48, (3,3), activation='relu'))

model.add(Dropout(0.5))

model.add(Flatten())

model.add(Dense(500, activation='relu'))

model.add(Dense(10, activation='softmax'))

model.summary()
#compiling model

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

x=model.fit(train_x, train_y, epochs=10, batch_size = 128, verbose= 2 , validation_split = 0.1)

loss, accuracy= model.evaluate(test_x, test_y, verbose = 0)

print(f'Accuracy: {accuracy*100}')
Practical 8 Implement Object Detection Using Transfer Learning of CNN Architectures

# for numerical analysis

import numpy as np
# to store and process in a dataframe
import pandas as pd

# for ploting graphs

import matplotlib.pyplot as plt
# advancec ploting
import seaborn as sns

# image processing
import matplotlib.image as mpimg

# train test split

from sklearn.model_selection import train_test_split
# model performance metrics
from sklearn.metrics import confusion_matrix, classification_report

# utility functions
from tensorflow.keras.utils import to_categorical
# sequential model
from tensorflow.keras.models import Sequential
# layers
from tensorflow.keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropout

# from keras.optimizers import RMSprop

# from keras.preprocessing.image import ImageDataGenerator
# from keras.callbacks import ReduceLROnPlateau

train = pd.read_csv("/content/test.csv")
test = pd.read_csv("/content/test.csv")

train.head()

test.head()
print(train.isna().sum().sum())
print(test.isna().sum().sum())

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(8, 5))
sns.countplot(train, palette='Dark2')
plt.title('Train labels count')
plt.show()
Practical 9 Implement Hyper Parameter Tuning and Regularization Practice -
• Minibatch Gradient Descent

import torch
import numpy as np
import matplotlib.pyplot as plt

# Creating a function f(X) with a slope of -5

X = torch.arange(-5, 5, 0.1).view(-1, 1)
func = -5 * X

# Adding Gaussian noise to the function f(X) and saving it in Y

Y = func + 0.4 * torch.randn(X.size())

...
# Plot and visualizing the data points in blue
plt.plot(X.numpy(), Y.numpy(), 'b+', label='Y')
plt.plot(X.numpy(), func.numpy(), 'r', label='func')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid('True', color='y')
plt.show()
...
# defining the function for forward pass for prediction
def forward(x):
return w * x + b

# evaluating data points with Mean Square Error (MSE)

def criterion(y_pred, y):
return torch.mean((y_pred - y) ** 2)

w = torch.tensor(-10.0, requires_grad = True)

b = torch.tensor(-20.0, requires_grad = True)

step_size = 0.1
loss_SGD = []
n_iter = 20

for i in range (n_iter):

# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_SGD.append(criterion(y_pred, Y).tolist())
for x, y in train_loader:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

import matplotlib.pyplot as plt

import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
torch.manual_seed(42)

# Creating a function f(X) with a slope of -5

X = torch.arange(-5, 5, 0.1).view(-1, 1)
func = -5 * X
# Adding Gaussian noise to the function f(X) and saving it in Y
Y = func + 0.4 * torch.randn(X.size())

w = torch.tensor(-10.0, requires_grad = True)

b = torch.tensor(-20.0, requires_grad = True)

# defining the function for forward pass for prediction

def forward(x):
return w * x + b

# evaluating data points with Mean Square Error (MSE)

def criterion(y_pred, y):
return torch.mean((y_pred - y) ** 2)

# Creating our dataset class

class Build_Data(Dataset):
# Constructor
def __init__(self):
self.x = torch.arange(-5, 5, 0.1).view(-1, 1)
self.y = -5 * X
self.len = self.x.shape[0]
# Getting the data
def __getitem__(self, index):
return self.x[index], self.y[index]
# Getting length of the data
def __len__(self):
return self.len

# Creating DataLoader object

dataset = Build_Data()
train_loader = DataLoader(dataset=dataset, batch_size=1)

step_size = 0.1
loss_SGD = []
n_iter = 20

for i in range (n_iter):

# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_SGD.append(criterion(y_pred, Y).tolist())
for x, y in train_loader:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
 # backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

...
train_loader_10 = DataLoader(dataset=dataset, batch_size=10)

w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)

step_size = 0.1
loss_MBGD_10 = []
iter = 20

for i in range (iter):

# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_MBGD_10.append(criterion(y_pred, Y).tolist())
for x, y in train_loader_10:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

...
train_loader_20 = DataLoader(dataset=dataset, batch_size=20)

w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)
step_size = 0.1
loss_MBGD_20 = []
iter = 20

for i in range(iter):
# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_MBGD_20.append(criterion(y_pred, Y).tolist())
for x, y in train_loader_20:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

import matplotlib.pyplot as plt

import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
torch.manual_seed(42)

# Creating a function f(X) with a slope of -5

X = torch.arange(-5, 5, 0.1).view(-1, 1)
func = -5 * X
# Adding Gaussian noise to the function f(X) and saving it in Y
Y = func + 0.4 * torch.randn(X.size())

w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)

# defining the function for forward pass for prediction

def forward(x):
return w * x + b

# evaluating data points with Mean Square Error (MSE)

def criterion(y_pred, y):
return torch.mean((y_pred - y) ** 2)
# Creating our dataset class
class Build_Data(Dataset):
# Constructor
def __init__(self):
self.x = torch.arange(-5, 5, 0.1).view(-1, 1)
self.y = -5 * X
self.len = self.x.shape[0]
# Getting the data
def __getitem__(self, index):
return self.x[index], self.y[index]
# Getting length of the data
def __len__(self):
return self.len

# Creating DataLoader object

dataset = Build_Data()
train_loader_10 = DataLoader(dataset=dataset, batch_size=10)

step_size = 0.1
loss_MBGD_10 = []
iter = 20

for i in range(n_iter):
# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_MBGD_10.append(criterion(y_pred, Y).tolist())
for x, y in train_loader_10:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updateing the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

train_loader_20 = DataLoader(dataset=dataset, batch_size=20)

# Reset w and b
w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)

loss_MBGD_20 = []

for i in range(n_iter):
# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_MBGD_20.append(criterion(y_pred, Y).tolist())
for x, y in train_loader_20:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

plt.plot(loss_SGD,label = "Stochastic Gradient Descent")

plt.plot(loss_MBGD_10,label = "Mini-Batch-10 Gradient Descent")
plt.plot(loss_MBGD_20,label = "Mini-Batch-20 Gradient Descent")
plt.xlabel('epoch')
plt.ylabel('Cost/total loss')
plt.legend()
plt.show()
import matplotlib.pyplot as plt
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
torch.manual_seed(42)

# Creating a function f(X) with a slope of -5

X = torch.arange(-5, 5, 0.1).view(-1, 1)
func = -5 * X
# Adding Gaussian noise to the function f(X) and saving it in Y
Y = func + 0.4 * torch.randn(X.size())

w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)

# defining the function for forward pass for prediction

def forward(x):
return w * x + b

# evaluating data points with Mean Square Error (MSE)

def criterion(y_pred, y):
return torch.mean((y_pred - y) ** 2)

# Creating our dataset class

class Build_Data(Dataset):
# Constructor
def __init__(self):
self.x = torch.arange(-5, 5, 0.1).view(-1, 1)
self.y = -5 * X
self.len = self.x.shape[0]
# Getting the data
def __getitem__(self, index):
return self.x[index], self.y[index]
# Getting length of the data
def __len__(self):
return self.len

# Creating DataLoader object

dataset = Build_Data()
train_loader = DataLoader(dataset=dataset, batch_size=1)

step_size = 0.1
loss_SGD = []
n_iter = 20
for i in range(n_iter):
# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_SGD.append(criterion(y_pred, Y).tolist())
for x, y in train_loader:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

train_loader_10 = DataLoader(dataset=dataset, batch_size=10)

# Reset w and b
w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)

loss_MBGD_10 = []

for i in range(n_iter):
# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_MBGD_10.append(criterion(y_pred, Y).tolist())
for x, y in train_loader_10:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()
train_loader_20 = DataLoader(dataset=dataset, batch_size=20)

# Reset w and b
w = torch.tensor(-10.0, requires_grad=True)
b = torch.tensor(-20.0, requires_grad=True)

loss_MBGD_20 = []

for i in range(n_iter):
# calculating loss as in the beginning of an epoch and storing it
y_pred = forward(X)
loss_MBGD_20.append(criterion(y_pred, Y).tolist())
for x, y in train_loader_20:
# making a prediction in forward pass
y_hat = forward(x)
# calculating the loss between original and predicted data points
loss = criterion(y_hat, y)
# backward pass for computing the gradients of the loss w.r.t to
learnable parameters
loss.backward()
# updating the parameters after each iteration
w.data = w.data - step_size * w.grad.data
b.data = b.data - step_size * b.grad.data
# zeroing gradients after each iteration
w.grad.data.zero_()
b.grad.data.zero_()

plt.plot(loss_SGD,label="Stochastic Gradient Descent")

plt.plot(loss_MBGD_10,label="Mini-Batch-10 Gradient Descent")
plt.plot(loss_MBGD_20,label="Mini-Batch-20 Gradient Descent")
plt.xlabel('epoch')
plt.ylabel('Cost/total loss')
plt.legend()
plt.show()