OSCR

Brain Tumor Classification in MRI Images Using Combined Transfer Learning and Convolutional Neural Networks.

Code ↔ Paper

8 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 8 matches
  1. [1] § 3. Materials and Methods ↔ custom_cnn.ipynb.ipynb, lines 1–55 · score 0.74 · EfficientNetV2L, MobileNetV2, ResNet152V2, Custom CNN, InceptionV3, pre
  2. [2] § 4. Experimental Results and Analysis ↔ custom_cnn.ipynb.ipynb, lines 1–55 · score 0.73 · Custom CNN model, MobileNetV2, ResNet152V2, InceptionV3, meningioma, pituitary
  3. [3] § 4. Experimental Results and Analysis › 4.1. Evaluation Metrics and Strategy ↔ pretrained_ensemble.ipynb.ipynb, lines 501–538 · score 0.67 · Squared Error, Absolute Error, F1 score, Recall, MAE, RMSE
  4. [4] § 3. Materials and Methods › 3.6. Design and Implementation of the Proposed Ensemble Model ↔ pretrained_ensemble.ipynb.ipynb, lines 554–572 · score 0.65 · EfficientNetV2L, MobileNetV2, ResNet152V2, InceptionV3, trained models, Xception
  5. [5] § 4. Experimental Results and Analysis › 4.4. Classification Results › 4.4.4. Training and Validation Accuracy and Loss Comparison ↔ pretrained_ensemble.ipynb.ipynb, lines 705–757 · score 0.62 · EfficientNetV2L, MobileNetV2, ResNet152V2, InceptionV3, validation, VGG16
  6. [6] § 3. Materials and Methods › 3.6. Design and Implementation of the Proposed Ensemble Model ↔ pretrained_ensemble.ipynb.ipynb, lines 612–648 · score 0.57 · MobileNetV2, ResNet152V2, InceptionV3, EfficientNetV2, trained models, Xception
  7. [7] § 3. Materials and Methods ↔ pretrained_ensemble.ipynb.ipynb, lines 157–185 · score 0.57 · dense layers, convolutional layers, softmax, class, models
  8. [8] § 3. Materials and Methods › 3.3. Customized CNN and Base Models for Feature Extraction ↔ pretrained_ensemble.ipynb.ipynb, lines 157–185 · score 0.54 · convolutional layers, flattened, ReLU, softmax, activated, ensemble

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 1,078 lines · 37 KB · no license · 6 matches

  1. # %%
  2. import sys
  3. import os
  4. import math
  5. import time
  6. import pathlib
  7. import pickle
  8. import numpy as np
  9. import pandas as pd
  10. import seaborn as sns
  12. import tensorflow as tf
  13. import matplotlib.pyplot as plt
  14. from tensorflow.keras import layers
  15. from tensorflow.keras.models import Model
  16. from tensorflow.keras.optimizers import Adam
  17. from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
  18. from tensorflow.keras.applications import InceptionV3
  19. from tensorflow.keras.applications import EfficientNetV2L
  20. from tensorflow.keras.applications import ResNet152V2
  21. from tensorflow.keras.applications import Xception
  22. from tensorflow.keras.applications import VGG16
  23. from tensorflow.keras.applications import MobileNetV2
  24. from sklearn.utils.class_weight import compute_class_weight
  25. from tensorflow.keras.models import load_model
  26. from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix, mean_absolute_error, mean_squared_error
  28. # %% [markdown]
  29. # # Dataset paths
  31. # %%
  32. # Dataset paths
  33. train_dir = pathlib.Path('/kaggle/input/brain-tumor-mri-dataset/Training')
  34. test_dir = pathlib.Path('/kaggle/input/brain-tumor-mri-dataset/Testing')
  36. img_height = 224
  37. img_width = 224
  38. batch_size = 32
  39. epochs = 50
  41. # %% [markdown]
  42. # # Data augmentation
  44. # %%
  45. # Dataset loading
  46. train_ds = tf.keras.utils.image_dataset_from_directory(
  47. train_dir,
  48. validation_split=0.2,
  49. subset="training",
  50. seed=123,
  51. image_size=(224, 224),
  52. batch_size=batch_size,
  53. shuffle=True,
  54. interpolation="bilinear",
  55. label_mode="int",
  56. )
  58. # Get class names
  59. class_names = train_ds.class_names
  60. print("Classes in the dataset:", class_names)
  62. # Normalize and apply data augmentation
  63. normalization_layer = tf.keras.layers.Rescaling(1./255)
  64. data_augmentation = tf.keras.Sequential([
  65. tf.keras.layers.RandomFlip("horizontal"),
  66. tf.keras.layers.RandomRotation(0.2),
  67. tf.keras.layers.RandomZoom(0.2),
  68. tf.keras.layers.RandomContrast(0.2),
  69. tf.keras.layers.RandomTranslation(0.1, 0.1),
  70. ])
  72. train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
  73. train_ds = train_ds.map(lambda x, y: (data_augmentation(x, training=True), y))
  75. # Validation dataset
  76. val_ds = tf.keras.utils.image_dataset_from_directory(
  77. train_dir,
  78. validation_split=0.2,
  79. subset="validation",
  80. seed=123,
  81. image_size=(224, 224),
  82. batch_size=batch_size,
  83. )
  85. val_ds = val_ds.map(lambda x, y: (normalization_layer(x), y))
  87. # Test dataset
  88. test_ds = tf.keras.utils.image_dataset_from_directory(
  89. test_dir,
  90. image_size=(224, 224),
  91. batch_size=batch_size,
  92. )
  94. test_ds = test_ds.map(lambda x, y: (normalization_layer(x), y))
  96. # %%
  97. def get_class_weights(train_ds, class_names):
  98. print("Calculating class weights...")
  100. labels = []
  101. for image_batch, label_batch in train_ds:
  102. labels.append(label_batch.numpy())
  104. labels = np.concatenate(labels)
  105. class_weights = compute_class_weight('balanced', classes=np.unique(labels), y=labels)
  107. class_weight_dict = {i: class_weights[i] for i in range(len(class_names))}
  108. print("Class weights calculated.")
  109. return class_weight_dict
  111. class_weight_dict = get_class_weights(train_ds, class_names)
  113. # %%
  114. # General Imports
  115. import matplotlib.pyplot as plt
  116. import seaborn as sns
  117. import numpy as np
  118. import os
  120. from sklearn.metrics import confusion_matrix
  122. # Neural Network imports
  123. import tensorflow as tf
  124. from tensorflow.keras.models import Sequential
  125. from tensorflow.keras.models import load_model
  126. from tensorflow.keras.layers import MaxPooling2D
  127. from tensorflow.keras.layers import Conv2D
  128. from tensorflow.keras.layers import Dense
  129. from tensorflow.keras.layers import Dropout
  130. from tensorflow.keras.layers import Flatten
  131. from tensorflow.keras.layers import Input
  132. from tensorflow.keras.optimizers import Adam
  134. # Image augmentation importrs
  135. from tensorflow.keras.utils import load_img
  136. from tensorflow.keras.preprocessing import image
  137. from tensorflow.keras.layers import RandomRotation
  138. from tensorflow.keras.layers import RandomContrast
  139. from tensorflow.keras.layers import RandomZoom
  140. from tensorflow.keras.layers import RandomFlip
  141. from tensorflow.keras.layers import RandomTranslation
  143. # Training Model callbacks
  144. from tensorflow.keras.callbacks import ReduceLROnPlateau
  145. from tensorflow.keras.callbacks import ModelCheckpoint
  147. # Check if GPU is available
  148. print(f'Tensorflow Version: {tf.__version__}')
  149. print("GPU Available:", tf.config.list_physical_devices('GPU')[0])
  151. # %%
  152. for image, label in train_ds.take(1):
  153. print("Label shape:", label.shape)
  154. print("Label:", label)
  157. # %%
  158. # # Building model
  159. image_size=(224, 224,3)
  160. model = Sequential([
  161. # Input tensor shape
  162. Input(image_size),
  164. # Convolutional layer 1
  165. Conv2D(64, (5, 5), activation="relu"),
  166. MaxPooling2D(pool_size=(3, 3)),
  168. # Convolutional layer 2
  169. Conv2D(64, (5, 5), activation="relu"),
  170. MaxPooling2D(pool_size=(3, 3)),
  172. # Convolutional layer 3
  173. Conv2D(128, (4, 4), activation="relu"),
  174. MaxPooling2D(pool_size=(2, 2)),
  176. # Convolutional layer 4
  177. Conv2D(128, (4, 4), activation="relu"),
  178. MaxPooling2D(pool_size=(2, 2)),
  179. Flatten(),
  181. # Dense layers
  182. Dense(512, activation="relu"),
  183. Dense(len(class_names), activation="softmax")
  185. ])
  187. # Model summary
  188. model.summary()
  190. # COompilng model with Adam optimizer
  191. optimizer = Adam(learning_rate=0.001, beta_1=0.85, beta_2=0.9925)
  192. model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics= ['accuracy'])
  196. import os
  197. import json
  198. import time
  199. import tensorflow as tf
  200. from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
  202. def train_custom_model(model, model_name, train_ds, val_ds, test_ds,
  203. learning_rate=0.001, epochs=50, class_weight=None,
  204. extra_callbacks=None):
  206. # Create save directory
  207. save_dir = '/kaggle/working/'
  208. os.makedirs(save_dir, exist_ok=True)
  210. # Compile model (if not compiled already)
  211. optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate, beta_1=0.85, beta_2=0.9925)
  212. # model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
  213. model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])
  215. print(f"\nSummary of {model_name}:")
  216. model.summary()
  218. # File paths
  219. model_path = os.path.join(save_dir, f'{model_name}.keras')
  220. best_model_path = os.path.join(save_dir, f'{model_name}_best.keras')
  221. history_path = os.path.join(save_dir, f'{model_name}_history.json')
  222. eval_path = os.path.join(save_dir, f'{model_name}_evaluation.json')
  223. time_path = os.path.join(save_dir, f'{model_name}_computation_time.txt')
  225. # Default callbacks
  226. model_checkpoint = ModelCheckpoint(best_model_path, monitor='val_loss', save_best_only=True, verbose=False)
  227. reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.8, patience=4, min_lr=1e-4, verbose=False)
  229. # Merge with extra callbacks if any
  230. callbacks = [model_checkpoint, reduce_lr]
  231. if extra_callbacks:
  232. callbacks.extend(extra_callbacks)
  234. # Train model with timing
  235. start_time = time.time()
  236. history = model.fit(
  237. train_ds,
  238. validation_data=val_ds,
  239. epochs=epochs,
  240. class_weight=class_weight,
  241. callbacks=callbacks,
  242. shuffle=True,
  243. verbose=True
  244. )
  245. end_time = time.time()
  246. computation_time = end_time - start_time
  248. print(f"Model training took {computation_time:.2f} seconds.")
  249. print(f"\nEvaluating {model_name}...")
  250. print(f"\nClass Weights used in training {model_name}: {class_weight}")
  252. # Evaluate model
  253. evaluation = model.evaluate(test_ds)
  254. loss, accuracy = evaluation
  255. print('Loss:', loss)
  257. print(f'Test Accuracy: {accuracy * 100:.2f}%')
  259. # Save final model
  260. model.save(model_path)
  261. print(f"Model saved to {model_path}")
  263. # Save training history
  264. with open(history_path, 'w') as f:
  265. history_dict = {key: [float(val) for val in values] for key, values in history.history.items()}
  266. json.dump(history_dict, f, indent=4)
  267. print(f"Training history saved to {history_path}")
  269. # Save evaluation
  270. eval_dict = {
  271. 'loss': float(loss),
  272. 'accuracy': float(accuracy),
  273. 'metrics': {
  274. 'loss': float(loss),
  275. 'accuracy': float(accuracy)
  276. }
  277. }
  278. with open(eval_path, 'w') as f:
  279. json.dump(eval_dict, f, indent=4)
  280. print(f"Evaluation results saved to {eval_path}")
  282. # Save computation time
  283. with open(time_path, 'w') as f:
  284. f.write(f"Training time: {computation_time:.2f} seconds\n")
  285. f.write(f"Training time: {computation_time / 60:.2f} minutes\n")
  286. f.write(f"Training time: {computation_time / 3600:.2f} hours\n")
  287. print(f"Computation time saved to {time_path}")
  289. return model, history, evaluation, computation_time
  293. # Custom callback for reducing learning rate at accuracy values
  294. class ReduceLROnMultipleAccuracies(tf.keras.callbacks.Callback):
  295. def __init__(self, thresholds, factor, monitor='val_accuracy', verbose=1):
  296. super(ReduceLROnMultipleAccuracies, self).__init__()
  297. self.thresholds = thresholds # List of accuracy thresholds
  298. self.factor = factor # Factor to reduce the learning rate
  299. self.monitor = monitor
  300. self.verbose = verbose
  301. self.thresholds_reached = [False] * len(thresholds) # Track each threshold
  303. def on_epoch_end(self, epoch, logs=None):
  304. current_accuracy = logs.get(self.monitor)
  305. for i, threshold in enumerate(self.thresholds):
  306. if current_accuracy >= threshold and not self.thresholds_reached[i]:
  307. optimizer = self.model.optimizer
  308. old_lr = optimizer.learning_rate.numpy()
  309. new_lr = old_lr * self.factor
  310. optimizer.learning_rate.assign(new_lr)
  311. self.thresholds_reached[i] = True # Mark this threshold as reached
  312. if self.verbose > 0:
  313. print(f"\nEpoch {epoch+1}: {self.monitor} reached {threshold}. Reducing learning rate from {old_lr} to {new_lr}.")
  315. # Try a custom callback
  316. thresholds = [0.96, 0.99, 0.9935]
  317. lr_callback = ReduceLROnMultipleAccuracies(thresholds=thresholds, factor=0.75, monitor='val_accuracy', verbose=False)
  321. model_name = "custom_cnn_model"
  322. model_rlr = ReduceLROnPlateau(monitor='val_loss', factor=0.8, min_lr=1e-4, patience=4, verbose=False)
  323. model_mc = ModelCheckpoint('custom_cnn_model_updated.keras', monitor='val_accuracy', mode='max', save_best_only=True, verbose=False)
  324. # Include your custom callback if needed
  325. model, history, evaluation, computation_time = train_custom_model(
  326. model=model,
  327. model_name=model_name,
  328. train_ds=train_ds,
  329. val_ds=test_ds,
  330. test_ds=test_ds,
  331. learning_rate=0.001,
  332. epochs=epochs,
  334. extra_callbacks=[model_rlr, model_mc],
  336. )
  338. # %% [markdown]
  339. # # Balancing using class weights
  341. # %%
  344. # %% [markdown]
  345. # # Create and train model
  347. # %%
  348. # def create_and_train_model(base_model, model_name, train_ds, val_ds, test_ds, num_classes=4, learning_rate=0.0001, epochs=epochs, class_weight=None):
  349. # for layer in base_model.layers[:10]:
  350. # layer.trainable = False
  352. # x = layers.GlobalAveragePooling2D()(base_model.output)
  353. # x = layers.Dense(512, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01))(x)
  354. # x = layers.Dropout(0.4)(x)
  355. # predictions = layers.Dense(num_classes, activation='softmax')(x)
  357. # model = Model(inputs=base_model.inputs, outputs=predictions)
  358. # model.compile(
  359. # optimizer=Adam(learning_rate=learning_rate, beta_1=0.9, beta_2=0.999),
  360. # loss=tf.losses.SparseCategoricalCrossentropy(),
  361. # metrics=['accuracy']
  362. # )
  364. # print(f"\nSummary of {model_name}:")
  365. # model.summary()
  367. # model_checkpoint = ModelCheckpoint(f'{model_name}.keras', monitor='val_loss', save_best_only=True)
  368. # reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, min_lr=1e-6)
  370. # start_time = time.time()
  371. # history = model.fit(
  372. # train_ds,
  373. # shuffle=True,
  374. # validation_data=val_ds,
  375. # epochs=epochs,
  376. # class_weight=class_weight,
  377. # callbacks=[model_checkpoint, reduce_lr]
  378. # )
  380. # # End time tracking
  381. # end_time = time.time()
  383. # # Calculate computation time
  384. # computation_time = end_time - start_time
  386. # print(f"Model training took {computation_time:.2f} seconds.")
  388. # print(f"\nEvaluating {model_name}...")
  389. # print(f"\nClass Weights used in training {model_name}: {class_weight}")
  390. # loss, accuracy = model.evaluate(test_ds)
  391. # print('Loss:', loss)
  392. # print(f'Test Accuracy: {accuracy * 100:.2f}%')
  393. # model.save(f'{model_name}.keras')
  394. # evaluation = model.evaluate(test_ds)
  396. # return model, history, evaluation, computation_time
  399. import os
  400. import json
  401. import time
  402. import tensorflow as tf
  403. from tensorflow.keras.layers import Dense, Dropout, GlobalAveragePooling2D
  404. from tensorflow.keras.models import Model
  405. from tensorflow.keras.optimizers import Adam
  406. from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
  408. def create_and_train_model(base_model, model_name, train_ds, val_ds, test_ds, num_classes=4,
  409. learning_rate=0.0001, epochs=50, class_weight=None):
  410. # Create save directory if it doesn't exist
  411. save_dir = '/kaggle/working/'
  412. os.makedirs(save_dir, exist_ok=True)
  414. # Freeze early layers
  415. for layer in base_model.layers[:10]:
  416. layer.trainable = False
  418. # Build model architecture
  419. x = GlobalAveragePooling2D()(base_model.output)
  420. x = Dense(512, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01))(x)
  421. x = Dropout(0.4)(x)
  422. predictions = Dense(num_classes, activation='softmax')(x)
  423. model = Model(inputs=base_model.inputs, outputs=predictions)
  425. # Compile model
  426. model.compile(
  427. optimizer=Adam(learning_rate=learning_rate, beta_1=0.9, beta_2=0.999),
  428. loss=tf.losses.SparseCategoricalCrossentropy(),
  429. metrics=['accuracy']
  430. )
  432. print(f"\nSummary of {model_name}:")
  433. model.summary()
  435. # Create file paths for saving
  436. model_path = os.path.join(save_dir, f'{model_name}.keras')
  437. best_model_path = os.path.join(save_dir, f'{model_name}_best.keras')
  438. history_path = os.path.join(save_dir, f'{model_name}_history.json')
  439. eval_path = os.path.join(save_dir, f'{model_name}_evaluation.json')
  440. time_path = os.path.join(save_dir, f'{model_name}_computation_time.txt')
  442. # Set up callbacks
  443. model_checkpoint = ModelCheckpoint(best_model_path, monitor='val_loss', save_best_only=True)
  444. reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, min_lr=1e-6)
  446. # Train model with time tracking
  447. start_time = time.time()
  448. history = model.fit(
  449. train_ds,
  450. shuffle=True,
  451. validation_data=val_ds,
  452. epochs=epochs,
  453. class_weight=class_weight,
  454. callbacks=[model_checkpoint, reduce_lr]
  455. )
  456. end_time = time.time()
  457. computation_time = end_time - start_time
  459. print(f"Model training took {computation_time:.2f} seconds.")
  460. print(f"\nEvaluating {model_name}...")
  461. print(f"\nClass Weights used in training {model_name}: {class_weight}")
  463. # Evaluate the model
  464. evaluation = model.evaluate(test_ds)
  465. loss, accuracy = evaluation
  466. print('Loss:', loss)
  467. print(f'Test Accuracy: {accuracy * 100:.2f}%')
  469. # Save model
  470. model.save(model_path)
  471. print(f"Model saved to {model_path}")
  473. # Save history
  474. with open(history_path, 'w') as f:
  475. history_dict = {key: [float(val) for val in values] for key, values in history.history.items()}
  476. json.dump(history_dict, f, indent=4)
  477. print(f"Training history saved to {history_path}")
  479. # Save evaluation
  480. eval_dict = {
  481. 'loss': float(loss),
  482. 'accuracy': float(accuracy),
  483. 'metrics': {
  484. 'loss': float(evaluation[0]),
  485. 'accuracy': float(evaluation[1])
  486. }
  487. }
  488. with open(eval_path, 'w') as f:
  489. json.dump(eval_dict, f, indent=4)
  490. print(f"Evaluation results saved to {eval_path}")
  492. # Save computation time
  493. with open(time_path, 'w') as f:
  494. f.write(f"Training time: {computation_time:.2f} seconds\n")
  495. f.write(f"Training time: {computation_time/60:.2f} minutes\n")
  496. f.write(f"Training time: {computation_time/3600:.2f} hours\n")
  497. print(f"Computation time saved to {time_path}")
  499. return model, history, evaluation, computation_time
  501. # %%
  502. def evaluate_model(model, test_ds, model_name):
  503. y_true = []
  504. y_pred = []
  506. for images, labels in test_ds:
  507. predictions = model.predict(images)
  508. y_pred.extend(np.argmax(predictions, axis=1))
  509. y_true.extend(labels.numpy())
  511. y_true = np.array(y_true)
  512. y_pred = np.array(y_pred)
  514. accuracy = accuracy_score(y_true, y_pred)
  515. precision = precision_score(y_true, y_pred, average='weighted')
  516. recall = recall_score(y_true, y_pred, average='weighted')
  517. f1 = f1_score(y_true, y_pred, average='weighted')
  518. mae = mean_absolute_error(y_true, y_pred)
  519. rmse = mean_squared_error(y_true, y_pred, squared=False)
  521. cm = confusion_matrix(y_true, y_pred)
  523. print(f"\nModel Evaluation Metrics for {model_name}:")
  524. print(f"Accuracy: {accuracy:.4f}")
  525. print(f"Precision: {precision:.4f}")
  526. print(f"Recall: {recall:.4f}")
  527. print(f"F1 Score: {f1:.4f}")
  528. print(f"MAE: {mae:.4f}")
  529. print(f"RMSE: {rmse:.4f}")
  531. plt.figure(figsize=(6, 6))
  532. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=range(4), yticklabels=range(4))
  533. plt.xlabel('Predicted Label')
  534. plt.ylabel('True Label')
  535. plt.title(f'Confusion Matrix - {model_name}')
  536. plt.show()
  538. return accuracy, precision, recall, f1, mae, rmse, cm
  540. # %%
  541. from tensorflow.keras.applications import InceptionV3
  543. # Path to your uploaded weights file
  544. weights_path = '/kaggle/input/inception_v3/tensorflow2/default/1/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'
  546. # Initialize the model without downloading weights
  547. base_model1 = InceptionV3(weights=None, include_top=False, input_shape=(224, 224, 3))
  549. # Load the weights from your uploaded file
  550. base_model1.load_weights(weights_path)
  552. print("InceptionV3 model loaded successfully with local weights!")
  554. # %% [markdown]
  555. # # Train all models with 30 epochs
  557. # %%
  558. # # Define the base models
  559. # base_model1 = InceptionV3(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
  560. # # base_model2 = EfficientNetV2L(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
  561. # # base_model3 = ResNet152V2(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
  562. # # base_model4 = Xception(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
  563. # # base_model5 = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
  564. # # base_model6 = MobileNetV2(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
  566. # %%
  567. model1, history1, evaluation1, time1 = create_and_train_model(base_model1, 'model1_inceptionv3_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  568. # # model2, history2, evaluation2, time2 = create_and_train_model(base_model2, 'model2_efficientnetv2l_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  569. # # model3, history3, evaluation3, time3 = create_and_train_model(base_model3, 'model3_resnet152v2_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  570. # # model4, history4, evaluation4, time4 = create_and_train_model(base_model4, 'model4_xception_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  571. # # model5, history5, evaluation5, time5 = create_and_train_model(base_model5, 'model5_vgg16_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  572. # # model6, history6, evaluation6, time6 = create_and_train_model(base_model6, 'model6_mobilenetv2_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  574. # %%
  575. # from tensorflow.keras.applications import (
  576. # InceptionV3, EfficientNetV2L, ResNet152V2,
  577. # Xception, VGG16, MobileNetV2
  578. # )
  580. # # InceptionV3 (which you already have)
  581. # base_model1 = InceptionV3(weights=None, include_top=False, input_shape=(224, 224, 3))
  582. # base_model1.load_weights('/kaggle/input/inception_v3/tensorflow2/default/1/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5')
  584. # # For EfficientNetV2L
  585. # base_model2 = EfficientNetV2L(weights=None, include_top=False, input_shape=(224, 224, 3))
  586. # base_model2.load_weights('/kaggle/input/efficientnet/tensorflow2/default/1/efficientnetv2-l_notop.h5')
  588. # # For ResNet152V2
  589. # base_model3 = ResNet152V2(weights=None, include_top=False, input_shape=(224, 224, 3))
  590. # base_model3.load_weights('/kaggle/input/resnet/tensorflow2/default/1/resnet152v2_weights_tf_dim_ordering_tf_kernels_notop.h5')
  592. # # For Xception
  593. # base_model4 = Xception(weights=None, include_top=False, input_shape=(224, 224, 3))
  594. # base_model4.load_weights('/kaggle/input/xception/tensorflow2/default/1/xception_weights_tf_dim_ordering_tf_kernels_notop.h5')
  596. # # For VGG16
  597. # base_model5 = VGG16(weights=None, include_top=False, input_shape=(224, 224, 3))
  598. # base_model5.load_weights('/kaggle/input/vgg16/tensorflow2/default/1/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5')
  600. # # For MobileNetV2
  601. # base_model6 = MobileNetV2(weights=None, include_top=False, input_shape=(224, 224, 3))
  602. # base_model6.load_weights('/kaggle/input/mobilenet/tensorflow2/default/1/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5')
  604. # # Now you can train your models
  605. # model1, history1, evaluation1, time1 = create_and_train_model(base_model1, 'model1_inceptionv3_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  606. # model2, history2, evaluation2, time2 = create_and_train_model(base_model2, 'model2_efficientnetv2l_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  607. # model3, history3, evaluation3, time3 = create_and_train_model(base_model3, 'model3_resnet152v2_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  608. # model4, history4, evaluation4, time4 = create_and_train_model(base_model4, 'model4_xception_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  609. # model5, history5, evaluation5, time5 = create_and_train_model(base_model5, 'model5_vgg16_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  610. # model6, history6, evaluation6, time6 = create_and_train_model(base_model6, 'model6_mobilenetv2_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  612. # %%
  613. from tensorflow.keras.applications import (
  614. InceptionV3, EfficientNetV2L, ResNet152V2,
  615. Xception, VGG16, MobileNetV2
  616. )
  618. # InceptionV3 (which you already have)
  619. base_model1 = InceptionV3(weights=None, include_top=False, input_shape=(224, 224, 3))
  620. base_model1.load_weights('/kaggle/input/inception_v3/tensorflow2/default/1/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5')
  622. # For EfficientNetV2L
  623. base_model2 = EfficientNetV2L(weights=None, include_top=False, input_shape=(224, 224, 3))
  624. base_model2.load_weights('/kaggle/input/efficientnet/tensorflow2/default/1/efficientnetv2-l_notop.h5')
  626. # For ResNet152V2
  627. base_model3 = ResNet152V2(weights=None, include_top=False, input_shape=(224, 224, 3))
  628. base_model3.load_weights('/kaggle/input/resnet/tensorflow2/default/1/resnet152v2_weights_tf_dim_ordering_tf_kernels_notop.h5')
  630. # For Xception
  631. base_model4 = Xception(weights=None, include_top=False, input_shape=(224, 224, 3))
  632. base_model4.load_weights('/kaggle/input/xception/tensorflow2/default/1/xception_weights_tf_dim_ordering_tf_kernels_notop.h5')
  634. # For VGG16
  635. base_model5 = VGG16(weights=None, include_top=False, input_shape=(224, 224, 3))
  636. base_model5.load_weights('/kaggle/input/vgg16/tensorflow2/default/1/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5')
  638. # For MobileNetV2
  639. base_model6 = MobileNetV2(weights=None, include_top=False, input_shape=(224, 224, 3))
  640. base_model6.load_weights('/kaggle/input/mobilenet/tensorflow2/default/1/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5')
  642. # Now you can train your models
  643. # model1, history1, evaluation1, time1 = create_and_train_model(base_model1, 'model1_inceptionv3_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  644. model2, history2, evaluation2, time2 = create_and_train_model(base_model2, 'model2_efficientnetv2l_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  645. model3, history3, evaluation3, time3 = create_and_train_model(base_model3, 'model3_resnet152v2_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  646. model4, history4, evaluation4, time4 = create_and_train_model(base_model4, 'model4_xception_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  647. model5, history5, evaluation5, time5 = create_and_train_model(base_model5, 'model5_vgg16_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  648. model6, history6, evaluation6, time6 = create_and_train_model(base_model6, 'model6_mobilenetv2_class_weights', train_ds, val_ds, test_ds, epochs=epochs, class_weight=class_weight_dict)
  650. # %%
  651. # # Define model names
  652. # model_names = [
  653. # "InceptionV3"
  655. # ]
  657. # # Store histories in a list
  658. # histories = [history1]
  660. # # Plot Training Accuracy
  661. # plt.figure(figsize=(12, 6))
  662. # for i, history in enumerate(histories):
  663. # plt.plot(history.history['accuracy'], label=f'{model_names[i]} Training')
  664. # plt.title('Training Accuracy over Epochs')
  665. # plt.xlabel('Epochs')
  666. # plt.ylabel('Accuracy')
  667. # plt.legend()
  668. # plt.grid()
  669. # plt.show()
  671. # # Plot Validation Accuracy
  672. # plt.figure(figsize=(12, 6))
  673. # for i, history in enumerate(histories):
  674. # plt.plot(history.history['val_accuracy'], label=f'{model_names[i]} Validation')
  675. # plt.title('Validation Accuracy over Epochs')
  676. # plt.xlabel('Epochs')
  677. # plt.ylabel('Accuracy')
  678. # plt.legend()
  679. # plt.grid()
  680. # plt.show()
  682. # # Plot Training Loss
  683. # plt.figure(figsize=(12, 6))
  684. # for i, history in enumerate(histories):
  685. # plt.plot(history.history['loss'], label=f'{model_names[i]} Training Loss')
  686. # plt.title('Training Loss over Epochs')
  687. # plt.xlabel('Epochs')
  688. # plt.ylabel('Loss')
  689. # plt.legend()
  690. # plt.grid()
  691. # plt.show()
  693. # # Plot Validation Loss
  694. # plt.figure(figsize=(12, 6))
  695. # for i, history in enumerate(histories):
  696. # plt.plot(history.history['val_loss'], label=f'{model_names[i]} Validation Loss')
  697. # plt.title('Validation Loss over Epochs')
  698. # plt.xlabel('Epochs')
  699. # plt.ylabel('Loss')
  700. # plt.legend()
  701. # plt.grid()
  702. # plt.show()
  705. # %%
  706. # Define model names
  707. model_names = [
  708. "InceptionV3", "EfficientNetV2L", "ResNet152V2",
  709. "Xception", "VGG16", "MobileNetV2"
  710. ]
  712. # Store histories in a list
  713. histories = [history1, history2, history3, history4, history5, history6]
  715. # Plot Training Accuracy
  716. plt.figure(figsize=(12, 6))
  717. for i, history in enumerate(histories):
  718. plt.plot(history.history['accuracy'], label=f'{model_names[i]} Training')
  719. plt.title('Training Accuracy over Epochs')
  720. plt.xlabel('Epochs')
  721. plt.ylabel('Accuracy')
  722. plt.legend()
  723. plt.grid()
  724. plt.show()
  726. # Plot Validation Accuracy
  727. plt.figure(figsize=(12, 6))
  728. for i, history in enumerate(histories):
  729. plt.plot(history.history['val_accuracy'], label=f'{model_names[i]} Validation')
  730. plt.title('Validation Accuracy over Epochs')
  731. plt.xlabel('Epochs')
  732. plt.ylabel('Accuracy')
  733. plt.legend()
  734. plt.grid()
  735. plt.show()
  737. # Plot Training Loss
  738. plt.figure(figsize=(12, 6))
  739. for i, history in enumerate(histories):
  740. plt.plot(history.history['loss'], label=f'{model_names[i]} Training Loss')
  741. plt.title('Training Loss over Epochs')
  742. plt.xlabel('Epochs')
  743. plt.ylabel('Loss')
  744. plt.legend()
  745. plt.grid()
  746. plt.show()
  748. # Plot Validation Loss
  749. plt.figure(figsize=(12, 6))
  750. for i, history in enumerate(histories):
  751. plt.plot(history.history['val_loss'], label=f'{model_names[i]} Validation Loss')
  752. plt.title('Validation Loss over Epochs')
  753. plt.xlabel('Epochs')
  754. plt.ylabel('Loss')
  755. plt.legend()
  756. plt.grid()
  757. plt.show()
  760. # %%
  763. # %%
  766. # %%
  769. # %%
  770. # After training models
  771. evaluate_model(model1, test_ds, 'model1_inceptionv3_class_weights')
  772. evaluate_model(model2, test_ds, 'model2_efficientnetv2l_class_weights')
  773. evaluate_model(model3, test_ds, 'model3_resnet152v2_class_weights')
  774. evaluate_model(model4, test_ds, 'model4_xception_class_weights')
  775. evaluate_model(model5, test_ds, 'model5_vgg16_class_weights')
  776. evaluate_model(model6, test_ds, 'model6_mobilenetv2_class_weights')
  778. # %% [markdown]
  779. # # Load models
  781. # %%
  782. from tensorflow.keras.models import load_model
  783. import os
  785. base_path = "/kaggle/input/custom_models/tensorflow2/default/1"
  786. print("Files in directory:")
  787. print(os.listdir(base_path))
  790. # %%
  791. model1 = load_model('/kaggle/input/custom_models/tensorflow2/default/1/model1_inceptionv3_class_weights_best.keras')
  793. model3 = load_model('/kaggle/input/custom_models/tensorflow2/default/1/model3_resnet152v2_class_weights.keras')
  794. model4 = load_model('/kaggle/input/custom_models/tensorflow2/default/1/model4_xception_class_weights.keras')
  795. model5 = load_model('/kaggle/input/custom_models/tensorflow2/default/1/model5_vgg16_class_weights_best.keras')
  796. model6 = load_model('/kaggle/input/custom_models/tensorflow2/default/1/model6_mobilenetv2_class_weights_best.keras')
  797. model7 = load_model('/kaggle/input/custom_cnn_updated/tensorflow2/default/1/custom_cnn_model_best.keras')
  798. # model2 = load_model('/kaggle/input/custom_models/tensorflow2/default/1/model2_efficientnetv2l_class_weights_best.keras')
  800. # %%
  801. # Define ensembles
  802. # ensemble1 = [model2, model4, model3]
  803. # ensemble2 = [model1, model2, model4]
  804. # ensemble3 = [model2, model3, model6]
  805. ensemble1 = [model7, model4, model3]
  806. ensemble2 = [model1, model7, model4]
  807. ensemble3 = [model7, model3, model6]
  809. # %%
  810. def ensemble_predict(models, test_ds):
  811. all_predictions = []
  812. y_true = []
  814. for images, labels in test_ds:
  815. y_true.extend(labels.numpy())
  816. preds = [model.predict(images, verbose=0) for model in models]
  817. all_predictions.append(np.mean(preds, axis=0))
  819. avg_predictions = np.vstack(all_predictions)
  820. final_predictions = np.argmax(avg_predictions, axis=1)
  821. return np.array(y_true), final_predictions, avg_predictions
  824. # %%
  825. # Function to evaluate ensemble and save results
  826. def evaluate_and_save_ensemble(models, test_ds, model_name):
  827. y_true, y_pred, avg_probs = ensemble_predict(models, test_ds)
  829. # Calculate metrics
  830. accuracy = accuracy_score(y_true, y_pred)
  831. precision = precision_score(y_true, y_pred, average='macro')
  832. recall = recall_score(y_true, y_pred, average='macro')
  833. f1 = f1_score(y_true, y_pred, average='macro')
  835. # Confusion Matrix
  836. cm = confusion_matrix(y_true, y_pred)
  837. sensitivity = np.mean(np.diag(cm) / np.sum(cm, axis=1))
  838. specificity = np.mean(np.diag(cm) / np.sum(cm, axis=0))
  840. # Additional metrics
  841. mae = mean_absolute_error(y_true, y_pred)
  842. rmse = np.sqrt(np.mean((y_true - y_pred) ** 2))
  844. # Print evaluation metrics
  845. print(f"\n=== Model Evaluation Metrics for {model_name} ===")
  846. print(f"Accuracy: {accuracy:.4f}")
  847. print(f"Precision: {precision:.4f}")
  848. print(f"Recall: {recall:.4f}")
  849. print(f"F1 Score: {f1:.4f}")
  850. print(f"Sensitivity: {sensitivity:.4f}")
  851. print(f"Specificity: {specificity:.4f}")
  852. print(f"MAE: {mae:.4f}")
  853. print(f"RMSE: {rmse:.4f}")
  855. # Save results
  856. with open(f'{model_name}_results.pkl', 'wb') as f:
  857. pickle.dump({'y_true': y_true, 'y_pred': y_pred, 'avg_probs': avg_probs}, f)
  859. print(f"Ensemble '{model_name}' results saved successfully!")
  861. # Plot confusion matrix
  862. plt.figure(figsize=(6, 6))
  863. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=range(4), yticklabels=range(4))
  864. plt.xlabel('Predicted Label')
  865. plt.ylabel('True Label')
  866. plt.title(f'Confusion Matrix - {model_name}')
  867. plt.show()
  870. # %%
  871. # Run evaluation for all ensembles
  872. evaluate_and_save_ensemble(ensemble1, test_ds, "ensemble1")
  873. evaluate_and_save_ensemble(ensemble2, test_ds, "ensemble2")
  874. evaluate_and_save_ensemble(ensemble3, test_ds, "ensemble3")
  876. # %%
  877. ensembles = ["Ensemble 1", "Ensemble 2", "Ensemble 3"]
  878. accuracy = [0.9947, 0.9924, 0.9908]
  879. precision = [0.9945, 0.9920, 0.9904]
  880. recall = [0.9946, 0.9921, 0.9905]
  881. f1_score = [0.9945, 0.9921, 0.9904]
  882. sensitivity = [0.9946, 0.9921, 0.9905]
  883. specificity = [0.9945, 0.9920, 0.9904]
  884. mae = [0.0076, 0.0137, 0.0130]
  885. rmse = [0.1172, 0.1747, 0.1487]
  888. colors = ["#203f85", "#1eb4cb", "#fdf6de", "#f03c29", "#fbd022"]
  891. plt.figure(figsize=(8, 5))
  892. plt.bar(ensembles, accuracy, color=colors[1])
  893. plt.xlabel("Ensemble Models")
  894. plt.ylabel("Accuracy")
  895. plt.title("Accuracy Comparison of Ensemble Models")
  896. plt.ylim(0.98, 1.0)
  897. for i, v in enumerate(accuracy):
  898. plt.text(i, v, f"{v:.4f}", ha='center', va='bottom', fontsize=12, color='black')
  899. plt.show()
  902. metrics = [precision, recall, f1_score]
  903. labels = ["Precision", "Recall", "F1 Score"]
  904. metric_colors = [colors[0], colors[3], colors[4]]
  906. plt.figure(figsize=(8, 5))
  907. bar_width = 0.25
  908. x = np.arange(len(ensembles))
  910. for i, metric in enumerate(metrics):
  911. plt.bar(x + i * bar_width, metric, width=bar_width, label=labels[i], color=metric_colors[i])
  913. plt.xlabel("Ensemble Models")
  914. plt.ylabel("Score")
  915. plt.title("Precision, Recall, and F1 Score Comparison")
  916. plt.xticks(x + bar_width, ensembles)
  917. plt.legend()
  918. plt.ylim(0.98, 1.0)
  919. plt.show()
  922. plt.figure(figsize=(8, 5))
  923. bar_width = 0.25
  924. x = np.arange(len(ensembles))
  926. plt.bar(x, mae, width=bar_width, label="MAE", color=colors[3])
  927. plt.bar(x + bar_width, rmse, width=bar_width, label="RMSE", color=colors[1])
  929. plt.xlabel("Ensemble Models")
  930. plt.ylabel("Error")
  931. plt.title("MAE and RMSE Comparison")
  932. plt.xticks(x + bar_width / 2, ensembles)
  933. plt.legend()
  934. plt.show()
  937. # %%
  938. ensembles = ["Ensemble 1", "Ensemble 2", "Ensemble 3"]
  939. accuracy = [0.9947, 0.9924, 0.9908]
  940. precision = [0.9945, 0.9920, 0.9904]
  941. recall = [0.9946, 0.9921, 0.9905]
  942. f1_score = [0.9945, 0.9921, 0.9904]
  943. sensitivity = [0.9946, 0.9921, 0.9905]
  944. specificity = [0.9945, 0.9920, 0.9904]
  945. mae = [0.0076, 0.0137, 0.0130]
  946. rmse = [0.1172, 0.1747, 0.1487]
  949. colors = ["#203f85", "#1eb4cb", "#fdf6de", "#f03c29", "#fbd022"]
  952. plt.figure(figsize=(8, 5))
  953. plt.bar(ensembles, accuracy, color=colors[1])
  954. plt.xlabel("Ensemble Models")
  955. plt.ylabel("Accuracy")
  956. plt.title("Accuracy Comparison of Ensemble Models")
  957. plt.ylim(0.98, 1.0)
  958. for i, v in enumerate(accuracy):
  959. plt.text(i, v, f"{v:.4f}", ha='center', va='bottom', fontsize=12, color='black')
  960. plt.show()
  963. metrics = [precision, recall, f1_score]
  964. labels = ["Precision", "Recall", "F1 Score"]
  965. metric_colors = [colors[0], colors[3], colors[4]]
  967. plt.figure(figsize=(8, 5))
  968. bar_width = 0.25
  969. x = np.arange(len(ensembles))
  971. for i, metric in enumerate(metrics):
  972. plt.bar(x + i * bar_width, metric, width=bar_width, label=labels[i], color=metric_colors[i])
  974. plt.xlabel("Ensemble Models")
  975. plt.ylabel("Score")
  976. plt.title("Precision, Recall, and F1 Score Comparison")
  977. plt.xticks(x + bar_width, ensembles)
  978. plt.legend()
  979. plt.ylim(0.98, 1.0)
  980. plt.show()
  983. plt.figure(figsize=(8, 5))
  984. bar_width = 0.25
  985. x = np.arange(len(ensembles))
  987. plt.bar(x, mae, width=bar_width, label="MAE", color=colors[3])
  988. plt.bar(x + bar_width, rmse, width=bar_width, label="RMSE", color=colors[1])
  990. plt.xlabel("Ensemble Models")
  991. plt.ylabel("Error")
  992. plt.title("MAE and RMSE Comparison")
  993. plt.xticks(x + bar_width / 2, ensembles)
  994. plt.legend()
  995. plt.show()
  998. # %%
  999. !zip -r /kaggle/working/all_outputs.zip /kaggle/working/
  1001. # %%
  1002. ensembles = ["Ensemble 1", "Ensemble 2", "Ensemble 3"]
  1003. accuracy = [0.9947, 0.9924, 0.9908]
  1004. precision = [0.9945, 0.9920, 0.9904]
  1005. recall = [0.9946, 0.9921, 0.9905]
  1006. f1_score = [0.9945, 0.9921, 0.9904]
  1007. sensitivity = [0.9946, 0.9921, 0.9905]
  1008. specificity = [0.9945, 0.9920, 0.9904]
  1009. mae = [0.0076, 0.0137, 0.0130]
  1010. rmse = [0.1172, 0.1747, 0.1487]
  1013. colors = ["#203f85", "#1eb4cb", "#fdf6de", "#f03c29", "#fbd022"]
  1016. plt.figure(figsize=(8, 5))
  1017. plt.bar(ensembles, accuracy, color=colors[1])
  1018. plt.xlabel("Ensemble Models")
  1019. plt.ylabel("Accuracy")
  1020. plt.title("Accuracy Comparison of Ensemble Models")
  1021. plt.ylim(0.98, 1.0)
  1022. for i, v in enumerate(accuracy):
  1023. plt.text(i, v, f"{v:.4f}", ha='center', va='bottom', fontsize=12, color='black')
  1024. plt.show()
  1027. metrics = [precision, recall, f1_score]
  1028. labels = ["Precision", "Recall", "F1 Score"]
  1029. metric_colors = [colors[0], colors[3], colors[4]]
  1031. plt.figure(figsize=(8, 5))
  1032. bar_width = 0.25
  1033. x = np.arange(len(ensembles))
  1035. for i, metric in enumerate(metrics):
  1036. plt.bar(x + i * bar_width, metric, width=bar_width, label=labels[i], color=metric_colors[i])
  1038. plt.xlabel("Ensemble Models")
  1039. plt.ylabel("Score")
  1040. plt.title("Precision, Recall, and F1 Score Comparison")
  1041. plt.xticks(x + bar_width, ensembles)
  1042. plt.legend()
  1043. plt.ylim(0.98, 1.0)
  1044. plt.show()
  1047. plt.figure(figsize=(8, 5))
  1048. bar_width = 0.25
  1049. x = np.arange(len(ensembles))
  1051. plt.bar(x, mae, width=bar_width, label="MAE", color=colors[3])
  1052. plt.bar(x + bar_width, rmse, width=bar_width, label="RMSE", color=colors[1])
  1054. plt.xlabel("Ensemble Models")
  1055. plt.ylabel("Error")
  1056. plt.title("MAE and RMSE Comparison")
  1057. plt.xticks(x + bar_width / 2, ensembles)
  1058. plt.legend()
  1059. plt.show()
  1062. # %%
  1065. # %%
  1068. # %%
  1071. # %%
  1074. # %%
  1077. # %%

