#!pip install opendatasets --quiet #Used for Kaggle Datasets

#!pip install torchsummary --quiet

#!pip install scikit-learn --quiet

#!pip install Pillow --quiet

import opendatasets as od

od.download('https://www.kaggle.com/datasets/andrewmvd/animal-faces')

import torch

import torch.nn as nn

from torch.optim import Adam

from torchvision.transforms import transforms

from torch.utils.data import Dataset, DataLoader

from sklearn.preprocessing import LabelEncoder #To convert strings to integers

import matplotlib.pyplot as plt

from PIL import Image #Read Images

import pandas as pd

import numpy as np

import os #Read from Directory

device = "cuda" if torch.cuda.is_available() else "cpu"

print(f"Device Available: {device}")

#Split Dataset to Train, Validation, Test

image_path = []

labels = []

for i in os.listdir("animal-faces/afhq"):

for label in os.listdir(f"animal-faces/afhq/{i}"):

for image in os.listdir(f"animal-faces/afhq/{i}/{label}"):

image_path.append(f"animal-faces/afhq/{i}/{label}/{image}")

labels.append(label)

data_df = pd.DataFrame(zip(image_path, labels), columns = ["image_path","labels"])

print(data_df["labels"].unique())

data_df.head(5)

train = data_df.sample(frac = 0.7) #70% of the data

test = data_df.drop(train.index)

val = test.sample(frac = 0.5) #70% of the data

test = test.drop(val.index)

print(data_df.shape)

print(train.shape)

print(val.shape)

print(test.shape)

label_encoder = LabelEncoder()

label_encoder.fit(data_df["labels"])

transform = transforms.Compose([

transforms.Resize((128,128)),

transforms.ToTensor(),

transforms.ConvertImageDtype(torch.float)

])

print(label_encoder)

class CustomImageDataset(Dataset):

def __init__(self, dataframe, transform=None):

self.dataframe = dataframe

self.transform = transform

self.labels = torch.tensor(label_encoder.transform(dataframe['labels'])).to(device)

def __len__(self):

return self.dataframe.shape[0]

def __getitem__(self, idx):

img_path = self.dataframe.iloc[idx, 0]

label = self.labels[idx]

image = Image.open(img_path).convert('RGB')

if self.transform:

image = self.transform(image).to(device)

return image, label

n_rows = 3

n_cols = 3

f, axarr = plt.subplots(n_rows, n_cols)

for row in range(n_rows):

for col in range(n_cols):

image = Image.open(data_df.sample(n = 1)['image_path'].iloc[0]).convert("RGB")

axarr[row, col].imshow(image)

axarr[row, col].axis('off')

train_dataset = CustomImageDataset(dataframe=train, transform=transform)

val_dataset = CustomImageDataset(dataframe=val, transform=transform)

test_dataset = CustomImageDataset(dataframe=test, transform=transform)

plt.show()

train_dataset = CustomImageDataset(dataframe=train, transform=transform)

val_dataset = CustomImageDataset(dataframe=val, transform=transform)

test_dataset = CustomImageDataset(dataframe=test, transform=transform)

#Hyperparameters

LR = 1e-4

BATCH_SIZE = 16

EPOCHS = 10

train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)

val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True)

class Net(nn.Module):

def __init__(self):

super().__init__()

self.conv1 = nn.Conv2d(3, 32, kernel_size = 3, padding = 1) #First Convolusion Layer

self.conv2 = nn.Conv2d(32, 64, kernel_size = 3, padding = 1) #Second Convolusion Layer

self.conv3 = nn.Conv2d(64, 128, kernel_size = 3, padding = 1)

self.pooling = nn.MaxPool2d(2,2) #Pooling Layer, will be used more than once

self.relu = nn.ReLU() #RELU Activation function

self.flatten = nn.Flatten() #Flatten

self.linear = nn.Linear((128 * 16 * 16), 128) #Traditional Dense(Linear)

self.output = nn.Linear(128, len(data_df['labels'].unique())) #Output Linear Layer

def forward(self, x):

