def get_model(cfg, training=True): tf.keras.backend.set_learning_phase(training) model = None n_classes = len(cfg.CLASSES.keys()) if cfg.model_type == "UNET": model = Unet(backbone_name=cfg.backbone_name, input_shape=cfg.input_shape, classes=n_classes, activation='sigmoid' if n_classes == 1 else 'softmax', weights=None, encoder_weights=cfg.encoder_weights, encoder_freeze=cfg.encoder_freeze, encoder_features=cfg.encoder_features, decoder_block_type=cfg.decoder_block_type, decoder_filters=cfg.decoder_filters, decoder_use_batchnorm=True) elif cfg.model_type == "FPN": model = FPN(backbone_name=cfg.backbone_name, input_shape=cfg.input_shape, classes=n_classes, activation='sigmoid' if n_classes == 1 else 'softmax', weights=None, encoder_weights=cfg.encoder_weights, encoder_freeze=cfg.encoder_freeze, encoder_features=cfg.encoder_features) else: print("Unsupported model type!") exit(1) if cfg.pretrained_model is not None: model.load_weights(cfg.pretrained_model) return model
def simple( img_path='/media/dengpingfan/leone/dpfan/gepeng/Dataset/3Dataset/img', gt_path='/media/dengpingfan/leone/dpfan/gepeng/Dataset/3Dataset/gt', batchSize=7, target_size=(256, 256), epoch=24, lr=0.03, steps_per_epoch=663, model_save_path='./models/FPN/fpn_camouflage_baseline.h5'): seed = 1 data_gen_args = dict(horizontal_flip=True, fill_mode='nearest') img_datagen = ImageDataGenerator(**data_gen_args) data_gen_args['rescale'] = 1. / 255 mask_datagen = ImageDataGenerator(**data_gen_args) img_gen = img_datagen.flow_from_directory(img_path, batch_size=batchSize, target_size=target_size, shuffle=True, class_mode=None, seed=seed) mask_gen = mask_datagen.flow_from_directory(gt_path, color_mode='grayscale', batch_size=batchSize, target_size=target_size, shuffle=True, class_mode=None, seed=seed) train_gen = zip(img_gen, mask_gen) # model = Xnet(backbone_name='vgg16', encoder_weights='imagenet', decoder_block_type='transpose') model = FPN(backbone_name='resnet50', classes=1, activation='sigmoid') print(model.summary()) opt = optimizers.SGD(lr=lr, momentum=0.9, decay=0.0001) model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['binary_accuracy']) save_best = callbacks.ModelCheckpoint(filepath=model_save_path, monitor='loss', save_best_only=True, verbose=1) early_stopping = callbacks.EarlyStopping(monitor='val_loss', patience=30, verbose=2, mode='min') callbacks_list = [save_best, early_stopping] model.fit_generator(train_gen, steps_per_epoch=steps_per_epoch, epochs=epoch, verbose=1, callbacks=callbacks_list)
def define_model(architecture='Unet', BACKBONE='resnet34', input_shape=(None, None, 4),encoder_weights=None): print('In define_model function') if architecture == 'Unet': model = Unet(BACKBONE, classes=3, activation='softmax', encoder_weights=encoder_weights, input_shape=input_shape) print('Unet model defined') elif architecture == 'FPN': model = FPN(BACKBONE, classes=3, activation='softmax', encoder_weights=encoder_weights, input_shape=input_shape) print('FPN model defined') elif architecture == 'Linknet': model = Linknet(BACKBONE, classes=3, activation='softmax', encoder_weights=encoder_weights, input_shape=input_shape) print('Linknet model defined') elif architecture == 'PSPNet': model = PSPNet(BACKBONE, classes=3, activation='softmax', encoder_weights=encoder_weights, input_shape=input_shape) print('PSPNet model defined') return model
def get_model(name, in_shape, n_classes, backend='resnet34'): if name == 'fpn': return FPN(backbone_name=backend, input_shape=in_shape, classes=n_classes, encoder_weights=None) if name == 'unet': return Unet(backbone_name=backend, input_shape=in_shape, classes=n_classes, encoder_weights=None) if name == 'pspnet': return PSPNet50(input_shape=in_shape, n_labels=n_classes) if name == 'deeplab': return Deeplabv3(input_shape=in_shape, classes=n_classes, weights=None) if name == 'biard': return biard_net(in_shape=in_shape, n_classes=n_classes) raise ValueError("Unknown model name")
def save_model_to_json(modeljsonfname): layers = get_feature_layers(backbone_name, 4) if backbone_type == 'FPN': model = FPN(input_shape=(None, None, num_channels), classes=num_mask_channels, encoder_weights=encoder_weights, backbone_name=backbone_name, activation=act_fcn, encoder_features=layers) elif backbone_type == 'Unet': model = Unet(input_shape=(None, None, num_channels), classes=num_mask_channels, encoder_weights=encoder_weights, backbone_name=backbone_name, activation=act_fcn, encoder_features=layers) #model.summary() # serialize model to JSON model_json = model.to_json() with open(modeljsonfname, "w") as json_file: json_file.write(model_json)
def Simple(weight_path='./models/FPN/fpn_camouflage_baseline.h5', img_path=test_dict["CHAMELEON"], target_size=(256, 256), batch_size=1, save_path="./results/FPN/CHAMELEON"): os.makedirs(save_path, exist_ok=True) print(img_path) data_gen_args = dict(fill_mode='nearest') img_datagen = ImageDataGenerator(**data_gen_args) test_gen = img_datagen.flow_from_directory(img_path, batch_size=batch_size, target_size=target_size, shuffle=False, class_mode=None) model = FPN(backbone_name='resnet50', classes=1, activation='sigmoid') # print(model.summary()) model.load_weights(weight_path) # opt = optimizers.Adam(lr=3e-4) # model.compile(optimizer=opt, # loss=bce_dice_loss, # metrics=["binary_crossentropy", mean_iou, dice_coef]) predicted_list = model.predict_generator(test_gen, steps=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=1) img_name_list = test_gen.order_filenames num = 0 for predict in predicted_list: img_name = img_name_list[num].split('/')[1] img_name = img_name.replace('.jpg', '.png') img = Convert(predict) cv2.imwrite(os.path.join(save_path, img_name), img) num += 1 print("[INFO] {}/{}".format(num, len(img_name_list)))
def build_pretrained_model(model_type, backbone_name, encoder_weights, freeze_encoder, activation='sigmoid'): if model_type == "Unet": return Unet(backbone_name=backbone_name, encoder_weights=encoder_weights, freeze_encoder=freeze_encoder, activation=activation) elif model_type == "FPN": return FPN(backbone_name=backbone_name, encoder_weights=encoder_weights, freeze_encoder=freeze_encoder, activation=activation) elif model_type == "Linknet": return Linknet(backbone_name=backbone_name, encoder_weights=encoder_weights, freeze_encoder=freeze_encoder, activation=activation) else: print('Pretrained model type is not supported.') return None
def train(self): # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5) # config = tf.ConfigProto(gpu_options=gpu_options) session_config = tf.ConfigProto(gpu_options=tf.GPUOptions( allow_growth=True, per_process_gpu_memory_fraction=0.6)) session = tf.Session(config=session_config) addresss = self.address warnings.filterwarnings('ignore', category=UserWarning, module='skimage') seed = 42 np.random.seed(10) print('Getting and resizing train images and masks ... ') sys.stdout.flush() counter = 0 self.IMG_WIDTH = 288 # for faster computing on kaggle self.IMG_HEIGHT = 288 # for faster computing on kaggle counter = 0 files_original_name = list() #self.num_bodyparts =1 if len(self.annotated) == 0: wx.MessageBox( 'Did you save your annotation?\n ' 'No annotation found in your file, please save and re-run', 'Error!', wx.OK | wx.ICON_ERROR) self.error = 1 return for i in range(0, len(self.annotated)): files_original_name.append(self.dataFrame[ self.dataFrame.columns[0]]._stat_axis[self.annotated[i]][7:]) img = imread(self.image_folder + os.sep + files_original_name[0]) IMG_CHANNELS = len(np.shape(img)) self.IMG_CHANNELS = IMG_CHANNELS self.file_name_for_prediction_confidence = files_original_name X_train = np.zeros((len( self.annotated), self.IMG_HEIGHT, self.IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8) Y_train = np.zeros((len(self.annotated), self.IMG_HEIGHT, self.IMG_WIDTH, self.num_bodyparts + 1), dtype=np.int) New_train = np.zeros( (len(self.annotated), self.IMG_HEIGHT, self.IMG_WIDTH), dtype=np.int) for l in range(0, len(self.annotated)): img = imread(self.image_folder + os.sep + files_original_name[l]) # mask_ = np.zeros((np.shape(img)[0],np.shape(img)[1],self.num_bodyparts)) mask_ = np.zeros( (np.shape(img)[0], np.shape(img)[1], self.num_bodyparts)) img = resize(img, (self.IMG_HEIGHT, self.IMG_WIDTH), mode='constant', preserve_range=True) X_train[counter] = img for j in range(0, self.num_bodyparts): mask_single_label = np.zeros((mask_.shape[0], mask_.shape[1])) #if annotation was assisted, x is negative points = np.asarray([ self.dataFrame[self.dataFrame.columns[j * 2]].values[ self.annotated[l]], self.dataFrame[self.dataFrame.columns[j * 2 + 1]].values[ self.annotated[l]] ], dtype=float) points = np.abs(points) if np.isnan(points[0]): continue cv2.circle(mask_single_label, (int(round( (points[0] * (2**4)))), int(round(points[1] * (2**4)))), int(round(self.markerSize * (2**4))), (255, 255, 255), thickness=-1, shift=4) mask_[:, :, j] = mask_single_label mask_ = resize(mask_, (self.IMG_HEIGHT, self.IMG_WIDTH), mode='constant', preserve_range=True) a, mask_ = cv2.threshold(mask_, 200, 255, cv2.THRESH_BINARY) mask_ = mask_ / 255.0 if len(np.shape(mask_)) == 2: mask_new = np.zeros( (np.shape(mask_)[0], np.shape(mask_)[1], 1)) mask_new[:, :, 0] = mask_ mask_ = mask_new for j in range(0, self.num_bodyparts): New_train[counter] = New_train[counter] + mask_[:, :, j] * (j + 1) # alternative method to build the ground truth # temp = temp + 1 # temp[temp == 0] = 1 # temp[temp > 1] = 0 # Y_train[counter, :, :,1:] = mask_ # Y_train[counter,:,:,0] = temp counter += 1 # try: Y_train = tf.keras.utils.to_categorical( New_train, num_classes=self.num_bodyparts + 1) except: wx.MessageBox( 'two or more labels are overlapping!\n ' 'Check annotation or re-perform the labeling operation', 'Error!', wx.OK | wx.ICON_ERROR) self.error = 1 return counter = 0 from segmentation_models import get_preprocessing self.processer = get_preprocessing(self.backbone) X_train = self.processer(X_train) print('Done!') from tensorflow.keras.preprocessing import image # Creating the training Image and Mask generator image_datagen = image.ImageDataGenerator(shear_range=0.5, rotation_range=50, zoom_range=0.2, width_shift_range=0.2, height_shift_range=0.2, fill_mode='reflect') mask_datagen = image.ImageDataGenerator(shear_range=0.5, rotation_range=50, zoom_range=0.2, width_shift_range=0.2, height_shift_range=0.2, fill_mode='reflect') # Keep the same seed for image and mask generators so they fit together image_datagen.fit(X_train[:int(X_train.shape[0] * 0.9)], augment=True, seed=seed) mask_datagen.fit(Y_train[:int(Y_train.shape[0] * 0.9)], augment=True, seed=seed) x = image_datagen.flow(X_train[:int(X_train.shape[0] * 0.9)], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) y = mask_datagen.flow(Y_train[:int(Y_train.shape[0] * 0.9)], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) # Creating the validation Image and Mask generator image_datagen_val = image.ImageDataGenerator() mask_datagen_val = image.ImageDataGenerator() image_datagen_val.fit(X_train[int(X_train.shape[0] * 0.9):], augment=True, seed=seed) mask_datagen_val.fit(Y_train[int(Y_train.shape[0] * 0.9):], augment=True, seed=seed) x_val = image_datagen_val.flow(X_train[int(X_train.shape[0] * 0.9):], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) y_val = mask_datagen_val.flow(Y_train[int(Y_train.shape[0] * 0.9):], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) train_generator = zip(x, y) val_generator = zip(x_val, y_val) from segmentation_models import Unet, PSPNet, Linknet, FPN from segmentation_models.losses import CategoricalFocalLoss from segmentation_models.utils import set_trainable import segmentation_models from tensorflow.keras.optimizers import RMSprop, SGD if self.architecture == 'Linknet': self.model = Linknet(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) elif self.architecture == 'unet': self.model = Unet(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) elif self.architecture == 'PSPnet': self.model = PSPNet(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) elif self.architecture == 'FPN': self.model = FPN(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) weights = np.zeros((1, self.num_bodyparts + 1), dtype=float) weight = 1.0 / self.num_bodyparts num_zeros = 1 # while (weight * 100 < 1): # weight = weight * 100 # num_zeros += 1 # # weight = int(weight * 100) / np.power(100, num_zeros) weights[0, 1:] = weight weights[0, 0] = 0.01 * len(self.bodyparts) while weights[0, 0] > weights[0, 1]: weights[0, 0] = weights[0, 0] / 10 num_zeros += 1 for i in range(1, len(self.bodyparts) + 1): weights[0, i] = weights[0, i] - 10**-(num_zeros + 1) if self.loss_function == "Weighted Categorical_cross_entropy": loss = self.weighted_categorical_crossentropy(weights) else: loss = segmentation_models.losses.DiceLoss(class_weights=weights) metric = segmentation_models.metrics.IOUScore(class_weights=weights, per_image=True) self.model.compile(optimizer=RMSprop(lr=self.learning_rate), loss=loss, metrics=[metric]) earlystopper = EarlyStopping(patience=6, verbose=1) # checkpointer = ModelCheckpoint(os.path.join(self.address, 'Unet.h5'), verbose=1, save_best_only=True) reduce_lr = keras.callbacks.LearningRateScheduler(self.lr_scheduler) # # model.fit_generator(train_generator, validation_data=val_generator, validation_steps=10, steps_per_epoch=50, # epochs=2, callbacks=[earlystopper, checkpointer],verbose=1) # model.load_weights(self.address + 'Temp_weights.h5') # set_trainable(model) # self.model.fit_generator( train_generator, validation_data=val_generator, steps_per_epoch=20, validation_steps=5, epochs=100, callbacks=[earlystopper, checkpointer, reduce_lr], verbose=1)
train_generator = AmateurDataFrameDataGenerator(df_train, classes_id=class_ids, batch_size=4, dim_image=dim_image) val_generator = AmateurDataFrameDataGenerator(df_val, classes_id=class_ids, batch_size=4, dim_image=dim_image) # preprocess input # from segmentation_models.backbones import get_preprocessing # preprocess_input = get_preprocessing(BACKBONE) # x_train = preprocess_input(x_train) # x_val = preprocess_input(x_val) # define model model = Unet(BACKBONE, classes=len(class_ids), encoder_weights='imagenet') model = FPN(BACKBONE, classes=len(class_ids), encoder_weights='imagenet') model = PSPNet(BACKBONE, classes=len(class_ids), encoder_weights='imagenet') model = Linknet(BACKBONE, classes=len(class_ids), encoder_weights='imagenet') model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score]) model.summary() modelCheckpoint = keras.callbacks.ModelCheckpoint(filepath='segmod_weights.{epoch:02d}-{val_loss:.4f}.hdf5', monitor='val_loss', verbose=0, save_best_only=False, save_weights_only=False, mode='auto', period=1) reduceLROnPlateau = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=7, verbose=1, mode='auto', min_delta=0.001, cooldown=0, min_lr=10e-7) model.fit_generator(generator=train_generator, steps_per_epoch=None, epochs=10, verbose=1,
input_layer = (config.img_w, config.img_h, config.im_bands) model = Unet(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights) if 'pspnet' in config.network: model = PSPNet(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights) elif 'fpn' in config.network: model = FPN(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights) elif 'linknet' in config.network: model = Linknet(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights) else: pass print(model.summary()) print("Train by : {}_{}".format(config.network, config.BACKBONE)) # sys.exit(-1)
def train_generatorh5(params): from hitif_losses import dice_coef_loss_bce from hitif_losses import double_head_loss print('-' * 30) print('Loading and preprocessing train data...') print('-' * 30) # Prepare for splitting the training set imgs_ind = np.arange(number_of_imgs) np.random.shuffle(imgs_ind) # Split 80-20 train_last_id = int(number_of_imgs * 0.80) # Generators training_generator = DataGeneratorH5( source_target_list_IDs=imgs_ind[0:train_last_id].copy(), **params) validation_generator = DataGeneratorH5( source_target_list_IDs=imgs_ind[train_last_id:number_of_imgs].copy(), **params) print('-' * 30) print('Creating and compiling model...') print('-' * 30) layers = get_feature_layers(backbone_name, 4) if backbone_type == 'FPN': model = FPN(input_shape=(None, None, num_channels), classes=num_mask_channels, encoder_weights=encoder_weights, encoder_freeze=freezeFlag, backbone_name=backbone_name, activation=act_fcn, encoder_features=layers) elif backbone_type == 'Unet': model = Unet(input_shape=(None, None, num_channels), classes=num_mask_channels, encoder_weights=encoder_weights, encoder_freeze=freezeFlag, backbone_name=backbone_name, activation=act_fcn, encoder_features=layers) #model.summary() #model.compile(optimizer=Adam(lr=1e-5), loss='binary_crossentropy', metrics=['binary_crossentropy','mean_squared_error',dice_coef, dice_coef_batch, dice_coef_loss_bce,focal_loss()]) #model.compile(optimizer=Adam(lr=1e-3), loss=dice_coef_loss_bce, metrics=['binary_crossentropy','mean_squared_error',dice_coef, dice_coef_batch,focal_loss()]) #model.compile(optimizer=Adam(lr=1e-3), loss=loss_fcn, metrics=['binary_crossentropy','mean_squared_error',dice_coef, dice_coef_batch,focal_loss()]) if loss_fcn == 'dice_coef_loss_bce': model.compile(optimizer=Adam(lr=1e-3), loss=dice_coef_loss_bce) elif loss_fcn == 'double_head_loss': model.compile(optimizer=Adam(lr=1e-3), loss=double_head_loss) else: model.compile(optimizer=Adam(lr=1e-3), loss=loss_fcn) # Loading previous weights for restarting if oldmodelwtsfname is not None: if os.path.isfile(oldmodelwtsfname) and reloadFlag: print('-' * 30) print('Loading previous weights ...') weights = np.load(oldmodelwtsfname, allow_pickle=True) model.set_weights(weights) #model.load_weights(oldmodelwtsfname) checkpoint_path = get_checkpoint_path(log_dir_name) print("checkpoint_path:", checkpoint_path) model_checkpoint = ModelCheckpoint(checkpoint_path, monitor='val_loss', save_best_only=True, save_weights_only=True) custom_checkpoint = Checkpoints(checkpoint_path, monitor='val_loss', verbose=1) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=25, min_lr=1e-6, verbose=1, restore_best_weights=True) model_es = EarlyStopping(monitor='val_loss', min_delta=1e-7, patience=15, verbose=1, mode='auto') csv_logger = CSVLogger(csvfname, append=True) #my_callbacks = [reduce_lr, model_es, csv_logger] #my_callbacks = [model_checkpoint, reduce_lr, model_es, csv_logger] my_callbacks = [custom_checkpoint, reduce_lr, model_es, csv_logger] print('-' * 30) print('Fitting model encoder freeze...') print('-' * 30) if freezeFlag and num_coldstart_epochs > 0: model.fit_generator(generator=training_generator, validation_data=validation_generator, use_multiprocessing=True, workers=num_gen_workers, epochs=num_coldstart_epochs, callbacks=my_callbacks, verbose=2) # release all layers for training set_trainable(model) # set all layers trainable and recompile model #model.summary() print('-' * 30) print('Fitting full model...') print('-' * 30) ## Retrain after the cold-start model.fit_generator(generator=training_generator, validation_data=validation_generator, use_multiprocessing=True, workers=num_gen_workers, epochs=num_finetuning_epochs, callbacks=my_callbacks, verbose=2) ## <<FIXME>>: GZ will work on it. # Find the last best epoch model weights and then symlink it to the modelwtsfname # Note that the symlink will have issues on NON-Linux OS so it is better to copy. '''
def train(self): seed = 42 # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5) # config = tf.ConfigProto(gpu_options=gpu_options) session_config = tf.ConfigProto(gpu_options=tf.GPUOptions( allow_growth=True, per_process_gpu_memory_fraction=0.6)) session = tf.Session(config=session_config) from segmentation_models import get_preprocessing self.processer = get_preprocessing(self.backbone) X_train = self.processer(self.X_train) Y_train = self.Y_train print('Done!') from tensorflow.keras.preprocessing import image # Creating the training Image and Mask generator image_datagen = image.ImageDataGenerator(shear_range=0.5, rotation_range=50, zoom_range=0.2, width_shift_range=0.2, height_shift_range=0.2, fill_mode='reflect') mask_datagen = image.ImageDataGenerator(shear_range=0.5, rotation_range=50, zoom_range=0.2, width_shift_range=0.2, height_shift_range=0.2, fill_mode='reflect') # Keep the same seed for image and mask generators so they fit together image_datagen.fit(X_train[:int(X_train.shape[0] * 0.9)], augment=True, seed=seed) mask_datagen.fit(Y_train[:int(Y_train.shape[0] * 0.9)], augment=True, seed=seed) x = image_datagen.flow(X_train[:int(X_train.shape[0] * 0.9)], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) y = mask_datagen.flow(Y_train[:int(Y_train.shape[0] * 0.9)], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) # Creating the validation Image and Mask generator image_datagen_val = image.ImageDataGenerator() mask_datagen_val = image.ImageDataGenerator() image_datagen_val.fit(X_train[int(X_train.shape[0] * 0.9):], augment=True, seed=seed) mask_datagen_val.fit(Y_train[int(Y_train.shape[0] * 0.9):], augment=True, seed=seed) x_val = image_datagen_val.flow(X_train[int(X_train.shape[0] * 0.9):], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) y_val = mask_datagen_val.flow(Y_train[int(Y_train.shape[0] * 0.9):], batch_size=self.BATCH_SIZE, shuffle=True, seed=seed) train_generator = zip(x, y) val_generator = zip(x_val, y_val) from segmentation_models import Unet, PSPNet, Linknet, FPN from segmentation_models.losses import CategoricalFocalLoss from segmentation_models.utils import set_trainable import segmentation_models from tensorflow.keras.optimizers import RMSprop, SGD #model = self.model(self.IMG_HEIGHT,self.IMG_WIDTH,self.IMG_CHANNELS) if self.architecture == 'Linknet': self.model = Linknet(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) elif self.architecture == 'unet': self.model = Unet(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) elif self.architecture == 'PSPnet': self.model = PSPNet(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) elif self.architecture == 'FPN': self.model = FPN(self.backbone, classes=self.num_bodyparts + 1, activation='softmax', encoder_weights=self.image_net, input_shape=(self.IMG_WIDTH, self.IMG_HEIGHT, self.IMG_CHANNELS)) weights = np.zeros((1, self.num_bodyparts + 1), dtype=float) weight = 1.0 / self.num_bodyparts num_zeros = 1 # while (weight * 100 < 1): # weight = weight * 100 # num_zeros += 1 # # weight = int(weight * 100) / np.power(100, num_zeros) weights[0, 1:] = weight weights[0, 0] = 0.01 * len(self.bodyparts) while weights[0, 0] > weights[0, 1]: weights[0, 0] = weights[0, 0] / 10 num_zeros += 1 for i in range(1, len(self.bodyparts) + 1): weights[0, i] = weights[0, i] - 10**-(num_zeros + 1) if self.loss_function == "Weighted Categorical_cross_entropy": loss = self.weighted_categorical_crossentropy(weights) else: loss = segmentation_models.losses.DiceLoss(class_weights=weights) metric = segmentation_models.metrics.IOUScore(class_weights=weights, per_image=True) self.model.compile(optimizer=RMSprop(lr=self.learning_rate), loss=loss, metrics=[metric]) earlystopper = EarlyStopping(patience=6, verbose=1) # checkpointer = ModelCheckpoint(os.path.join(self.address, 'Unet.h5'), verbose=1, save_best_only=True) reduce_lr = keras.callbacks.LearningRateScheduler(self.lr_scheduler) # # model.fit_generator(train_generator, validation_data=val_generator, validation_steps=10, steps_per_epoch=50, # epochs=2, callbacks=[earlystopper, checkpointer],verbose=1) # model.load_weights(self.address + 'Temp_weights.h5') # set_trainable(model) # self.model.fit_generator( train_generator, validation_data=val_generator, steps_per_epoch=20, validation_steps=5, epochs=100, callbacks=[earlystopper, checkpointer, reduce_lr], verbose=1)
import tensorflow as tf import numpy as np from segmentation_models import FPN import matplotlib.pyplot as plt model = FPN( backbone_name="mobilenetv2", input_shape=(None, None, 3), classes=7, activation="sigmoid", weights=None, encoder_weights="imagenet", encoder_features="default", pyramid_block_filters=256, pyramid_use_batchnorm=True, pyramid_aggregation="concat", pyramid_dropout=None, ) image = np.load("./data/image.npy") label = np.load("./data/label.npy") model.compile( loss=lambda labels, predictions: tf.keras.losses.binary_crossentropy( labels[:, :, :, 1:], predictions ), optimizer="adam", metrics=["accuracy"], ) model.fit( [image],
if __name__ == '__main__': generator = SegDataGenerator(TRAIN_PATH, ANNO_PATH, batch_size=2, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3), mask_shape=(IMG_HEIGHT, IMG_WIDTH, len(CLASS_COLOR)), preprocessing_function=make_aug, classes_colors=CLASS_COLOR, prob_aug=1) input_layer = Input(shape=(IMG_HEIGHT, IMG_WIDTH, 3)) model = FPN(backbone_name=args.backbone, input_tensor=input_layer, encoder_weights='imagenet', classes=len(CLASS_COLOR), use_batchnorm=True, dropout=0.25, activation='softmax') save_name = 'weights/' + args.backbone + '.h5' callbacks_list = [ ModelCheckpoint(save_name, monitor='loss', verbose=1, save_best_only=True, mode='min', save_weights_only=True), ReduceLROnPlateau(monitor='loss', factor=0.2, patience=2, min_lr=1e-5) ]
encoder_weights=config.weights, n_upsample_blocks=4, decoder_block_type=config.decoder_block_type, classes=config.nb_class, activation=config.activation) elif config.model == "PSPNet": model = PSPNet( backbone_name=config.backbone, encoder_weights=config.weights, #decoder_block_type=config.decoder_block_type, classes=config.nb_class, activation=config.activation) elif config.model == "FPN": model = FPN( backbone_name=config.backbone, encoder_weights=config.weights, #decoder_block_type=config.decoder_block_type, classes=config.nb_class, activation=config.activation) else: raise None model.compile( optimizer="Adam", #optimizer=Adam(lr=1e-4, decay=5e-4) loss=bce_dice_loss, metrics=["binary_crossentropy", mean_iou, dice_coef]) # plot_model(model, to_file=os.path.join(model_path, config.exp_name+".png")) if os.path.exists(os.path.join(model_path, config.exp_name + ".txt")): os.remove(os.path.join(model_path, config.exp_name + ".txt")) with open(os.path.join(model_path, config.exp_name + ".txt"), 'w') as fh: model.summary(positions=[.3, .55, .67, 1.], print_fn=lambda x: fh.write(x + '\n'))
assert len(train_generator.cat_ids) == len(val_generator.cat_ids) else: assert False # preprocess input # from segmentation_models.backbones import get_preprocessing # preprocess_input = get_preprocessing(BACKBONE) # x_train = preprocess_input(x_train) # x_val = preprocess_input(x_val) # define model #model = Unet(BACKBONE, classes=number_of_classes, encoder_weights='imagenet',activation='softmax') # model = Linknet(BACKBONE, classes=number_of_classes, encoder_weights='imagenet') model = FPN(BACKBONE, classes=number_of_classes, encoder_weights='imagenet',activation='softmax') # model = PSPNet(BACKBONE, classes=number_of_classes, encoder_weights='imagenet') # for multiclass segmentation choose another loss and metric model.compile('Adam', loss='categorical_crossentropy', metrics=['categorical_accuracy']) #model.compile('Adam', loss=cce_jaccard_loss, metrics=[jaccard_score]) model.summary() #from keras.utils import plot_model #plot_model(model, to_file='model.png') modelCheckpoint = keras.callbacks.ModelCheckpoint(filepath=model_checkpoint_prefix+'_weights.{epoch:02d}-{val_loss:.4f}.hdf5',
reduceLROnPlateau = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, verbose=1, mode='auto', min_delta=0.01, cooldown=0, min_lr=10e-7) ''' Some times, it is useful to train only randomly initialized decoder in order not to damage weights of properly trained encoder with huge gradients during first steps of training. In this case, all you need is just pass freeze_encoder = True argument while initializing the model. ''' freeze_encoder = True if os.name == 'nt': freeze_encoder = False if number_of_classes > 1: if architecture == 'PSP': model = PSPNet(backbone, input_shape=dim_image, classes=number_of_classes, encoder_weights='imagenet', activation='softmax', freeze_encoder=freeze_encoder) elif architecture == 'FPN': model = FPN(backbone, input_shape=dim_image, classes=number_of_classes, encoder_weights='imagenet', activation='softmax', freeze_encoder=freeze_encoder) else: assert False model.compile('Adam', loss='categorical_crossentropy', metrics=['categorical_accuracy']) model.summary() else: assert 1 == number_of_classes if architecture == 'PSP': model = PSPNet(backbone, input_shape=dim_image, classes=1, encoder_weights='imagenet', activation='sigmoid', freeze_encoder=freeze_encoder) elif architecture == 'FPN': model = FPN(backbone, input_shape=dim_image, classes=1, encoder_weights='imagenet', activation='sigmoid', freeze_encoder=freeze_encoder) elif architecture == 'Linknet': model = Linknet(backbone, input_shape=dim_image, classes=1, encoder_weights='imagenet', activation='sigmoid', freeze_encoder=freeze_encoder) elif architecture == 'Unet': model = Unet(backbone, input_shape=dim_image, classes=1, encoder_weights='imagenet', activation='sigmoid', freeze_encoder=freeze_encoder) else:
model = None if model_type == "unet": model = Unet( model_backbone, classes=2, input_shape=(input_size[0], input_size[1], 3), encoder_weights=model_weights, decoder_filters=unet_filters, activation="softmax", ) elif model_type == "fpn": model = FPN( model_backbone, classes=2, input_shape=(input_size[0], input_size[1], 3), encoder_weights=model_weights, pyramid_block_filters=fpn_filters, pyramid_dropout=fpn_dropout, activation="softmax", ) model.summary() model.compile( optimizer=optimizer, loss=globals()[loss], metrics=["accuracy", dice_coef, segmentation_models.metrics.iou_score], ) # Choose checkpoint path checkpoint_path = "./Weights/"
from segmentation_models import get_preprocessing from segmentation_models.losses import bce_jaccard_loss from segmentation_models.metrics import iou_score from tensorflow.keras.datasets import mnist BACKBONE = 'resnet34' preprocess_input = get_preprocessing(BACKBONE) # load your data (x_train, y_train),( x_val, y_val) = mnist.load_data() # preprocess input x_train = preprocess_input(x_train) x_val = preprocess_input(x_val) # define model model = FPN(BACKBONE, input_shape=(224, 224, 6),classes=9, encoder_weights=None) model.compile('Adam', loss=bce_jaccard_loss, metrics=[iou_score]) # fit model model.fit( x=x_train, y=y_train, batch_size=16, epochs=100, validation_data=(x_val, y_val), )
#################################################### ############# Set model parameters ################# #################################################### if model_name == 'Unet': model = Unet(backbone_name=backbone_name, classes=n_classes, activation='softmax') elif model_name == 'PSPNet': model = PSPNet(backbone_name=backbone_name, classes=n_classes, activation='softmax') elif model_name == 'FPN': model = FPN(backbone_name=backbone_name, classes=n_classes, activation='softmax') elif model_name == 'Linknet': model = Linknet(backbone_name=backbone_name, classes=n_classes, activation='softmax') else: print('Please provide the right model name') model.compile('Adam', loss='categorical_crossentropy', metrics=['categorical_accuracy']) #################################################### ############# Training model ####################### ####################################################
out = Conv2D(3, kernel_size=3, activation=active3, padding='same', kernel_initializer='he_normal')(l5) # out= Conv2D(1, kernel_size=k_3, activation='relu', padding='same', kernel_initializer='he_normal',name="nothing")(out1) model = Model(inp, out, name='shallow') elif k_mod == "FPN": # N = x_train.shape[-1] if N == 3: model = FPN(BACKBONE, input_shape=(size, size, 3), classes=3, activation='softmax', encoder_weights='imagenet', encoder_freeze=False) else: base_model = FPN(BACKBONE, input_shape=(size, size, 3), classes=3, activation='softmax', encoder_weights='imagenet', encoder_freeze=False) inp = Input(shape=(size, size, N)) bn = BatchNormalization()(inp) l1 = Conv2D(3, (1, 1))( bn) # map N channels data to 3 channels out = base_model(l1) model = Model(inp, out, name=base_model.name)