Brain Tumor Multi-Classification with PSO

import numpy as np
import pandas as pd
import os

base_path = "/kaggle/input/pmram-bangladeshi-brain-cancer-mri-dataset/PMRAM
Bangladeshi Brain Cancer - MRI Dataset/PMRAM Bangladeshi Brain Cancer - MRI
Dataset/Augmented Data/Augmented"
categories = ["512Glioma","512Meningioma","512Normal","512Pituitary" ]

image_paths = []
labels = []

for category in categories:

category_path = os.path.join(base_path, category)
for image_name in os.listdir(category_path):
image_path = os.path.join(category_path, image_name)
image_paths.append(image_path)
labels.append(category)
df = pd.DataFrame({
"image_path": image_paths,
"label": labels
})

df.head()

image_path label
0 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Glioma
1 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Glioma
2 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Glioma
3 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Glioma
4 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Glioma

df.tail()

image_path label
5999 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Pituitary
6000 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Pituitary
6001 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Pituitary
6002 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Pituitary
6003 /kaggle/input/pmram-bangladeshi-brain-cancer-m... 512Pituitary

df.shape

(6004, 2)

df.columns

Index(['image_path', 'label'], dtype='object')

df.duplicated().sum()

df.isnull().sum()

image_path 0
label 0
dtype: int64

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6004 entries, 0 to 6003
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 image_path 6004 non-null object
1 label 6004 non-null object
dtypes: object(2)
memory usage: 93.9+ KB
df['label'].unique()

array(['512Glioma', '512Meningioma', '512Normal', '512Pituitary'],

dtype=object)

df['label'].value_counts()

label
512Glioma 1501
512Meningioma 1501
512Normal 1501
512Pituitary 1501
Name: count, dtype: int64

import seaborn as sns

import matplotlib.pyplot as plt

sns.set_style("whitegrid")

fig, ax = plt.subplots(figsize=(8, 6))

sns.countplot(data=df, x="label", palette="viridis", ax=ax)

ax.set_title("Distribution of Tumor Types", fontsize=14, fontweight='bold')

ax.set_xlabel("Tumor Type", fontsize=12)
ax.set_ylabel("Count", fontsize=12)

for p in ax.patches:
ax.annotate(f'{int(p.get_height())}',
(p.get_x() + p.get_width() / 2., p.get_height()),
ha='center', va='bottom', fontsize=11, color='black',
xytext=(0, 5), textcoords='offset points')

plt.show()

label_counts = df["label"].value_counts()

fig, ax = plt.subplots(figsize=(8, 6))

colors = sns.color_palette("viridis", len(label_counts))

ax.pie(label_counts, labels=label_counts.index, autopct='%1.1f%%',

startangle=140, colors=colors, textprops={'fontsize': 12, 'weight':
'bold'},
wedgeprops={'edgecolor': 'black', 'linewidth': 1})

ax.set_title("Distribution of Tumor Types - Pie Chart", fontsize=14,

fontweight='bold')

plt.show()
import cv2

num_images = 5

plt.figure(figsize=(15, 12))

for i, category in enumerate(categories):

category_images = df[df['label'] ==
category]['image_path'].iloc[:num_images]

for j, img_path in enumerate(category_images):

img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

plt.subplot(len(categories), num_images, i * num_images + j + 1)

plt.imshow(img)
plt.axis('off')
plt.title(category)

plt.tight_layout()
plt.show()
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense,
Activation, Dropout, BatchNormalization
from tensorflow.keras import regularizers

import warnings
warnings.filterwarnings("ignore")

print ('check')

check

train_df_new, temp_df_new = train_test_split(

df,
train_size=0.8,
shuffle=True,
 random_state=42,
stratify=df['label']
)

valid_df_new, test_df_new = train_test_split(

temp_df_new,
test_size=0.5,
shuffle=True,
random_state=42,
stratify=temp_df_new['label']
)

batch_size = 16
img_size = (224, 224)
channels = 3
img_shape = (img_size[0], img_size[1], channels)

