train_model.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296
  1. # main imports
  2. import numpy as np
  3. import pandas as pd
  4. import sys, os, argparse
  5. import json
  6. # model imports
  7. import cnn_models as models
  8. import tensorflow as tf
  9. import keras
  10. from keras import backend as K
  11. from keras.callbacks import ModelCheckpoint
  12. from sklearn.metrics import roc_auc_score, accuracy_score, precision_score, recall_score, f1_score
  13. from keras.utils import to_categorical
  14. # image processing imports
  15. import cv2
  16. from sklearn.utils import shuffle
  17. # config imports
  18. sys.path.insert(0, '') # trick to enable import of main folder module
  19. import custom_config as cfg
  20. def main():
  21. parser = argparse.ArgumentParser(description="Train Keras model and save it into .json file")
  22. parser.add_argument('--data', type=str, help='dataset filename prefix (without .train and .val)', required=True)
  23. parser.add_argument('--output', type=str, help='output file name desired for model (without .json extension)', required=True)
  24. parser.add_argument('--tl', type=int, help='use or not of transfer learning (`VGG network`)', default=0, choices=[0, 1])
  25. parser.add_argument('--batch_size', type=int, help='batch size used as model input', default=cfg.keras_batch)
  26. parser.add_argument('--epochs', type=int, help='number of epochs used for training model', default=cfg.keras_epochs)
  27. parser.add_argument('--balancing', type=int, help='specify if balacing of classes is done or not', default="1")
  28. parser.add_argument('--chanels', type=int, help="given number of chanels if necessary", default=0)
  29. parser.add_argument('--size', type=str, help="Size of input images", default="100, 100")
  30. #parser.add_argument('--val_size', type=float, help='percent of validation data during training process', default=cfg.val_dataset_size)
  31. args = parser.parse_args()
  32. p_data_file = args.data
  33. p_output = args.output
  34. p_tl = args.tl
  35. p_batch_size = args.batch_size
  36. p_epochs = args.epochs
  37. p_balancing = bool(args.balancing)
  38. p_chanels = args.chanels
  39. p_size = args.size.split(',')
  40. #p_val_size = args.val_size
  41. initial_epoch = 0
  42. ########################
  43. # 1. Get and prepare data
  44. ########################
  45. print("Preparing data...")
  46. dataset_train = pd.read_csv(p_data_file + '.train', header=None, sep=";")
  47. dataset_val = pd.read_csv(p_data_file + '.val', header=None, sep=";")
  48. print("Train set size : ", len(dataset_train))
  49. print("val set size : ", len(dataset_val))
  50. # default first shuffle of data
  51. dataset_train = shuffle(dataset_train)
  52. dataset_val = shuffle(dataset_val)
  53. print("Reading all images data...")
  54. # getting number of chanel
  55. if p_chanels == 0:
  56. n_chanels = len(dataset_train[1][1].split('::'))
  57. else:
  58. n_chanels = p_chanels
  59. print("Number of chanels : ", n_chanels)
  60. img_width, img_height = [ int(s) for s in p_size ]
  61. print(img_width, img_height)
  62. # specify the number of dimensions
  63. if K.image_data_format() == 'chanels_first':
  64. if n_chanels > 1:
  65. input_shape = (1, n_chanels, img_width, img_height)
  66. else:
  67. input_shape = (n_chanels, img_width, img_height)
  68. else:
  69. if n_chanels > 1:
  70. input_shape = (1, img_width, img_height, n_chanels)
  71. else:
  72. input_shape = (img_width, img_height, n_chanels)
  73. # get dataset with equal number of classes occurences if wished
  74. if p_balancing:
  75. print("Balancing of data")
  76. noisy_df_train = dataset_train[dataset_train.iloc[:, 0] == 1]
  77. not_noisy_df_train = dataset_train[dataset_train.iloc[:, 0] == 0]
  78. nb_noisy_train = len(noisy_df_train.index)
  79. noisy_df_val = dataset_val[dataset_val.iloc[:, 0] == 1]
  80. not_noisy_df_val = dataset_val[dataset_val.iloc[:, 0] == 0]
  81. nb_noisy_val = len(noisy_df_val.index)
  82. final_df_train = pd.concat([not_noisy_df_train[0:nb_noisy_train], noisy_df_train])
  83. final_df_val = pd.concat([not_noisy_df_val[0:nb_noisy_val], noisy_df_val])
  84. else:
  85. print("No balancing of data")
  86. final_df_train = dataset_train
  87. final_df_val = dataset_val
  88. # check if specific number of chanels is used
  89. if p_chanels == 0:
  90. # `::` is the separator used for getting each img path
  91. if n_chanels > 1:
  92. final_df_train[1] = final_df_train[1].apply(lambda x: [cv2.imread(path, cv2.IMREAD_GRAYSCALE) for path in x.split('::')])
  93. final_df_val[1] = final_df_val[1].apply(lambda x: [cv2.imread(path, cv2.IMREAD_GRAYSCALE) for path in x.split('::')])
  94. else:
  95. final_df_train[1] = final_df_train[1].apply(lambda x: cv2.imread(x, cv2.IMREAD_GRAYSCALE))
  96. final_df_val[1] = final_df_val[1].apply(lambda x: cv2.imread(x, cv2.IMREAD_GRAYSCALE))
  97. else:
  98. final_df_train[1] = final_df_train[1].apply(lambda x: cv2.imread(x))
  99. final_df_val[1] = final_df_val[1].apply(lambda x: cv2.imread(x))
  100. # reshape array data
  101. final_df_train[1] = final_df_train[1].apply(lambda x: np.array(x).reshape(input_shape))
  102. final_df_val[1] = final_df_val[1].apply(lambda x: np.array(x).reshape(input_shape))
  103. # shuffle data another time
  104. final_df_train = shuffle(final_df_train)
  105. final_df_val = shuffle(final_df_val)
  106. final_df_train_size = len(final_df_train.index)
  107. final_df_val_size = len(final_df_val.index)
  108. validation_split = final_df_val_size / (final_df_train_size + final_df_val_size)
  109. print("----------------------------------------------------------")
  110. print("Validation size is based of `.val` content")
  111. print("Validation split is now set at", validation_split)
  112. print("----------------------------------------------------------")
  113. # use of the whole data set for training
  114. x_dataset_train = final_df_train.iloc[:,1:]
  115. x_dataset_val = final_df_val.iloc[:,1:]
  116. y_dataset_train = final_df_train.iloc[:,0]
  117. y_dataset_val = final_df_val.iloc[:,0]
  118. x_data_train = []
  119. for item in x_dataset_train.values:
  120. #print("Item is here", item)
  121. x_data_train.append(item[0])
  122. x_data_train = np.array(x_data_train)
  123. x_data_val = []
  124. for item in x_dataset_val.values:
  125. #print("Item is here", item)
  126. x_data_val.append(item[0])
  127. x_data_val = np.array(x_data_val)
  128. print("End of loading data..")
  129. print("Train set size (after balancing) : ", final_df_train_size)
  130. print("val set size (after balancing) : ", final_df_val_size)
  131. #######################
  132. # 2. Getting model
  133. #######################
  134. # create backup folder for current model
  135. model_backup_folder = os.path.join(cfg.backup_model_folder, p_output)
  136. if not os.path.exists(model_backup_folder):
  137. os.makedirs(model_backup_folder)
  138. # add of callback models
  139. filepath = os.path.join(cfg.backup_model_folder, p_output, p_output + "-{auc:02f}-{val_auc:02f}__{epoch:02d}.hdf5")
  140. checkpoint = ModelCheckpoint(filepath, monitor='val_auc', verbose=1, save_best_only=True, mode='max')
  141. callbacks_list = [checkpoint]
  142. # check if backup already exists
  143. weights_filepath = None
  144. backups = sorted(os.listdir(model_backup_folder))
  145. if len(backups) > 0:
  146. # retrieve last backup epoch of model
  147. last_model_backup = None
  148. max_last_epoch = 0
  149. for backup in backups:
  150. last_epoch = int(backup.split('__')[1].replace('.hdf5', ''))
  151. if last_epoch > max_last_epoch and last_epoch < p_epochs:
  152. max_last_epoch = last_epoch
  153. last_model_backup = backup
  154. if last_model_backup is None:
  155. print("Epochs asked is already computer. Noee")
  156. sys.exit(1)
  157. initial_epoch = max_last_epoch
  158. print("-------------------------------------------------")
  159. print("Previous backup model found", last_model_backup, "with already", initial_epoch, "done...")
  160. print("Resuming from epoch", str(initial_epoch + 1))
  161. print("-------------------------------------------------")
  162. # load weights
  163. weights_filepath = os.path.join(model_backup_folder, last_model_backup)
  164. print(n_chanels)
  165. model = models.get_model(n_chanels, input_shape, p_tl, weights_filepath)
  166. model.summary()
  167. # concatenate train and validation data (`validation_split` param will do the separation into keras model)
  168. y_data = np.concatenate([y_dataset_train.values, y_dataset_val.values])
  169. x_data = np.concatenate([x_data_train, x_data_val])
  170. y_data_categorical = to_categorical(y_data)
  171. #print(y_data_categorical)
  172. # validation split parameter will use the last `%` data, so here, data will really validate our model
  173. model.fit(x_data, y_data_categorical, validation_split=validation_split, initial_epoch=initial_epoch, epochs=p_epochs, batch_size=p_batch_size, callbacks=callbacks_list)
  174. y_dataset_val_categorical = to_categorical(y_dataset_val)
  175. score = model.evaluate(x_data_val, y_dataset_val_categorical, batch_size=p_batch_size)
  176. print("Accuracy score on val dataset ", score)
  177. if not os.path.exists(cfg.saved_models_folder):
  178. os.makedirs(cfg.saved_models_folder)
  179. # save the model into HDF5 file
  180. model_output_path = os.path.join(cfg.saved_models_folder, p_output + '.json')
  181. json_model_content = model.to_json()
  182. with open(model_output_path, 'w') as f:
  183. print("Model saved into ", model_output_path)
  184. json.dump(json_model_content, f, indent=4)
  185. model.save_weights(model_output_path.replace('.json', '.h5'))
  186. # Get results obtained from model
  187. y_train_prediction = model.predict(x_data_train)
  188. y_val_prediction = model.predict(x_data_val)
  189. # y_train_prediction = [1 if x > 0.5 else 0 for x in y_train_prediction]
  190. # y_val_prediction = [1 if x > 0.5 else 0 for x in y_val_prediction]
  191. y_train_prediction = np.argmax(y_train_prediction, axis=1)
  192. y_val_prediction = np.argmax(y_val_prediction, axis=1)
  193. acc_train_score = accuracy_score(y_dataset_train, y_train_prediction)
  194. acc_val_score = accuracy_score(y_dataset_val, y_val_prediction)
  195. f1_train_score = f1_score(y_dataset_train, y_train_prediction)
  196. f1_val_score = f1_score(y_dataset_val, y_val_prediction)
  197. recall_train_score = recall_score(y_dataset_train, y_train_prediction)
  198. recall_val_score = recall_score(y_dataset_val, y_val_prediction)
  199. pres_train_score = precision_score(y_dataset_train, y_train_prediction)
  200. pres_val_score = precision_score(y_dataset_val, y_val_prediction)
  201. roc_train_score = roc_auc_score(y_dataset_train, y_train_prediction)
  202. roc_val_score = roc_auc_score(y_dataset_val, y_val_prediction)
  203. # save model performance
  204. if not os.path.exists(cfg.results_information_folder):
  205. os.makedirs(cfg.results_information_folder)
  206. perf_file_path = os.path.join(cfg.results_information_folder, cfg.csv_model_comparisons_filename)
  207. # write header if necessary
  208. if not os.path.exists(perf_file_path):
  209. with open(perf_file_path, 'w') as f:
  210. f.write(cfg.perf_train_header_file)
  211. # add information into file
  212. with open(perf_file_path, 'a') as f:
  213. line = p_output + ';' + str(len(dataset_train)) + ';' + str(len(dataset_val)) + ';' \
  214. + str(final_df_train_size) + ';' + str(final_df_val_size) + ';' \
  215. + str(acc_train_score) + ';' + str(acc_val_score) + ';' \
  216. + str(f1_train_score) + ';' + str(f1_val_score) + ';' \
  217. + str(recall_train_score) + ';' + str(recall_val_score) + ';' \
  218. + str(pres_train_score) + ';' + str(pres_val_score) + ';' \
  219. + str(roc_train_score) + ';' + str(roc_val_score) + '\n'
  220. f.write(line)
  221. print("You can now run your model with your own `test` dataset")
  222. if __name__== "__main__":
  223. main()