x = self.conv1(x)

x = self.pooling(x)

x = self.relu(x)

x = self.conv2(x)

x = self.pooling(x)

x = self.relu(x)

x = self.conv3(x)

x = self.pooling(x)

x = self.relu(x)

x = self.flatten(x)

x = self.linear(x)

x = self.output(x)

return x

model = Net().to(device) #Create an instance of the model and move it to the GPU

from torchsummary import summary

summary(model, input_size = (3, 128, 128))

criterion = nn.CrossEntropyLoss()

optimizer = Adam(model.parameters(), lr = LR)

total_loss_train_plot = []

total_loss_validation_plot = []

total_acc_train_plot = []

total_acc_validation_plot = []

for epoch in range(EPOCHS):

total_acc_train = 0

total_loss_train = 0

total_loss_val = 0

total_acc_val = 0

for inputs, labels in train_loader:

optimizer.zero_grad()

outputs = model(inputs)

train_loss = criterion(outputs, labels)

total_loss_train += train_loss.item()

train_loss.backward()

train_acc = (torch.argmax(outputs, axis = 1) == labels).sum().item()

total_acc_train += train_acc

optimizer.step()

with torch.no_grad():

for inputs, labels in val_loader:

outputs = model(inputs)

val_loss = criterion(outputs, labels)

total_loss_val += val_loss.item()

val_acc = (torch.argmax(outputs, axis = 1) == labels).sum().item()

total_acc_val += val_acc

total_loss_train_plot.append(round(total_loss_train/1000, 4))

total_loss_validation_plot.append(round(total_loss_val/1000, 4))

total_acc_train_plot.append(round(total_acc_train/(train_dataset.__len__())*100, 4))

total_acc_validation_plot.append(round(total_acc_val/(val_dataset.__len__())*100, 4))

print(f'''Epoch {epoch+1}/{EPOCHS}, Train Loss: {round(total_loss_train/100, 4)} Train Accuracy {round((total_acc_train)/train_dataset.__len__() * 100, 4)}

Validation Loss: {round(total_loss_val/100, 4)} Validation Accuracy: {round((total_acc_val)/val_dataset.__len__() * 100, 4)}''')

print("="*25)

with torch.no_grad():

total_loss_test = 0

total_acc_test = 0

for inputs, labels in test_loader:

predictions = model(inputs)

acc = (torch.argmax(predictions, axis = 1) == labels).sum().item()

total_acc_test += acc

test_loss = criterion(predictions, labels)

total_loss_test += test_loss.item()

print(f"Accuracy Score is: {round((total_acc_test/test_dataset.__len__()) * 100, 4)} and Loss is {round(total_loss_test/1000, 4)}")

fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(15, 5))

axs[0].plot(total_loss_train_plot, label='Training Loss')

axs[0].plot(total_loss_validation_plot, label='Validation Loss')

axs[0].set_title('Training and Validation Loss over Epochs')

axs[0].set_xlabel('Epochs')

axs[0].set_ylabel('Loss')

axs[0].legend()

axs[1].plot(total_acc_train_plot, label='Training Accuracy')

axs[1].plot(total_acc_validation_plot, label='Validation Accuracy')

axs[1].set_title('Training and Validation Accuracy over Epochs')

axs[1].set_xlabel('Epochs')

axs[1].set_ylabel('Accuracy')

axs[1].legend()

plt.tight_layout()

plt.show()

#inference

# 1- read image

# 2- Transform using transform object

# 3- predict through the model

# 4- inverse transform by label encoder

def predict_image(image_path):

image = Image.open(image_path).convert('RGB')

image_tensor = transform(image).to(device)

output = model(image_tensor.unsqueeze(0))

predicted_class = torch.argmax(output, axis=1).item()

return label_encoder.inverse_transform([predicted_class])

# Visualize the image

image_path = "cat_image.jpeg"

image = Image.open(image_path)

plt.imshow(image)

plt.axis('off')

plt.show()

# Predict

print("Prediction:\n")

print(predict_image(image_path))