tr_gen = ImageDataGenerator(rescale=1./255)
ts_gen = ImageDataGenerator(rescale=1./255)

train_gen_new = tr_gen.flow_from_dataframe(
train_df_new,
x_col='image_path',
y_col='label',
target_size=img_size,
class_mode='sparse',
color_mode='rgb',
shuffle=True,
batch_size=batch_size
)

valid_gen_new = ts_gen.flow_from_dataframe(
valid_df_new,
x_col='image_path',
y_col='label',
target_size=img_size,
class_mode='sparse',
color_mode='rgb',
shuffle=True,
batch_size=batch_size
)

test_gen_new = ts_gen.flow_from_dataframe(
test_df_new,
x_col='image_path',
y_col='label',
target_size=img_size,
class_mode='sparse',
color_mode='rgb',
shuffle=False,
 batch_size=batch_size
)

Found 4803 validated image filenames belonging to 4 classes.

Found 600 validated image filenames belonging to 4 classes.
Found 601 validated image filenames belonging to 4 classes.

import tensorflow as tf

print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))

Num GPUs Available: 2

gpus = tf.config.list_physical_devices('GPU')
if gpus:
try:
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
print("GPU is set for TensorFlow")
except RuntimeError as e:
print(e)

GPU is set for TensorFlow

import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D,
GlobalAveragePooling2D, Dense, BatchNormalization
from tensorflow.keras import backend as K
import numpy as np
from tensorflow.keras.losses import SparseCategoricalCrossentropy

IMG_WIDTH = 224
IMG_HEIGHT = 224
IMG_CHANNELS = 3
NUM_CLASSES = 4
NUM_PARTICLES = 5
EPOCHS = 3
BATCH_SIZE = 16
W = 0.5
C1 = 1
C2 = 1
LEARNING_RATE_ADAM = 1e-4

def build_classifier(input_shape=(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)):

inputs = Input(shape=input_shape)

c1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)

c1 = BatchNormalization()(c1)
p1 = MaxPooling2D((2, 2))(c1)
 c2 = Conv2D(64, (3, 3), activation='relu', padding='same')(p1)
c2 = BatchNormalization()(c2)
p2 = MaxPooling2D((2, 2))(c2)

c3 = Conv2D(128, (3, 3), activation='relu', padding='same')(p2)

c3 = BatchNormalization()(c3)
p3 = MaxPooling2D((2, 2))(c3)

c4 = Conv2D(256, (3, 3), activation='relu', padding='same')(p3)

c4 = BatchNormalization()(c4)
p4 = MaxPooling2D((2, 2))(c4)

c5 = Conv2D(512, (3, 3), activation='relu', padding='same')(p4)

c5 = BatchNormalization()(c5)

gap = GlobalAveragePooling2D()(c5)
d1 = Dense(512, activation='relu')(gap)
d1 = BatchNormalization()(d1)
outputs = Dense(NUM_CLASSES, activation='softmax')(d1)

return Model(inputs=inputs, outputs=outputs)

def get_flattened_weights(model):
weights = model.get_weights()
flattened = np.concatenate([w.flatten() for w in weights])
return flattened

def set_weights_from_flat(model, flat_weights):

weights = []
index = 0
for w in model.get_weights():
shape = w.shape
size = np.prod(shape)
weights.append(flat_weights[index:index+size].reshape(shape))
index += size
model.set_weights(weights)

scce = SparseCategoricalCrossentropy()

def calculate_fitness(model, flat_weights, generator, loss_function):

set_weights_from_flat(model, flat_weights)
total_loss = 0
total_samples = 0
for i in range(len(generator)):
images, labels = generator[i]
preds = model(images, training=False)
loss = loss_function(labels, preds)
total_loss += loss.numpy() * images.shape[0]
total_samples += images.shape[0]
 return total_loss / total_samples

def train_classifier_with_pso(model, train_gen, val_gen, loss_function,

num_particles=NUM_PARTICLES, epochs=EPOCHS,
w=W, c1=C1, c2=C2):

initial_weights = get_flattened_weights(model)
dim = len(initial_weights)

