def train(image_path, mask_path):
print('load data>>>>')
image_train, image_valid, mask_train, mask_valid = preprocess_data_train(
image_path, mask_path, size=64, replica=3, split=True)
print('data loading complete!')
print('model loaded>>>>')
print('fitting model>>>>')
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(graph=tf.get_default_graph(), config=config) as sess:
K.set_session(sess)
sess.run(tf.global_variables_initializer())
os.environ["CUDA_VISIBLE_DEVICES"] = "0, 1"
stop = EarlyStopping(patience=4)
# checkpoint = ModelCheckpoint(filepath='/checkpoint-{epoch:02d}-{val_loss:.4f}.hdf5',
# monitor='val_loss', verbose=1, save_best_only=True)
model = unet(lr=1e-4)
model.summary()
model.fit_generator(
generator=generator(image_train, mask_train),
steps_per_epoch=len(image_train),
epochs=10,
validation_data=[image_valid, mask_valid],
#validation_steps=64,
verbose=1,
callbacks=[stop])
model.save_weights('./weight.h5')
def gen_meteor_mask_from_folder(self, image_folder, output_folder):
print("\nGenerating mask from Unet ...")
if not os.path.exists(output_folder):
os.mkdir(output_folder)
# The image size supported is (256, 256)
unet_model = model.unet(input_size=(settings.UNET_IMAGE_SIZE,
settings.UNET_IMAGE_SIZE, 1))
unet_model.load_weights(settings.UNET_SAVED_MODEL)
test_image_list = os.listdir(image_folder)
num_image = len(test_image_list)
testGene = unet_proc.testGenerator(image_folder, as_gray=True)
'''
test_datagen = ImageDataGenerator(rescale=1. / 255)
batch_size = 1
# test_folder = os.path.dirname(image_folder)
test_generator = test_datagen.flow_from_directory(
image_folder,
target_size=(256, 256),
batch_size=batch_size,
color_mode='grayscale',
shuffle=False,
class_mode=None)
'''
results = unet_model.predict_generator(testGene, num_image, verbose=1)
# results = unet_model.predict_generator(test_generator, num_image, verbose=1)
unet_proc.saveResult_V2(output_folder, results, test_image_list)
def prediction(im, is_pc, pretrained_weights=None):
"""
Calculate the prediction of the label corresponding to image im
Param:
im: a numpy array image (numpy array), with max size 2048x2048
Return:
res: the predicted distribution of probability of the labels (numpy array)
"""
# pad with zeros such that is divisible by 16
(nrow, ncol) = im.shape
row_add = 16 - nrow % 16
col_add = 16 - ncol % 16
padded = np.pad(im, ((0, row_add), (0, col_add)))
if pretrained_weights is None:
if is_pc:
pretrained_weights = path_weights + 'unet_weights_batchsize_25_Nepochs_100_SJR0_10.hdf5'
else:
pretrained_weights = path_weights + 'weights_budding_BF_multilab_0_1.hdf5'
if not os.path.exists(pretrained_weights):
raise ValueError('Path does not exist')
# WHOLE CELL PREDICTION
model = unet(pretrained_weights=pretrained_weights,
input_size=(None, None, 1))
results = model.predict(padded[np.newaxis, :, :, np.newaxis], batch_size=1)
res = results[0, :, :, 0]
return res[:nrow, :ncol]
def get_model(args, input_shape=(512, 512, 5)):
if args.modelweights != None:
custom_objects = custom_objects = {
'binary_accuracy': binary_accuracy,
'recall': recall,
'precision': precision,
'dice_coefficient': dice_coefficient,
'dice_coefficient_loss': dice_coefficient_loss,
'weighted_binary_crossentropy_loss':
weighted_binary_crossentropy_loss
}
return load_model(args.modelweights, custom_objects=custom_objects)
#else:
#if(args.model=="BVNet3D"):
#train_data, label_data = get_training_patches(train_files, args.label, remove_only_background_patches=True)
#val_data, val_label = get_training_patches(train_files, args.label)
#model = BVNet3D(input_size =train_data.shape[1:], loss=get_loss(args.loss))
#return model, train_data, label_data, val_data, val_label
#train_data, label_data = get_train_data_slices(train_files, tag=args.label)
#print("Done geting training slices...")
#val_data, val_label = get_slices(val_files, args.label)
#print("Done geting validation slices...")
else:
if (args.model == "BVNet3D"):
return BVNet3D(input_size=(64, 64, 64, 1),
loss=get_loss(args.loss, args.label))
if (args.model == "BVNet"):
return BVNet(input_size=input_shape,
loss=get_loss(args.loss, args.label))
if (args.model == "unet"):
return unet(input_size=input_shape,
loss=get_loss(args.loss, args.label))
def main():
model_dir = './checkpoints/seg2/DismapDiceLoss_k3/model_at_epoch_042.dat'
save_dir = './test/1015/DismapDiceLoss_k3'
test_txt_path = './data/seg1/test.txt'
model = unet(in_channel=1, n_classes=1)
model = load_model(model, model_dir)
model = model.cuda()
model.eval()
test_dataset = GuideWireDataset(test_txt_path)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=BATCH_SIZE,
shuffle=False,
num_workers=NUM_WORKERS)
prefetcher = data_prefetcher(test_loader)
input, _, _ = prefetcher.next()
i = -1
while input is not None:
i += 1
with torch.no_grad():
output = model(input)
output = torch.sigmoid(output).squeeze().data.cpu().numpy()
output[output < 0.5] = 0
output[output >= 0.5] = 1
cv2.imwrite(os.path.join(save_dir,
str(i) + '_output.jpg'), output * 255)
print(str(i) + ' finish!')
input, _, _ = prefetcher.next()
def main():
targetSize = (256, 256)
model = unet(input_size=targetSize + (3, ))
model.load_weights("checkpoints/color_shapes/shapes_20_0.0000_1.000.hdf5")
while True:
shapeImage, _ = generate_shapes(img_shape=targetSize + (3, ),
bgColor=[117, 122, 125],
shapeColor=[180, 211, 250])
batch = adjustImage(shapeImage, targetSize, asGray=False)
results = model.predict(batch, batch_size=1, verbose=0)
results = np.round(np.squeeze(results[0]) * 255, 0).astype(np.uint8)
cv2.imshow('image', shapeImage)
cv2.imshow('results', results)
while True:
key = cv2.waitKey()
if key == 27:
return
if key == ord('d'):
break
cv2.imshow('image', np.zeros_like(shapeImage))
cv2.imshow('results', np.zeros_like(shapeImage))
def run(flags_obj):
data_aug_args = dict(rotation_range=0.2,
width_shift_range=0.05,
height_shift_range=0.05,
shear_range=0.05,
zoom_range=0.05,
horizontal_flip=True,
fill_mode='nearest')
train_gene = train_generator(flags_obj, data_aug_args)
model = unet(flags_obj, n_filters=64)
model.compile(optimizer=tf.keras.optimizers.Adam(
learning_rate=flags_obj.learning_rate),
loss=tf.keras.losses.BinaryCrossentropy(),
metrics=['accuracy'])
example = load_example(flags_obj)
example_img = imageio.imread('data/membrane/test/image/0.png')
# Save first prediction without training.
save_prediction(model, example_img, example, 0)
test_ds = load_test_dataset()
history = model.fit_generator(train_gene,
epochs=flags_obj.epoch,
steps_per_epoch=flags_obj.steps_per_epoch,
validation_data=test_ds,
callbacks=[DisplayCallback(model, example)])
create_gif()
plot_history(history, flags_obj.epoch)
def train_model():
(
train_clean_paths,
train_noisy_paths,
test_clean_paths,
test_noisy_paths,
) = split_data()
print("Train data:", len(train_clean_paths))
print("Test data:", len(test_clean_paths))
train_generator = data_generator(train_clean_paths, train_noisy_paths)
test_generator = data_generator(test_clean_paths, test_noisy_paths)
print("Initialize the model...")
model = unet(pretrained_weights=weights_path)
print("Start training...")
model.fit_generator(
generator=train_generator,
validation_data=test_generator,
steps_per_epoch=cnf.steps_per_epoch,
epochs=cnf.epochs,
validation_steps=cnf.validation_steps,
)
print("Finishing training...")
if SAVE_WEIGHTS:
model.save_weights(f"weights/{str(datetime.now())}_unet_model.h5")
return model
def train(self):
from model import unet
from data import trainGenerator
from keras.callbacks import ModelCheckpoint
from keras.optimizers import Adam
from keras.callbacks import ReduceLROnPlateau
# myGene = trainGenerator(4, 'data', 'colorImage', 'label', self.data_gen_args, image_color_mode='rgb',
# target_size=self.targetSize, flag_multi_class=True, num_class=6, save_to_dir=None)
myGene = self.getTrainGenerator()
model = unet(input_size=self.targetSize + (1, ))
model.compile(optimizer=Adam(lr=1e-4),
loss='binary_crossentropy',
metrics=['accuracy'])
chckPtsDir = 'checkpoints/membrane/multiclass'
os.makedirs(chckPtsDir, exist_ok=True)
chckPtsPath = os.path.join(
chckPtsDir, 'unet_multiclass_{epoch}_{loss:.3f}_{acc:.3f}.hdf5')
model_checkpoint = ModelCheckpoint(chckPtsPath,
monitor='loss',
verbose=1,
save_best_only=True)
# reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.2, patience=4, min_lr=0.001)
model.fit_generator(myGene,
steps_per_epoch=20,
epochs=3,
callbacks=[model_checkpoint])
def unet_crf():
model = unet()
model.load_weights("./unet_membrane.hdf5")
testGene = testGenerator("./dataset/membrane/test/img", 1)
labelGene = labelGenerator("./dataset/membrane/test/label", 1)
dataset = zip(testGene, labelGene)
for idx, (data, target) in enumerate(dataset):
pred = model.predict(data, 1, verbose=1)
pred = pred.squeeze()
print("pred", pred.shape)
# original image, 0-255, 3 channel
img = cv2.imread("./dataset/membrane/test/img/%s" % str(idx) + ".png")
# perform dense crf
final_mask = dense_crf(idx, np.array(img).astype(np.uint8), pred)
# binarization score map to get predict result of Unet
mask_pos = pred >= 0.5
mask_neg = pred < 0.5
pred[mask_pos] = 1
pred[mask_neg] = 0
pred = np.uint8(pred)
pred = pred * 255
pred = Image.fromarray(pred, 'L')
pred.save('./{}.png'.format(idx))
# draw result after denseCRF
final_mask = np.uint8(final_mask)
final_mask = final_mask * 255
crf = Image.fromarray(final_mask, 'L')
crf.save('./img/{}.png'.format(idx))
def train():
"""
A function to perform training by initializing the values of the model object.
ModelCheckpoint is used to save the trained weights.
fit_generator starts the training process.
"""
model = unet(in_shape=(256, 512, 3),
num_classes=7,
lrate=1e-4,
decay_rate=5e-4,
vgg_path=None,
dropout_rate=0.5)
# Define callbacks
mod_save = ModelCheckpoint(filepath='gpu_exp_6classes_model_weight.h5',
save_weights_only=True)
# training
model.fit_generator(data_generator('data.h5', 4, 'train'),
steps_per_epoch=2975 // 4,
validation_data=data_generator('data.h5', 4, 'val'),
validation_steps=500 / 4,
callbacks=[mod_save],
epochs=100,
verbose=1)
def bn_update(tf_config, logger):
dataset = data.Dataset(cfg.DATASET, cfg.RNG_SEED)
cfg.MODEL.BN_MOMENTUM = 0.
assert cfg.MODEL.BN_MOMENTUM == 0., 'BN_MOMENTUM should be 0. for update step'
imgs, _ = dataset.preprocessing(training=True,
augment=False,
batch_size=dataset.train_num,
num_epochs=1)
net, _ = model.unet(imgs,
bn_training=True,
dropout_training=False,
dataset=cfg.DATASET)
with tf.variable_scope('cls'):
_ = tf.layers.conv2d(net, 1, 1, activation=tf.nn.relu)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
saver = tf.train.Saver(max_to_keep=1000)
with tf.Session(config=tf_config) as sess:
weights_path = tf.train.latest_checkpoint(cfg.OUTPUT_DIR)
logger.info('Restoring weights from {}'.format(weights_path))
saver.restore(sess, weights_path)
sess.run(update_ops)
weights_path = saver.save(sess,
os.path.join(cfg.OUTPUT_DIR, 'bn-model'),
global_step=int(weights_path.split('-')[-1]))
logger.info('Updating weights to {}'.format(weights_path))
tf.reset_default_graph()
def trainColor():
from model import unet
from data import trainGenerator
from keras.callbacks import ModelCheckpoint
from keras.optimizers import Adam
from keras.callbacks import ReduceLROnPlateau
data_gen_args = dict(rotation_range=0.2,
width_shift_range=0.05,
height_shift_range=0.05,
shear_range=0.05,
zoom_range=0.05,
horizontal_flip=True,
fill_mode='nearest')
targetSize = (256, 256)
myGene = trainGenerator(4, 'data/membrane/train', 'colorImage', 'label', data_gen_args, image_color_mode='rgb',
target_size=targetSize, save_to_dir=None)
model = unet(input_size=targetSize + (3,))
model.compile(optimizer=Adam(lr=1e-4), loss='binary_crossentropy', metrics=['accuracy'])
chckPtsDir = 'checkpoints'
os.makedirs(chckPtsDir, exist_ok=True)
chckPtsPath = os.path.join(chckPtsDir, 'unet_membrane_{epoch}_{loss:.3f}_{acc:.3f}.hdf5')
model_checkpoint = ModelCheckpoint(chckPtsPath, monitor='loss', verbose=1, save_best_only=True)
# reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.2, patience=4, min_lr=0.001)
model.fit_generator(myGene, steps_per_epoch=2000, epochs=17, callbacks=[model_checkpoint])
def main():
images_path = '/Users/ericfornaciari/Desktop/data/images/patches/raw/1024x1024/'
masks_path = '/Users/ericfornaciari/Desktop/data/masks/patches/encoded/1024x1024/'
images = np.zeros((len(os.listdir(images_path)), 1024, 1024, 3), np.uint16)
masks = np.zeros((len(os.listdir(masks_path)), 1024, 1024, 1), np.bool)
for i, filename in enumerate(os.listdir(images_path)):
images[i, :, :, :] = imread(os.path.join(images_path, filename))
for i, filename in enumerate(os.listdir(masks_path)):
masks[i, :, :, :] = np.load(os.path.join(masks_path, filename),
allow_pickle=True)
unet = model.unet(input_size=(1024, 1024, 3))
unet.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
earlystopper = EarlyStopping(patience=5, verbose=1)
checkpointer = ModelCheckpoint('init.h5', verbose=1, save_best_only=True)
unet.fit(images,
masks,
validation_split=0.1,
batch_size=16,
epochs=50,
callbacks=[earlystopper, checkpointer])
def train(args):
# data augmentation configuration
data_gen_args = dict(rotation_range=0.2,
width_shift_range=0.05,
height_shift_range=0.05,
shear_range=0.05,
zoom_range=0.05,
horizontal_flip=True,
fill_mode='nearest')
# training set
myGene = trainGenerator(2,
os.path.join(args.root, 'train'),
'image',
'label',
data_gen_args,
target_size=(512, 512),
save_to_dir=None)
# model
model = unet()
model_checkpoint = ModelCheckpoint(args.save_path,
monitor='loss',
verbose=1,
save_best_only=True)
# train
model.fit_generator(myGene,
steps_per_epoch=2000,
epochs=5,
callbacks=[model_checkpoint])
def main():
data_gen_args = dict(rotation_range=0.2,
width_shift_range=0.05,
height_shift_range=0.05,
shear_range=0.05,
zoom_range=0.05,
horizontal_flip=True,
fill_mode='nearest')
img_gen_arg_dict = dict(directory = train_path,
classes = [image_folder],
class_mode = None,
color_mode = image_color_mode,
target_size = target_size,
batch_size = batch_size,
save_to_dir = save_to_dir,
save_prefix = image_save_prefix,
seed = seed)
mask_gen_arg_dict = dict(directory = train_path,
classes = [mask_folder],
class_mode = None,
color_mode = mask_color_mode,
target_size = target_size,
batch_size = batch_size,
save_to_dir = save_to_dir,
save_prefix = mask_save_prefix,
seed = seed)
val_img_gen_arg_dict = dict(directory = val_path,
classes = [val_image_folder],
class_mode = None,
color_mode = image_color_mode,
target_size = target_size,
batch_size = batch_size,
save_to_dir = save_to_dir,
save_prefix = image_save_prefix,
seed = seed)
val_mask_gen_arg_dict = dict(directory = val_path,
classes = [mask_folder],
class_mode = None,
color_mode = mask_color_mode,
target_size = target_size,
batch_size = batch_size,
save_to_dir = save_to_dir,
save_prefix = mask_save_prefix,
seed = seed)
myGene = trainGenerator(data_gen_args, img_gen_arg_dict, mask_gen_arg_dict)
valGene = trainGenerator(data_gen_args, val_img_gen_arg_dict, val_mask_gen_arg_dict)
history = LossHistory()
model = unet()
model_checkpoint = ModelCheckpoint(model_path, monitor='loss', verbose=1, save_best_only=True)
model.fit_generator(myGene, steps_per_epoch=300, epochs=10, validation_data=valGene, validation_steps=30, callbacks=[model_checkpoint, history])
history.loss_plot('epoch', result_image_path)
print('result saved')
testGene = testGenerator(test_path, test_image_type)
results = model.predict_generator(testGene, 10, verbose=1)
saveResult(result_save_path, results)
def eval_and_save_result(dataset_dir, model_path, eval_result_dirpath,
eval_summary_name='eval_summary.yml',
files_2b_copied=None,
num_filters=64,num_maxpool=4,
modulo=16):
'''
'''
#---- load ----
train_dir = os.path.join(dataset_dir,'train')
valid_dir = os.path.join(dataset_dir,'valid')
test_dir = os.path.join(dataset_dir,'test')
train_img_dir = os.path.join(train_dir,'image')
train_label_dir = os.path.join(train_dir,'label')
valid_img_dir = os.path.join(valid_dir,'image')
valid_label_dir = os.path.join(valid_dir,'label')
test_img_dir = os.path.join(test_dir, 'image')
test_label_dir = os.path.join(test_dir, 'label')
assert_exists(train_img_dir)
assert_exists(train_label_dir)
assert_exists(valid_img_dir)
assert_exists(valid_label_dir)
assert_exists(test_img_dir)
assert_exists(test_label_dir)
train_inputs = list(load_imgs(train_img_dir))
train_answers = list(load_imgs(train_label_dir))
valid_inputs = list(load_imgs(valid_img_dir))
valid_answers = list(load_imgs(valid_label_dir))
test_inputs = list(load_imgs(test_img_dir))
test_answers = list(load_imgs(test_label_dir))
#---- eval ----
segnet = model.unet(model_path, (None,None,1),
num_filters=num_filters, num_maxpool=num_maxpool)
train_iou_arr, train_result_tuples = evaluate(segnet, train_inputs, train_answers, modulo)
valid_iou_arr, valid_result_tuples = evaluate(segnet, valid_inputs, valid_answers, modulo)
test_iou_arr, test_result_tuples = evaluate(segnet, test_inputs, test_answers, modulo)
K.clear_session()
print('Evaluation completed!')
#---- save ----
summary_path, train_path, valid_path, test_path = make_eval_directory(eval_result_dirpath,
eval_summary_name)
save_eval_summary(summary_path, train_iou_arr, valid_iou_arr, test_iou_arr)
print('Evaluation summary is saved!')
save_img_tuples(train_result_tuples, train_path)
save_img_tuples(valid_result_tuples, valid_path)
save_img_tuples(test_result_tuples, test_path)
print('Evaluation result images are saved!')
if files_2b_copied is None:
files_2b_copied = [model_path]
else:
files_2b_copied.append(model_path)
for file_path in files_2b_copied:
file_name = os.path.basename(file_path)
shutil.copyfile(file_path, os.path.join(eval_result_dirpath, file_name))
print("file '%s' is copyed into '%s'" % (file_name,eval_result_dirpath))
def test_unet():
from utils import calc_params
from model import unet
import torch
model = unet()
calc_params(model)
x = torch.randn(1, 3, 192, 128)
print(model(x).shape)
def train_and_predict(data_path, data_filename, batch_size, n_epoch):
"""
Create a model, load the data, and train it.
"""
"""
Step 1: Load the data
"""
hdf5_filename = os.path.join(data_path, data_filename)
print("-" * 30)
print("Loading the data from HDF5 file ...")
print("-" * 30)
imgs_train, msks_train, imgs_validation, msks_validation, \
imgs_testing, msks_testing = \
load_data(hdf5_filename, args.batch_size,
[args.crop_dim, args.crop_dim],
args.channels_first, args.seed)
print("-" * 30)
print("Creating and compiling model ...")
print("-" * 30)
"""
Step 2: Define the model
"""
unet_model = unet()
model = unet_model.create_model(imgs_train.shape, msks_train.shape)
model_filename, model_callbacks = unet_model.get_callbacks()
# If there is a current saved file, then load weights and start from
# there.
saved_model = os.path.join(args.output_path, args.inference_filename)
if os.path.isfile(saved_model):
model.load_weights(saved_model)
"""
Step 3: Train the model on the data
"""
print("-" * 30)
print("Fitting model with training data ...")
print("-" * 30)
model.fit(imgs_train,
msks_train,
batch_size=batch_size,
epochs=n_epoch,
validation_data=(imgs_validation, msks_validation),
verbose=1,
shuffle="batch",
callbacks=model_callbacks)
"""
Step 4: Evaluate the best model
"""
print("-" * 30)
print("Loading the best trained model ...")
print("-" * 30)
unet_model.evaluate_model(model_filename, imgs_testing, msks_testing)
def __init__(self, _train_list, _val_list, _inf_list, _dag_it = 0, _input_shape = (256, 1024, 3),
_train_steps = 500, _val_steps = 200, _num_epochs = 15, _batch_size = 4, _gpu_num = '0, 1',
_no_inidices = True, _segnet = False):
self.dag_it = _dag_it
self.train_list = _train_list
self.val_list = _val_list
self.inf_list = _inf_list
self.base_dir = '/media/localadmin/Test/11Nils/kitti/dataset/sequences/Data/'
self.img_dir = 'images/'
self.label_dir = 'labels/'
self.inf_dir = 'inf/'
self.dag_dir = 'dagger/'
self.log_dir = 'log/'
self.optimizer = 'adagrad'
self.gpu_num = _gpu_num # '1'
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = self.gpu_num
self.untrained = 'store_true'
self.loss = 'categorical_crossentropy'
self.output_mode = 'softmax'
self.pool_size = (2, 2)
self.kernel = 3
self.input_shape = _input_shape # (128, 512, 3)
self.n_labels = 3 # num classes
self.val_steps = _val_steps
self.epoch_steps = _train_steps
self.n_epochs = _num_epochs
self.batch_size = _batch_size
self.filters = 8
self.b_pool_indices = _no_inidices
self.b_use_segnet = _segnet
if not self.b_pool_indices and not self.b_use_segnet:
self.model = unet_wIndices(self.input_shape, self.n_labels, self.filters, self.kernel, self.pool_size,
self.output_mode)
elif not self.b_use_segnet:
self.model = unet(self.input_shape, self.n_labels, self.filters, self.kernel, self.pool_size,
self.output_mode)
else:
self.model = segnet(self.input_shape, self.n_labels, self.filters, self.kernel, self.pool_size,
self.output_mode)
print(self.model.summary())
list_gpus_trained = [int(x) for x in self.gpu_num.split(',')]
self.num_gpus = len(list_gpus_trained)
if self.num_gpus > 1:
trained_gpu_str = ', '.join(str(e) for e in list_gpus_trained)
print('Training on GPU\'s: ' + trained_gpu_str)
self.multi_model = multi_gpu_model(self.model, gpus = self.num_gpus)
else:
self.multi_model = self.model
self.multi_model.compile(loss = self.loss, optimizer = self.optimizer, metrics = ['accuracy'])
plot_model(model = self.multi_model, to_file = self.base_dir + 'model.png')
print(print_summary(self.multi_model))
self.std = [0.32636853, 0.31895106, 0.30716496]
self.mean = [0.39061851, 0.38151629, 0.3547171]
self.es_cb = []
self.tb_cb = []
self.cp_cb = []
def run():
input_dim = (768, 768, 3)
print("Instantiating model...")
model = unet(input_dim)
print(model.summary())
print("Creating training generator...")
val_generator = load_data_generator('data/val_images', 'data/val_masks', batch_size=2)
train_generator = load_data_generator('data/images', 'data/masks', batch_size=2)
plot_generator(val_generator)
def create_unet(myGene):
mdl = model.unet()
model_checkpoint = ModelCheckpoint('../model/unet_membrane.hdf5', monitor='loss',verbose=1, save_best_only=True)
history = mdl.fit_generator(myGene,steps_per_epoch=steps,epochs=epochs,callbacks=[model_checkpoint])
print(history.history['loss'])
# ulozit historiu
#with open('../model/history.json', 'w') as f:
#json.dump(history.history, f)
data.saveHist('../model/history.json', history)
return mdl, history.history
def plotSavedModel(modeindex):
# Import Dataset
modes = DataSet.learningModes
data = DataSet(modes[modeindex])
data.print()
# Network Parameters
WIDTH = data.WIDTH
HEIGHT = data.HEIGHT
CHANNELS = data.CHANNELS_IN
NUM_INPUTS = WIDTH * HEIGHT * CHANNELS
NUM_OUTPUTS = data.CHANNELS_OUT
# Network Varibles and placeholders
X = tf.placeholder(tf.float32, [None, HEIGHT, WIDTH, CHANNELS]) # Input
Y = tf.placeholder(
tf.float32, [None, HEIGHT, WIDTH, NUM_OUTPUTS]) # Truth Data - Output
global_step = tf.Variable(0,
dtype=tf.int32,
trainable=False,
name='global_step')
# Define loss and optimizer
prediction = model.unet(X, NUM_OUTPUTS)
# Setup Saver
saver = tf.train.Saver()
# Initalize varibles, and run network
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
ckpt = ckpt = tf.train.get_checkpoint_state('./checkpoints/' +
modes[modeindex])
if (ckpt and ckpt.model_checkpoint_path):
print('Restoring Prev. Model ....')
saver.restore(sess, ckpt.model_checkpoint_path)
print('Model Loaded....')
# Show results
prediction = sess.run(prediction,
feed_dict={
X: data.x_test,
Y: data.y_test
})
# Compute metrics of prediction
metrics = do_metrics(prediction, data)
# index = np.random.randint(data.x_test.shape[0])
index = 4
print('Selecting Test Image #', index)
plot(data, prediction, modeindex, index)
def main():
# 构建模型.
model = unet(input_shape=(320, 320, 3), num_cls=32)
# 加载模型
model.load_weights("weights/unet_camvid_weights.h5")
sumiou = 0
sumacc = 0
root = "dataset/test/"
testList = os.listdir("dataset/test/")
# 数据
for file in testList:
if file.endswith("png"):
labelfile = "C:\\Users\\41648\\Downloads\\camvid-master\\camvid-master\\LabeledApproved_full\\" + \
file.split(".")[0] + "_L.png"
gtfile = "dataset/testannot/" + file.split(".")[0] + "_P.png"
image = cv2.imread(os.path.join(root, file))
image = cv2.resize(image, (320, 320))
image_ = np.float32(image) / 255.
batch_test_img = np.expand_dims(image_, axis=0)
pred = model.predict(batch_test_img)[0]
gt = cv2.imread(gtfile, 0)
gt = cv2.resize(gt, (320, 320))
pr = pred.argmax(axis=2)
sumacc += np.sum((gt == pr)) / (320 * 320)
iouCls = np.zeros((32, 2))
for cl in range(32):
if np.sum((gt == cl)) > 0:
intersection = np.sum((gt == cl) * (pr == cl))
union = np.sum(np.maximum((gt == cl), (pr == cl)))
iou = float(intersection) / (union + EPS)
iouCls[cl][0] += 1
iouCls[cl][1] += iou
# print(iouCls)
sumiou += iouCls
seg_img = visualize_segmentation(pr,
image,
n_classes=32,
colors=class_colors,
overlay_img=False,
show_legends=False,
class_names=class_names)
seg_img = np.asarray(seg_img, np.uint8)
seg_img = cv2.cvtColor(seg_img, cv2.COLOR_RGB2BGR)
label = cv2.imread(labelfile)
label = cv2.resize(label, (320, 320))
out = np.hstack([label, image, seg_img])
# cv2.imwrite("result/"+file,out)
cv2.imshow("seg_img", out)
cv2.waitKey(50)
def main():
model = unet(input_size=(512, 512, 3))
model.load_weights("unet_pins.hdf5")
framesDir = '/home/trevol/HDD_DATA/Computer_Vision_Task/Computer_Vision_Task/frames_6'
savePath = '/home/trevol/HDD_DATA/Computer_Vision_Task/Computer_Vision_Task/frames_6_unet_pins_only'
for image, fileName in yieldImages(framesDir):
results = model.predict(image, verbose=0)
result = (results[0, :, :, 0] * 255).astype(np.uint8)
skimage.io.imsave(
os.path.join(savePath, fileName.replace('.jpg', '.png')), result)
def train(validate_input=False):
training_generator = MyAugGenerator(BATCH_SIZE, train_path, 'training_images', 'training_labels', aug_dict, IMG_SIZE)
val_generator = MyAugGenerator(BATCH_SIZE, train_path, 'training_images', 'training_labels', {}, IMG_SIZE)
if validate_input:
validate_generator(training_generator)
model = unet(IMG_SIZE, dropout)
model.compile(optimizer=Adam(lr=learning_rate), loss=wbce_loss, metrics=my_metrics)
model_checkpoint = ModelCheckpoint('unet_checkpoint.hdf5', monitor='loss', save_best_only=True)
model.fit(training_generator,
validation_data=val_generator,
epochs=EPOCHS,
callbacks=[model_checkpoint])
def main_():
image, originalImage = readImage('testData/f_0021_1400.00_1.40.jpg',
as_gray=True)
model = unet(input_size=(512, 512, 1))
model.load_weights("checkpoints/unet_grayscale_pins_4_0.0021_0.999.hdf5")
results = model.predict(image, batch_size=1, verbose=0)
results = np.round(np.squeeze(results[0]) * 255, 0).astype(np.uint8)
cv2.imshow('image', originalImage)
cv2.imshow('results', results)
cv2.waitKey()
def draw(model_path, image_path):
model = unet()
model.load_weights(model_path)
testGene = testGenerator(image_path, 5, target_size=(512, 512))
results = model.predict_generator(testGene, 5, verbose=1)
results = results > 0.5
for i in range(results.shape[0]):
array = np.uint8(results[i].squeeze())
array = array * 255
img = Image.fromarray(array, 'L')
img.save('{}.png'.format(i))
def main_():
model = unet()
model.load_weights("../unet_membrane_5_0.123_0.946.hdf5")
# image, originalImage = readImage('../data/membrane/test/0.png', target_size=(256, 256), as_gray=True)
image, originalImage = readImage('data/image/f_0350_23333.33_23.33.jpg',
target_size=(256, 256),
as_gray=True)
results = model.predict(image, batch_size=1, verbose=0)
results = np.round(np.squeeze(results[0]) * 255, 0).astype(np.uint8)
cv2.imshow('image', originalImage)
cv2.imshow('results', results)
cv2.waitKey()
def predict256x256x3_n_save():
targetSize = (256, 256)
model = unet(input_size=targetSize + (3, ))
model.load_weights("checkpoints/rgb/unet_pins_20_0.001_1.000.hdf5")
framesDir = '/home/trevol/HDD_DATA/Computer_Vision_Task/Computer_Vision_Task/frames_6'
savePath = '/home/trevol/HDD_DATA/Computer_Vision_Task/Computer_Vision_Task/frames_6_unet_pins_only'
for batch, originalImage, fileName in yieldImages(framesDir,
targetSize,
as_gray=False):
results = model.predict(batch, verbose=0)
results = np.round((results[0, :, :, 0] * 255), 0).astype(np.uint8)
skimage.io.imsave(
os.path.join(savePath, fileName.replace('.jpg', '.png')), results)
