Datasets
Models
Downloads: 1
[198e90]:
/
leukemia detection.ipynb
943 lines (942 with data), 67.5 kB
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "59654c10",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"modules loaded\n"
]
}
],
"source": [
"import os\n",
"os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
"\n",
"import tensorflow as tf\n",
"from tensorflow import keras\n",
"from tensorflow.keras import backend as K\n",
"from tensorflow.keras.layers import Dense, Activation,Dropout,Conv2D, MaxPooling2D,BatchNormalization, Flatten\n",
"from tensorflow.keras.optimizers import Adam, Adamax\n",
"from tensorflow.keras.metrics import categorical_crossentropy\n",
"from tensorflow.keras import regularizers\n",
"from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
"from tensorflow.keras.models import Model, load_model, Sequential\n",
"import numpy as np\n",
"import pandas as pd\n",
"import shutil\n",
"import time\n",
"import cv2 as cv2\n",
"from tqdm import tqdm\n",
"from sklearn.model_selection import train_test_split\n",
"import matplotlib.pyplot as plt\n",
"from matplotlib.pyplot import imshow\n",
"import seaborn as sns\n",
"sns.set_style('darkgrid')\n",
"from PIL import Image\n",
"from sklearn.metrics import confusion_matrix, classification_report\n",
"from IPython.core.display import display, HTML\n",
"# stop annoying tensorflow warning messages\n",
"import logging\n",
"logging.getLogger(\"tensorflow\").setLevel(logging.ERROR)\n",
"print ('modules loaded')"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "fa7de5f3",
"metadata": {},
"outputs": [],
"source": [
"def show_image_samples(gen ):\n",
" t_dict=gen.class_indices\n",
" classes=list(t_dict.keys()) \n",
" images,labels=next(gen) # get a sample batch from the generator \n",
" plt.figure(figsize=(20, 20))\n",
" length=len(labels)\n",
" if length<25: #show maximum of 25 images\n",
" r=length\n",
" else:\n",
" r=25\n",
" for i in range(r):\n",
" plt.subplot(5, 5, i + 1)\n",
" image=images[i]/255\n",
" plt.imshow(image)\n",
" index=np.argmax(labels[i])\n",
" class_name=classes[index]\n",
" plt.title(class_name, color='blue', fontsize=12)\n",
" plt.axis('off')\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "3cc88fda",
"metadata": {},
"outputs": [],
"source": [
"def show_images(tdir):\n",
" classlist=os.listdir(tdir)\n",
" length=len(classlist)\n",
" columns=5\n",
" rows=int(np.ceil(length/columns)) \n",
" plt.figure(figsize=(20, rows * 4))\n",
" for i, klass in enumerate(classlist): \n",
" classpath=os.path.join(tdir, klass)\n",
" imgpath=os.path.join(classpath, '1.jpg')\n",
" img=plt.imread(imgpath)\n",
" plt.subplot(rows, columns, i+1)\n",
" plt.axis('off')\n",
" plt.title(klass, color='blue', fontsize=12)\n",
" plt.imshow(img)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "564a3b4b",
"metadata": {},
"outputs": [],
"source": [
"def print_in_color(txt_msg,fore_tupple,back_tupple,):\n",
" #prints the text_msg in the foreground color specified by fore_tupple with the background specified by back_tupple \n",
" #text_msg is the text, fore_tupple is foregroud color tupple (r,g,b), back_tupple is background tupple (r,g,b)\n",
" rf,gf,bf=fore_tupple\n",
" rb,gb,bb=back_tupple\n",
" msg='{0}' + txt_msg\n",
" mat='\\33[38;2;' + str(rf) +';' + str(gf) + ';' + str(bf) + ';48;2;' + str(rb) + ';' +str(gb) + ';' + str(bb) +'m' \n",
" print(msg .format(mat), flush=True)\n",
" print('\\33[0m', flush=True) # returns default print color to back to black\n",
" return"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "9bbdb8ab",
"metadata": {},
"outputs": [],
"source": [
"class LRA(keras.callbacks.Callback):\n",
" def __init__(self,model, base_model, patience,stop_patience, threshold, factor, dwell, batches, initial_epoch,epochs, ask_epoch):\n",
" super(LRA, self).__init__()\n",
" self.model=model\n",
" self.base_model=base_model\n",
" self.patience=patience # specifies how many epochs without improvement before learning rate is adjusted\n",
" self.stop_patience=stop_patience # specifies how many times to adjust lr without improvement to stop training\n",
" self.threshold=threshold # specifies training accuracy threshold when lr will be adjusted based on validation loss\n",
" self.factor=factor # factor by which to reduce the learning rate\n",
" self.dwell=dwell\n",
" self.batches=batches # number of training batch to runn per epoch\n",
" self.initial_epoch=initial_epoch\n",
" self.epochs=epochs\n",
" self.ask_epoch=ask_epoch\n",
" self.ask_epoch_initial=ask_epoch # save this value to restore if restarting training\n",
" # callback variables \n",
" self.count=0 # how many times lr has been reduced without improvement\n",
" self.stop_count=0 \n",
" self.best_epoch=1 # epoch with the lowest loss \n",
" self.initial_lr=float(tf.keras.backend.get_value(model.optimizer.lr)) # get the initiallearning rate and save it \n",
" self.highest_tracc=0.0 # set highest training accuracy to 0 initially\n",
" self.lowest_vloss=np.inf # set lowest validation loss to infinity initially\n",
" self.best_weights=self.model.get_weights() # set best weights to model's initial weights\n",
" self.initial_weights=self.model.get_weights() # save initial weights if they have to get restored \n",
" \n",
" def on_train_begin(self, logs=None): \n",
" if self.base_model != None:\n",
" status=base_model.trainable\n",
" if status:\n",
" msg=' initializing callback starting training with base_model trainable'\n",
" else:\n",
" msg='initializing callback starting training with base_model not trainable'\n",
" else:\n",
" msg='initialing callback and starting training' \n",
" print_in_color (msg, (244, 252, 3), (55,65,80)) \n",
" msg='{0:^8s}{1:^10s}{2:^9s}{3:^9s}{4:^9s}{5:^9s}{6:^9s}{7:^10s}{8:10s}{9:^8s}'.format('Epoch', 'Loss', 'Accuracy',\n",
" 'V_loss','V_acc', 'LR', 'Next LR', 'Monitor','% Improv', 'Duration')\n",
" print_in_color(msg, (244,252,3), (55,65,80)) \n",
" self.start_time= time.time()\n",
" \n",
" def on_train_end(self, logs=None):\n",
" stop_time=time.time()\n",
" tr_duration= stop_time- self.start_time \n",
" hours = tr_duration // 3600\n",
" minutes = (tr_duration - (hours * 3600)) // 60\n",
" seconds = tr_duration - ((hours * 3600) + (minutes * 60))\n",
"\n",
" self.model.set_weights(self.best_weights) # set the weights of the model to the best weights\n",
" msg=f'Training is completed - model is set with weights from epoch {self.best_epoch} '\n",
" print_in_color(msg, (0,255,0), (55,65,80))\n",
" msg = f'training elapsed time was {str(hours)} hours, {minutes:4.1f} minutes, {seconds:4.2f} seconds)'\n",
" print_in_color(msg, (0,255,0), (55,65,80)) \n",
" \n",
" def on_train_batch_end(self, batch, logs=None):\n",
" acc=logs.get('accuracy')* 100 # get training accuracy \n",
" loss=logs.get('loss')\n",
" msg='{0:20s}processing batch {1:4s} of {2:5s} accuracy= {3:8.3f} loss: {4:8.5f}'.format(' ', str(batch), str(self.batches), acc, loss)\n",
" print(msg, '\\r', end='') # prints over on the same line to show running batch count \n",
" \n",
" def on_epoch_begin(self,epoch, logs=None):\n",
" self.now= time.time()\n",
" \n",
" def on_epoch_end(self, epoch, logs=None): # method runs on the end of each epoch\n",
" later=time.time()\n",
" duration=later-self.now \n",
" lr=float(tf.keras.backend.get_value(self.model.optimizer.lr)) # get the current learning rate\n",
" current_lr=lr\n",
" v_loss=logs.get('val_loss') # get the validation loss for this epoch\n",
" acc=logs.get('accuracy') # get training accuracy \n",
" v_acc=logs.get('val_accuracy')\n",
" loss=logs.get('loss') \n",
" if acc < self.threshold: # if training accuracy is below threshold adjust lr based on training accuracy\n",
" monitor='accuracy'\n",
" if epoch ==0:\n",
" pimprov=0.0\n",
" else:\n",
" pimprov= (acc-self.highest_tracc )*100/self.highest_tracc\n",
" if acc>self.highest_tracc: # training accuracy improved in the epoch \n",
" self.highest_tracc=acc # set new highest training accuracy\n",
" self.best_weights=self.model.get_weights() # traing accuracy improved so save the weights\n",
" self.count=0 # set count to 0 since training accuracy improved\n",
" self.stop_count=0 # set stop counter to 0\n",
" if v_loss<self.lowest_vloss:\n",
" self.lowest_vloss=v_loss\n",
" color= (0,255,0)\n",
" self.best_epoch=epoch + 1 # set the value of best epoch for this epoch \n",
" else: \n",
" # training accuracy did not improve check if this has happened for patience number of epochs\n",
" # if so adjust learning rate\n",
" if self.count>=self.patience -1: # lr should be adjusted\n",
" color=(245, 170, 66)\n",
" lr= lr* self.factor # adjust the learning by factor\n",
" tf.keras.backend.set_value(self.model.optimizer.lr, lr) # set the learning rate in the optimizer\n",
" self.count=0 # reset the count to 0\n",
" self.stop_count=self.stop_count + 1 # count the number of consecutive lr adjustments\n",
" self.count=0 # reset counter\n",
" if self.dwell:\n",
" self.model.set_weights(self.best_weights) # return to better point in N space \n",
" else:\n",
" if v_loss<self.lowest_vloss:\n",
" self.lowest_vloss=v_loss \n",
" else:\n",
" self.count=self.count +1 # increment patience counter \n",
" else: # training accuracy is above threshold so adjust learning rate based on validation loss\n",
" monitor='val_loss'\n",
" if epoch ==0:\n",
" pimprov=0.0\n",
" else:\n",
" pimprov= (self.lowest_vloss- v_loss )*100/self.lowest_vloss\n",
" if v_loss< self.lowest_vloss: # check if the validation loss improved \n",
" self.lowest_vloss=v_loss # replace lowest validation loss with new validation loss \n",
" self.best_weights=self.model.get_weights() # validation loss improved so save the weights\n",
" self.count=0 # reset count since validation loss improved \n",
" self.stop_count=0 \n",
" color=(0,255,0) \n",
" self.best_epoch=epoch + 1 # set the value of the best epoch to this epoch\n",
" else: # validation loss did not improve\n",
" if self.count>=self.patience-1: # need to adjust lr\n",
" color=(245, 170, 66)\n",
" lr=lr * self.factor # adjust the learning rate \n",
" self.stop_count=self.stop_count + 1 # increment stop counter because lr was adjusted \n",
" self.count=0 # reset counter\n",
" tf.keras.backend.set_value(self.model.optimizer.lr, lr) # set the learning rate in the optimizer\n",
" if self.dwell:\n",
" self.model.set_weights(self.best_weights) # return to better point in N space\n",
" else: \n",
" self.count =self.count +1 # increment the patience counter \n",
" if acc>self.highest_tracc:\n",
" self.highest_tracc= acc\n",
" msg=f'{str(epoch+1):^3s}/{str(self.epochs):4s} {loss:^9.3f}{acc*100:^9.3f}{v_loss:^9.5f}{v_acc*100:^9.3f}{current_lr:^9.5f}{lr:^9.5f}{monitor:^11s}{pimprov:^10.2f}{duration:^8.2f}'\n",
" print_in_color (msg,color, (55,65,80))\n",
" if self.stop_count> self.stop_patience - 1: # check if learning rate has been adjusted stop_count times with no improvement\n",
" msg=f' training has been halted at epoch {epoch + 1} after {self.stop_patience} adjustments of learning rate with no improvement'\n",
" print_in_color(msg, (0,255,255), (55,65,80))\n",
" self.model.stop_training = True # stop training\n",
" else: \n",
" if self.ask_epoch !=None:\n",
" if epoch + 1 >= self.ask_epoch:\n",
" if base_model.trainable:\n",
" msg='enter H to halt training or an integer for number of epochs to run then ask again'\n",
" else:\n",
" msg='enter H to halt training ,F to fine tune model, or an integer for number of epochs to run then ask again'\n",
" print_in_color(msg, (0,255,255), (55,65,80))\n",
" ans=input('')\n",
" if ans=='H' or ans=='h':\n",
" msg=f'training has been halted at epoch {epoch + 1} due to user input'\n",
" print_in_color(msg, (0,255,255), (55,65,80))\n",
" self.model.stop_training = True # stop training\n",
" elif ans == 'F' or ans=='f':\n",
" if base_model.trainable:\n",
" msg='base_model is already set as trainable'\n",
" else:\n",
" msg='setting base_model as trainable for fine tuning of model'\n",
" self.base_model.trainable=True\n",
" print_in_color(msg, (0, 255,255), (55,65,80))\n",
" msg='{0:^8s}{1:^10s}{2:^9s}{3:^9s}{4:^9s}{5:^9s}{6:^9s}{7:^10s}{8:^8s}'.format('Epoch', 'Loss', 'Accuracy',\n",
" 'V_loss','V_acc', 'LR', 'Next LR', 'Monitor','% Improv', 'Duration')\n",
" print_in_color(msg, (244,252,3), (55,65,80)) \n",
" self.count=0\n",
" self.stop_count=0 \n",
" self.ask_epoch = epoch + 1 + self.ask_epoch_initial \n",
" \n",
" else:\n",
" ans=int(ans)\n",
" self.ask_epoch +=ans\n",
" msg=f' training will continue until epoch ' + str(self.ask_epoch) \n",
" print_in_color(msg, (0, 255,255), (55,65,80))\n",
" msg='{0:^8s}{1:^10s}{2:^9s}{3:^9s}{4:^9s}{5:^9s}{6:^9s}{7:^10s}{8:10s}{9:^8s}'.format('Epoch', 'Loss', 'Accuracy',\n",
" 'V_loss','V_acc', 'LR', 'Next LR', 'Monitor','% Improv', 'Duration')\n",
" print_in_color(msg, (244,252,3), (55,65,80))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "e155beef",
"metadata": {},
"outputs": [],
"source": [
"def tr_plot(tr_data, start_epoch):\n",
" #Plot the training and validation data\n",
" tacc=tr_data.history['accuracy']\n",
" tloss=tr_data.history['loss']\n",
" vacc=tr_data.history['val_accuracy']\n",
" vloss=tr_data.history['val_loss']\n",
" Epoch_count=len(tacc)+ start_epoch\n",
" Epochs=[]\n",
" for i in range (start_epoch ,Epoch_count):\n",
" Epochs.append(i+1) \n",
" index_loss=np.argmin(vloss)# this is the epoch with the lowest validation loss\n",
" val_lowest=vloss[index_loss]\n",
" index_acc=np.argmax(vacc)\n",
" acc_highest=vacc[index_acc]\n",
" plt.style.use('fivethirtyeight')\n",
" sc_label='best epoch= '+ str(index_loss+1 +start_epoch)\n",
" vc_label='best epoch= '+ str(index_acc + 1+ start_epoch)\n",
" fig,axes=plt.subplots(nrows=1, ncols=2, figsize=(20,8))\n",
" axes[0].plot(Epochs,tloss, 'r', label='Training loss')\n",
" axes[0].plot(Epochs,vloss,'g',label='Validation loss' )\n",
" axes[0].scatter(index_loss+1 +start_epoch,val_lowest, s=150, c= 'blue', label=sc_label)\n",
" axes[0].set_title('Training and Validation Loss')\n",
" axes[0].set_xlabel('Epochs')\n",
" axes[0].set_ylabel('Loss')\n",
" axes[0].legend()\n",
" axes[1].plot (Epochs,tacc,'r',label= 'Training Accuracy')\n",
" axes[1].plot (Epochs,vacc,'g',label= 'Validation Accuracy')\n",
" axes[1].scatter(index_acc+1 +start_epoch,acc_highest, s=150, c= 'blue', label=vc_label)\n",
" axes[1].set_title('Training and Validation Accuracy')\n",
" axes[1].set_xlabel('Epochs')\n",
" axes[1].set_ylabel('Accuracy')\n",
" axes[1].legend()\n",
" plt.tight_layout\n",
" #plt.style.use('fivethirtyeight')\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "35f70802",
"metadata": {},
"outputs": [],
"source": [
"def print_info( test_gen, preds, print_code, save_dir, subject ):\n",
" class_dict=test_gen.class_indices\n",
" labels= test_gen.labels\n",
" file_names= test_gen.filenames \n",
" error_list=[]\n",
" true_class=[]\n",
" pred_class=[]\n",
" prob_list=[]\n",
" new_dict={}\n",
" error_indices=[]\n",
" y_pred=[]\n",
" for key,value in class_dict.items():\n",
" new_dict[value]=key # dictionary {integer of class number: string of class name}\n",
" # store new_dict as a text fine in the save_dir\n",
" classes=list(new_dict.values()) # list of string of class names \n",
" errors=0 \n",
" for i, p in enumerate(preds):\n",
" pred_index=np.argmax(p) \n",
" true_index=labels[i] # labels are integer values\n",
" if pred_index != true_index: # a misclassification has occurred\n",
" error_list.append(file_names[i])\n",
" true_class.append(new_dict[true_index])\n",
" pred_class.append(new_dict[pred_index])\n",
" prob_list.append(p[pred_index])\n",
" error_indices.append(true_index) \n",
" errors=errors + 1\n",
" y_pred.append(pred_index) \n",
" tests=len(preds)\n",
" acc= (1-errors/tests) *100\n",
" msg= f'There were {errors} errors in {tests} test cases Model accuracy= {acc: 6.2f} %'\n",
" print_in_color(msg,(0,255,255),(55,65,80))\n",
" if print_code !=0:\n",
" if errors>0:\n",
" if print_code>errors:\n",
" r=errors\n",
" else:\n",
" r=print_code \n",
" msg='{0:^28s}{1:^28s}{2:^28s}{3:^16s}'.format('Filename', 'Predicted Class' , 'True Class', 'Probability')\n",
" print_in_color(msg, (0,255,0),(55,65,80))\n",
" for i in range(r): \n",
" split1=os.path.split(error_list[i]) \n",
" split2=os.path.split(split1[0]) \n",
" fname=split2[1] + '/' + split1[1]\n",
" msg='{0:^28s}{1:^28s}{2:^28s}{3:4s}{4:^6.4f}'.format(fname, pred_class[i],true_class[i], ' ', prob_list[i])\n",
" print_in_color(msg, (255,255,255), (55,65,60))\n",
" #print(error_list[i] , pred_class[i], true_class[i], prob_list[i]) \n",
" else:\n",
" msg='With accuracy of 100 % there are no errors to print'\n",
" print_in_color(msg, (0,255,0),(55,65,80))\n",
" if errors>0:\n",
" plot_bar=[]\n",
" plot_class=[]\n",
" for key, value in new_dict.items(): \n",
" count=error_indices.count(key) \n",
" if count!=0:\n",
" plot_bar.append(count) # list containg how many times a class c had an error\n",
" plot_class.append(value) # stores the class \n",
" fig=plt.figure()\n",
" fig.set_figheight(len(plot_class)/3)\n",
" fig.set_figwidth(10)\n",
" plt.style.use('fivethirtyeight')\n",
" for i in range(0, len(plot_class)):\n",
" c=plot_class[i]\n",
" x=plot_bar[i]\n",
" plt.barh(c, x, )\n",
" plt.title( ' Errors by Class on Test Set')\n",
" y_true= np.array(labels) \n",
" y_pred=np.array(y_pred)\n",
" if len(classes)<= 30:\n",
" # create a confusion matrix \n",
" cm = confusion_matrix(y_true, y_pred ) \n",
" length=len(classes)\n",
" if length<8:\n",
" fig_width=8\n",
" fig_height=8\n",
" else:\n",
" fig_width= int(length * .5)\n",
" fig_height= int(length * .5)\n",
" plt.figure(figsize=(fig_width, fig_height))\n",
" sns.heatmap(cm, annot=True, vmin=0, fmt='g', cmap='Blues', cbar=False) \n",
" plt.xticks(np.arange(length)+.5, classes, rotation= 90)\n",
" plt.yticks(np.arange(length)+.5, classes, rotation=0)\n",
" plt.xlabel(\"Predicted\")\n",
" plt.ylabel(\"Actual\")\n",
" plt.title(\"Confusion Matrix\")\n",
" plt.show()\n",
" clr = classification_report(y_true, y_pred, target_names=classes, digits= 4)\n",
" print(\"Classification Report:\\n----------------------\\n\", clr)\n",
" return acc/100"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e7d27934",
"metadata": {},
"outputs": [],
"source": [
"def saver(save_path, model, model_name, subject, accuracy,img_size, scalar, generator): \n",
" # first save the model\n",
" save_id=str (model_name + '-' + subject +'-'+ str(acc)[:str(acc).rfind('.')+3] + '.h5')\n",
" model_save_loc=os.path.join(save_path, save_id)\n",
" model.save(model_save_loc)\n",
" print_in_color ('model was saved as ' + model_save_loc, (0,255,0),(55,65,80)) \n",
" # now create the class_df and convert to csv file \n",
" class_dict=generator.class_indices \n",
" height=[]\n",
" width=[]\n",
" scale=[]\n",
" for i in range(len(class_dict)):\n",
" height.append(img_size[0])\n",
" width.append(img_size[1])\n",
" scale.append(scalar)\n",
" Index_series=pd.Series(list(class_dict.values()), name='class_index')\n",
" Class_series=pd.Series(list(class_dict.keys()), name='class') \n",
" Height_series=pd.Series(height, name='height')\n",
" Width_series=pd.Series(width, name='width')\n",
" Scale_series=pd.Series(scale, name='scale by')\n",
" class_df=pd.concat([Index_series, Class_series, Height_series, Width_series, Scale_series], axis=1) \n",
" csv_name='class_dict.csv'\n",
" csv_save_loc=os.path.join(save_path, csv_name)\n",
" class_df.to_csv(csv_save_loc, index=False) \n",
" print_in_color ('class csv file was saved as ' + csv_save_loc, (0,255,0),(55,65,80)) \n",
" return model_save_loc, csv_save_loc\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "6268a332",
"metadata": {},
"outputs": [],
"source": [
"def predictor(sdir, csv_path, model_path, averaged=True, verbose=True): \n",
" # read in the csv file\n",
" class_df=pd.read_csv(csv_path) \n",
" class_count=len(class_df['class'].unique())\n",
" img_height=int(class_df['height'].iloc[0])\n",
" img_width =int(class_df['width'].iloc[0])\n",
" img_size=(img_width, img_height) \n",
" scale=class_df['scale by'].iloc[0] \n",
" # determine value to scale image pixels by\n",
" try: \n",
" s=int(scale)\n",
" s2=1\n",
" s1=0\n",
" except:\n",
" split=scale.split('-')\n",
" s1=float(split[1])\n",
" s2=float(split[0].split('*')[1])\n",
" path_list=[]\n",
" paths=os.listdir(sdir) \n",
" for f in paths:\n",
" path_list.append(os.path.join(sdir,f))\n",
" if verbose:\n",
" print (' Model is being loaded- this will take about 10 seconds')\n",
" model=load_model(model_path)\n",
" image_count=len(path_list) \n",
" image_list=[]\n",
" file_list=[]\n",
" good_image_count=0\n",
" for i in range (image_count): \n",
" try:\n",
" img=cv2.imread(path_list[i])\n",
" img=cv2.resize(img, img_size)\n",
" img=cv2.cvtColor(img, cv2.COLOR_BGR2RGB) \n",
" good_image_count +=1\n",
" img=img*s2 - s1 \n",
" image_list.append(img)\n",
" file_name=os.path.split(path_list[i])[1]\n",
" file_list.append(file_name)\n",
" except:\n",
" if verbose:\n",
" print ( path_list[i], ' is an invalid image file')\n",
" if good_image_count==1: # if only a single image need to expand dimensions\n",
" averaged=True\n",
" image_array=np.array(image_list) \n",
" # make predictions on images, sum the probabilities of each class then find class index with\n",
" # highest probability\n",
" preds=model.predict(image_array) \n",
" if averaged:\n",
" psum=[]\n",
" for i in range (class_count): # create all 0 values list\n",
" psum.append(0) \n",
" for p in preds: # iterate over all predictions\n",
" for i in range (class_count):\n",
" psum[i]=psum[i] + p[i] # sum the probabilities \n",
" index=np.argmax(psum) # find the class index with the highest probability sum \n",
" klass=class_df['class'].iloc[index] # get the class name that corresponds to the index\n",
" prob=psum[index]/good_image_count * 100 # get the probability average \n",
" # to show the correct image run predict again and select first image that has same index\n",
" for img in image_array: #iterate through the images \n",
" test_img=np.expand_dims(img, axis=0) # since it is a single image expand dimensions \n",
" test_index=np.argmax(model.predict(test_img)) # for this image find the class index with highest probability\n",
" if test_index== index: # see if this image has the same index as was selected previously\n",
" if verbose: # show image and print result if verbose=1\n",
" plt.axis('off')\n",
" plt.imshow(img) # show the image\n",
" print (f'predicted species is {klass} with a probability of {prob:6.4f} % ')\n",
" break # found an image that represents the predicted class \n",
" return klass, prob, img, None\n",
" else: # create individual predictions for each image\n",
" pred_class=[]\n",
" prob_list=[]\n",
" for i, p in enumerate(preds):\n",
" index=np.argmax(p) # find the class index with the highest probability sum\n",
" klass=class_df['class'].iloc[index] # get the class name that corresponds to the index\n",
" image_file= file_list[i]\n",
" pred_class.append(klass)\n",
" prob_list.append(p[index]) \n",
" Fseries=pd.Series(file_list, name='image file')\n",
" Lseries=pd.Series(pred_class, name= 'species')\n",
" Pseries=pd.Series(prob_list, name='probability')\n",
" df=pd.concat([Fseries, Lseries, Pseries], axis=1)\n",
" if verbose:\n",
" length= len(df)\n",
" print (df.head(length))\n",
" return None, None, None, df"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "516211e9",
"metadata": {},
"outputs": [],
"source": [
"def trim (df, max_size, min_size, column):\n",
" df=df.copy()\n",
" original_class_count= len(list(df[column].unique()))\n",
" print ('Original Number of classes in dataframe: ', original_class_count)\n",
" sample_list=[] \n",
" groups=df.groupby(column)\n",
" for label in df[column].unique(): \n",
" group=groups.get_group(label)\n",
" sample_count=len(group) \n",
" if sample_count> max_size :\n",
" strat=group[column]\n",
" samples,_=train_test_split(group, train_size=max_size, shuffle=True, random_state=123, stratify=strat) \n",
" sample_list.append(samples)\n",
" elif sample_count>= min_size:\n",
" sample_list.append(group)\n",
" df=pd.concat(sample_list, axis=0).reset_index(drop=True)\n",
" final_class_count= len(list(df[column].unique())) \n",
" if final_class_count != original_class_count:\n",
" print ('*** WARNING*** dataframe has a reduced number of classes' )\n",
" balance=list(df[column].value_counts())\n",
" print (balance)\n",
" return df"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "0b66bd08",
"metadata": {},
"outputs": [],
"source": [
"def balance(train_df,max_samples, min_samples, column, working_dir, image_size):\n",
" train_df=train_df.copy()\n",
" train_df=trim (train_df, max_samples, min_samples, column) \n",
" # make directories to store augmented images\n",
" aug_dir=os.path.join(working_dir, 'aug')\n",
" if os.path.isdir(aug_dir):\n",
" shutil.rmtree(aug_dir)\n",
" os.mkdir(aug_dir)\n",
" for label in train_df['labels'].unique(): \n",
" dir_path=os.path.join(aug_dir,label) \n",
" os.mkdir(dir_path)\n",
" # create and store the augmented images \n",
" total=0\n",
" gen=ImageDataGenerator(horizontal_flip=True, rotation_range=20, width_shift_range=.2,\n",
" height_shift_range=.2, zoom_range=.2)\n",
" groups=train_df.groupby('labels') # group by class\n",
" for label in train_df['labels'].unique(): # for every class \n",
" group=groups.get_group(label) # a dataframe holding only rows with the specified label \n",
" sample_count=len(group) # determine how many samples there are in this class \n",
" if sample_count< max_samples: # if the class has less than target number of images\n",
" aug_img_count=0\n",
" delta=max_samples-sample_count # number of augmented images to create\n",
" target_dir=os.path.join(aug_dir, label) # define where to write the images \n",
" aug_gen=gen.flow_from_dataframe( group, x_col='filepaths', y_col=None, target_size=image_size,\n",
" class_mode=None, batch_size=1, shuffle=False, \n",
" save_to_dir=target_dir, save_prefix='aug-', color_mode='rgb',\n",
" save_format='jpg')\n",
" while aug_img_count<delta:\n",
" images=next(aug_gen) \n",
" aug_img_count += len(images)\n",
" total +=aug_img_count\n",
" print('Total Augmented images created= ', total)\n",
" # create aug_df and merge with train_df to create composite training set ndf\n",
" if total>0:\n",
" aug_fpaths=[]\n",
" aug_labels=[]\n",
" classlist=os.listdir(aug_dir)\n",
" for klass in classlist:\n",
" classpath=os.path.join(aug_dir, klass) \n",
" flist=os.listdir(classpath) \n",
" for f in flist: \n",
" fpath=os.path.join(classpath,f) \n",
" aug_fpaths.append(fpath)\n",
" aug_labels.append(klass)\n",
" Fseries=pd.Series(aug_fpaths, name='filepaths')\n",
" Lseries=pd.Series(aug_labels, name='labels')\n",
" aug_df=pd.concat([Fseries, Lseries], axis=1)\n",
" train_df=pd.concat([train_df,aug_df], axis=0).reset_index(drop=True)\n",
" \n",
" print (list(train_df['labels'].value_counts()) )\n",
" return train_df "
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "8fc60cf6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Input image shape is (450, 450, 3)\n"
]
},
{
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x154c002b0a0>"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"img_path=r'C:\\Users\\Vinay Wadhwa\\Downloads\\archive\\C-NMC_Leukemia\\training_data\\fold_0\\all\\UID_11_10_1_all.bmp'\n",
"img=plt.imread(img_path)\n",
"print ('Input image shape is ',img.shape)\n",
"plt.axis('off')\n",
"imshow(img)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ed426a89",
"metadata": {},
"outputs": [],
"source": [
"def preprocess (sdir, trsplit, vsplit):\n",
" filepaths=[]\n",
" labels=[] \n",
" folds=os.listdir(sdir)\n",
" for fold in folds:\n",
" foldpath=os.path.join(sdir,fold)\n",
" classlist=os.listdir(foldpath)\n",
" for klass in classlist:\n",
" classpath=os.path.join(foldpath,klass)\n",
" flist=os.listdir(classpath)\n",
" for f in flist:\n",
" fpath=os.path.join(classpath,f)\n",
" filepaths.append(fpath)\n",
" labels.append(klass)\n",
" Fseries=pd.Series(filepaths, name='filepaths')\n",
" Lseries=pd.Series(labels, name='labels')\n",
" df=pd.concat([Fseries, Lseries], axis=1) \n",
" dsplit=vsplit/(1-trsplit)\n",
" strat=df['labels']\n",
" train_df, dummy_df=train_test_split(df, train_size=trsplit, shuffle=True, random_state=123, stratify=strat)\n",
" strat=dummy_df['labels']\n",
" valid_df, test_df= train_test_split(dummy_df, train_size=dsplit, shuffle=True, random_state=123, stratify=strat)\n",
" print('train_df length: ', len(train_df), ' test_df length: ',len(test_df), ' valid_df length: ', len(valid_df))\n",
" # check that each dataframe has the same number of classes to prevent model.fit errors\n",
" trcount=len(train_df['labels'].unique())\n",
" tecount=len(test_df['labels'].unique())\n",
" vcount=len(valid_df['labels'].unique())\n",
" if trcount < tecount : \n",
" msg='** WARNING ** number of classes in training set is less than the number of classes in test set'\n",
" print_in_color(msg, (255,0,0), (55,65,80))\n",
" msg='This will throw an error in either model.evaluate or model.predict'\n",
" print_in_color(msg, (255,0,0), (55,65,80))\n",
" if trcount != vcount:\n",
" msg='** WARNING ** number of classes in training set not equal to number of classes in validation set' \n",
" print_in_color(msg, (255,0,0), (55,65,80))\n",
" msg=' this will throw an error in model.fit'\n",
" print_in_color(msg, (255,0,0), (55,65,80))\n",
" print ('train df class count: ', trcount, 'test df class count: ', tecount, ' valid df class count: ', vcount) \n",
" ans=input('Enter C to continue execution or H to halt execution')\n",
" if ans =='H' or ans == 'h':\n",
" print_in_color('Halting Execution', (255,0,0), (55,65,80))\n",
" import sys\n",
" sys.exit('program halted by user') \n",
" print(list(train_df['labels'].value_counts()))\n",
" return train_df, test_df, valid_df"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "beb2abf0",
"metadata": {},
"outputs": [],
"source": [
"sdir=r'C:\\Users\\Vinay Wadhwa\\Downloads\\archive\\C-NMC_Leukemia\\training_data'\n",
"trsplit=.9\n",
"vsplit=.05\n",
"train_df, test_df, valid_df= preprocess(sdir,trsplit, vsplit)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6c3cd360",
"metadata": {},
"outputs": [],
"source": [
"max_samples= 3050\n",
"min_samples=0\n",
"column='labels'\n",
"working_dir = r'./'\n",
"img_size=(300,300)\n",
"train_df=trim(train_df, max_samples, min_samples, column)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e337f302",
"metadata": {},
"outputs": [],
"source": [
"channels=3\n",
"batch_size=10\n",
"img_shape=(img_size[0], img_size[1], channels)\n",
"length=len(test_df)\n",
"test_batch_size=sorted([int(length/n) for n in range(1,length+1) if length % n ==0 and length/n<=80],reverse=True)[0] \n",
"test_steps=int(length/test_batch_size)\n",
"print ( 'test batch size: ' ,test_batch_size, ' test steps: ', test_steps)\n",
"def scalar(img): \n",
" return img # EfficientNet expects pixelsin range 0 to 255 so no scaling is required\n",
"trgen=ImageDataGenerator(preprocessing_function=scalar, horizontal_flip=True)\n",
"tvgen=ImageDataGenerator(preprocessing_function=scalar)\n",
"msg=' for the train generator'\n",
"print(msg, '\\r', end='') \n",
"train_gen=trgen.flow_from_dataframe( train_df, x_col='filepaths', y_col='labels', target_size=img_size, class_mode='categorical',\n",
" color_mode='rgb', shuffle=True, batch_size=batch_size)\n",
"msg=' for the test generator'\n",
"print(msg, '\\r', end='') \n",
"test_gen=tvgen.flow_from_dataframe( test_df, x_col='filepaths', y_col='labels', target_size=img_size, class_mode='categorical',\n",
" color_mode='rgb', shuffle=False, batch_size=test_batch_size)\n",
"msg=' for the validation generator'\n",
"print(msg, '\\r', end='')\n",
"valid_gen=tvgen.flow_from_dataframe( valid_df, x_col='filepaths', y_col='labels', target_size=img_size, class_mode='categorical',\n",
" color_mode='rgb', shuffle=True, batch_size=batch_size)\n",
"classes=list(train_gen.class_indices.keys())\n",
"class_count=len(classes)\n",
"train_steps=int(np.ceil(len(train_gen.labels)/batch_size))\n",
"labels=test_gen.labels"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "45192270",
"metadata": {},
"outputs": [],
"source": [
"show_image_samples(train_gen)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "be76b54c",
"metadata": {},
"outputs": [],
"source": [
"model_name='EfficientNetB3'\n",
"base_model=tf.keras.applications.efficientnet.EfficientNetB3(include_top=False, weights=\"imagenet\",input_shape=img_shape, pooling='max') \n",
"x=base_model.output\n",
"x=keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001 )(x)\n",
"x = Dense(32, kernel_regularizer = regularizers.l2(l = 0.016),activity_regularizer=regularizers.l1(0.006),\n",
" bias_regularizer=regularizers.l1(0.006) ,activation='relu')(x)\n",
"x=Dropout(rate=.45, seed=123)(x) \n",
"output=Dense(class_count, activation='softmax')(x)\n",
"model=Model(inputs=base_model.input, outputs=output)\n",
"model.compile(Adamax(learning_rate=.001), loss='categorical_crossentropy', metrics=['accuracy']) "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3a18c5d9",
"metadata": {},
"outputs": [],
"source": [
"epochs =20\n",
"patience= 1 # number of epochs to wait to adjust lr if monitored value does not improve\n",
"stop_patience =3 # number of epochs to wait before stopping training if monitored value does not improve\n",
"threshold=.9 # if train accuracy is < threshhold adjust monitor accuracy, else monitor validation loss\n",
"factor=.5 # factor to reduce lr by\n",
"dwell=True # experimental, if True and monitored metric does not improve on current epoch set modelweights back to weights of previous epoch\n",
"freeze=False # if true free weights of the base model\n",
"ask_epoch=5 # number of epochs to run before asking if you want to halt training\n",
"batches=train_steps\n",
"callbacks=[LRA(model=model,base_model= base_model,patience=patience,stop_patience=stop_patience, threshold=threshold,\n",
" factor=factor,dwell=dwell, batches=batches,initial_epoch=0,epochs=epochs, ask_epoch=ask_epoch )]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "af65bfd1",
"metadata": {},
"outputs": [],
"source": [
"history=model.fit(x=train_gen, epochs=epochs, verbose=0, callbacks=callbacks, validation_data=valid_gen,\n",
" validation_steps=None, shuffle=False, initial_epoch=0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf5aff88",
"metadata": {},
"outputs": [],
"source": [
"subject='leukemia'\n",
"print_code=0\n",
"preds=model.predict(test_gen) \n",
"acc=print_info( test_gen, preds, print_code, working_dir, subject ) "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "09616c28",
"metadata": {},
"outputs": [],
"source": [
"model_save_loc, csv_save_loc=saver(working_dir, model, model_name, subject, acc, img_size, 1, train_gen)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4926bf84",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "c14e1862",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.2"
}
},
"nbformat": 4,
"nbformat_minor": 5
}