particles = np.array([initial_weights + np.random.randn(dim)*0.1 for _ in

range(num_particles)])
velocities = np.zeros((num_particles, dim))

personal_bests = particles.copy()
personal_best_fitness = np.array([float('inf')] * num_particles)
global_best = None
global_best_fitness = float('inf')

for epoch in range(epochs):

print(f"PSO Epoch {epoch+1}/{epochs}")

for i in range(num_particles):
current_fitness = calculate_fitness(model, particles[i],
train_gen, loss_function)

if current_fitness < personal_best_fitness[i]:

personal_best_fitness[i] = current_fitness
personal_bests[i] = particles[i].copy()

if current_fitness < global_best_fitness:

global_best_fitness = current_fitness
global_best = particles[i].copy()

for i in range(num_particles):
r1 = np.random.rand(dim)
r2 = np.random.rand(dim)
velocities[i] = (w * velocities[i]
+ c1 * r1 * (personal_bests[i] - particles[i])
+ c2 * r2 * (global_best - particles[i]))
particles[i] += velocities[i]

print(f"Current Best Fitness: {global_best_fitness:.4f}")

set_weights_from_flat(model, global_best)
return model

if __name__ == '__main__':
print("Building classifier model...")
model_pso = build_classifier()
 print("Training classifier with PSO...")
try:
trained_model_pso = train_classifier_with_pso(
model_pso,
train_gen_new,
valid_gen_new,
scce
)
trained_model_pso.summary()

print("\n--- Training with Adam for Comparison ---")

model_adam = build_classifier()
model_adam.compile(

optimizer=tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE_ADAM),
loss=SparseCategoricalCrossentropy(),
metrics=['accuracy']
)

history_adam = model_adam.fit(
train_gen_new,
validation_data=valid_gen_new,
epochs=EPOCHS,
verbose=1
)
model_adam.summary()

except ValueError as e:
print(f"An error occurred during training: {e}")

Building classifier model...

Training classifier with PSO...
PSO Epoch 1/3
Current Best Fitness: 9.2883
PSO Epoch 2/3
Current Best Fitness: 3.0716
PSO Epoch 3/3
Current Best Fitness: 3.0716

Model: "functional"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━
━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃
Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━
━━━━━━━━━━┩
│ input_layer (InputLayer) │ (None, 224, 224, 3) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d (Conv2D) │ (None, 224, 224, 32) │
896 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization │ (None, 224, 224, 32) │
128 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d (MaxPooling2D) │ (None, 112, 112, 32) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_1 (Conv2D) │ (None, 112, 112, 64) │
18,496 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_1 │ (None, 112, 112, 64) │
256 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_1 (MaxPooling2D) │ (None, 56, 56, 64) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_2 (Conv2D) │ (None, 56, 56, 128) │
73,856 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_2 │ (None, 56, 56, 128) │
512 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_2 (MaxPooling2D) │ (None, 28, 28, 128) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_3 (Conv2D) │ (None, 28, 28, 256) │
295,168 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_3 │ (None, 28, 28, 256) │
1,024 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_3 (MaxPooling2D) │ (None, 14, 14, 256) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_4 (Conv2D) │ (None, 14, 14, 512) │
1,180,160 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_4 │ (None, 14, 14, 512) │
2,048 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ global_average_pooling2d │ (None, 512) │
0 │
│ (GlobalAveragePooling2D) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ dense (Dense) │ (None, 512) │
262,656 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_5 │ (None, 512) │
2,048 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ dense_1 (Dense) │ (None, 4) │
2,052 │
└──────────────────────────────────────┴─────────────────────────────┴───────
──────────┘

Total params: 1,839,300 (7.02 MB)

Trainable params: 1,836,292 (7.00 MB)

Non-trainable params: 3,008 (11.75 KB)

--- Training with Adam for Comparison ---

