def test_pipeline(seg_model, cla_model, seg_preprocess_type,
cls_preprocess_type, activation, cls_treshold, verbose):
train2 = util.restructure_data_frame('Severstal_Dataset\\test.csv')
seg_preprocess = sm.get_preprocessing(seg_preprocess_type)
cls_preprocess = sm.get_preprocessing(cls_preprocess_type)
bs = 1
classes = 4 if activation == 'sigmoid' else 5
test_batches = SegmentationDataGenerator(train2,
shapes=((bs, 256, 1600), ),
subset='test')
n_samples = test_batches.__len__()
dice_res = 0
iterator = iter(test_batches)
for _ in tqdm(range(n_samples)):
images, masks = next(iterator)
for i in range(len(images)):
image = images[i].astype(np.int16)
mask = masks[i]
seg_x = seg_preprocess(image)
cls_x = cls_preprocess(image)
#Predict if the current image is defective or not
cls_res = cla_model.predict(np.reshape(cls_x, (1, 256, 1600, 3)))
#If it is most probable defective, the result is a whole zero mask
if (cls_res < cls_treshold):
res = np.zeros((256, 1600, classes), dtype=np.uint8)
if classes == 5:
res[:, :, 4] = 1
#Otherwise apply segmentation
else:
res = seg_model.predict(np.reshape(seg_x, (1, 256, 1600, 3)))
res = np.reshape(res, (256, 1600, classes))
res[np.where(res < 0.5)] = 0
res[np.where(res >= 0.5)] = 1
#Update dice value
dice_res += dice_coef(mask.astype(np.uint8), res.astype(np.uint8))
if (verbose):
coef = dice_coef(mask.astype(np.uint8), res.astype(np.uint8))
util.show_img_and_def((image, mask, res),
('orig', 'mask', 'pred ' + str(coef)))
print(dice_res / (n_samples * bs))
def test_classification(cls_model, cls_preprocess_type):
train2 = util.restructure_data_frame('Severstal_Dataset\\test.csv')
cls_preprocess = sm.get_preprocessing(cls_preprocess_type)
bs = 2
test_batches = ClassificationDataGenerator(train2,
shapes=((bs, 256, 1600), ),
subset='test')
n_samples = test_batches.__len__()
iterator = iter(test_batches)
for _ in tqdm(range(n_samples)):
images, trues = next(iterator)
for i in range(len(images)):
image = images[i].astype(np.int16)
true = trues[i]
cls_x = cls_preprocess(image)
#Predict if the current image is defective or not
cls_res = cls_model.predict(np.reshape(cls_x, (1, 256, 1600, 3)))
update_acc_matrix(true, cls_res)
print('True positive: ', acc_matrix[0], 'False positive: ', acc_matrix[1])
print('False negative: ', acc_matrix[2], 'True Negative: ', acc_matrix[3])
def test_scans_generator(scans_directory_path: Path,
batch_size=1,
target_size=(256, 256),
shuffle=False,
backbone="efficientnetb0"):
"""
Tensorflow dataset test generator
:param scans_directory_path: Directory with "images" folder containing scan slices
:param batch_size: batch size
:param target_size: image target size
:param shuffle: Whether to shuffle the data (default: True) If set to False, sorts the data in alphanumeric order.
:param backbone: backbone name of network you will use
:return: A DirectoryIterator yielding tuples of (x) where x is a numpy array containing
a batch of images with shape (batch_size, *target_size, channels) and y is a numpy array of corresponding labels
"""
preprocess_input = get_preprocessing(backbone)
images_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
preprocessing_function=preprocess_input)
test_images_generator = images_datagen.flow_from_directory(
directory=scans_directory_path,
target_size=target_size,
batch_size=batch_size,
seed=42,
shuffle=shuffle,
class_mode=None,
interpolation="bilinear")
test_samples = test_images_generator.n
return test_images_generator, test_samples
def load_dataset_classification(preprocess_type):
train2 = util.restructure_data_frame('Severstal_Dataset\\train.csv')
idx = int(0.8 * len(train2))
print()
preprocess = sm.get_preprocessing(preprocess_type)
shapes = ((4, 256, 1600), )
train_batches = ClassificationDataGenerator(
train2.iloc[:idx],
shuffle=True,
preprocess=preprocess,
shapes=shapes,
augmentation_parameters=augmentation_parameters)
valid_batches = ClassificationDataGenerator(train2.iloc[idx:],
shuffle=True,
preprocess=preprocess)
"""
iterator = iter(train_batches)
for _ in range(20):
images, defect = next(iterator)
for i in range(len(images)):
image = images[i].astype(np.uint8)
print (defect[i])
util.show_imgs((image,image),('orig','orig'),('',''))
"""
return train_batches, valid_batches
def setup_data(x, mean, std, backbone, batch_size=1, image_size=224):
preprocess_input = sm.get_preprocessing(backbone)
x = preprocess_input(x)
fake_y = np.zeros_like(x)[:,:,:,0]
ds = (
tf.data.Dataset.from_tensor_slices((x, fake_y))
.batch(batch_size, drop_remainder=True)
.map(
partial(
processing_data_functions(
key="validation",
size=image_size,
p=None,
mean=mean,
std=std
),
bs=batch_size,
),
num_parallel_calls=tf.data.AUTOTUNE
)
.prefetch(tf.data.AUTOTUNE)
)
return ds
def Predict(self, img_path, vis=True):
'''
User function: Run inference on image and visualize it. Output mask saved as output_mask.npy
Args:
img_path (str): Relative path to the image file
vis (bool): If True, predicted mask is displayed.
Returns:
list: List of bounding box locations of predicted objects along with classes.
'''
dirPath = "tmp_test"
if (os.path.isdir(dirPath)):
shutil.rmtree(dirPath)
os.mkdir(dirPath)
os.mkdir(dirPath + "/img_dir")
os.mkdir(dirPath + "/gt_dir")
os.system("cp " + img_path + " " + dirPath + "/img_dir")
os.system("cp " + img_path + " " + dirPath + "/gt_dir")
x_test_dir = dirPath + "/img_dir"
y_test_dir = dirPath + "/gt_dir"
if (self.system_dict["params"]["image_shape"][0] % 32 != 0):
self.system_dict["params"]["image_shape"][0] += (
32 - self.system_dict["params"]["image_shape"][0] % 32)
if (self.system_dict["params"]["image_shape"][1] % 32 != 0):
self.system_dict["params"]["image_shape"][1] += (
32 - self.system_dict["params"]["image_shape"][1] % 32)
preprocess_input = sm.get_preprocessing(
self.system_dict["params"]["backbone"])
test_dataset = Dataset(
x_test_dir,
y_test_dir,
self.system_dict["params"]["classes_dict"],
classes_to_train=self.system_dict["params"]["classes_to_train"],
augmentation=get_validation_augmentation(
self.system_dict["params"]["image_shape"][0],
self.system_dict["params"]["image_shape"][1]),
preprocessing=get_preprocessing(preprocess_input),
)
test_dataloader = Dataloder(test_dataset, batch_size=1, shuffle=False)
image, gt_mask = test_dataset[0]
image = np.expand_dims(image, axis=0)
pr_mask = self.system_dict["local"]["model"].predict(image).round()
np.save("output_mask.npy", pr_mask)
if (vis):
visualize(
image=denormalize(image.squeeze()),
pr_mask=pr_mask[..., 0].squeeze(),
)
def get_pred_dataset(filenames, images_dir, backbone, target_size):
# Preprocessing
prep_fn = preprocessing_fn(custom_fn=sm.get_preprocessing(backbone))
# Build dataset
dataset = DatasetImages(filenames, imgs_dir=images_dir, da_fn=ts_da_fn(*target_size),
preprocess_fn=prep_fn, target_size=target_size, memory_map=False)
return dataset
def __init__(self, name, models_path, use_page_cache=False):
if not re.match(r"^[a-z0-9/]+$", name):
raise ValueError("illegal model name '%s'" % name)
self._name = name
self._page_cache = None
models_path = Path(models_path)
network_path = models_path / name
for filename in ("meta.json", "model.h5"):
asset_path = network_path / filename
if not asset_path.exists():
raise RuntimeError("no model file found at %s" % asset_path)
# Loads the meta.json file in each part of the model. This is used to load and set
# various attributes dynamically.
with open(network_path / "meta.json", "r") as f:
meta = json.loads(f.read())
# Loads the types of labels that can be applied to the image
classes = meta["classes"]
if False:
# Alternate loading method. Not tested
model = getattr(segmentation_models,
meta["model"])(meta["backbone"],
classes=len(classes),
activation="softmax")
logging.info("loading model at %s" %
str(network_path / "model.h5"))
model.load_weights(str(network_path / "model.h5"))
else:
"""Loads a Keras model from the specified path"""
# see https://github.com/qubvel/segmentation_models/issues/153
# see https://stackoverflow.com/questions/54835331/how-do-i-load-a-keras-saved-model-with-custom-optimizer
model = load_model(str(network_path / "model.h5"), compile=False)
# Loads the pre-processing backend for the segmentation model library.
# What backend it is loading is defined in the meta.json in each saved model.
self._preprocess = segmentation_models.get_preprocessing(
meta["backbone"])
self._model = model
self._full_size = tuple(meta["full_size"])
self._full_shape = tuple(reversed(self._full_size))
self._tile_size = tuple(meta["tile_size"])
# Generated a list of of Tile objects via the Tiles object callable method
self._tiles = list(
Tiles(self._tile_size, beta0=meta["tile_beta"])(meta["full_size"]))
# Set the types of classes
self._classes = enum.Enum(meta["type"] + "Label",
dict((v, i) for i, v in enumerate(classes)))
# Set the model type, Region or Separator
self._type = meta["type"]
def Predict_Frame(self, path, vis=True):
'''
User function: Run inference on image and visualize it. Output mask saved as output_mask.npy
Args:
img_path (str): Relative path to the image file
vis (bool): If True, predicted mask is displayed.
Returns:
list: List of bounding box locations of predicted objects along with classes.
'''
preprocess_input = sm.get_preprocessing(
self.system_dict["params"]["backbone"])
image_normalize = preprocess_input(path)
print(image_normalize)
image = cv2.resize(image_normalize, (int(
len(image_normalize[0]) * 1024 / len(image_normalize[1])), 1024),
interpolation=cv2.INTER_LINEAR)
image = np.expand_dims(image, axis=0)
print("bla bla bla bla ")
print()
print()
print()
print(len(image[0]))
pr_mask = self.system_dict["local"]["model"].predict(image).round()
np.save("output_mask.npy", pr_mask)
'''
if(vis):
visualize(
image=denormalize(image.squeeze()),
pr_mask=pr_mask[..., 0].squeeze(),
)
'''
img_list = [denormalize(image.squeeze())]
label_list = ["image"]
print(img_list)
for i in range(len(self.system_dict["params"]["classes_to_train"])):
img_list.append(pr_mask[..., i].squeeze())
label_list.append(
self.system_dict["params"]["classes_to_train"][i])
print(img_list)
if (vis):
visualize2(label_list, img_list)
return (pr_mask, img_list)
def load_model(path, input_shape, num_classes=4, backbone='resnet18'):
model = Linknet(backbone_name=backbone,
input_shape=input_shape,
classes=num_classes,
activation='softmax')
model.load_weights(path)
return model, sm.get_preprocessing(backbone)
class Config:
BACKBONE = 'efficientnetb3'
BATCH_SIZE = 1
preprocess_input = sm.get_preprocessing(BACKBONE)
activation = 'softmax'
epochs = 50
threshold = 0.5
class_names = []
def get_model():
"""Gets the model used for training the dataset
Returns:
model: the model used for training
preprocess: the preprocessing model
"""
preprocess = sm.get_preprocessing('resnet34')
model = sm.Unet('resnet34', input_shape=(128, 800, 3), classes=4, activation='sigmoid')
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=[dice_coef])
return model, preprocess
def makeModel(optimizer='Adam', encoder='resnet18', encoder_freeze=False):
preprocess_input = sm.get_preprocessing(encoder)
model = sm.Unet(encoder,
classes=1,
encoder_weights='imagenet',
encoder_freeze=encoder_freeze)
model.compile(optimizer=optimizer,
loss=sm.losses.bce_jaccard_loss,
metrics=[sm.metrics.iou_score])
return model, preprocess_input
def get_model(backbone):
if backbone == "resnet34":
from segmentation_models import Unet
model = Unet("resnet34",
encoder_weights='imagenet',
classes=1,
activation='sigmoid',
encoder_freeze=True)
prep_fn = preprocessing_fn(custom_fn=sm.get_preprocessing("resnet34"))
return model, prep_fn
else:
raise ValueError("Unknown backbone")
def init():
"""
Initialize Segmenter building the segmentation model (UNet with Efficientnetb7 as backbone) and loading
its corresponding weights
"""
print("Initializing Segmenter...")
model = sm.Unet(config.SEGMENTER_BACKBONE,
encoder_weights='imagenet',
input_shape=config.SEGMENTER_IM_SIZE)
model.load_weights(config.SEGMENTER_WEIGHT_PATH)
Segmenter.__segmentation_model = model
Segmenter.__preprocess_input = sm.get_preprocessing(
config.SEGMENTER_BACKBONE)
print("Done.")
def __init__(self, config):
self.type = config['type']
self.backbone = config['backbone']
self.n_class = config['n_class']
self.activate = config['activation']
self.encoder_weights = config.get('encoder_weights', None)
self.preprocessing = sm.get_preprocessing(self.backbone)
local_device_protos = device_lib.list_local_devices()
n_available_gpus = len([x.name for x in local_device_protos if x.device_type == 'GPU'])
if n_available_gpus < 2:
self.model = self._build()
else:
with tf.device('/cpu:0'):
self.cpu_model = self._build()
self.model = keras.utils.multi_gpu_model(self.cpu_model, gpus=n_available_gpus)
def __init__(self, name, models_path, use_page_cache=False):
if not re.match(r"^[a-z0-9/]+$", name):
raise ValueError("illegal model name '%s'" % name)
self._name = name
self._page_cache = None
models_path = Path(models_path)
network_path = models_path / name
for filename in ("meta.json", "model.h5"):
asset_path = network_path / filename
if not asset_path.exists():
raise RuntimeError("no model file found at %s" % asset_path)
with open(network_path / "meta.json", "r") as f:
meta = json.loads(f.read())
classes = meta["classes"]
if False:
model = getattr(segmentation_models,
meta["model"])(meta["backbone"],
classes=len(classes),
activation="softmax")
logging.info("loading model at %s" %
str(network_path / "model.h5"))
model.load_weights(str(network_path / "model.h5"))
else:
# see https://github.com/qubvel/segmentation_models/issues/153
# see https://stackoverflow.com/questions/54835331/how-do-i-load-a-keras-saved-model-with-custom-optimizer
model = load_model(str(network_path / "model.h5"), compile=False)
self._preprocess = segmentation_models.get_preprocessing(
meta["backbone"])
self._model = model
self._full_size = tuple(meta["full_size"])
self._full_shape = tuple(reversed(self._full_size))
self._tile_size = tuple(meta["tile_size"])
self._tiles = list(
Tiles(self._tile_size, beta0=meta["tile_beta"])(meta["full_size"]))
self._classes = enum.Enum(meta["type"] + "Label",
dict((v, i) for i, v in enumerate(classes)))
self._type = meta["type"]
def load_dataset_segmentation(preprocess_type,
activation='sigmoid',
use_balanced_dataset=True,
shapes=((5, 256, 384), (5, 256, 512))):
np.random.seed(15)
train2 = util.restructure_data_frame('Severstal_Dataset\\train.csv')
train_idxs, valid_idxs = util.get_random_split(train2)
preprocess = sm.get_preprocessing(preprocess_type)
#shapes = ((5,256,384),(5,256,512))
train_batches = SegmentationDataGenerator(
train2.iloc[train_idxs],
shapes=shapes,
shuffle=True,
use_balanced_dataset=use_balanced_dataset,
preprocess=preprocess,
augmentation_parameters=augmentation_parameters,
use_defective_only=False,
activation=activation)
valid_batches = SegmentationDataGenerator(train2.iloc[valid_idxs],
shuffle=True,
preprocess=preprocess)
"""
iterator = iter(valid_batches)
for _ in range(100):
images, masks = next(iterator)
for i in range(len(images)):
image = images[i].astype(np.int16)
mask = masks[i]
util.show_img_and_def((image, mask) , ('orig','mask'))
#util.show_imgs((image, mask[:,:,0], mask[:,:,1], mask[:,:,2], mask[:,:,3], mask[:,:,4]),
#('img', '0', '1', '2', '3', '4'), ('','','','','',''))
#util.show_imgs((image, mask[:,:,0], mask[:,:,1], mask[:,:,2], mask[:,:,3]),
#('img', '0', '1', '2', '3'), ('','','','',''))
"""
return train_batches, valid_batches
def get_model_definition():
backbone = 'mobilenet'
n_classes = 2
lr = 0.001
activation = 'softmax'
pre_process_input = sm.get_preprocessing(backbone)
optimizer = keras.optimizers.Adam(lr)
metrics = [
sm.metrics.FScore(threshold=0.5),
]
model = sm.Linknet(backbone,
classes=n_classes,
activation=activation,
encoder_freeze=True)
if n_classes == 1:
loss = sm.losses.BinaryFocalLoss()
else:
loss = sm.losses.CategoricalFocalLoss()
model.compile(optimizer, loss, metrics)
return model, pre_process_input
def __init__(self,
list_IDs,
df,
target_df=None,
mode='fit',
base_path='../../dados/train_images',
batch_size=32,
dim=(1400, 2100),
n_channels=3,
reshape=None,
augment=False,
n_classes=4,
random_state=2019,
shuffle=True,
backbone='resnet34',
gamma=None,
TTA=False,
randomcrop=False,
classes=None):
self.dim = dim
self.batch_size = batch_size
self.df = df
self.mode = mode
self.base_path = base_path
self.target_df = target_df
self.list_IDs = list_IDs
self.reshape = reshape
self.n_channels = n_channels
self.augment = augment
self.n_classes = n_classes
self.gamma = gamma
self.shuffle = shuffle
self.random_state = random_state
self.preprocess_input = sm.get_preprocessing(backbone)
self.TTA = TTA
self.randomcrop = randomcrop
self.classes = classes
self.image_name = []
self.on_epoch_end()
np.random.seed(self.random_state)
def _build_keypoint_preprocessing(input_shape, backbone):
"""Builds the preprocessing function for the Field Keypoint Detector Model.
"""
sm_preprocessing = sm.get_preprocessing(backbone)
def preprocessing(input_img, **kwargs):
to_normalize = False if np.percentile(input_img, 98) > 1.0 else True
if len(input_img.shape) == 4:
print(
"Only preprocessing single image, we will consider the first one of the batch"
)
image = input_img[0] * 255.0 if to_normalize else input_img[0] * 1.0
else:
image = input_img * 255.0 if to_normalize else input_img * 1.0
image = cv2.resize(image, input_shape)
image = sm_preprocessing(image)
return image
return preprocessing
def train_net():
args = parser.parse_args()
final_path = args.model_final_path
checkpoint_path = args.model_checkpoint_path
dataset_path = args.dataset_path
with tf.device("/gpu:0"):
backbone = 'resnet50'
preprocess_input = get_preprocessing(backbone)
# load your data
x_train, y_train, x_val, y_val = from_directory_datagen(dataset_path)
# preprocess input
x_train = preprocess_input(x_train)
x_val = preprocess_input(x_val)
# define model
model = Unet(backbone, encoder_weights='imagenet', input_shape=(256, 256, 3))
model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-3), loss=dice_loss,
metrics=[f1_score, iou_score])
check_point = [ModelCheckpoint(checkpoint_path + 'model-{epoch:03d}-{val_f1-score:03f}.h5', verbose=1,
monitor='val_f1-score',
save_best_only=True, mode='max')]
# fit model
model.fit(
x=(pair for pair in zip(x_train, y_train)),
epochs=10,
steps_per_epoch=x_train.n // x_train.batch_size,
validation_data=(pair for pair in zip(x_val, y_val)),
validation_steps=x_val.n // x_val.batch_size,
verbose=1,
shuffle=True,
callbacks=check_point,
)
model.save(final_path + 'final_model.h5')
def predict():
# Delete files from previous runs in inference folder
files = glob.glob(app.config['INFERENCE_DIR'] + '/*.*')
for f in files:
os.remove(f)
# Option 1: Get user-uploaded image
if flask.request.files.get('file'):
image = flask.request.files['file']
image.save(os.path.join(app.config['INFERENCE_DIR'], 'upload.png'))
# If we had chosen to save the file under its original filename, for
# security we would have run: filename = secure_filename(image.filename)
# Option 2: Get chosen default image
elif flask.request.form.get('test'):
image = os.path.join(app.config['APP_STATIC'],
flask.request.form.get('test'))
# Pre-processing: read the image, pad/resize it and apply EfficientNet preprocessing
image_id = os.path.basename(image)
image = skimage.io.imread(image, plugin='matplotlib')
if image.shape[-1] == 4: # remove alpha channel
image = image[..., :3]
HEIGHT = image.shape[0]
WIDTH = image.shape[1]
preprocess_input = sm.get_preprocessing(BACKBONE)
resize_preprocess_transform = A.Compose([
#A.PadIfNeeded(768, 1024, p=1.0, border_mode=0),
A.Resize(height=768, width=1024, p=1.0),
A.Lambda(image=preprocess_input)
])
resized_preprocessed = resize_preprocess_transform(image=image)
image = resized_preprocessed["image"]
print("--> Image loaded - going to detection...")
# Run detection, return to original size and save predicted mask
image = np.expand_dims(image, axis=0)
pr_mask = model.predict(image)
pr_mask = pr_mask.squeeze()
image = denormalize(image).squeeze()
inverse_resize_transform = A.Compose([
#A.PadIfNeeded(HEIGHT, WIDTH, p=1.0, border_mode=0),
A.Resize(height=HEIGHT, width=WIDTH, p=1.0)
])
inverse_resized = inverse_resize_transform(image=image, mask=pr_mask)
image, pr_mask = inverse_resized["image"], inverse_resized["mask"]
skimage.io.imsave(os.path.join(app.config['INFERENCE_DIR'], "pr_mask.png"),
pr_mask)
print("--> Detection successful - now saving results for display...")
# Post-processing: delineate contours to get polygons, delete smaller ones, save as JSON
# T = 204
# formworks = threshold_image(img_as_ubyte(pr_mask[...,0]), threshold = T)
# pumps = threshold_image(img_as_ubyte(pr_mask[...,1]), threshold = T)
# contours_formworks = measure.find_contours(formworks, 1)
# contours_pumps = measure.find_contours(pumps, 1)
# contours_formworks = [x.round(0).tolist() for x in np.array(contours_formworks)]
# contours_pumps = [x.round(0).tolist() for x in np.array(contours_pumps)]
# pr_polygons = json_template
# try:
# for idx, contour in enumerate(contours_formworks.extend(contours_pumps)):
# poly = Polygon(contour)
# if poly.area < 300: # very few ground truth formworks & pumps are <300px area
# continue
# _, concave_hull_coords = alpha_shape(poly, alpha=0.01)
# details =
# if contour is in contours_formworks:
# category_id
# pr_polygons['annotations'].append(details)
# pr_polygons[f'formwork_{idx+1}'] = concave_hull_coords
# except:
# print('Post-processing failed - review alpha_shape function.')
# with open(os.path.join(app.config['INFERENCE_DIR'],'pr_polygons.json'), 'w') as f:
# json.dump(pr_polygons, f)
grayscale = rgb2gray(pr_mask)
contours = measure.find_contours(grayscale, 0.1)
pr_polygons = {}
try:
for idx, contour in enumerate(contours):
poly = Polygon(contour)
if poly.area < 300: # very few ground truth formworks & pumps are <300px area
continue
_, concave_hull_coords = alpha_shape(poly, alpha=0.01)
pr_polygons[f'polygon_{idx}'] = concave_hull_coords
#pr_polygons[f'polygon_{idx}'] = contour
except:
print('Post-processing failed - review alpha_shape function.')
with open(os.path.join(app.config['INFERENCE_DIR'], 'pr_polygons.json'),
'w') as f:
json.dump(pr_polygons, f)
# Overlay detected polygons on original image and save result
fig, ax = plt.subplots()
ax.imshow(image)
colors = random_colors(len(contours))
for idx, contour in enumerate(contours):
#ax.plot(contour[:, 1], contour[:, 0], linewidth=2)
color = colors[idx]
p = patches.Polygon(list(zip(contour[:, 1], contour[:, 0])),
facecolor=color,
edgecolor=color,
alpha=0.5)
ax.add_patch(p)
ax.axis('off')
plt.savefig(os.path.join(app.config['INFERENCE_DIR'], "result.png"),
bbox_inches='tight',
pad_inches=0.0)
plt.close()
# Save detection summary
data = {}
data["Successful detection"] = True
try:
#data["Number of detected formworks"] = len(contours_formworks)
data["Number of detected formworks"] = len(pr_polygons)
data["Number of detected pumps"] = 0
except:
data["Number of detected objects"] = len(contours)
data_df = pd.DataFrame(data, index=[0]).T
data_df.to_excel(os.path.join(app.config['INFERENCE_DIR'],
"detection_summary.xlsx"),
header=False)
print("--> Saving done - showing success page.\n")
return flask.render_template('success.html', data=data)
def __init__(self, model_name, models_path, name=None, grayscale=False):
if not re.match(r"^[a-z0-9/]+$", model_name):
raise ValueError("illegal model name '%s'" % model_name)
if name is None:
name = model_name
self._name = name
_check_predictor_name(self._name)
models_path = Path(models_path)
network_path = models_path / model_name
for filename in ("meta.json", "model.h5"):
asset_path = network_path / filename
if not asset_path.exists():
raise FileNotFoundError("no model file found at %s" %
asset_path)
with open(network_path / "meta.json", "r") as f:
meta = json.loads(f.read())
classes = meta["classes"]
import segmentation_models
# the following commented code fails to work.
# see https://github.com/qubvel/segmentation_models/issues/153
# and https://stackoverflow.com/questions/54835331/how-do-i-load-a-keras-saved-model-with-custom-optimizer
'''
model = getattr(segmentation_models, meta["model"])(
meta["backbone"],
classes=len(classes),
activation="softmax")
logging.info("loading model at %s" % str(network_path / "model.h5"))
model.load_weights(str(network_path / "model.h5"))
'''
# note that we need keras.models.load_model, as
# tensorflow.keras.models.load_model won't work,
# see https://github.com/keras-team/keras-contrib/issues/488
# and https://github.com/tensorflow/tensorflow/issues/25200
# so we need a separate keras installation here.
from keras.models import load_model
model = load_model(str(network_path / "model.h5"), compile=False)
self._preprocess = segmentation_models.get_preprocessing(
meta["backbone"])
self._model = model
self._full_size = tuple(meta["full_size"])
self._full_shape = tuple(reversed(self._full_size))
self._tile_size = tuple(meta["tile_size"])
self._tiles = list(
Tiles(self._tile_size, beta0=meta["tile_beta"])(meta["full_size"]))
self._type = PredictorType[meta["type"].upper()]
self._classes = self._type.classes(
dict((v, i) for i, v in enumerate(classes)))
self._grayscale = grayscale
preprocessing_fn (callbale): data normalization function
(can be specific for each pretrained neural network)
Return:
transform: albumentations.Compose
"""
_transform = [
A.Lambda(image=preprocessing_fn),
]
return A.Compose(_transform)
# network
best_weight = model_folder+'/best_model-{:03d}.h5'.format(epoch)
CLASSES = []
preprocess_input = sm.get_preprocessing(backbone)
#create model
# CLASSES = ['live', 'inter', 'dead']
CLASSES = ['live', 'dead']
n_classes = len(CLASSES) + 1
activation = 'softmax'
net_func = globals()[net_arch]
decoder_filters=(int(nb_filters),int(nb_filters/2), int(nb_filters/4), int(nb_filters/8), int(nb_filters/16))
model = net_func(backbone, classes=n_classes, encoder_weights = None, activation=activation,\
decoder_block_type = upsample, feature_version = feature_version, decoder_filters = decoder_filters)
#model = net_func(backbone, classes=n_classes, encoder_weights = None, activation=activation,\
# decoder_block_type = upsample, decoder_filters = decoder_filters)
# model = net_func(backbone, classes=n_classes, activation=activation)
model.summary()
#load best weights
df_val['Has_Hemorrhage'].value_counts()
df_diag.to_csv('df_data.csv.gz', compression='gzip', index=False)
df_train.to_csv('df_train.csv.gz', compression='gzip', index=False)
df_val.to_csv('df_val.csv.gz', compression='gzip', index=False)
df_test.to_csv('df_test.csv.gz', compression='gzip', index=False)
# check if the files were saved
!ls
from segmentation_models import get_preprocessing # this line has an error in the docs
BACKBONE = 'densenet121'
preprocess_input = get_preprocessing(BACKBONE)
# We are only using brain images for training.
# These are originally single channel images but cv2 will read them with 3 channels.
def train_generator(batch_size=30):
while True:
# load the data in chunks (batches)
for df in pd.read_csv('df_train.csv.gz', chunksize=batch_size):
# get the list of images
image_id_list = list(df['new_image_fname'])
mask_id_list = list(df['new_mask_fname'])
def main():
#sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))
# paths
file_root = os.path.join("/opt", "data", "gaul_severstal_data")
project_dir = os.path.join("/opt", "project")
log_dir = os.path.join(project_dir, "src", "logs", "fit",
datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
images_dir = os.path.join(file_root, "train_images")
df_path = os.path.join(file_root, "train.csv")
local_tune_dir = os.path.join(project_dir, "src", "tune")
plot_dir = os.path.join(project_dir, "src", "plots")
# dataset split
training_split = 0.6
validation_split = 0.2
testing_split = 1.0 - (training_split + validation_split)
# unet encoder backbone
backbone = 'vgg16'
# data options
classes = [3]
n_classes = len(classes)
use_greyscale = False
batch_size = 1
# load in damage labels
train_df, val_df, test_df = load_dataframe_split(df_path,
classes=classes,
val_size=validation_split,
test_size=testing_split)
# image resizing parameters
image_scale_down = 5
height = int(np.floor(256 / image_scale_down / 32) * 32)
width = int(np.floor(1600 / image_scale_down / 32) * 32)
image_channels = 1 if use_greyscale else 3
resize_shape = (
height, width, image_channels
) # original is (256, 1600, 3), needs to be divisible by 32
mask_shape = (height, width, n_classes)
# image preprocessing
preprocessing_input = sm.get_preprocessing(backbone)
# loss
dice_loss = sm.losses.DiceLoss()
# metrics
iou_score = sm.metrics.IOUScore(threshold=0.5)
metrics = [iou_score]
# datasets and dataloaders
train_dataset, val_dataset, test_dataset = get_datasets(
images_dir=images_dir,
preprocessing_input=preprocessing_input,
resize_shape=resize_shape,
train_df=train_df,
val_df=val_df,
test_df=test_df,
use_greyscale=use_greyscale)
train_dataloader, val_dataloader, test_dataloader = get_dataloaders(
train_dataset=train_dataset,
val_dataset=val_dataset,
test_dataset=test_dataset,
train_batch_size=batch_size)
# tuner config
config = {
"dropout":
tune.grid_search([0.1, 0.2, 0.3, 0.4, 0.5]),
"learning_rate":
tune.grid_search([1e-5, 1e-4, 1e-3, 1e-2]),
"optimizer":
tune.grid_search([keras.optimizers.Adam, keras.optimizers.RMSprop]),
"encoder_freeze":
tune.grid_search([True, False]),
}
# best model config
best_config = {
"dropout": 0.1,
"learning_rate": 1e-4,
"optimizer": keras.optimizers.Adam,
"encoder_freeze": False,
}
use_best_config = True
config = best_config if use_best_config else config
# search algorithm
# hyperopt = HyperOptSearch(metric="val_iou_score", mode="max")
# trial scheduler
hyperband = HyperBandScheduler(metric="val_iou_score", mode="max")
# tune model or load best_model.h5
tune_model = True
model_name = "best_model.h5"
if tune_model:
analysis = tune.run(
tune.with_parameters(train_unet,
train_dataloader=train_dataloader,
val_dataloader=val_dataloader,
loss=dice_loss,
metrics=metrics),
resources_per_trial={"gpu": 1},
config=config,
# search_alg=hyperopt,
scheduler=hyperband,
local_dir=local_tune_dir)
else:
model = keras.models.load_model(model_name,
custom_objects={
"dice_loss": dice_loss,
"iou_score": iou_score
})
use_test = True
evaluate_dataset = test_dataset if use_test else val_dataset
evaluate_dataloader = test_dataloader if use_test else val_dataloader
make_plots = False
if make_plots is True:
for i in range(len(evaluate_dataset)):
imageId = evaluate_dataset.ids[i]
image, true_mask = evaluate_dataset[i]
image = np.expand_dims(image, axis=0)
pr_mask = model.predict(image)
image = denormalize(image[0])
pr_mask = denormalize(pr_mask[0]).astype('uint8')
visualize(image,
true_mask,
pr_mask,
name=imageId,
save_dir=plot_dir)
# model evaluation and baseline comparison
evaluate_results = model.evaluate(evaluate_dataloader, batch_size=1)
for i, val in enumerate(evaluate_results):
print(f'{model.metrics_names[i]}: {val}')
# baseline is a mask covering the entire left half of the image
baseline_mask = np.zeros(mask_shape)
baseline_mask[:, :np.int(width / 2), :] = 1
baseline_iou_scores = []
for i in range(len(evaluate_dataset)):
image, true_mask = evaluate_dataset[i]
image = denormalize(image)
iou = iou_score(true_mask.astype('float32'), baseline_mask)
#visualize(image, true_mask, baseline_mask.astype('uint8'))
baseline_iou_scores.append(iou)
average_baseline_iou = np.average(baseline_iou_scores)
print(f'baseline iou_score: {average_baseline_iou}')
classes=2 if border else 1,
activation='sigmoid',
encoder_weights='imagenet',
encoder_freeze=not trainable_encoder,
downsample_factor=8,
psp_conv_filters=512,
psp_pooling_type='avg',
psp_use_batchnorm=True,
psp_dropout=None)
else:
print('Invalid segmentation model type')
exit(0)
return model
preprocessing = sm.get_preprocessing(backbone)
iou = sm.metrics.IOUScore(per_image=False)
def bce_dice_loss(y_true, y_pred):
bce = tf.keras.losses.binary_crossentropy(y_true, y_pred)
y_true_ = y_true[..., 0] # !!! only first channel
y_pred_ = y_pred[..., 0] # !!! only first channel
dice = sm.losses.dice_loss(y_true_, y_pred_)
return bce + dice
def iou_fc(y_true, y_pred):
y_true_ = y_true[..., 0] # !!! only first channel
y_pred_ = y_pred[..., 0] # !!! only first channel
return iou(y_true_, y_pred_)
'shuffle': True
}
X_train = np.array(X_train)
X_train = X_train.reshape(X_train.shape[0])
X_val = np.array(X_val)
X_val = X_val.reshape(X_val.shape[0])
training_generator = DataGenerator(X_train, mask_data, **params)
validation_generator = DataGenerator(X_val, mask_data, **params)
import segmentation_models as sm
BACKBONE = 'resnet34'
preprocess_input = sm.get_preprocessing(BACKBONE)
rooftopsolar_model1 = sm.Unet(BACKBONE, encoder_weights='imagenet')
rooftopsolar_model1.compile(
'Adam',
loss=sm.losses.bce_jaccard_loss,
metrics=[sm.metrics.iou_score],
)
epochs = 80
early_stopping_callback = EarlyStopping(monitor='val_loss', patience=5)
checkpointer = ModelCheckpoint('rooftopsolar_model6.h5',
monitor='loss',
verbose=1,
save_best_only=True)
# In[11]:
BACKBONE = 'efficientnetb3'
BATCH_SIZE = 1
CLASSES = [
'road', 'sidewalk', 'building', 'traffic light', 'traffic sign',
'vegetation', 'person', 'car'
]
CLASS_WEIGHTS = np.array([2, 2, 1, 2, 2, 1, 2, 2,
0.5]) # last weight is added for backgound (0.5)
# CLASSES = ['road', 'car']
# CLASS_WEIGHTS = np.array([2, 2, 0.5]) # last weight is added for backgound (0.5)
LR = 0.001
EPOCHS = 100
preprocess_input = sm.get_preprocessing(BACKBONE)
# In[12]:
# 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)
# In[13]:
# define optomizer
optim = keras.optimizers.Adam(LR)
