def load_model(self):
tag = 'deeplab_' + self.model_name + '_' + self.dataset
print('> Loading Model [%s] ' % (self.model_name))
with self.sess.as_default():
with tf.variable_scope('model'):
self.model = Deeplabv3(weights=self.dataset,
backbone=self.model_name,
weights_path=auto_download(
self.folder, tag))
if self.save_and_reload:
# Save and reload the model to avoid batch normalization issues
model_weights = tf.compat.v1.get_collection(
tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES,
scope='model')
print('> Saving Model')
tf.compat.v1.train.Saver(model_weights).save(
self.sess, 'tmp/')
print('> Reload Model')
tf.compat.v1.train.Saver(model_weights).restore(
self.sess, 'tmp/')
self.model_in = self.model.layers[0].input
self.model_out = self.model.layers[-1].output
self.model_softmax = tf.compat.v1.nn.softmax(self.model_out, -1)
self.model_label_out = tf.cast(
tf.compat.v1.math.argmax(self.model_out, -1), tf.uint8)
def main(args):
model = Deeplabv3(classes=21,
activation='softmax',
alpha=0.25,
weights=None)
model.summary()
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
t = DataGenerator(args.train_data_dir)
v = DataGenerator(args.val_data_dir)
callbacks = [
tf.keras.callbacks.TensorBoard(),
tf.keras.callbacks.ModelCheckpoint(
filepath='model-{epoch:02d}.h5',
save_best_only=True,
save_weights_only=True,
),
tf.keras.callbacks.ReduceLROnPlateau(
monitor='val_loss',
patience=4,
factor=0.1,
),
tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=9),
]
model.fit_generator(
t,
epochs=1000,
validation_data=v,
callbacks=callbacks,
)
def main(args):
import tensorflow as tf
from deeplab.model import Deeplabv3
deeplab_model = Deeplabv3(
classes=2,
activation='softmax',
model_path=args.model_from,
)
deeplab_model.save(args.model_to)
def build_compile(optimizer,
input_height=360,
input_width=480,
extra_metrics=[]):
"""build and compile a Keras model. deeplab was taken from https://github.com/bonlime/keras-deeplab-v3-plus"""
model = Deeplabv3(input_shape=(input_height, input_width, 3), classes=2)
model.compile(loss="categorical_crossentropy",
optimizer=optimizer,
metrics=['accuracy'] + extra_metrics)
return model
def load_model(self):
tag = 'deeplab_' + self.model_name
fn_weight = auto_download(self.folder,tag)
print('> Loading Model [%s] ' % (self.model_name))
with self.sess.as_default():
with tf.variable_scope('model'):
model = Deeplabv3(weights='pascal_voc', backbone=self.model_name, weights_path = fn_weight)
self.model = model
model_weights = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES, scope='model')
print('> Saving Model')
tf.compat.v1.train.Saver(model_weights).save(self.sess, 'tmp/')
print('> Reload Model')
tf.compat.v1.train.Saver(model_weights).restore(self.sess, 'tmp/')
self.model_in = model.layers[0].input
self.model_out = model.layers[-1].output
self.model_softmax = tf.compat.v1.nn.softmax(self.model_out,-1)
self.model_label_out = tf.cast(tf.compat.v1.math.argmax(self.model_out,-1),tf.uint8)
def main(args):
from deeplab.model import Deeplabv3
trained_image_width = args.dim
mean_subtraction_value = 127.5
image = np.array(Image.open(args.input_path))
# resize to max dimension of images from training dataset
w, h, _ = image.shape
ratio = float(trained_image_width) / np.max([w, h])
resized_image = np.array(
Image.fromarray(image.astype('uint8')).resize(
(int(ratio * h), int(ratio * w))))
# apply normalization for trained dataset images
resized_image = (resized_image / mean_subtraction_value) - 1.
# pad array to square image to match training images
pad_x = int(trained_image_width - resized_image.shape[0])
pad_y = int(trained_image_width - resized_image.shape[1])
resized_image = np.pad(resized_image, ((0, pad_x), (0, pad_y), (0, 0)),
mode='constant')
# make prediction
deeplab_model = Deeplabv3(classes=2,
activation='softmax',
model_path=args.model_path)
res = deeplab_model.predict(np.expand_dims(resized_image, 0))
labels = np.argmax(res.squeeze(), -1)
# remove padding and resize back to original image
if pad_x > 0:
labels = labels[:-pad_x]
if pad_y > 0:
labels = labels[:, :-pad_y]
labels = np.array(Image.fromarray(labels.astype('uint8')).resize((h, w)))
img_result = np.ones_like(labels)
img_result[labels == 1] = 0
cv2.imwrite(args.output_path, img_result * 255)
def main():
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
if args.gpu >= 0:
cudnn.enabled = True
if args.v3:
model = Deeplabv3(num_classes=args.num_classes)
else:
model = Deeplab(num_classes=args.num_classes)
model.train()
if args.gpu >= 0:
if args.distributed:
model = nn.DataParallel(model).cuda()
else:
model.cuda(args.gpu)
cudnn.benchmark = True
if args.model is not None:
saved_state_dict = torch.load(args.model)
model.load_state_dict(saved_state_dict)
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
trainloader = data.DataLoader(ImageDataSet(args.data_dir,
args.data_list,
max_iters=args.num_steps *
args.batch_size,
crop_size=input_size,
scale=args.random_scale,
mirror=args.random_mirror,
mean=IMG_MEAN),
batch_size=args.batch_size,
shuffle=True,
num_workers=5,
pin_memory=False)
optimizer = optim.SGD([{
'params': get_1x_lr_params_NOscale(model, True),
'lr': args.lr
}, {
'params': get_10x_lr_params(model, True),
'lr': 10 * args.lr
}],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
optimizer.zero_grad()
interp = nn.Upsample(size=input_size, mode='bilinear')
for i_iter, batch in enumerate(trainloader):
images, labels, _, _ = batch
images = images.cuda(async=True)
labels = labels.cuda(async=True)
images = Variable(images)
optimizer.zero_grad()
adjust_lr(optimizer, i_iter)
pred = interp(model(images))
loss = loss_calc(pred, labels, args.gpu)
print("Step: {}, Loss: {}".format(i_iter, float(loss.data)))
loss.backward()
optimizer.step()
if i_iter >= args.num_steps - 1:
torch.save(
model.state_dict(),
osp.join(args.snapshot_dir,
'model_' + str(args.num_steps) + '.pth'))
break
if i_iter % args.save_steps == 0 and i_iter != 0:
torch.save(
model.state_dict(),
osp.join(args.snapshot_dir, 'model_' + str(i_iter) + '.pth'))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model")
parser.add_argument("--data-dir", type=str, default="./datasets")
parser.add_argument("--data-list", type=str, default="./datasets/val.txt")
parser.add_argument("--ignore-label", type=int, default=255)
parser.add_argument("--num-classes", type=int, default=2)
parser.add_argument("--v3", action="store_true")
parser.add_argument("--distributed", action="store_true")
parser.add_argument("--gpu",
type=int,
default=0,
help="choose gpu device.")
args = parser.parse_args()
if args.v3:
model = Deeplabv3(num_classes=args.num_classes)
else:
model = Deeplab(num_classes=args.num_classes)
if args.gpu >= 0:
if args.distributed:
model = nn.DataParallel(model).cuda()
else:
model.cuda(args.gpu)
saved_state_dict = torch.load(args.model)
model.load_state_dict(saved_state_dict)
model.eval()
testloader = data.DataLoader(ImageDataSet(args.data_dir,
args.data_list,
crop_size=(720, 1280),
mean=IMG_MEAN,
scale=False,
mirror=False),
batch_size=1,
shuffle=False,
pin_memory=False)
interp = nn.Upsample(size=(720, 1280), mode='bilinear')
data_list = []
for index, batch in enumerate(testloader):
if index % 100 == 0:
print('%d processd' % (index))
image, label, size, name = batch
image = image.cuda()
label = label
size = size[0].numpy()
start = time.time()
output = model(Variable(image, volatile=True))
output = interp(output).cpu().data[0].numpy()
#output = output[:, :size[0], :size[1]]
gt = np.asarray(label[0].numpy()[:size[0], :size[1]], dtype=np.int)
output = output.transpose(1, 2, 0)
output = np.asarray(np.argmax(output, axis=2), dtype=np.int)
target = np.where(output > 0)
corner = get_corner(target)
print(corner)
rt, lb = get_rt_and_lb(corner[1], corner[2], target)
corner = (corner[0], rt, lb, corner[3])
elapsed_time = time.time() - start
print("elapsed_time:{0}".format(elapsed_time) + "[sec]")
show_circle(corner,
os.path.join(args.data_dir, "images/" + name[0] + ".jpg"),
name[0], index)
show_all(gt, output, index)
data_list.append([gt.flatten(), output.flatten()])
get_iou(data_list, args.num_classes)
def main():
print(Deeplabv3)
deeplab_model = Deeplabv3(input_shape=(None, None, 3), classes=4)