Epoch 1/3
301/301 ━━━━━━━━━━━━━━━━━━━━ 39s 86ms/step - accuracy: 0.6743 - loss: 0.8383
- val_accuracy: 0.3150 - val_loss: 3.2158
Epoch 2/3
301/301 ━━━━━━━━━━━━━━━━━━━━ 15s 48ms/step - accuracy: 0.8521 - loss: 0.3948
- val_accuracy: 0.4250 - val_loss: 2.8024
Epoch 3/3
301/301 ━━━━━━━━━━━━━━━━━━━━ 14s 46ms/step - accuracy: 0.8718 - loss: 0.3288
- val_accuracy: 0.7517 - val_loss: 0.6994

Model: "functional_1"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━
━━━━━━━━━━┓
┃ Layer (type) ┃ Output Shape ┃
Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━
━━━━━━━━━━┩
│ input_layer_1 (InputLayer) │ (None, 224, 224, 3) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_5 (Conv2D) │ (None, 224, 224, 32) │
896 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_6 │ (None, 224, 224, 32) │
128 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_4 (MaxPooling2D) │ (None, 112, 112, 32) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_6 (Conv2D) │ (None, 112, 112, 64) │
18,496 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_7 │ (None, 112, 112, 64) │
256 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_5 (MaxPooling2D) │ (None, 56, 56, 64) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_7 (Conv2D) │ (None, 56, 56, 128) │
73,856 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_8 │ (None, 56, 56, 128) │
512 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_6 (MaxPooling2D) │ (None, 28, 28, 128) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_8 (Conv2D) │ (None, 28, 28, 256) │
295,168 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_9 │ (None, 28, 28, 256) │
1,024 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ max_pooling2d_7 (MaxPooling2D) │ (None, 14, 14, 256) │
0 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ conv2d_9 (Conv2D) │ (None, 14, 14, 512) │
1,180,160 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_10 │ (None, 14, 14, 512) │
2,048 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ global_average_pooling2d_1 │ (None, 512) │
0 │
│ (GlobalAveragePooling2D) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ dense_2 (Dense) │ (None, 512) │
262,656 │
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ batch_normalization_11 │ (None, 512) │
2,048 │
│ (BatchNormalization) │ │
│
├──────────────────────────────────────┼─────────────────────────────┼───────
──────────┤
│ dense_3 (Dense) │ (None, 4) │
2,052 │
└──────────────────────────────────────┴─────────────────────────────┴───────
──────────┘

Total params: 5,511,886 (21.03 MB)

Trainable params: 1,836,292 (7.00 MB)

Non-trainable params: 3,008 (11.75 KB)

Optimizer params: 3,672,586 (14.01 MB)

def plot_training_history(history):
epochs = range(1, len(history.history['loss']) + 1)

plt.figure(figsize=(12, 5))

# Plot training & validation loss

plt.subplot(1, 2, 1)
plt.plot(epochs, history.history['loss'], 'bo-', label='Training Loss')
plt.plot(epochs, history.history['val_loss'], 'r^-', label='Validation
Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Training and Validation Loss')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(epochs, history.history['accuracy'], 'bo-', label='Training
Accuracy')
plt.plot(epochs, history.history['val_accuracy'], 'r^-',
label='Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.show()

plot_training_history(history_adam)
import seaborn as sns
from sklearn.metrics import classification_report, confusion_matrix

test_gen_new.reset()

y_true = test_gen_new.classes

y_pred_probs = model_adam.predict(test_gen_new, steps=len(test_gen_new))

y_pred = np.argmax(y_pred_probs, axis=1)

print("Classification Report:")
print(classification_report(y_true, y_pred))

cm = confusion_matrix(y_true, y_pred)

plt.figure(figsize=(8,6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
xticklabels=range(NUM_CLASSES), yticklabels=range(NUM_CLASSES))
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.title("Confusion Matrix")
plt.show()

38/38 ━━━━━━━━━━━━━━━━━━━━ 7s 173ms/step

Classification Report:
precision recall f1-score support

0 0.86 0.70 0.77 150

1 0.52 0.97 0.68 150
2 0.98 0.68 0.80 151
3 0.98 0.64 0.77 150
 accuracy 0.75 601
macro avg 0.84 0.75 0.76 601
weighted avg 0.84 0.75 0.76 601