pretrained_ensemble.ipynb.ipynb at commit 78bfc24, no license · at the source

Overview

Authors: Maisam Abbas1, Muhammad Hassan1, Ran-Zan Wang1, Chin-Hung Teng2
ORCID iDs: Maisam Abbas, Muhammad Hassan, Chin-Hung Teng
  1. Department of Computer Science and Engineering, Yuan Ze University, Yuandong Rd. Zhongli District, Taoyuan 32003, Taiwan; (M.A.); (M.H.)
  2. Department of Information Communication, Yuan Ze University, Yuandong Rd. Zhongli District, Taoyuan 32003, Taiwan
Institutions: Yuan Ze University (Taiwan)
Journal: Journal of imaging, volume 12, issue 6, article 233
Dates: received 23 March 2026; accepted 24 May 2026; published online 28 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/jimaging12060233 · PMID 42346896 · PMCID PMC13301762 · OpenAlex W7162665632
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), other condition (population)
Methods: Statistics, Machine learning
Keywords: brain tumor classification, Magnetic Resonance Imaging (MRI), convolutional neural network, transfer learning, pre-trained models
Topic: Brain Tumor Detection and Classification (Neurology, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 68 references in the paper

Abstract

Early and accurate brain tumor detection is vital for effective treatment. We propose a deep learning framework for MRI-based brain tumor classification, featuring a novel Custom CNN evaluated independently alongside six pre-trained models for comparative analysis (InceptionV3, EfficientNetV2L, ResNet152V2, Xception, VGG16, and MobileNetV2). Additionally, three separate ensemble models are constructed to analyze whether model combination improves performance. Experiments conducted on the Kaggle-Multiclass brain MRI dataset show that the proposed Custom CNN achieves the best performance, with an accuracy of 99.54%, and features a task-specific architecture (0.57M parameters) that achieves superior performance through domain-specific feature learning and computational efficiency, thus outperforming both individual pre-trained models and ensemble approaches. Among pre-trained models, EfficientNetV2L (99.47%) and InceptionV3 (99.39%) show competitive results, while the best ensemble model achieves 99.47% accuracy, indicating clinical deployment potential pending external validation. These results demonstrate that the proposed Custom CNN provides superior performance without requiring ensemble complexity, thus highlighting its effectiveness and efficiency for automated brain tumor classification.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 8 matches between paragraphs and lines of code.

Maisamilens/brain-tumor-classification

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 78bfc245eb09943c3788e28d95b4002705faf88b, 23 July 2026
Languages: Jupyter (2)
Size: 5 files, 2 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, 2 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Keras (1 file), Matplotlib (1 file), NumPy (1 file), pandas (1 file), scikit-learn (1 file), seaborn (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
3 files
At the source: github.com/Maisamilens/brain-tumor-classification

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 2 scripts, each with its path and the digest of its content;
  • 8 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data Availability Statement

The datasets analyzed and utilized in this study are publicly available. The brain tumor MRI dataset by Jun Cheng can be accessed via Figshare [51]. Additional datasets used include the Brain Tumor Classification (MRI) dataset by Sartaj Bhuvaji [52], the Br35H Brain Tumor Detection dataset by Ahmed Hamada [53], and the Kaggle multiclass Brain Tumor MRI dataset by Masoud Nickparvar [54]. The source code for this work is publicly available at: https://github.com/Maisamilens/brain-tumor-classification (accessed on 23 May 2026).

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 5 keywords, 53 references.

Cite

This paper

Abbas, M., Hassan, M., Wang, R.-Z., & Teng, C.-H. (2026). Brain Tumor Classification in MRI Images Using Combined Transfer Learning and Convolutional Neural Networks. Journal of imaging, 12(6), 233. https://doi.org/10.3390/jimaging12060233

BibTeX

@article{abbas2026brain,
author = {Abbas, Maisam and Hassan, Muhammad and Wang, Ran-Zan and Teng, Chin-Hung},
title = {{Brain Tumor Classification in MRI Images Using Combined Transfer Learning and Convolutional Neural Networks}},
journal = {Journal of imaging},
year = {2026},
month = may,
volume = {12},
number = {6},
pages = {233},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {2313-433X},
doi = {10.3390/jimaging12060233},
url = {https://doi.org/10.3390/jimaging12060233},
pmid = {42346896},
pmcid = {PMC13301762}
}

RIS

TY - JOUR
AU - Abbas, Maisam
AU - Hassan, Muhammad
AU - Wang, Ran-Zan
AU - Teng, Chin-Hung
TI - Brain Tumor Classification in MRI Images Using Combined Transfer Learning and Convolutional Neural Networks
T2 - Journal of imaging
J2 - J Imaging
PY - 2026
DA - 2026/05/28
VL - 12
IS - 6
SP - 233
SN - 2313-433X
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/jimaging12060233
UR - https://doi.org/10.3390/jimaging12060233
LA - en
ER -

CSL-JSON

{
"id": "10.3390/jimaging12060233",
"type": "article-journal",
"title": "Brain Tumor Classification in MRI Images Using Combined Transfer Learning and Convolutional Neural Networks",
"container-title": "Journal of imaging",
"author": [
{
"family": "Abbas",
"given": "Maisam"
},
{
"family": "Hassan",
"given": "Muhammad"
},
{
"family": "Wang",
"given": "Ran-Zan"
},
{
"family": "Teng",
"given": "Chin-Hung"
}
],
"container-title-short": "J Imaging",
"volume": "12",
"issue": "6",
"page": "233",
"DOI": "10.3390/jimaging12060233",
"PMID": "42346896",
"PMCID": "PMC13301762",
"ISSN": "2313-433X",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/jimaging12060233",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
28
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1186/s40708-026-00325-x
CAE-BrainNet: a statistically validated class-adaptive attention ensemble model for explainable brain tumor classification from MRI.
Journal: Brain informatics
In common: kaggle.com/datasets/ahmedhamada0, kaggle.com/datasets/sartajbhuvaji, 2 other datasets, structural MRI / diffusion, other condition, 3 references
[2] doi:10.1038/s41598-026-45675-y [code]
Multi-class classification of brain tumor using a ResNet101 backbone integrated with multi-scale deformable attention module and advanced data augmentations.
Journal: Scientific reports
In common: seaborn, scikit-learn, pandas, 2 other tools, structural MRI / diffusion, other condition, 6 references
[3] doi:10.3390/diagnostics16111745
Brain Tumor Classification and Segmentation in MR Images Using EfficientNet and U-Net++ Models.
Journal: Diagnostics (Basel, Switzerland)
In common: kaggle.com/datasets/sartajbhuvaji, figshare 1512427, 1 other dataset, structural MRI / diffusion, other condition, 1 reference
[4] doi:10.3390/brainsci16050468
Advancing Brain Tumor Diagnosis Using Deep Learning: A Systematic and Critical Review on Methodological Approaches to Glioma Segmentation and Classification Through Multiparametric MRI.
Journal: Brain sciences
In common: kaggle.com/datasets/sartajbhuvaji, figshare 1512427, 1 other dataset, structural MRI / diffusion, other condition, 1 reference
[5] doi:10.3389/frai.2026.1849051
Query-guided learning for efficient and interpretable multi-class brain tumor classification in MRI.
Journal: Frontiers in artificial intelligence
In common: kaggle.com/datasets/ahmedhamada0, kaggle.com/datasets/masoudnickparvar, structural MRI / diffusion, other condition, 3 references
[6] doi:10.1371/journal.pone.0346821
LHW-Net: An ensemble-based machine learning framework for brain tumor classification.
Journal: PloS one
In common: kaggle.com/datasets/ahmedhamada0, figshare 1512427, 1 other dataset, other condition, 1 reference
[7] doi:10.1038/s41598-026-46803-4 [code]
BrainGraphNet-ViT model: a hybrid model combining vision transformers and graph convolutional networks for brain tumor diagnosis.
Journal: Scientific reports
In common: kaggle.com/datasets/ahmedhamada0, kaggle.com/datasets/sartajbhuvaji, 1 other dataset, structural MRI / diffusion, other condition
[8] doi:10.1038/s41598-026-51236-0
A minimal-net CNN model for an IoT-based brain tumor detection and monitoring system.
Journal: Scientific reports
In common: kaggle.com/datasets/sartajbhuvaji, kaggle.com/datasets/masoudnickparvar, structural MRI / diffusion, other condition, 2 references
[9] doi:10.1038/s41598-026-52615-3
MANet: a multimodal attention convolutional neural network for brain tumor classification.
Journal: Scientific reports
In common: figshare 1512427, kaggle.com/datasets/masoudnickparvar, structural MRI / diffusion, other condition, 2 references
[10] doi:
NeuroTrustNet: a cost-effective multimodal ensemble framework for brain tumor classification under cross-dataset variability
Journal: Frontiers in artificial intelligence
In common: kaggle.com/datasets/sartajbhuvaji, kaggle.com/datasets/masoudnickparvar, other condition, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.