Scribd
Upload
22 views5 pages

Experiment 3

Uploaded by

mohammed.ansari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
22 views5 pages

Experiment 3

Uploaded by

mohammed.ansari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Experiment - 3

Name: Ansari Mohammed Shanouf Valijan


Class: B.E. Computer Engineering, Semester - VII
UID: 2021300004
Batch: M

Aim:
To use a pre-trained CNN model for a given problem.

Objective:
▪ To use the pre-trained models like ResNet, VGGNet, etc for a classification task.

Theory:

VGG-16 Architecture
Pretrained Convolutional Neural Network (CNN) models such as ResNet and VGGNet are
powerful tools in deep learning, particularly for tasks like image classification, object
detection, and more. These models have been trained on large datasets, like ImageNet, and
possess learned features that can be reused for similar tasks, reducing the need for vast
amounts of data or computational resources. Leveraging pretrained models allows for
transfer learning, where the knowledge gained from one task (e.g., distinguishing between a
thousand classes of objects) is applied to a new, more specific task. By fine-tuning the
pretrained weights on new datasets, the model can be adapted efficiently to the target
problem.

ResNet (Residual Network) and VGGNet are two popular architectures for transfer learning.
VGGNet, known for its simplicity, uses deep stacks of convolutional layers, each with a small
kernel size, making it easy to understand and implement. However, the deeper architecture
leads to many parameters, making training and inference computationally expensive. ResNet,
on the other hand, introduces skip connections, allowing information to bypass certain layers.
This innovation helps overcome the vanishing gradient problem in very deep networks,
allowing models with hundreds of layers to converge efficiently. Thus, ResNet is often
preferred for deeper architectures because of its improved training stability.

Using pretrained models like VGGNet or ResNet comes with multiple advantages, including
faster convergence and potentially higher accuracy, as the network starts with weights that
already encode useful patterns. These models are particularly valuable in cases where labeled
data is limited. Instead of training a network from scratch, researchers can use the pretrained
model as a feature extractor, only retraining the final classification layer for their specific task.
This method speeds up the process and reduces the computational resources required,
making pretrained models a go-to choice for many real-world applications.

Problem Statement:
Using VGG-16 as the base pre-trained CNN network, develop a model that requires less
amount of training to properly classify a given image as that of a cat or a dog.

Implementation:
Pretrained CNN Notebook
Importing the required libraries
import tensorflow as tf
from tensorflow.keras.applications import VGG16
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.models import Model
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt

Organizing the dataset consisting of images of cats and dogs (3000 images)
dataset_url = 'https://storage.googleapis.com/mledu-
datasets/cats_and_dogs_filtered.zip'
data_dir = tf.keras.utils.get_file('cats_and_dogs', origin=dataset_url,
extract=True)
data_dir = data_dir.replace('cats_and_dogs', 'cats_and_dogs_filtered')

train_dir = f"{data_dir}/train"
validation_dir = f"{data_dir}/validation"

Defining data generators that would be used to produce batches of images for the purpose
of training and testing
train_datagen = ImageDataGenerator(rescale=1./255)
validation_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
train_dir, target_size=(224, 224), batch_size=32, class_mode='binary')

validation_generator = validation_datagen.flow_from_directory(
validation_dir, target_size=(224, 224), batch_size=32, class_mode='binary')

Defining the base model (using VGG16)


base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224,
3))

Modifying the model


x = base_model.output
x = Flatten()(x)
x = Dense(128, activation='relu')(x)
predictions = Dense(1, activation='sigmoid')(x)

Freezing specific layers from the pretrained model to avoid changing specific weights
model = Model(inputs=base_model.input, outputs=predictions)
for layer in base_model.layers:
layer.trainable = False

Compiling the model


model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
Training the model using minimal data (Took about an hour)
history = model.fit(
train_generator,
steps_per_epoch=train_generator.samples // train_generator.batch_size,
validation_data=validation_generator,
validation_steps=validation_generator.samples //
validation_generator.batch_size,
epochs=4,
verbose=1)

Evaluating the trained model


loss, accuracy = model.evaluate(validation_generator)
print(f"Validation Accuracy: {accuracy * 100:.2f}%")

32/32 ━━━━━━━━━━━━━━━━━━━━ 540s 17s/step - accuracy: 0.8920 - loss:


0.2598
Validation Accuracy: 89.20%

Plotting the model’s training history


plt.plot(history.history['accuracy'], label='train accuracy')
plt.plot(history.history['val_accuracy'], label='validation accuracy')
plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'], label='validation loss')
plt.legend()
plt.title('Training and Validation Metrics')
plt.show()
Making predictions on an example data
images, labels = next(validation_generator)
img = images[0]
img_array = tf.keras.preprocessing.image.img_to_array(img)
img_array = tf.expand_dims(img_array, axis=0) / 255.0

prediction = model.predict(img_array)
print("Predicted class:", "Dog" if prediction > 0.5 else "Cat")
plt.imshow(img)
plt.axis('off')
plt.show()

1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 1s/step


Predicted class: Cat

Inferences:
▪ The VGG-16 pre-trained convolutional network proved to be really beneficial in
building a classifier for identifying cats’ and dogs’ images while using minimal data for
training.
▪ The concerned model built was found to have a validation accuracy of 89.20% at the
end of training.
▪ Upon plotting the training history of the model, it can be noticed that the validation
accuracy of the model was comparatively higher than the training accuracy which may
be due to weight parameters of the pre-trained VGG-16 model. However, these
accuracies converge towards the end of training.

You might also like