def show_frame():
global operators_val
global display
global window
ret, frame = cap.read()
# frame = cv2.imread('ade20k_example.jpg')
frame = cv2.resize(frame, (0, 0), fx=0.9, fy=0.9)
frame = cv2.flip(frame, 1)
if int(operators_val.get()) == 0:
pass
elif int(operators_val.get()) == 1:
x, img = load_test(frame, short=200)
output = seg_net.demo(x)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
print(predict.shape)
mask = get_color_pallete(predict, 'pascal_voc')
img = np.asarray(mask)
print(img.shape)
mask = cv2.resize(img, (frame.shape[1], frame.shape[0]))
frame = frame.astype(np.float32) + mask.astype(np.float32)
frame[frame > 255] = 255
frame = frame.astype(np.uint8)
elif int(operators_val.get()) == 2:
x, img = load_test(frame, short=200)
class_IDs, scores, bounding_boxs = net(x)
frame = plot_bbox(frame,
img,
bounding_boxs[0],
scores[0],
class_IDs[0],
class_names=net.classes)
elif int(operators_val.get()) == 3:
frame = 255 - frame
elif int(operators_val.get()) == 4:
model = gluoncv.model_zoo.get_model('psp_resnet50_ade',
pretrained=True)
img, _ = load_test(frame, 150)
output = model.demo(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
mask = get_color_pallete(predict, 'ade20k')
img = np.asarray(mask.convert('RGB'))
mask = cv2.resize(img, (frame.shape[1], frame.shape[0]))
frame = frame.astype(np.float32) + mask.astype(np.float32)
frame[frame > 255] = 255
frame = frame.astype(np.uint8)
cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)
img = Image.fromarray(cv2image)
imgtk = ImageTk.PhotoImage(image=img)
display.imgtk = imgtk
display.configure(image=imgtk)
window.after(10, show_frame)
def process(self, filename):
origimg = image.imread(filename + '.png')
img = self.transform_fn(origimg)
img = img.expand_dims(0).as_in_context(self.ctx)
output = self.model.demo(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
s = set([])
for (x, y), value in np.ndenumerate(predict):
s.add(value)
print(s) #0:background, 15:person
marginmap = np.zeros((predict.shape[0], predict.shape[1]), np.uint8)
for (h, w), value in np.ndenumerate(predict):
if marginmap[h][w] == 0 and value == 15:
for u in range(-20, 20):
for v in range(-20, 20):
try:
marginmap[h + u][w + v] = 1
predict[h + u][w + v] = 15.0
except:
pass
mask = get_color_pallete(predict, self.palletename)
mask.save(filename + '_marginmask.png')
mask2 = np.array(mask.convert('RGB'))
overlay = cv2.addWeighted(origimg.asnumpy(), 0.5, mask2, 0.5, 0)
overlay = Image.fromarray(overlay)
overlay.save(filename + '_marginoverlay.png')
def my_color_palette(npimg, dataset: str):
"""
Visualize image and return PIL.Image with color palette.
:param npimg: Single channel numpy image with shape `H, W, 1`
:param dataset: dataset name
"""
if dataset in ('pascal_voc', 'ade20k', 'citys', 'mhpv1'):
return get_color_pallete(npimg, dataset=dataset)
elif dataset == 'camvid':
npimg[npimg == -1] = 11
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(cam_palette)
return out_img
elif dataset == 'mapillary':
npimg[npimg == -1] = 65
color_img = _apply_mapillary_palette(npimg)
out_img = Image.fromarray(color_img)
return out_img
elif dataset == 'aeroscapes':
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(aeroscapes_palette)
return out_img
else:
raise RuntimeError("Un-defined palette for data {}".format(dataset))
def imageSegment(model_name, input_pic):
# Load Images
img = mx.image.imread("images/" + input_pic)
# Transform
transform_fn = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225])
])
img = transform_fn(img)
# Add extra dimension to img for batch size
img = img.expand_dims(0)
# Assume pretrained
net = gcv.model_zoo.get_model(model_name, pretrained=True)
# Output has dimensions of: (# images, # classes, pixelY, pixelX) in logits
out = net.predict(img)
out = out[0]
# pred will contain the class index with highest probability for each pixel
pred = mx.nd.argmax(out, 0).asnumpy()
pred_img = get_color_pallete(pred, 'ade20k')
plt.figure()
plt.imshow(pred_img)
def test_quantization(model, args, test_data, size, num_class, pred_offset):
# output folder
outdir = 'outdir_int8'
if not os.path.exists(outdir):
os.makedirs(outdir)
print(model)
metric = gluoncv.utils.metrics.SegmentationMetric(num_class)
tbar = tqdm(test_data)
metric.reset()
tic = time.time()
for i, (batch, dsts) in enumerate(tbar):
if args.eval:
targets = mx.gluon.utils.split_and_load(dsts, ctx_list=args.ctx, even_split=False)
data = mx.gluon.utils.split_and_load(batch, ctx_list=args.ctx, batch_axis=0, even_split=False)
outputs = None
for x in data:
output = model(x)
outputs = output if outputs is None else nd.concat(outputs, output, axis=0)
metric.update(targets, outputs)
pixAcc, mIoU = metric.get()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
for data, impath in zip(batch, dsts):
data = data.as_in_context(args.ctx[0])
if len(data.shape) < 4:
data = nd.expand_dims(data, axis=0)
predict = model(data)[0]
predict = mx.nd.squeeze(mx.nd.argmax(predict, 1)).asnumpy() + pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
speed = size / (time.time() - tic)
print('Inference speed with batchsize %d is %.2f img/sec' % (args.batch_size, speed))
def test(args):
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
# dataset and dataloader
if args.eval:
testset = get_segmentation_dataset(
args.dataset, split='val', mode='testval', transform=input_transform, root='/mnt/mdisk/xcq/VOCdevkit/')
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
testset = get_segmentation_dataset(
args.dataset, split='test', mode='test', transform=input_transform, root='/mnt/mdisk/xcq/VOCdevkit/')
test_data = gluon.data.DataLoader(
testset, args.test_batch_size, shuffle=False, last_batch='keep',
batchify_fn=ms_batchify_fn, num_workers=args.workers)
# create network
if args.model_zoo is not None:
model = get_model(args.model_zoo, pretrained=True)
else:
model = get_segmentation_model(model=args.model, dataset=args.dataset, ctx=args.ctx,
backbone=args.backbone, norm_layer=args.norm_layer,
norm_kwargs=args.norm_kwargs, aux=args.aux,
base_size=args.base_size, crop_size=args.crop_size)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
if os.path.isfile(args.resume):
model.load_parameters(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
print(model)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
targets = [target.as_in_context(predicts[0].context) \
for target in dsts]
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description( 'pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
im_paths = dsts
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
def test(args):
# output folder
means = nd.array([123, 117, 104])
std = nd.array([58.395, 57.12, 57.375])
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# dataset and dataloader
if args.eval:
img = image.imread('./0000000152.png')
img = img.astype('float32')
img = img - means
img = img / std
img = nd.transpose(img, (2, 0, 1))
img = nd.expand_dims(img, axis=0)
testset = get_segmentation_dataset(
args.dataset, split='val', mode='testval', transform=input_transform, root='/mnt/mdisk/xcq/VOCdevkit/')
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
testset = get_segmentation_dataset(
args.dataset, split='test', mode='test', transform=input_transform, root='/mnt/mdisk/xcq/VOCdevkit/')
if args.model_zoo is not None:
model = get_model(args.model_zoo, pretrained=True)
else:
model = get_segmentation_model(model=args.model, dataset=args.dataset, ctx=args.ctx,
backbone=args.backbone, norm_layer=args.norm_layer,
norm_kwargs=args.norm_kwargs, aux=args.aux,
base_size=args.base_size, crop_size=args.crop_size)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
if os.path.isfile(args.resume):
model.load_parameters(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
print(model)
predicts = model(img)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
targets = [target.as_in_context(predicts[0].context) \
for target in dsts]
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description( 'pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
im_paths = dsts
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
def getColor(self, predict, dataset='ade20k', saved_name=''):
colored = get_color_pallete(predict, dataset)
if saved_name != '':
try:
colored.save(saved_name)
# io.imsave(saved_name, colored, check_contrast=False)
except Exception as e:
print("Error in saving file in getSeg():", e, saved_name)
return colored
def show_color_pallete(predict):
from gluoncv.utils.viz import get_color_pallete
import matplotlib.image as mpimg
mask = get_color_pallete(predict, 'pascal_voc')
mask.save('output.png')
# show the predicted mask
mmask = mpimg.imread('output.png')
plt.imshow(mmask)
plt.show()
def test_quantization(model, args, input_transform):
# output folder
outdir = 'outdir_int8'
if not os.path.exists(outdir):
os.makedirs(outdir)
# hybridize
model.hybridize(static_alloc=True, static_shape=True)
# get dataset
if args.eval:
testset = get_segmentation_dataset(
args.dataset, split='val', mode=args.mode, transform=input_transform)
else:
testset = get_segmentation_dataset(
args.dataset, split='test', mode=args.mode, transform=input_transform)
size = len(testset)
batchify_fn = ms_batchify_fn if testset.mode == 'test' else None
test_data = gluon.data.DataLoader(
testset, args.batch_size, batchify_fn=batchify_fn, last_batch='keep',
shuffle=False, num_workers=args.workers)
print(model)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
tbar = tqdm(test_data)
metric.reset()
tic = time.time()
for i, (batch, dsts) in enumerate(tbar):
if args.eval:
targets = mx.gluon.utils.split_and_load(dsts, ctx_list=args.ctx, even_split=False)
data = mx.gluon.utils.split_and_load(batch, ctx_list=args.ctx, batch_axis=0, even_split=False)
outputs = None
for x in data:
output = model(x)
outputs = output if outputs is None else nd.concat(outputs, output, axis=0)
metric.update(targets, outputs)
pixAcc, mIoU = metric.get()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
for data, impath in zip(batch, dsts):
data = data.as_in_context(args.ctx[0])
if len(data.shape) < 4:
data = nd.expand_dims(data, axis=0)
predict = model(data)[0]
predict = mx.nd.squeeze(mx.nd.argmax(predict, 1)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
speed = size / (time.time() - tic)
print('Inference speed with batchsize %d is %.2f img/sec' % (args.batch_size, speed))
def plot_image(model, img):
st.warning("Inferencing from Model..")
output = model.predict(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
mask = get_color_pallete(predict, 'mhpv1')
mask.save('output.png')
mmask = mpimg.imread('output.png')
image = mpimg.imread('saved_image.jpg')
st.set_option('deprecation.showPyplotGlobalUse', False)
st.success("Pose Estimation Successful!! Plotting Image..")
st.image(image, width=500, height=500)
st.image(mmask, width=500, height=500)
def test(model, args, input_transform):
# DO NOT modify!!! Only support batch_size=ngus
batch_size = args.ngpus
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# get dataset
if args.eval:
testset = get_segmentation_dataset(args.dataset,
split='val',
mode='testval',
transform=input_transform)
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
testset = get_segmentation_dataset(args.dataset,
split='test',
mode='test',
transform=input_transform)
test_data = gluon.data.DataLoader(testset,
batch_size,
shuffle=False,
last_batch='keep',
batchify_fn=ms_batchify_fn,
num_workers=args.workers)
print(model)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
targets = [target.as_in_context(predicts[0].context) \
for target in dsts]
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
im_paths = dsts
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
def test(args):
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
# dataset and dataloader
testset = get_segmentation_dataset(args.dataset,
split='test',
transform=input_transform)
test_data = gluon.data.DataLoader(testset,
args.test_batch_size,
last_batch='keep',
batchify_fn=test_batchify_fn,
num_workers=args.workers)
# create network
model = get_segmentation_model(model=args.model,
dataset=args.dataset,
backbone=args.backbone,
norm_layer=args.norm_layer)
print(model)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
# load pretrained weight
assert (args.resume is not None)
if os.path.isfile(args.resume):
model.load_params(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
tbar = tqdm(test_data)
for i, (data, im_paths) in enumerate(tbar):
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict, 1)).asnumpy()
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
def get_color_palette(npimg, dataset: str = 'pascal_voc'):
"""
Visualize image and return PIL.Image with color palette.
:param npimg: Single channel numpy image with shape `H, W, 1`
:param dataset: dataset name
"""
if dataset in ('pascal_voc', 'ade20k', 'citys', 'mhpv1'):
return get_color_pallete(npimg, dataset=dataset)
elif dataset == 'camvid':
npimg[npimg == -1] = 11
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(cam_palette)
return out_img
elif dataset == 'kittizhang':
npimg = npimg + 1
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(kittizhang_palette)
return out_img
elif dataset == 'kittixu':
npimg = npimg + 1
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(kittixu_palette)
return out_img
elif dataset == 'kittiros':
npimg[npimg == -1] = 11
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(kittiros_palette)
return out_img
elif dataset == 'gatech':
npimg = npimg + 1
out_img = Image.fromarray(npimg.astype('uint8'))
out_img.putpalette(gatech_palette)
return out_img
else:
raise RuntimeError("Un-defined palette for data {}".format(dataset))
def test(model, args, input_transform):
# DO NOT modify!!! Only support batch_size=ngus
batch_size = args.ngpus
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# get dataset
if args.eval:
testset = get_segmentation_dataset(
args.dataset, split='val', mode='testval', transform=input_transform)
else:
testset = get_segmentation_dataset(
args.dataset, split='test', mode='test', transform=input_transform)
if 'icnet' in args.model:
test_data = gluon.data.DataLoader(
testset, batch_size, shuffle=False, last_batch='rollover',
num_workers=args.workers)
else:
test_data = gluon.data.DataLoader(
testset, batch_size, shuffle=False, last_batch='rollover',
batchify_fn=ms_batchify_fn, num_workers=args.workers)
print(model)
if 'icnet' in args.model:
evaluator = DataParallelModel(SegEvalModel(model), ctx_list=args.ctx)
else:
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
if 'icnet' in args.model:
tbar = tqdm(test_data)
t_gpu = 0
num = 0
for i, (data, dsts) in enumerate(tbar):
tic = time.time()
outputs = evaluator(data.astype('float32', copy=False))
t_gpu += time.time() - tic
num += 1
outputs = [x[0] for x in outputs]
targets = mx.gluon.utils.split_and_load(dsts, ctx_list=args.ctx, even_split=False)
metric.update(targets, outputs)
pixAcc, mIoU = metric.get()
gpu_time = t_gpu / num
tbar.set_description('pixAcc: %.4f, mIoU: %.4f, t_gpu: %.2fms' % (pixAcc, mIoU, gpu_time*1000))
else:
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
targets = [target.as_in_context(predicts[0].context) \
for target in dsts]
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
im_paths = dsts
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
def test(args):
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
# dataset and dataloader
if args.eval:
testset = get_segmentation_dataset(args.dataset,
split='val',
mode='testval',
transform=input_transform)
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
testset = get_segmentation_dataset(args.dataset,
split='test',
mode='test',
transform=input_transform)
test_data = gluon.data.DataLoader(testset,
args.test_batch_size,
last_batch='keep',
batchify_fn=ms_batchify_fn,
num_workers=args.workers)
# create network
if args.model_zoo is not None:
model = get_model(args.model_zoo, pretrained=True)
else:
model = get_segmentation_model(model=args.model,
dataset=args.dataset,
ctx=args.ctx,
backbone=args.backbone,
norm_layer=args.norm_layer)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
if os.path.isfile(args.resume):
model.load_params(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
print(model)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
targets = dsts
predicts = evaluator.parallel_forward(data)
for predict, target in zip(predicts, targets):
target = target.as_in_context(predict[0].context)
correct, labeled = batch_pix_accuracy(predict[0], target)
inter, union = batch_intersection_union(
predict[0], target, testset.num_class)
total_correct += correct.astype('int64')
total_label += labeled.astype('int64')
total_inter += inter.astype('int64')
total_union += union.astype('int64')
pixAcc = np.float64(1.0) * total_correct / (
np.spacing(1, dtype=np.float64) + total_label)
IoU = np.float64(1.0) * total_inter / (
np.spacing(1, dtype=np.float64) + total_union)
mIoU = IoU.mean()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
im_paths = dsts
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy()
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
print("frame_save_full_path is " + frame_save_full_path)
file_dirs = os.listdir(frame_save_full_path)
video_name = video[:-4].split("/")[-1]
# inference by using pretrained model
for file in file_dirs:
if file.endswith(
(
".bmp",
".dib",
".png",
".jpg",
".jpeg",
".pbm",
".pgm",
".ppm",
".tif",
".tiff",
)
):
img = image.imread(os.path.join(frame_save_full_path, file))
img = test_transform(img, ctx)
output = model.predict(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
mask = get_color_pallete(predict, "citys")
mask.save(os.path.join(output_data_path, video_name + "_" + file))
else:
continue
class_index = mx.nd.argmax(px_logit, axis=0)
# now convert float to int
class_index = class_index[0].astype('int').asscalar()
print(class_index)
# 2
# what is this class index?
# check the lookup table from indecies to labels
from gluoncv.data.ade20k.segmentation import ADE20KSegmentation
class_label = ADE20KSegmentation.CLASSES[class_index]
print(class_label)
# sky
# now perform it for all pixels
# axis=0 corresponds to channel dimension which are the classes
# output is a probability distributed across classes for every pixel
output_proba = mx.nd.softmax(output, axis=0)
output_heatmap = output_proba[2]
# plt.imshow(output_heatmap.asnumpy())
# plt.show()
prediction = mx.nd.argmax(output, 0).asnumpy()
# print(prediction)
# visualize most likely class
from gluoncv.utils.viz import get_color_pallete
prediction_image = get_color_pallete(prediction, 'ade20k')
plt.imshow(prediction_image)
plt.show()
##############################################################################
# normalize the image using dataset mean
from gluoncv.data.transforms.presets.segmentation import test_transform
img = test_transform(img, ctx)
##############################################################################
# Load the pre-trained model and make prediction
# ----------------------------------------------
#
# get pre-trained model
model = gluoncv.model_zoo.get_model('icnet_resnet50_mhpv1', pretrained=True)
##############################################################################
# make prediction using single scale
output = model.predict(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
##############################################################################
# Add color pallete for visualization
from gluoncv.utils.viz import get_color_pallete
import matplotlib.image as mpimg
mask = get_color_pallete(predict, 'mhpv1')
mask.save('output.png')
##############################################################################
# show the predicted mask
mmask = mpimg.imread('output.png')
plt.imshow(mmask)
plt.show()
from gluoncv.data import CitySegmentation
train_dataset = CitySegmentation(split='train')
val_dataset = CitySegmentation(split='val')
print('Training images:', len(train_dataset))
print('Validation images:', len(val_dataset))
################################################################
# Get the first sample
# --------------------
#
import numpy as np
img, mask = val_dataset[0]
# get pallete for the mask
from gluoncv.utils.viz import get_color_pallete
mask = get_color_pallete(mask.asnumpy(), dataset='citys')
mask.save('mask.png')
################################################################
# Visualize data and label
# ------------------------
#
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
# subplot 1 for img
fig = plt.figure()
fig.add_subplot(1, 2, 1)
plt.imshow(img.asnumpy().astype('uint8'))
# subplot 2 for the mask
mmask = mpimg.imread('mask.png')
fig.add_subplot(1, 2, 2)
from gluoncv.data import ADE20KSegmentation
train_dataset = ADE20KSegmentation(split='train')
val_dataset = ADE20KSegmentation(split='val')
print('Training images:', len(train_dataset))
print('Validation images:', len(val_dataset))
################################################################
# Get the first sample
# --------------------
#
import numpy as np
img, mask = val_dataset[0]
# get pallete for the mask
from gluoncv.utils.viz import get_color_pallete
mask = get_color_pallete(mask.asnumpy(), dataset='ade20k')
mask.save('mask.png')
################################################################
# Visualize data and label
# ------------------------
#
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
# subplot 1 for img
fig = plt.figure()
fig.add_subplot(1,2,1)
plt.imshow(img.asnumpy().astype('uint8'))
# subplot 2 for the mask
mmask = mpimg.imread('mask.png')
##############################################################################
# For data augmentation,
# we follow the standard data augmentation routine to transform the input image
# and the ground truth label map synchronously. (*Note that "nearest"
# mode upsample are applied to the label maps to avoid messing up the boundaries.*)
# We first randomly scale the input image from 0.5 to 2.0 times, then rotate
# the image from -10 to 10 degrees, and crop the image with padding if needed.
# Finally a random Gaussian blurring is applied.
#
# Random pick one example for visualization:
from random import randint
idx = randint(0, len(trainset))
img, mask = trainset[idx]
from gluoncv.utils.viz import get_color_pallete, DeNormalize
# get color pallete for visualize mask
mask = get_color_pallete(mask.asnumpy(), dataset='pascal_voc')
mask.save('mask.png')
# denormalize the image
img = DeNormalize([.485, .456, .406], [.229, .224, .225])(img)
img = np.transpose((img.asnumpy() * 255).astype(np.uint8), (1, 2, 0))
##############################################################################
# Plot the image and mask
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
# subplot 1 for img
fig = plt.figure()
fig.add_subplot(1, 2, 1)
plt.imshow(img)
# subplot 2 for the mask
# we follow the standard data augmentation routine to transform the input image
# and the ground truth label map synchronously. (*Note that "nearest"
# mode upsample are applied to the label maps to avoid messing up the boundaries.*)
# We first randomly scale the input image from 0.5 to 2.0 times, then rotate
# the image from -10 to 10 degrees, and crop the image with padding if needed.
# Finally a random Gaussian blurring is applied.
#
# Random pick one example for visualization:
import random
from datetime import datetime
random.seed(datetime.now())
idx = random.randint(0, len(trainset))
img, mask = trainset[idx]
from gluoncv.utils.viz import get_color_pallete, DeNormalize
# get color pallete for visualize mask
mask = get_color_pallete(mask.asnumpy(), dataset='pascal_voc')
mask.save('mask.png')
# denormalize the image
img = DeNormalize([.485, .456, .406], [.229, .224, .225])(img)
img = np.transpose((img.asnumpy()*255).astype(np.uint8), (1, 2, 0))
##############################################################################
# Plot the image and mask
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
# subplot 1 for img
fig = plt.figure()
fig.add_subplot(1,2,1)
plt.imshow(img)
# subplot 2 for the mask
# Load the pre-trained model and make prediction
# ----------------------------------------------
#
# get pre-trained model
model = gluoncv.model_zoo.get_model('fcn_resnet101_voc', pretrained=True)
##############################################################################
# make prediction using single scale
output = model.demo(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
##############################################################################
# Add color pallete for visualization
from gluoncv.utils.viz import get_color_pallete
import matplotlib.image as mpimg
mask = get_color_pallete(predict, 'pascal_voc')
mask.save('output.png')
##############################################################################
# show the predicted mask
mmask = mpimg.imread('output.png')
plt.imshow(mmask)
plt.show()
##############################################################################
# More Examples
# -------------
#
#.. image:: https://raw.githubusercontent.com/dmlc/web-data/master/gluoncv/segmentation/voc_examples/4.jpg
# :width: 45%
#
transforms.Normalize([.485, .456, .406], [.229, .224, .225])
])
img = transform_fn(img)
img = img.expand_dims(0).as_in_context(ctx)
##############################################################################
# Load the pre-trained model and make prediction
# ----------------------------------------------
#
# get pre-trained model
model = gluoncv.model_zoo.get_model('deeplab_resnet101_ade', pretrained=True)
##############################################################################
# make prediction using single scale
output = model.demo(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
##############################################################################
# Add color pallete for visualization
from gluoncv.utils.viz import get_color_pallete
import matplotlib.image as mpimg
mask = get_color_pallete(predict, 'ade20k')
mask.save('output.png')
##############################################################################
# show the predicted mask
mmask = mpimg.imread('output.png')
plt.imshow(mmask)
plt.show()
def main():
start = timer()
print('Processing Start time: %.1f' % (start))
print("current time", datetime.now())
gauth = GoogleAuth()
gauth.LocalWebserverAuth()
drive = GoogleDrive(gauth)
# Auto-iterate through all files that matches this query
file_list = drive.ListFile({'q': "'root' in parents"}).GetList()
for file in file_list:
# print('title: {}, id: {}'.format(file1['title'], file1['id']))
file_id = None
if file['title'] == "semanticsegmentation":
print('Folder Found')
file_id = file['id']
break
if file_id is not None:
classes = ["wall","building;edifice","sky","floor;flooring","tree","ceiling","road;route","bed","windowpane;window","grass","cabinet","sidewalk;pavement","person;individual;someone;somebody;mortal;soul","earth;ground","door;double;door","table","mountain;mount","plant;flora;plant;life","curtain;drape;drapery;mantle;pall","chair","car;auto;automobile;machine;motorcar","water","painting;picture","sofa;couch;lounge","shelf","house","sea","mirror","rug;carpet;carpeting","field","armchair","seat","fence;fencing","desk","rock;stone","wardrobe;closet;press","lamp","bathtub;bathing;tub;bath;tub","railing;rail","cushion","base;pedestal;stand","box","column;pillar","signboard;sign","chest;of;drawers;chest;bureau;dresser","counter","sand","sink","skyscraper","fireplace;hearth;open;fireplace","refrigerator;icebox","grandstand;covered;stand","path","stairs;steps","runway","case;display;case;showcase;vitrine","pool;table;billiard;table;snooker;table","pillow","screen;door;screen","stairway;staircase","river","bridge;span","bookcase","blind;screen","coffee;table;cocktail;table","toilet;can;commode;crapper;pot;potty;stool;throne","flower","book","hill","bench","countertop","stove;kitchen;stove;range;kitchen;range;cooking;stove","palm;palm;tree","kitchen;island","computer;computing;machine;computing;device;data;processor;electronic;computer;information;processing;system","swivel;chair","boat","bar","arcade;machine","hovel;hut;hutch;shack;shanty","bus;autobus;coach;charabanc;double-decker;jitney;motorbus;motorcoach;omnibus;passenger;vehicle","towel","light;light;source","truck;motortruck","tower","chandelier;pendant;pendent","awning;sunshade;sunblind","streetlight;street;lamp","booth;cubicle;stall;kiosk","television;television;receiver;television;set;tv;tv;set;idiot;box;boob;tube;telly;goggle;box","airplane;aeroplane;plane","dirt;track","apparel;wearing;apparel;dress;clothes","pole","land;ground;soil","bannister;banister;balustrade;balusters;handrail","escalator;moving;staircase;moving;stairway","ottoman;pouf;pouffe;puff;hassock","bottle","buffet;counter;sideboard","poster;posting;placard;notice;bill;card","stage","van","ship","fountain","conveyer;belt;conveyor;belt;conveyer;conveyor;transporter","canopy","washer;automatic;washer;washing;machine","plaything;toy","swimming;pool;swimming;bath;natatorium","stool","barrel;cask","basket;handbasket","waterfall;falls","tent;collapsible;shelter","bag","minibike;motorbike","cradle","oven","ball","food;solid;food","step;stair","tank;storage;tank","trade;name;brand;name;brand;marque","microwave;microwave;oven","pot;flowerpot","animal;animate;being;beast;brute;creature;fauna","bicycle;bike;wheel;cycle","lake","dishwasher;dish;washer;dishwashing;machine","screen;silver;screen;projection;screen","blanket;cover","sculpture","hood;exhaust;hood","sconce","vase","traffic;light;traffic;signal;stoplight","tray","ashcan;trash;can;garbage;can;wastebin;ash;bin;ash-bin;ashbin;dustbin;trash;barrel;trash;bin","fan","pier;wharf;wharfage;dock","crt;screen","plate","monitor;monitoring;device","bulletin;board;notice;board","shower","radiator","glass;drinking;glass","clock","flag"]
files = glob.glob(r'/Users/divyachandana/Documents/NJIT/work/summertasks/jun1-jun5/atlanta/*.jpg')
print("Total Files",len(files))
columns = ['filename','class','total_pixel','individual_pixel','ratio','timestamp']
# ---------- drive code -----
with open('semantic_results_atlanta.csv','a') as csvfile:
csvwriter = csv.writer(csvfile,lineterminator='\n')
# csvwriter.writerow(columns)
# i=0
for f in files:
file_check_query = "select count(*) from {} where filename like '%{}%'".format('semantic_results_atlanta', os.path.basename(f))
# print(file_check_query)
# i += 1
# print(i)
count = dbms.get_count_result(file_check_query)
# print(count)
if count > 0: continue
# print('resuming',f)
try:
img = image.imread(f)
img = image.resize_short(img, 1024)
# img = image.resize_short(img, 100)
# print("filename: ", f)
# ctx = mx.gpu(0)
img = test_transform(img, ctx)
# print("img: ", img)
output = model.predict(img)
# print("output: ", output)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
# print("predict: ", predict)
mask = get_color_pallete(predict, 'ade20k')
# predict.save('predict.png')
# mmask = mpimg.imread('output.png')
predict = predict.astype(numpy.uint8)
convert_single_array = numpy.array(predict)
unique_numbers = numpy.unique(convert_single_array)
# print(unique_numbers)
new_basename = os.path.basename(f).replace(".jpg", ".png")
new_name = os.path.join('output/', new_basename)
mask.save(new_name)
# color_img = image.imread(new_name)
# colors, counts = numpy.unique(color_img.reshape(-1, 3), return_counts=True, axis=0)
total_pixel = numpy.sum(predict)
d_file = drive.CreateFile({'parents': [{'id': file_id}], 'title': os.path.basename(new_name)})
d_file.SetContentFile(new_name)
d_file.Upload()
# print('Created file %s with mimeType %s' % (d_file['title'], d_file['mimeType']))
combile_all_csv_data = []
combine_sql_srting_format = []
for i in unique_numbers:
individual_count = numpy.sum(predict == i)
# print(individual_count)
csv_data = []
csv_data.append(os.path.basename(f))
csv_data.append(classes[i])
csv_data.append(total_pixel)
csv_data.append(individual_count)
csv_data.append(round((individual_count/total_pixel),6))
time_stamp = datetime.now()
csv_data.append(time_stamp)
# csv_data = [filename,predict,colors,counts,total_pixel]
# print(csv_data)
combile_all_csv_data.append(csv_data)
sql_srting = ["NULL" if val == None else "'"+str(val)+"'" for val in csv_data]
sql_srting_format = ",".join([str(val) for val in sql_srting])
combine_sql_srting_format.append(sql_srting_format)
csvwriter.writerows(combile_all_csv_data)
dbms.insertmany_sqlite3('semantic_results_atlanta',','.join(columns),combine_sql_srting_format)
os.remove(new_name)
# if idx % 10 == 0:
# print("Processed: ", idx)
except Exception as e:
print("Error in :", ' ' + f, e)
continue
print('Finished')
end = timer()
print('Processing time: %.1f' % (end - start))
def test(args):
# output folder
#outdir = 'outdir'
outdir = 'outdir_01262021'
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
# dataset and dataloader
if args.eval:
#testset = get_segmentation_dataset(
# args.dataset, split='val', mode='testval', transform=input_transform)
#testset = COCOSemantic(split='val', mode='testval', transform=input_transform)
testset = COCOSemantic(split='val',
mode='testval',
transform=input_transform)
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
#testset = get_segmentation_dataset(
# args.dataset, split='test', mode='test', transform=input_transform)
testset = COCOSemantic(split='test',
mode='testval',
transform=input_transform)
print("testset.num_class: ")
print(testset.num_class)
#test_data = gluon.data.DataLoader(
# testset, args.test_batch_size, shuffle=False, last_batch='keep',
# batchify_fn=ms_batchify_fn, num_workers=args.workers)
# what is this one used for? ms_batchify_fn """Multi-size batchfy function"""
test_data = gluon.data.DataLoader(testset,
args.test_batch_size,
last_batch='keep',
num_workers=args.workers)
"""
# only used for generating mask ground truth.
print(len(testset.ids))
for i in np.arange(len(testset.ids)):
img_out, mask_out = testset[i]
"""
# create network
if args.model_zoo is not None:
model = get_model(args.model_zoo, pretrained=True)
else:
#model = get_segmentation_model(model=args.model, dataset=args.dataset, ctx=args.ctx,
# backbone=args.backbone, norm_layer=args.norm_layer,
# norm_kwargs=args.norm_kwargs, aux=args.aux,
# base_size=args.base_size, crop_size=args.crop_size)
model = model_zoo.PSPNet(
nclass=testset.num_class,
backbone=args.backbone,
aux=args.aux,
pretrained_base=False,
#norm_layer=args.norm_layer,
#norm_kwargs=args.norm_kwargs,
#crop_size=args.crop_size,
ctx=args.ctx)
model.cast(args.dtype)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
if os.path.isfile(args.resume):
#model.load_parameters(args.resume, ctx=args.ctx)
model.load_parameters(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
print(model)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
# this is used in the val, not test
#evaluator2 = DataParallelModel(SegEvalModel(model), args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
#predicts = [ pred[0] for pred in evaluator.parallel_forward(data)]
#targets = [target.as_in_context(predicts[0].context) \
# for target in dsts]
#predicts = evaluator(data.astype(args.dtype, copy=False))
#predicts = [x[0] for x in predicts]
# method 3
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
#predicts = [[x for x in predicts1]]
print(len(predicts))
print(len(predicts[0]))
print(len(predicts[0][0]))
#predicts = mx.nd.expand_dims(mx.nd.array(predicts1), axis=0)
predicts2 = mx.nd.expand_dims(predicts[0], axis=0)
predicts3 = [predicts2.as_in_context(predicts[0].context)]
targets = mx.gluon.utils.split_and_load(dsts,
args.ctx,
even_split=False)
print("i: ")
print(i)
#print(predicts2)
#print(len(targets[0]))
#print(targets)
#bbb = np.array([[[1],[2],[3]],[[7],[6],[0]]])
#bbb = np.array(predicts)
targets2 = targets[0]
print(predicts2.shape)
#print(predicts3)
print(targets2.shape)
#print(targets2)
metric.update(targets, predicts3)
pixAcc, mIoU = metric.get()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
im_paths = dsts
#print("im_paths: ")
#print(im_paths)
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
print('i: ')
print(i)
#print(predict)
#print(predict[0])
#predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy() + \
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 0)).asnumpy() + \
testset.pred_offset
#print('predict: ')
#print(predict)
mask = get_color_pallete(predict, args.dataset)
#print('mask: ')
#print(mask)
#print("outname: ")
#print(os.path.splitext(impath)[0])
#outname = os.path.splitext(impath)[0] + '.png'
#mask.save(os.path.join(outdir, outname))
outname = 'predict_mask_' + str(i) + '.png'
mask.save(os.path.join(outdir, outname))
# we follow the standard data augmentation routine to transform the input image
# and the ground truth label map synchronously. (*Note that "nearest"
# mode upsample are applied to the label maps to avoid messing up the boundaries.*)
# We first randomly scale the input image from 0.5 to 2.0 times, then rotate
# the image from -10 to 10 degrees, and crop the image with padding if needed.
# Finally a random Gaussian blurring is applied.
#
# Random pick one example for visualization:
import random
from datetime import datetime
random.seed(datetime.now())
idx = random.randint(0, len(trainset))
img, mask = trainset[idx]
from gluoncv.utils.viz import get_color_pallete, DeNormalize
# get color pallete for visualize mask
mask = get_color_pallete(mask.asnumpy(), dataset='ade20k')
mask.save('mask.png')
# denormalize the image
img = DeNormalize([.485, .456, .406], [.229, .224, .225])(img)
img = np.transpose((img.asnumpy()*255).astype(np.uint8), (1, 2, 0))
##############################################################################
# Plot the image and mask
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
# subplot 1 for img
fig = plt.figure()
fig.add_subplot(1,2,1)
plt.imshow(img)
# subplot 2 for the mask
def test(args):
# output folder
outdir = 'train_logs/outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# dataset and dataloader
testset = get_custom_segm_dataset("test", args)
test_data = gluon.data.DataLoader(
testset,
args.test_batch_size,
shuffle=False,
last_batch='keep',
batchify_fn=ms_batchify_fn if args.tta else None,
num_workers=args.workers)
# create network
if args.model_zoo is not None:
model = get_pretrained_segmentation_model(args)
if args.resume is not None:
resume_checkpoint(model, args)
print("loading checkpoint from %s for testing" % args.resume)
else:
model = get_segmentation_model(model=args.model,
dataset=args.dataset,
ctx=args.ctx,
backbone=args.backbone,
norm_layer=args.norm_layer,
norm_kwargs=args.norm_kwargs,
aux=args.aux,
base_size=args.base_size,
crop_size=args.crop_size)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
resume_checkpoint(model, args)
# print(model)
if args.tta:
evaluator = MultiEvalModel(model,
testset.num_class,
ctx_list=args.ctx,
scales=[0.75, 1.0, 1.25, 1.5, 1.75])
else:
evaluator = DataParallelModel(SegEvalModel(model), args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
if args.tta:
predicts = [
pred[0].expand_dims(0)
for pred in evaluator.parallel_forward(data)
]
targets = [target.as_in_context(predicts[0].context).expand_dims(0) \
for target in dsts]
else:
data = data.astype(args.dtype, copy=False)
predicts = evaluator(data)
predicts = [x[0] for x in predicts]
if args.test_flip:
assert (data.ndim == 4)
fdata = data.flip(3)
fpredicts = evaluator(fdata)
predicts = [(x + y[0].flip(3)) / 2
for x, y in zip(predicts, fpredicts)]
targets = mx.gluon.utils.split_and_load(dsts,
args.ctx,
even_split=False)
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description('pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
mx.nd.waitall()
else:
im_paths = dsts
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 1)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
import mxnet as mx
from mxnet import image
from mxnet.gluon.data.vision import transforms
import gluoncv
import cv2
# using cpu
ctx = mx.cpu(0)
filename= '71.jpeg'
# load the image
img = image.imread(filename)
from matplotlib import pyplot as plt
#plt.imshow(img.asnumpy())
#plt.show()
from gluoncv.data.transforms.presets.segmentation import test_transform
img = test_transform(img, ctx)
# get pre-trained model
model = gluoncv.model_zoo.get_model('fcn_resnet101_voc', pretrained=True)
output = model.predict(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
from gluoncv.utils.viz import get_color_pallete
import matplotlib.image as mpimg
mask = get_color_pallete(predict, 'pascal_voc')
mask.save('output.png')
def test(args):
if not horse_change:
# output folder
# outdir = 'outdir'
outdir = args.outdir
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
# transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
# transforms.Normalize([0, 0, 0], [1, 1, 1]),
# transforms.Normalize([0], [100]), # this is for 1 channel: ([0], [1]) ([556.703], [482.175])
])
# dataset and dataloader
if args.eval:
testset = get_segmentation_dataset(args.dataset,
split='val',
mode='testval',
transform=input_transform)
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
testset = get_segmentation_dataset(args.dataset,
split='test',
mode='test',
transform=input_transform)
test_data = gluon.data.DataLoader(testset,
args.test_batch_size,
shuffle=False,
last_batch='keep',
batchify_fn=ms_batchify_fn,
num_workers=args.workers)
# create network
if args.model_zoo is not None:
model = get_model(args.model_zoo, pretrained=True)
else:
model = get_segmentation_model(model=args.model,
dataset=args.dataset,
ctx=args.ctx,
backbone=args.backbone,
norm_layer=args.norm_layer,
norm_kwargs=args.norm_kwargs,
aux=args.aux,
base_size=args.base_size,
crop_size=args.crop_size)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
if os.path.isfile(args.resume):
model.load_parameters(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
# print(model) # [horse]: do not print model
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
print('testset.pred_offset:', testset.pred_offset) # horse
print('model.crop_size', model.crop_size) # horse
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
# print('data', data[0].shape) # horse
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
# print('predicts', predicts[0].shape)
targets = [target.as_in_context(predicts[0].context) \
for target in dsts]
# horse begin
'''
predict = mx.nd.squeeze(mx.nd.argmax(predicts[0], 0)).asnumpy() + \
testset.pred_offset
'''
# horse end
print('targets', targets[0].shape)
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description( 'pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
output_score_map = True # [horse added]
if output_score_map:
# score_map_dir = 'scoredir'
score_map_dir = args.scoredir
if not os.path.exists(score_map_dir):
os.makedirs(score_map_dir)
im_paths = dsts
# print('data', data[0].shape) # horse
predicts = evaluator.parallel_forward(data)
# print(predicts[0].shape)
for predict, impath in zip(predicts, im_paths):
# change from 1 to 0 [horse]
# print('predict:', predict[0].shape) # predict: (3, 127, 207)
if output_score_map:
score_map_name = os.path.splitext(impath)[0] + '.pkl'
score_map_path = os.path.join(score_map_dir, score_map_name)
with open(score_map_path, 'wb') as fo:
pickle.dump(predict[0].asnumpy()[0:3,:,:], fo)
'''
if i == 50:
with open('have_a_look.pkl', 'wb') as fo:
pickle.dump(predict[0].asnumpy(),fo)
'''
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 0)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
# print('predict:', predict.shape) # predict: (127, 207)
# print('mask:', mask) # it is a PIL.Image.Image
mask.save(os.path.join(outdir, outname))
# break
if horse_change:
# >>>>>>>>>> >>>>>>>>>> >>>>>>>>>> >>>>>>>>>> >>>>>>>>>> >>>>>>>>>>
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
# transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
# transforms.Normalize([0, 0, 0], [1, 1, 1]),
# transforms.Normalize([0], [100]), # this is for 1 channel: ([0], [1]) ([556.703], [482.175])
])
# dataset and dataloader
if args.eval:
testset = get_segmentation_dataset(args.dataset,
split='val',
mode='testval',
transform=input_transform)
total_inter, total_union, total_correct, total_label = \
np.int64(0), np.int64(0), np.int64(0), np.int64(0)
else:
testset = get_segmentation_dataset(args.dataset,
split='test',
mode='test',
transform=input_transform)
test_data = gluon.data.DataLoader(testset,
args.batch_size, # args.test_batch_size, [horse changed this]
shuffle=False,
last_batch='keep',
batchify_fn=ms_batchify_fn,
num_workers=args.workers)
# create network
if args.model_zoo is not None:
model = get_model(args.model_zoo, pretrained=True)
else:
model = get_segmentation_model(model=args.model,
dataset=args.dataset,
ctx=args.ctx,
backbone=args.backbone,
norm_layer=args.norm_layer,
norm_kwargs=args.norm_kwargs,
aux=args.aux,
base_size=args.base_size,
crop_size=args.crop_size)
# load pretrained weight
assert args.resume is not None, '=> Please provide the checkpoint using --resume'
if os.path.isfile(args.resume):
model.load_parameters(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
# print(model) # [horse]: do not print model
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
metric = gluoncv.utils.metrics.SegmentationMetric(testset.num_class)
print('testset.pred_offset:', testset.pred_offset) # horse
print('model.crop_size', model.crop_size) # horse
tbar = tqdm(test_data)
for i, (data, dsts) in enumerate(tbar):
if args.eval:
# print('data', data[0].shape) # horse
predicts = [pred[0] for pred in evaluator.parallel_forward(data)]
# print('predicts', predicts[0].shape)
targets = [target.as_in_context(predicts[0].context) \
for target in dsts]
# horse begin
'''
predict = mx.nd.squeeze(mx.nd.argmax(predicts[0], 0)).asnumpy() + \
testset.pred_offset
'''
# horse end
print('targets', targets[0].shape)
metric.update(targets, predicts)
pixAcc, mIoU = metric.get()
tbar.set_description( 'pixAcc: %.4f, mIoU: %.4f' % (pixAcc, mIoU))
else:
output_score_map = True # [horse added]
if output_score_map:
score_map_dir = 'scoredir'
im_paths = dsts
print('data', data[0].shape) # horse
predicts = evaluator.parallel_forward(data)
print(predicts[0].shape)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict[0], 0)).asnumpy() + \
testset.pred_offset
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
# normalize the image using dataset mean
from gluoncv.data.transforms.presets.segmentation import test_transform
img = test_transform(img, ctx)
##############################################################################
# Load the pre-trained model and make prediction
# ----------------------------------------------
#
# get pre-trained model
model = gluoncv.model_zoo.get_model('deeplab_resnet101_ade', pretrained=True)
##############################################################################
# make prediction using single scale
output = model.predict(img)
predict = mx.nd.squeeze(mx.nd.argmax(output, 1)).asnumpy()
##############################################################################
# Add color pallete for visualization
from gluoncv.utils.viz import get_color_pallete
import matplotlib.image as mpimg
mask = get_color_pallete(predict, 'ade20k')
mask.save('output.png')
##############################################################################
# show the predicted mask
mmask = mpimg.imread('output.png')
plt.imshow(mmask)
plt.show()
num_workers=batch_size)
##############################################################################
# Plot an Example of generated images:
#
# Random pick one example for visualization:
import random
from datetime import datetime
random.seed(datetime.now())
idx = random.randint(0, len(trainset))
img, mask = trainset[idx]
from gluoncv.utils.viz import get_color_pallete, DeNormalize
# get color pallete for visualize mask
mask = get_color_pallete(mask.asnumpy(), dataset='coco')
mask.save('mask.png')
# denormalize the image
img = DeNormalize([.485, .456, .406], [.229, .224, .225])(img)
img = np.transpose((img.asnumpy()*255).astype(np.uint8), (1, 2, 0))
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
# subplot 1 for img
fig = plt.figure()
fig.add_subplot(1,2,1)
plt.imshow(img)
# subplot 2 for the mask
mmask = mpimg.imread('mask.png')
fig.add_subplot(1,2,2)
