# epoch_log=epoch_log, # x_test=x_test, # on_epoch_end=lambda epoch, logs, epoch_log, x_test: eval_epoch(epoch_log, x_test, epoch, logs), # on_train_end=lambda logs: epoch_log.close() #) #def eval_epoch(epoch_log, x_test, epoch, logs): # """ Write loss to a log and predict on sample images """ # epoch_log.write( # json.dumps({'epoch': epoch, 'loss': logs['loss']}) + '\n') # cv2.imwrite("../training_visualisations/test_epoch_{}.png".format(epoch), model.predict(x_test[1])) # Define model model = sm.Unet(BACKBONE, encoder_weights='imagenet', input_shape=(None, None, img_n_channels)) model.compile('Adam', loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score]) print("fitting model...") # fit model model.fit_generator( generator=training_generator, epochs=200, steps_per_epoch=50, validation_data=validation_generator, validation_steps=10, callbacks=[PredOnEpochEnd(logs_dir, x_train=train_sample, x_test=test_sample, pred_path=train_vis_dir, run_id=run_id), model_save_checkpoint], use_multiprocessing=True )
import keras, cv2 import pandas as pd from tta_wrapper import tta_segmentation import segmentation_models as sm from data import DataGenerator from utils import post_process, mask2rle sub_df = pd.read_csv('../data/sample_submission.csv') sub_df['ImageId'] = sub_df['Image_Label'].apply(lambda x: x.split('_')[0]) test_imgs = pd.DataFrame(sub_df['ImageId'].unique(), columns=['ImageId']) # # Predict on Test Set model1 = sm.Unet('efficientnetb4', classes=4, input_shape=(320, 480, 3), activation='sigmoid') model1.load_weights('../efn_unet.h5') model2 = sm.Unet('resnet18', classes=4, input_shape=(320, 480, 3), activation='sigmoid') model2.load_weights('../resnet18_unet.h5') model3 = sm.Unet('densenet121', classes=4, input_shape=(320, 480, 3), activation='sigmoid') model3.load_weights('../dense_unet.h5') model1 = tta_segmentation(model1, h_flip=True, h_shift=(-10, 10), merge='mean') model2 = tta_segmentation(model2, h_flip=True, h_shift=(-10, 10), merge='mean') model3 = tta_segmentation(model3, h_flip=True, h_shift=(-10, 10), merge='mean')
n += 1 return 'weights/best_weights_{}.hdf5'.format(n) callbacks = [ ModelCheckpoint(monitor='val_loss', filepath=verify_model(), save_best_only=True, save_weights_only=True, verbose=1), TensorBoard(log_dir='logs') ] data_train = list_dir('input/train') data_valid = list_dir('input/valid') model = sm.Unet('resnet101', encoder_weights='imagenet') model.compile( 'Adam', loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score], ) model.fit(train_generator(), callbacks=callbacks, verbose=1, epochs=100, steps_per_epoch=np.ceil(float(len(data_train)) / float(16)), validation_data=valid_generator(), validation_steps=np.ceil(float(len(data_valid)) / float(16)))
######################################################################## BACKBONE1 = 'resnet34' preprocess_input1 = sm.get_preprocessing(BACKBONE1) # preprocess input X_train1 = preprocess_input1(X_train) X_test1 = preprocess_input1(X_test) ##################################################################### ###Model 1 #Using same backbone for both models # define model (Change to unet or Linknet based on the need ) model1 = sm.Unet(BACKBONE1, encoder_weights='imagenet', classes=n_classes, activation=activation) # compile keras model with defined optimozer, loss and metrics model1.compile(optim, total_loss, metrics=metrics) #model1.compile(optimizer='adam', loss='categorical_crossentropy', metrics=metrics) print(model1.summary()) start1 = datetime.now() history1 = model1.fit(X_train1, y_train_cat, batch_size=8, epochs=50,
if gpus: # Restrict TensorFlow to only use the first GPU try: tf.config.experimental.set_visible_devices(gpus[GPU_GLOBAL], 'GPU') except RuntimeError as e: # Visible devices must be set at program startup print(e) print(gpus) ################################################## BACKBONE = 'resnet34' preprocess_input = sm.get_preprocessing(BACKBONE) # define model model = sm.Unet(BACKBONE, encoder_weights='imagenet') model.compile( 'Adam', loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score], ) inicio = time.time() ####### treinamento model.fit( x=x_train, y=y_train, batch_size=BATCH_SIZE_GLOBAL, epochs=NUMERO_EPOCAS_GLOBAL, validation_data=(x_val, y_val),
! unzip Val.zip ! pip install -U segmentation-models import segmentation_models as sm import keras from keras import optimizers from keras.preprocessing.image import ImageDataGenerator keras.backend.set_image_data_format('channels_last') import os !nvidia-smi ############ online learning ########################## ############ run the block at bottom first########## model = sm.Unet('resnet34',classes=1, activation='sigmoid',input_shape=(None, None, 3)) # for layer in model.layers: # layer.trainable=True # layerName=str(layer.name) # if layerName.startswith("decoder") or layerName.startswith("Final_"): # layer.trainable=True # else: layer.trainable=False #freeze/unfreeze the encoder folder = 'kite-surf' sgd = optimizers.SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True) model.compile(optimizer=sgd,loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score],) load_shot(folder,'00') train_generator, val_generator = val_loader(folder) model.load_weights('drive/My Drive/65iou.h5') #load parent model history = model.fit_generator(
def TheModel(batch_size_, restore): dataset = input_fn(batch_size_, datasettype='train') datasetval = input_fn(batch_size_, datasettype='validation') train_set = 'PASCAL' set_partition = 1 if train_set == 'LIP': t_steps = int(set_partition * (30462 / batch_size_)) v_steps = int(set_partition * (10000 / batch_size_)) elif train_set == 'PASCAL': t_steps = int(set_partition * (1716 / batch_size_)) v_steps = int(set_partition * (1817 / batch_size_)) BACKBONE = 'efficientnetb3' CLASSES = ['background', 'torso', 'head', 'arms', 'hands', 'legs', 'feet'] LR = 0.0001 EPOCHS = 10 # define network parameters n_classes = (len(CLASSES) + 1 ) # case for binary and multiclass segmentation activation = 'softmax' optim = k.optimizers.Adam(LR) #create model model = sm.Unet(BACKBONE, classes=n_classes, activation=activation) # Segmentation models losses can be combined together by '+' and scaled by integer or float factor # set class weights for dice_loss (car: 1.; pedestrian: 2.; background: 0.5;) #dice_loss = sm.losses.DiceLoss(class_weights=np.array([0.3, 1, 1, 1, 1, 1, 1])) #focal_loss = sm.losses.CategoricalFocalLoss() #total_loss = dice_loss + focal_loss total_loss = sm.losses.categorical_focal_dice_loss # actulally total_loss can be imported directly from library, above example just show you how to manipulate with losses # total_loss = sm.losses.binary_focal_dice_loss # or sm.losses.categorical_focal_dice_loss metrics = [ sm.metrics.IOUScore(threshold=0.5), sm.metrics.FScore(threshold=0.5) ] # compile keras model with defined optimozer, loss and metrics model.compile(optim, total_loss, metrics) customcallbacks = [ k.callbacks.ModelCheckpoint('./best_model.h5', save_weights_only=True, save_best_only=True, mode='min'), k.callbacks.ReduceLROnPlateau(), ] # train model history = model.fit_generator( dataset, steps_per_epoch=t_steps, epochs=EPOCHS, callbacks=customcallbacks, validation_data=datasetval, validation_steps=v_steps, ) # Plot training & validation iou_score values plt.figure(figsize=(30, 5)) plt.subplot(121) plt.plot(history.history['iou_score']) plt.plot(history.history['val_iou_score']) plt.title('Model iou_score') plt.ylabel('iou_score') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') # Plot training & validation loss values plt.subplot(122) plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.show() # #create model # model = sm.Unet(BACKBONE, classes=n_classes, activation=activation) # #Get training dataset # dataset=input_fn(batch_size_,datasettype = 'train') # #Get Validation dataset # datasetval = input_fn(batch_size_,datasettype = 'validation') # #Defining the resulting metrics # metrics =[fn1,fn2,fn3,fn4,fn5,fn6,fn7] # train_set = 'PASCAL' # LIP or PASCAL # set_partition = 1 # if train_set == 'LIP': # t_steps = int(set_partition*(30462/batch_size_)) # v_steps = int(set_partition*(10000/batch_size_)) # elif train_set == 'PASCAL': # t_steps = int(set_partition*(1716/batch_size_)) # v_steps = int(set_partition*(1817/batch_size_)) # #Restoring model possibility # if restore == True: # model = tf.contrib.saved_model.load_keras_model('./saved_models/1561026721') # else: # #The Model with Resnet50, BatchNorm, SGD optimizer and Categorical Cross-entropy Loss # model=tf.keras.models.Sequential() # inputs=tf.keras.layers.Input(shape=(250,250,3)) # model.add(ResNet50(include_top=False, weights='imagenet',input_tensor=inputs, pooling=None, classes = 7)) # model.add(tf.keras.layers.Conv2D(7,(1,1))) # model.add(layers.BatchNormalization()) # model.add(tf.keras.layers.Lambda(lambda x: tf.image.resize_bilinear(x,(250,250)))) # model.summary() # learning_rate = 0.002 # sgd = tf.keras.optimizers.SGD(learning_rate, momentum=0.8, nesterov=True) # model.compile(optimizer=sgd, #SGD with momemtum usually gives good enough results without too many parameters as is the case for ADAMoptimizer # loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits = True), # metrics=metrics) # history=model.fit(dataset,validation_data = datasetval, epochs=10, steps_per_epoch=t_steps,validation_steps=v_steps) # 2975 Training Images - 1525 Test Images - 500 validation Images # #Saving the model after training # saved_model_path = tf.contrib.saved_model.save_keras_model(model, "./saved_models/saved_model_test7bigsparse") return model
FScore(threshold=cfg.metric_threshold, per_image=cfg.metric_per_image), Precision(threshold=cfg.metric_threshold, per_image=cfg.metric_per_image), Recall(threshold=cfg.metric_threshold, per_image=cfg.metric_per_image), TruePositives(thresholds=cfg.metric_threshold), TrueNegatives(thresholds=cfg.metric_threshold), FalsePositives(thresholds=cfg.metric_threshold), FalseNegatives(thresholds=cfg.metric_threshold) ] # with mirrored_strategy.scope(): model = sm.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) model.compile(optim, loss, metrics) callbacks = [ ModelCheckpoint( cfg.base_model_path + ".{epoch:03d}-{val_loss:.6f}.h5", monitor='val_loss', # verbose=1, save_best_only=(not cfg.SAVE_ALL_MODELS), save_weights_only=False,
BACKBONE = 'densenet121' #'densenet121'fenadeğil #'resnet101' #'resnet34' #'efficientnetb6' #'inceptionresnetv2' BATCH_SIZE = 16 CLASSES = ['dolins'] LR = 0.0001 #0.0001 best for adam EPOCHS = 100 preprocess_input = sm.get_preprocessing(BACKBONE) #create model model = sm.Unet(BACKBONE, classes=1, activation="sigmoid") # load best weights model.load_weights("/content/drive/MyDrive/Dolin_Segmentation/results/densenet121/best_model.h5") image_path="/content/drive/MyDrive/Dolin_Segmentation/test_image.png" c=cv2.imread(image_path) plt.imshow(c) plt.show() print(c.shape) #---------------------------------------------------------------------------------------------------- import cv2 import matplotlib.pyplot as plt import numpy as np import os
n_classes=4 ) val_generator = DataGenerator( val_idx, df=mask_count_df, target_df=train_df, batch_size=BATCH_SIZE, reshape=(320, 480), augment=False, n_channels=3, n_classes=4 ) model = sm.Unet( 'resnet34', classes=4, input_shape=(320, 480, 3), activation='sigmoid' ) model.compile(optimizer=Nadam(lr=0.0002), loss=bce_dice_loss, metrics=[dice_coef]) model.summary() checkpoint = ModelCheckpoint('model.h5', save_best_only=True) history = model.fit_generator( train_generator, validation_data=val_generator, callbacks=[checkpoint], epochs=30 ) with open('history.json', 'w') as f: json.dump(history.history, f)
BACKBONE = 'resnet34' preprocess_input = sm.get_preprocessing(BACKBONE) # load your data x_train, y_train = ld_data( "/Users/abhinav/Documents/Foot Data and Manipulations/Training/AugmentedDataset/" ), ld_data( "/Users/abhinav/Documents/Foot Data and Manipulations/Training/AugmentedAnnotations/" ) # preprocess input # x_train = preprocess_input(x_train) # x_val = preprocess_input(x_val) # define model model = sm.Unet(BACKBONE, classes=2, encoder_weights='imagenet') model.compile( 'Adam', loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score], ) # fit model # if you use data generator use model.fit_generator(...) instead of model.fit(...) # more about `fit_generator` here: https://keras.io/models/sequential/#fit_generator model.fit( x=x_train, y=y_train, #batch_size=16, epochs=100, steps_per_epoch=5
def unet_train(): BACKBONE = 'efficientnetb0' model = sm.Unet(BACKBONE, encoder_weights='imagenet', classes=1) image_datagen = ImageDataGenerator( **aug_dict, preprocessing_function=normalize_classif) mask_datagen = ImageDataGenerator(**aug_dict, preprocessing_function=normalize_classif) val_image_datagen = ImageDataGenerator( {}, preprocessing_function=normalize_classif) val_mask_datagen = ImageDataGenerator( {}, preprocessing_function=normalize_classif) seed = 1 STEP_SIZE_TRAIN = TRAIN_SIZE // BATCH_SIZE STEP_SIZE_VALID = VALID_SIZE // BATCH_SIZE image_generator = image_datagen.flow_from_directory( join(data_path, 'classification'), target_size=IMG_SIZE, classes=['training_images'], class_mode=None, seed=seed, batch_size=BATCH_SIZE, color_mode='rgb') mask_generator = mask_datagen.flow_from_directory( join(data_path, 'classification'), classes=['training_labels'], target_size=IMG_SIZE, class_mode=None, seed=seed, batch_size=BATCH_SIZE, color_mode='rgb') val_image_generator = val_image_datagen.flow_from_directory( data_path, classes=['validation_images_cancer'], target_size=IMG_SIZE, class_mode=None, seed=seed, batch_size=BATCH_SIZE, color_mode='rgb') val_mask_generator = val_mask_datagen.flow_from_directory( data_path, classes=['validation_labels_cancer'], target_size=IMG_SIZE, class_mode=None, seed=seed, batch_size=BATCH_SIZE, color_mode='rgb') train_generator = zip(image_generator, mask_generator) val_generator = zip(val_image_generator, val_mask_generator) model_checkpoint = ModelCheckpoint('unet_16_efc_all.hdf5', monitor='loss', save_best_only=True, period=1) tensorboard_callback = TensorBoard(log_dir='./logs/unet_16') drop_alpha = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5) model.compile(optimizer=Adam(lr=learning_rate), loss=wbce_loss, metrics=my_metrics) model.fit(train_generator, validation_data=val_generator, epochs=EPOCHS, verbose=1, steps_per_epoch=STEP_SIZE_TRAIN, validation_steps=STEP_SIZE_VALID, callbacks=[model_checkpoint, tensorboard_callback, drop_alpha])
if not os.path.exists(y_valid_dir): raise ValueError( 'The dataset path \'{dataset_path}\' does not contain a folder named validation_annotated.' .format(dataset_path=args.dataset_path)) # Build the model backbones = ['efficientnetb5', 'mobilenetv2', 'efficientnetb3'] if (args.backbone not in backbones): raise ValueError( 'The backbone \'{backbone}\' does not exist. Choose mobilenetv2 or efficientnetb5' .format(backbone=args.backbone)) model = sm.Unet(args.backbone, input_shape=(480, 320, 3), classes=1, activation='sigmoid', decoder_filters=(128, 64, 32, 16, 8)) preprocess_input = sm.get_preprocessing(args.backbone) optimizer = keras.optimizers.Adam(args.learning_rate) model.compile(optimizer, sm.losses.binary_focal_dice_loss, [sm.metrics.IOUScore(threshold=0.5)]) # Dataset for training images train_dataset = Dataset( x_train_dir, y_train_dir, classes=['Avalanche'],
batch_size = 8 myGene = trainGenerator(batch_size, data_dir, 'train_images', 'train_labels', data_gen_args_val, save_to_dir=None) myGeneval = trainGenerator(batch_size, data_dir, 'val_images', 'val_labels', data_gen_args_val, save_to_dir=None) model = sm.Unet('efficientnetb4', input_shape=(512, 512, 3), classes=1, activation='sigmoid', encoder_weights='imagenet') model.summary() model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-3), loss=sm.losses.DiceLoss(), metrics=[sm.metrics.iou_score, dice_coef, 'accuracy']) model_checkpoint = ModelCheckpoint('segmentation.h5', monitor='val_loss', verbose=1, save_best_only=True) model.fit_generator(myGene, validation_data=myGeneval, epochs=100, callbacks=[model_checkpoint], steps_per_epoch=int((2075 * 2) // batch_size),
if __name__ == '__main__': if not os.path.isdir(config.train_data_path): print("train data does not exist in the path:\n {}".format( config.train_data_path)) sys.exit(-1) if len(config.band_list) == 0: print("Error: band_list should not be empty!") sys.exit(-2) input_layer = (config.img_w, config.img_h, len(config.band_list)) if 'unet' in config.network: model = sm.Unet(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights) elif 'pspnet' in config.network: model = sm.PSPNet(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights, psp_dropout=config.dropout) elif 'fpn' in config.network: model = sm.FPN(backbone_name=config.BACKBONE, input_shape=input_layer, classes=config.nb_classes, activation=config.activation, encoder_weights=config.encoder_weights,
height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") with h5py.File("dataset/Training/bgr_comp_hand_segmentation_data.h5", "r") as hdf: data = hdf.get("images") images = np.array(data) data2 = hdf.get("masks") annotations = np.array(data2) # model = unet2(input_size=(128, 128, 3)) model = sm.Unet(BACKBONE, classes=1, input_shape=(256, 256, 3)) # model = sm.FPN(backbone_name=BACKBONE, encoder_weights='imagenet', # activation='sigmoid', classes=1, pyramid_dropout=0.5) model.compile(optimizer=Adam(lr=0.0001), loss=sm.losses.jaccard_loss, metrics=[mean_iou]) train_steps = len(images) // batch_size test_steps = len(annotations) // batch_size train_generator = get_segmentation_generator_flow(images[:750], annotations[:750], target_size, batch_size,
data_manager = BatchManager(256, 256, './dataset/data/images/', './dataset/data/masks/') x_train, y_train = data_manager.get_data() valid_manager = BatchManager(256, 256, './dataset/valid/images/', './dataset/valid/masks/') x_val, y_val = valid_manager.get_data() print('Reading complete') x_train = preprocess_input(x_train) y_train = preprocess_input(y_train) model = sm.Unet(backbone, classes=1, activation='sigmoid', encoder_weights='imagenet') # dice_loss = sm.losses.DiceLoss() # focal_loss = sm.losses.BinaryFocalLoss() # total_loss = dice_loss + (1 * focal_loss) # metrics = [sm.metrics.IOUScore(threshold=0.5), sm.metrics.FScore(threshold=0.5)] # model.compile('Adam', total_loss, metrics) model.compile( 'Adam', loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score], )
#orig = cv2.imread('./data/test_images/test_2.jpg') #orig = cv2.imread('./data/test_images/58-05-008.png') orig = cv2.imread('./data/test_images/geo-eye.tif') #image = cv2.merge((orig, orig, orig)) #orig = cv2.imread('./data/test_images/yangambi_orthomosaic_modified.jpg') image = cv2.cvtColor(orig, cv2.COLOR_BGR2RGB) # define network parameters n_classes = 1 if len(CLASSES) == 1 else (len(CLASSES) + 1) # case for binary and multiclass segmentation activation = 'sigmoid' if n_classes == 1 else 'softmax' #create model model = sm.Unet( BACKBONE, classes=n_classes, activation=activation, #encoder_weights='imagenet' ) # define optomizer optim = keras.optimizers.Adam(LR) # Segmentation models losses can be combined together by '+' and scaled by integer or float factor dice_loss = sm.losses.DiceLoss() focal_loss = sm.losses.BinaryFocalLoss() if n_classes == 1 else sm.losses.CategoricalFocalLoss() total_loss = dice_loss + (1 * focal_loss) metrics = [sm.metrics.IOUScore(threshold=0.5), sm.metrics.FScore(threshold=0.5)] # compile keras model with defined optimozer, loss and metrics model.compile(optim, total_loss, metrics)
def main(): global args args = parse_args() torch.backends.cudnn.benchmark = True args.distributed = False if 'WORLD_SIZE' in os.environ: args.distributed = int(os.environ['WORLD_SIZE']) > 1 args.gpu = 0 args.world_size = 1 if args.distributed: args.gpu = args.local_rank torch.cuda.set_device(args.gpu) torch.distributed.init_process_group(backend='nccl', init_method='env://') args.world_size = torch.distributed.get_world_size() assert torch.backends.cudnn.enabled, 'Amp requires cudnn backend to be enabled.' to_save = Path(args.save) path_to_load = Path(args.load) if path_to_load.is_file(): print(f"=> Loading checkpoint '{path_to_load}'") checkpoint = torch.load( path_to_load, map_location=lambda storage, loc: storage.cuda(args.gpu)) print(f"=> Loaded checkpoint '{path_to_load}'") else: raise args = checkpoint['args'] print(args) n_classes = args.n_classes if args.cls: print('With classification') else: print('Without classification') model = smp.Unet(encoder_name=args.encoder, encoder_weights='imagenet', classes=n_classes, activation='sigmoid', n_classes=n_classes if args.cls else None) if args.sync_bn: print('using apex synced BN') model = apex.parallel.convert_syncbn_model(model) model.cuda() # Initialize Amp. Amp accepts either values or strings for the optional override arguments, # for convenient interoperation with argparse. if args.fp16: model = apex.amp.initialize( model, opt_level=args.opt_level, keep_batchnorm_fp32=args.keep_batchnorm_fp32, loss_scale=args.loss_scale) # For distributed training, wrap the model with apex.parallel.DistributedDataParallel. # This must be done AFTER the call to amp.initialize. If model = DDP(model) is called # before model, ... = amp.initialize(model, ...), the call to amp.initialize may alter # the types of model's parameters in a way that disrupts or destroys DDP's allreduce hooks. if args.distributed: # By default, apex.parallel.DistributedDataParallel overlaps communication with # computation in the backward pass. # model = DDP(model) # delay_allreduce delays all communication to the end of the backward pass. model = apex.parallel.DistributedDataParallel(model, delay_allreduce=True) # work_dir = Path(args.work_dir) work_dir = path_to_load.parent model.load_state_dict(checkpoint['state_dict']) path_to_data = Path(args.data) _, dev_gps = get_data_groups(path_to_data / 'train.csv.zip', args) dev_ds = SeverStalDS(dev_gps, root=path_to_data / 'train', transform=dev_transform) dev_sampler = None if args.distributed: dev_sampler = torch.utils.data.distributed.DistributedSampler(dev_ds) batch_size = args.batch_size dev_loader = torch.utils.data.DataLoader(dev_ds, batch_size=min(batch_size, 16), shuffle=False, sampler=dev_sampler, num_workers=4, collate_fn=collate_fn, pin_memory=True) metric = Dice(n_classes=n_classes, thresh=0.5) x = torch.rand(2, 3, 256, 256).cuda() model = model.eval() model.encoder.set_swish(memory_efficient=False) with torch.no_grad(): traced_model = torch.jit.trace(model, x) traced_model.save(str(work_dir / f'model_{path_to_load.stem}.pt')) del traced_model del model model = torch.jit.load(str(work_dir / f'model_{path_to_load.stem}.pt')).cuda().eval() with torch.no_grad(): metric.clean() trgs, preds, preds_cls = epoch_step(dev_loader, f'[ Validating dev.. ]', model=model, metric=metric) print(f'dice dev {metric.evaluate()}') if str(to_save) == '': return to_save1 = to_save / 'pred_masks_tta' if not to_save1.exists(): to_save1.mkdir(parents=True) to_save2 = to_save / 'pred_clss_tta' if not to_save2.exists(): to_save2.mkdir(parents=True) with tqdm.tqdm(zip(dev_gps, preds, preds_cls), total=len(preds)) as pbar: for (fname, _), p1, p2 in pbar: np.save(to_save1 / fname, p1) np.save(to_save2 / fname, p2)
import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split from data import * from unet import * from dense_unet import * from config import * from metrics import * from pretrained_backbone_unet import * import segmentation_models as sm sm.set_framework('tf.keras') #STANDARD UNET #model = create_unet_model(SHAPE) MODEL_ARCHITECTURE = sm.Unet('vgg19', encoder_weights='imagenet') def plot_images(dataset): for x, y in dataset: print(x.shape) print(y.shape) print(x[0][125]) print(y[0][125]) plt.figure(figsize=(10, 10)) img = x[0] plt.subplot(1, 2, 1)
n_channels=3, n_classes=4) val_generator = DataGenerator( val_idx, df=mask_count_df, target_df=train_df, batch_size=BATCH_SIZE, reshape=(320, 480), augment=False, n_channels=3, n_classes=4) model = sm.Unet( 'efficientnetb3', classes=4, input_shape=(320, 480, 3), activation='sigmoid' ) model.compile(optimizer=Nadam(lr=0.0002), loss=loss.bce_dice_loss, metrics=[loss.dice_coef]) model.summary() train_metric_callback = PrAucCallback(train_generator) val_callback = PrAucCallback(val_generator, stage='val') #fpath = 'weights.{epoch:02d}-{loss:.2f}-{dice_coef:.2f}-{val_loss:.2f}-{val_dice_coef:.2f}.hdf5' #checkpoint = ModelCheckpoint(os.path.join(args.out_path, fpath), save_best_only=True, monitor='val_loss', period=1) history = model.fit_generator( train_generator, validation_data=val_generator, callbacks=[train_metric_callback, val_callback],, epochs=30,
tf.keras.backend.set_image_data_format('channels_last') img_w = 256 img_h = 256 models_string = ['inceptionv3', 'senet154', 'vgg16'] models = [] preproc_fs = [] for model_string in models_string: models.append( sm.Unet(model_string, classes=3, activation='softmax', input_shape=(img_h, img_w, 3), encoder_weights=None)) preproc_fs.append(sm.get_preprocessing(model_string)) firstTentative = NeuralNetworkFlow( seed=1996, dataset_path='/content/Development_Dataset/Training', n_classes=3, out_h=img_h, out_w=img_w, img_h=img_h, img_w=img_w, batch_size=32, n_test_images=15) firstTentative.apply_data_augmentation()
def train(weights_paths, model_name="unet", batch_size=16, loss_name="bce"): BATCH_SIZE = batch_size # for reference about the BUFFER_SIZE in shuffle: # https://stackoverflow.com/questions/46444018/meaning-of-buffer-size-in-dataset-map-dataset-prefetch-and-dataset-shuffle BUFFER_SIZE = 1000 dataset = {"train": train_dataset, "val": val_dataset} # -- Train Dataset --# dataset['train'] = dataset['train'].map( load_image_train, num_parallel_calls=tf.data.experimental.AUTOTUNE) dataset['train'] = dataset['train'].shuffle(buffer_size=BUFFER_SIZE, seed=SEED) dataset['train'] = dataset['train'].repeat() dataset['train'] = dataset['train'].batch(BATCH_SIZE) dataset['train'] = dataset['train'].prefetch(buffer_size=AUTOTUNE) #-- Validation Dataset --# dataset['val'] = dataset['val'].map(load_image_test) dataset['val'] = dataset['val'].repeat() dataset['val'] = dataset['val'].batch(BATCH_SIZE) dataset['val'] = dataset['val'].prefetch(buffer_size=AUTOTUNE) print(dataset['train']) print(dataset['val']) if model_name == "unet": model = sm.Unet('efficientnetb4', input_shape=(None, None, 3), classes=N_CLASSES, activation='sigmoid', encoder_weights=None, weights=weights_paths) if model_name == "fpn": model = sm.FPN('efficientnetb4', input_shape=(None, None, 3), classes=N_CLASSES, activation='sigmoid', encoder_weights=None) if model_name == "psp": model = sm.PSPNet('efficientnetb4', input_shape=(IMG_SIZE, IMG_SIZE, 3), classes=N_CLASSES, activation='sigmoid', encoder_weights=None) optimizer = tf.keras.optimizers.Adam(learning_rate=0.01) # 0.001 if loss_name == "bce": loss = tf.keras.losses.BinaryCrossentropy() elif loss_name == "bce_jaccard": loss = sm.losses.bce_jaccard_loss elif loss_name == "bce_jaccard_focal": loss = sm.losses.binary_focal_jaccard_loss elif loss_name == "binary_focal_dice": loss = sm.losses.binary_focal_dice_loss model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy', sm.metrics.iou_score, dice_coe]) EPOCHS = 50 STEPS_PER_EPOCH = TRAINSET_SIZE // BATCH_SIZE VALIDATION_STEPS = VALSET_SIZE // BATCH_SIZE callbacks = [ tf.keras.callbacks.ModelCheckpoint( 'results/weights/' + str(model_name) + '_' + str(loss_name) + '.h5', monitor='val_dice_coe', mode='max', verbose=1, save_best_only=True, save_weights_only=False), tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=8, min_lr=0.00001) ] results = model.fit(dataset['train'], epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, validation_steps=VALIDATION_STEPS, callbacks=callbacks, validation_data=dataset['val']) plt.figure(figsize=(8, 8)) plt.title("Learning curve") plt.plot(results.history["loss"], label="loss") plt.plot(results.history["val_loss"], label="val_loss") plt.plot(np.argmin(results.history["val_loss"]), np.min(results.history["val_loss"]), marker="x", color="r", label="best model") plt.xlabel("Epochs") plt.ylabel("log_loss") plt.legend() plt.savefig('./results/plots/train_loss_' + str(model_name) + '_' + str(loss_name) + '.png') plt.figure(figsize=(8, 8)) plt.title("Learning curve") plt.plot(results.history["dice_coe"], label="dice_coe") plt.plot(results.history["val_dice_coe"], label="val_dice_coe") plt.plot(np.argmax(results.history["val_dice_coe"]), np.max(results.history["val_dice_coe"]), marker="x", color="r", label="best model") plt.xlabel("Epochs") plt.ylabel("Dice Coeff") plt.legend() plt.savefig('./Results/plots/train_dice_' + str(model_name) + '_' + str(loss_name) + '.png') plt.figure(figsize=(8, 8)) plt.title("Learning curve") plt.plot(results.history["iou_score"], label="iou_score") plt.plot(results.history["val_iou_score"], label="val_iou_score") plt.plot(np.argmax(results.history["val_iou_score"]), np.max(results.history["val_iou_score"]), marker="x", color="r", label="best model") plt.xlabel("Epochs") plt.ylabel("IOU") plt.legend() plt.savefig('./Results/plots/train_IOU_' + str(model_name) + '_' + str(loss_name) + '.png') plt.figure(figsize=(8, 8)) plt.title("Learning curve") plt.plot(results.history["accuracy"], label="accuracy") plt.plot(results.history["val_accuracy"], label="val_accuracy") plt.plot(np.argmax(results.history["val_accuracy"]), np.max(results.history["val_accuracy"]), marker="x", color="r", label="best model") plt.xlabel("Epochs") plt.ylabel("accuracy") plt.legend() plt.savefig('./Results/plots/train_accuracy_' + str(model_name) + '_' + str(loss_name) + '.png')
RESULTADOS_finetuning = [] # Define the K-fold Cross Validator kfold = KFold(n_splits=num_folds, shuffle=True, random_state=1) # K-fold Cross Validation model evaluation fold_no = 1 for train, test in kfold.split(imagens, mascaras_medico): print("######### KFOLD ", fold_no, "#########") ###### CRIA O MODELO BACKBONE = 'resnet34' preprocess_input = sm.get_preprocessing(BACKBONE) # define model model = sm.Unet(BACKBONE, encoder_weights='imagenet', encoder_freeze=True) model.compile( 'Adam', loss=sm.losses.bce_jaccard_loss, metrics=[sm.metrics.iou_score], ) ###### dividir treino e validação, lembrando que como são 5 folds, tem 80% pra trein e 20% para test. Então dos 80% de treino pego 25% para validação. E ai mantenho a mesma proporção de antes do kfold (60% treino, 20% teste e 20% validação) x_train, x_val, y_train, y_val = train_test_split(imagens[train], mascaras_medico[train], test_size=0.25, random_state=11) x_train = np.asarray(x_train) y_train = (np.asarray(y_train) > threshold_otsu(np.asarray(y_train))) x_val = np.asarray(x_val)
weight_mask = torch.zeros_like(y_true).float() unique_object_labels = torch.unique(y_true) for obj in unique_object_labels: num_pixels = torch.sum(y_true == obj, dtype=torch.float) weight_mask[y_true == obj] = 1 / num_pixels loss = torch.sum(cce_loss * weight_mask**2) / torch.sum(weight_mask**2) return loss else: print("ENTERED WRONG") return cce_loss # Initialize Network Architecture and Start From Pretrained Baseline model_unet = sm.Unet(backbone_name=BACKBONE, encoder_weights=None, activation=ACTIVATION_FN, classes=N_CLASSES) # TODO: choose loss model_unet.compile( RMSprop(), loss=custom_loss ) #loss=JaccardLoss(class_weights=LOSS_WEIGHTS), metrics=[IOUScore()] callbacks_unet = [ ReduceLROnPlateau(factor=0.1, patience=5, min_lr=0.00001, verbose=1), ModelCheckpoint(CHECKPOINT_FILE, verbose=1, save_best_only=True, save_weights_only=True) ] # TODO: Selectively load weights based off testing # model_unet.load_weights(BASELINE_FILE)
# print(mask1) # plt.imshow(mask1) # plt.show() # break # if i==1: # break # i=i+1 # define network parameters n_classes = 4 #if len(CLASSES) == 1 else (len(CLASSES) + 1) # case for binary and multiclass segmentation activation = 'softmax' #create model model = sm.Unet(BACKBONE, classes=n_classes, activation=activation, encoder_weights='imagenet', encoder_freeze=True) #model.load_weights('C:/Users/guptav/Desktop/new 22.11/logs/ep01-val_loss0.72.h5') # define optomizer optim = keras.optimizers.Adam(lr=0.0) # Segmentation models losses can be combined together by '+' and scaled by integer or float factor dice_loss = sm.losses.DiceLoss() focal_loss = sm.losses.BinaryFocalLoss() total_loss = dice_loss + (1 * focal_loss) # actulally total_loss can be imported directly from library, above example just show you how to manipulate with losses # total_loss = sm.losses.binary_focal_dice_loss # or sm.losses.categorical_focal_dice_loss metrics = [
CLASSES = ['background', 'current', 'neighbour'] LR = 1e-4 EPOCHS = 5 preprocess_input = sm.get_preprocessing(BACKBONE) # In[12]: # define network parameters n_classes = len(CLASSES) # case for binary and multiclass segmentation activation = 'sigmoid' if n_classes == 1 else 'softmax' #create model model = sm.Unet(BACKBONE, classes=n_classes, activation=activation) # In[13]: # define optomizer optim = keras.optimizers.Adam(LR) # Segmentation models losses can be combined together by '+' and scaled by integer or float factor # set class weights for dice_loss (background: 0.5; current: 2.; neighbour: 2.; ) dice_loss = sm.losses.DiceLoss(class_weights=np.array([0.5, 2, 1])) focal_loss = sm.losses.BinaryFocalLoss() if n_classes == 1 else sm.losses.CategoricalFocalLoss() total_loss = dice_loss + (1 * focal_loss) # actulally total_loss can be imported directly from library, above example just show you how to manipulate with losses
val_img_data_gen = ImageDataAugmentor(augment=AUGMENTATIONS, augment_seed=123) val_img_gen = val_img_data_gen.flow_from_directory('temp_training/Validation/images/',target_size=(img_height,img_width),class_mode=None, shuffle=True, seed=123,batch_size=batch_size) val_mask_data_gen = ImageDataAugmentor(augment=AUGMENTATIONS, augment_seed=123, augment_mode='mask') val_mask_gen = val_mask_data_gen.flow_from_directory('temp_training/Validation/masks/',target_size=(img_height,img_width), class_mode=None, shuffle=True, seed=123,batch_size=batch_size) val_gen = my_image_mask_generator(val_img_gen,val_mask_gen) IMG_SIZE=512 # arrêter d'entrainer le modèle quand la mean_iou sur la zone de validation commence à stagner early_stopping_callback = EarlyStopping(monitor='val_loss', patience=15, mode='min') #ou max ?? # reduce learning rate during the training reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.4,patience=7, verbose=1,min_lr=0.00005, mode='min') #optimizeAdam = Adam(lr=0.00075, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) optimizeAdam = Adam(lr=0.00075) input_layer = Input(shape=(IMG_SIZE, IMG_SIZE,3), name='image_in') unetmodel = sm.Unet(backbone_name='efficientnetb2', encoder_weights='imagenet',input_shape=(IMG_SIZE, IMG_SIZE, 3),classes=1) out = unetmodel(input_layer) model = Model(inputs=[input_layer], outputs=out) #model = multi_gpu_model(model) lrIni = 0.00075 numLoop=1 for i in range(0,numLoop): my_file = Path("temp_training/checkpoint{}.h5".format(i-1)) if my_file.is_file(): print("training round {}".format(i+1)) print("loading checkpoint ... ") model = load_model(Path("temp_training/checkpoint{}.h5".format(i-1))) print("checkpoint loaded !") else:
""" @Author Willian Antunes """ import os import cv2 import sys import numpy as np from model.model import unet_256 import tensorflow as tf import segmentation_models as sm model = sm.Unet('vgg16', encoder_weights='imagenet') model.load_weights(filepath='weights/best_weights_1.hdf5') os.environ['CUDA_VISIBLE_DEVICES'] = '-1' print(model.summary()) def load_image_for_predict(img, input_size=(256, 256)): data = [] data.append(img) img_name = list(map(lambda s: s.split('/')[-1], data)) img_name = list(map(lambda s: s.split('.')[0], img_name)) img = cv2.imread(img) #img = cv2.resize(img, (625, 352)) img = img[:405, ] img = cv2.resize(img, input_size) img = img.reshape((1,) + img.shape) img = np.array(img, np.float32) / 255
self.batch_size] batch_y = self.y[idx * self.batch_size:(idx + 1) * self.batch_size] batch_y = tf.keras.utils.to_categorical(y=batch_y, num_classes=N_CLASSES) return batch_x, batch_y training_generator = CustomDataGenerator(x_train, y_train, batch_size=BATCH_SIZE) validation_generator = CustomDataGenerator(x_valid, y_valid, batch_size=BATCH_SIZE) testing_generator = CustomDataGenerator(x_test, y_test, batch_size=BATCH_SIZE) # %% -------------------------------------- UNet Model ----------------------------------------------------------------- unet_model = sm.Unet(backbone_name='resnet101', encoder_weights='imagenet', classes=169, input_shape=(224, 224, 3), activation='softmax') unet_model.summary() # %% -------------------------------------- Training Prep ---------------------------------------------------------- def dice_loss(y_true, y_pred, eps=1e-6, spatial_axes=[1, 2], from_logits=False): num_classes = y_pred.shape[-1] # Transform logits in probabilities, and one-hot the ground-truth: # Compute Dice numerator and denominator: num_perclass = 2 * tf.math.reduce_sum(y_pred * y_true, axis=spatial_axes) den_perclass = tf.math.reduce_sum(y_pred + y_true, axis=spatial_axes) # Compute Dice and average over batch and classes: