def test_model():
model_name = "fcn_8"
h = 224
w = 256
n_c = 100
check_path = tempfile.mktemp()
m = all_models.model_from_name[model_name](n_c,
input_height=h,
input_width=w)
m.train(train_images=tr_im,
train_annotations=tr_an,
steps_per_epoch=2,
epochs=2,
checkpoints_path=check_path)
m.train(train_images=tr_im,
train_annotations=tr_an,
steps_per_epoch=2,
epochs=2,
checkpoints_path=check_path,
augmentation_name='aug_geometric',
do_augment=True)
m.predict_segmentation(np.zeros((h, w, 3))).shape
predict_multiple(inp_dir=te_im,
checkpoints_path=check_path,
out_dir="/tmp")
predict_multiple(inps=[np.zeros((h, w, 3))] * 3,
checkpoints_path=check_path,
out_dir="/tmp")
ev = m.evaluate_segmentation(inp_images_dir=te_im, annotations_dir=te_an)
assert ev['frequency_weighted_IU'] > 0.01
print(ev)
o = predict(inp=np.zeros((h, w, 3)), checkpoints_path=check_path)
o = predict(inp=np.zeros((h, w, 3)),
checkpoints_path=check_path,
overlay_img=True,
class_names=['nn'] * n_c,
show_legends=True)
print("pr")
o.shape
ev = evaluate(inp_images_dir=te_im,
annotations_dir=te_an,
checkpoints_path=check_path)
assert ev['frequency_weighted_IU'] > 0.01
def test_model():
model_name = "fcn_8"
h = 224
w = 256
n_c = 100
check_path = "/tmp/%d" % (random.randint(0, 199999))
m = models.model_from_name[model_name](n_c, input_height=h, input_width=w)
m.train(train_images=tr_im,
train_annotations=tr_an,
steps_per_epoch=2,
epochs=2,
checkpoints_path=check_path)
m.predict_segmentation(np.zeros((h, w, 3))).shape
predict_multiple(inp_dir=te_im,
checkpoints_path=check_path,
out_dir="/tmp")
predict_multiple(inps=[np.zeros((h, w, 3))] * 3,
checkpoints_path=check_path,
out_dir="/tmp")
o = predict(inp=np.zeros((h, w, 3)), checkpoints_path=check_path)
o.shape
def main():
from keras_segmentation.predict import predict
# Read original image from Input folder
img_original = cv2.imread('./Images/Input/img_original.jpg')
# Prediction method
predict(
# path to trained model
checkpoints_path="./Model_CNN_Segmentation/model",
# input image path from images/skull striping
inp="./Images/Input/img_original.jpg",
# output image path from ./Images/CNN_Output
out_fname="./Images/CNN_Output/img_segment_by_cnn.jpg")
try:
# Read segmented image from output folder
# check weather yes image or no
result, features = get_rf_result()
# if no use tha blank mask
if result == 0:
img = cv2.imread('./Images/CNN_Output/blank_mask.jpg',
cv2.IMREAD_GRAYSCALE)
else:
img = cv2.imread('./Images/CNN_Output/img_segment_by_cnn.jpg',
cv2.IMREAD_GRAYSCALE)
# given threshold to get tumor mask
thresh = 200
thresh_value, img_binary = cv2.threshold(img, thresh, 255,
cv2.THRESH_BINARY)
# contour for suspicious point
cnts = cv2.findContours(img_binary.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# look over the contours to find max and draw the suspicious area by green
c1_max = max(cnts, key=cv2.contourArea)
cv2.drawContours(img_original, [c1_max], -1, (0, 255, 0), 2)
# writing tumor marked image into ./Images/CNN_Output/img_tumor_marked.jpg
cv2.imwrite('./Images/CNN_Output/img_tumor_marked.jpg', img_original)
except:
cv2.imwrite('./Images/CNN_Output/img_tumor_marked.jpg', img_original)
print("An exception occurred")
def main():
from keras_segmentation.predict import predict
# Read original image from Input folder
img_original = cv2.imread('./Images/Input/img_original.jpg')
# Prediction method
predict(
# path to trained model
checkpoints_path="./Model_CNN_Skull_Remove/model",
# input image path from images/original
inp="./Images/Input/img_original.jpg",
# output image path from ./Images/CNN_Output
out_fname="./Images/CNN_Skull_Remove_Output/img_skull_removed_by_cnn_mask.jpg"
)
try:
# threshold value
thresh = 200
# read image
img = cv2.imread('./Images/CNN_Skull_Remove_Output/img_skull_removed_by_cnn_mask.jpg', cv2.IMREAD_GRAYSCALE)
# binary threshold
thresh_value, img_binary = cv2.threshold(img, thresh, 255, cv2.THRESH_BINARY)
cnts = cv2.findContours(img_binary.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# look over the contours to find max and draw the suspicious area by green
c1_max = max(cnts, key=cv2.contourArea)
# convert to array
pts = np.array(c1_max, dtype=np.int32)
# find the bounding rectangles
rect = cv2.boundingRect(pts)
x, y, w, h = rect
cropped = img_original[y:y + h, x:x + w].copy()
pts = pts - pts.min(axis=0)
mask = np.zeros(cropped.shape[:2], np.uint8)
cv2.drawContours(mask, [pts], -1, 255, -1, cv2.LINE_AA)
# do bit-op
out = cv2.bitwise_and(cropped, cropped, mask=mask)
# writing tumor marked image into ./Images/CNN_Output/img_tumor_marked.jpg
cv2.imwrite('./Images/CNN_Skull_Remove_Output/img_skull_removed_by_cnn.jpg', out)
except:
print("An exception occurred")
def wormLabelAccuracy(imageName, image, actualDirectory, wormDict):
imageorigsize = image.shape
image = cv.resize(image, (704, 512), interpolation=cv.INTER_AREA)
model = resnet50_unet(3, input_height=512, input_width=704)
checkpointsPath = "../checkpoints/resnet_unet_3"
model_from_checkpoint_path(model, checkpointsPath)
predictedim = predict.predict(model=model, inp=image)
total = 0
correct = 0
cm = np.zeros((2, 2))
for key in wormDict.keys():
#print(key)
if key[:3] == imageName:
wormim = cv.imread(actualDirectory + key)
wormim = cv.cvtColor(wormim, cv.COLOR_BGR2GRAY)
wormim = cv.resize(wormim, (imageorigsize[1], imageorigsize[0]),
interpolation=cv.INTER_AREA)
testim = np.zeros_like(predictedim)
mask = wormim != 0
testim[mask] = predictedim[mask]
test1d = testim.flatten()
counts = np.bincount(test1d)
ifcorrect = False
if len(counts == 1):
counts = np.append(counts, 0)
if len(counts == 2):
counts = np.append(counts, 0)
if counts[1] > counts[2] and wormDict[key] == 1:
correct += 1
cm[0][0] += 1
ifcorrect = True
elif counts[1] > counts[2] and wormDict[key] == 2:
cm[0][1] += 1
elif counts[1] < counts[2] and wormDict[key] == 1:
cm[1][0] += 1
elif counts[1] < counts[2] and wormDict[key] == 2:
cm[1][1] += 1
correct += 1
ifcorrect = True
total += 1
#print(key, ifcorrect)
print(correct, total)
print(cm)
return correct, total, cm
def saveVisualizeImages(dir, savedir, predict):
for file in glob(dir + "*"):
image = cv.imread(file)
if predict:
checkpointsPath = "../checkpoints/resnet_unet_3"
model = resnet50_unet(3, input_height=512, input_width=704)
model_from_checkpoint_path(model, checkpointsPath)
out = predict.predict(model=model, inp=image)
im = visualizeImage(out)
cv.imwrite(
"{save}/{name}".format(save=savedir,
name=os.path.basename(file)), im)
else:
im = visualizeImage(image)
cv.imwrite(
"{save}/{name}".format(save=savedir,
name=os.path.basename(file)), im)
def find_classes(inp, out_fname):
pr = predict(model=pspnet_50_ADE_20K(), inp=inp, out_fname=out_fname)
CDict = seg2ann(seg_file=out_fname)
k = 0
classnum_list = []
for key in sorted(CDict.keys(), reverse=True):
k = k + 1
if k > 10:
break
if key != 0:
classnum_list.append(CDict[key][0])
print(CDict[key])
print(classnum_list)
return (classnum_list)
def predictImageType(image):
image = cv.resize(image, (704, 512), interpolation=cv.INTER_AREA)
model = resnet50_unet(3, input_height=512, input_width=704)
checkpointsPath = "../checkpoints/resnet_unet_3"
model_from_checkpoint_path(model, checkpointsPath)
out = predict.predict(model=model, inp=image)
out1d = out.flatten()
counts = np.bincount(out1d)
if counts[1] > counts[2]:
print("alive")
return "alive"
else:
print("dead")
return "dead"
def color_callback(self, color_img_ros):
"""
Callback function for color image, do semantic segmantation and show the decoded image. For test purpose
\param color_img_ros (sensor_msgs.Image) input ros color image message
"""
print('callback')
try:
color_img = self.bridge.imgmsg_to_cv2(
color_img_ros, "bgr8") # Convert ros msg to numpy array
except CvBridgeError as e:
print(e)
# Do semantic segmantation
seg = predict(model=self.new_model, inp=color_img)
seg = seg.astype(np.uint8)
#print (seg.shape)
#print (color_img.shape)
# Do semantic segmantation
'''
class_probs = self.predict(color_img)
confidence, label = class_probs.max(1)
confidence, label = confidence.squeeze(0).numpy(), label.squeeze(0).numpy()
label = resize(label, (self.img_height, self.img_width), order = 0, mode = 'reflect', preserve_range = True) # order = 0, nearest neighbour
label = label.astype(np.int)
# Add semantic class colors
decoded = decode_segmap(label, self.n_classes, self.cmap) # Show input image and decoded image
confidence = resize(confidence, (self.img_height, self.img_width), mode = 'reflect', preserve_range = True)
'''
cv2.imshow('Camera image', color_img)
cv2.imshow('seg', seg)
#cv2.imshow('confidence', confidence)
#cv2.imshow('Semantic segmantation', decoded)
cv2.waitKey(3)
import cv2
from keras_segmentation.predict import predict, model_from_checkpoint_path
import random
#https://divamgupta.com/image-segmentation/2019/06/06/deep-learning-semantic-segmentation-keras.html
model = model_from_checkpoint_path("checkpoints/resnet50_unet_1")
cap = cv2.VideoCapture("test.mp4")
if (cap.isOpened() == False):
print("Error opening video stream or file")
while (cap.isOpened()):
ret, frame = cap.read()
if ret == True:
mask, mask_image = predict(model=model, inp=frame)
cv2.imshow('Frame', mask_image)
# Press Q on keyboard to exit
if cv2.waitKey(25) & 0xFF == ord('q'):
break
else:
break
cap.release()
cv2.destroyAllWindows()
def predict_segmentation(model, img):
resized_img = cv2.resize(img, (473, 473))
resized_out = predict(model, inp=resized_img)
out = cv2.resize(resized_out, (512, 512), interpolation=cv2.INTER_NEAREST)
return out.astype(np.uint8)
# optimizer_name='adadelta' , do_augment=True , augmentation_name="aug_all",
# checkpoints_path = "weights/vgg_unet_1" , epochs=10
# )
# =============================================================================
# Display the model's architecture
model.summary()
# Save the entire model to a HDF5 file.
# The '.h5' extension indicates that the model should be saved to HDF5.
model.save('vgg_unet_1.h5')
from keras_segmentation.predict import predict
predict(checkpoints_path="weights/vgg_unet_1",
inp="dataset1/images_prepped_test/3.png",
out_fname="3_predict.png")
from keras_segmentation.predict import predict_multiple
predict_multiple(checkpoints_path="weights/vgg_unet_1",
inp_dir="dataset1/images_prepped_test/",
out_dir="weights/out/")
'''
#------------------------------------------------------------------------------
#
# Verification of Input and Predicted Results
#
#------------------------------------------------------------------------------
'''
def color_depth_callback(self, color_img_ros, depth_img_ros):
"""
Callback function to produce point cloud registered with semantic class color based on input color image and depth image
\param color_img_ros (sensor_msgs.Image) the input color image (bgr8)
\param depth_img_ros (sensor_msgs.Image) the input depth image (registered to the color image frame) (float32) values are in meters
"""
tic = rospy.Time.now()
diff = tic - self.last_time
if diff.to_sec() < self.throttle_rate:
return
self.last_time = rospy.Time.now()
# Convert ros Image message to numpy array
try:
color_img = self.bridge.imgmsg_to_cv2(color_img_ros, "bgr8")
depth_img = self.bridge.imgmsg_to_cv2(depth_img_ros, "32FC1")
except CvBridgeError as e:
print(e)
# Resize depth
if depth_img.shape[0] is not self.img_height or depth_img.shape[
1] is not self.img_width:
depth_img = resize(
depth_img, (self.img_height, self.img_width),
order=0,
mode='reflect',
preserve_range=True) # order = 0, nearest neighbour
depth_img = depth_img.astype(np.float32)
# realsense camera gives depth measurements in mm
if self.real_sense:
depth_img = depth_img / 1000.0
################## Save all the Images for debugging #####################
'''
filename = self.test_image_path_output_folder + "image" + str(self.imgCounter) + ".png"
print (filename)
cv2.imwrite(filename, color_img)
self.imgCounter = self.imgCounter + 1 ;
'''
##########################################################################
semantic_color = predict(model=self.new_model, inp=color_img)
################## Save all the Images for debugging #####################
'''
filename = self.test_image_path_output_folder + "semanticimage" + str(self.imgSemanticCounter) + ".png"
print (filename)
cv2.imwrite(filename, semantic_color)
self.imgSemanticCounter = self.imgSemanticCounter + 1 ;
'''
##########################################################################
#label_d = semantic_color.max(1)
#label_d = resize(label_d, (self.img_height, self.img_width), order = 0, mode = 'reflect', preserve_range = True) # order = 0, nearest neighbour
#label_d = label_d.astype(np.uint8)
semantic_color = semantic_color.astype(np.uint8)
#decoded = decode_segmap(label_d, self.n_classes, self.cmap) # Show input image and decoded image
# Publish semantic image
if self.sem_img_pub.get_num_connections() > 0:
try:
semantic_color_msg = self.bridge.cv2_to_imgmsg(semantic_color,
encoding="bgr8")
#rgb_img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
self.sem_img_pub.publish(semantic_color_msg)
except CvBridgeError as e:
print(e)
cloud_ros = self.cloud_generator.generate_cloud_semantic(
color_img, depth_img, semantic_color, color_img_ros.header.stamp)
#Publish point cloud
#self.get_label(pred_labels)
self.pcl_pub.publish(cloud_ros)
def __init__(self, gen_pcl=True):
"""
Constructor
\param gen_pcl (bool) whether generate point cloud, if set to true the node will subscribe to depth image
"""
self.real_sense = rospy.get_param('/semantic_pcl/real_sense')
self.imgCounter = 0
self.imgSemanticCounter = 0
#self.labels_pub = rospy.Publisher("/semantic_pcl/labels", OverlayText, queue_size=1)
self.labels_list = []
#self.text = OverlayText()
# Get image size
self.img_width, self.img_height = rospy.get_param(
'/camera/width'), rospy.get_param('/camera/height')
self.throttle_rate = rospy.get_param('/semantic_pcl/throttle_rate')
self.last_time = rospy.Time.now()
# Set up CNN is use semantics
print('Setting up CNN model...')
# Set device
#self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Get dataset
self.dataset = rospy.get_param('/semantic_pcl/dataset')
# Setup model
model_name = 'vgg_unet'
model_path = rospy.get_param('/semantic_pcl/model_path')
model_json_path = rospy.get_param('/semantic_pcl/model_json_path')
test_image_path_input = rospy.get_param(
'/model_params/test_image_path_input')
test_image_path_output = rospy.get_param(
'/model_params/test_image_path_output')
model_input_height = rospy.get_param(
'/model_params/model_input_height')
model_input_width = rospy.get_param('/model_params/model_input_width')
model_output_height = rospy.get_param(
'/model_params/model_output_height')
model_output_width = rospy.get_param(
'/model_params/model_output_width')
model_n_classes = rospy.get_param('/model_params/model_n_classes')
model_checkpoints_path = rospy.get_param(
'/model_params/model_checkpoints_path')
self.test_image_path_output_folder = rospy.get_param(
'/model_params/test_image_path_output_folder')
if self.dataset == 'kucarsRisk':
self.n_classes = 7 # Semantic class number
# load the model + weights
# Recreate the exact same model, including its weights and the optimizer
#self.new_model = model_from_json(model_path,custom_objects=None)
#clear_session()
self.new_model = load_model(model_path) #,custom_objects=None)
self.new_model.input_width = model_input_width
self.new_model.input_height = model_input_height
self.new_model.output_width = model_output_width
self.new_model.output_height = model_output_height
self.new_model.n_classes = model_n_classes
# Show the model architecture
self.new_model.summary()
print("Loaded model from disk")
self.new_model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
##### One Image Prediction ####
img = cv2.imread(test_image_path_input)
predict(model=self.new_model,
inp=test_image_path_input,
out_fname=test_image_path_output)
out = cv2.imread(test_image_path_output)
out_rgb = cv2.cvtColor(out, cv2.COLOR_BGR2RGB)
#plt.imshow(out)
#plt.show()
self.cmap = color_map(
N=self.n_classes,
normalized=True) # Color map for semantic classes
# Declare array containers
# Set up ROS
print('Setting up ROS...')
self.bridge = CvBridge(
) # CvBridge to transform ROS Image message to OpenCV image
# Semantic image publisher
self.sem_img_pub = rospy.Publisher(
"/semantic_pcl/semantic_hazard_image", Image, queue_size=1)
# Set up ros image subscriber
# Set buff_size to average msg size to avoid accumulating delay
if gen_pcl:
# Point cloud frame id
frame_id = rospy.get_param('/semantic_pcl/frame_id')
# Camera intrinsic matrix
fx = rospy.get_param('/camera/fx')
fy = rospy.get_param('/camera/fy')
cx = rospy.get_param('/camera/cx')
cy = rospy.get_param('/camera/cy')
intrinsic = np.matrix([[fx, 0, cx], [0, fy, cy], [0, 0, 1]],
dtype=np.float32)
self.pcl_pub = rospy.Publisher("/semantic_pcl/semantic_pcl",
PointCloud2,
queue_size=1)
self.color_sub = message_filters.Subscriber(
rospy.get_param('/semantic_pcl/color_image_topic'),
Image,
queue_size=1,
buff_size=30 * 480 * 640)
self.depth_sub = message_filters.Subscriber(
rospy.get_param('/semantic_pcl/depth_image_topic'),
Image,
queue_size=1,
buff_size=40 * 480 * 640
) # increase buffer size to avoid delay (despite queue_size = 1)
self.ts = message_filters.ApproximateTimeSynchronizer(
[self.color_sub, self.depth_sub], queue_size=1, slop=0.3
) # Take in one color image and one depth image with a limite time gap between message time stamps
self.ts.registerCallback(self.color_depth_callback)
#self.cloud_generator = ColorPclGenerator(intrinsic, self.img_width,self.img_height, frame_id , self.point_type)
self.cloud_generator = ColorPclSemanticGenerator(
intrinsic, self.img_width, self.img_height, frame_id)
else:
print("No Cloud generation")
self.image_sub = rospy.Subscriber(
rospy.get_param('/semantic_pcl/color_image_topic'),
Image,
self.color_callback,
queue_size=1,
buff_size=30 * 480 * 640)
semantic_colored_labels_srv = rospy.Service(
'get_semantic_colored_labels', GetSemanticColoredLabels,
self.get_semantic_colored_labels)
print('Ready.')
def evaluate(self,
model=None,
inp_images=None,
annotations=None,
inp_images_dir=None,
annotations_dir=None,
checkpoints_path=None):
"""Evaluate the loaded model for an imgs set and segs"""
with self.graph.as_default():
with self.session.as_default():
self.signals.log.emit("Début de la session d'évaluation")
if model is None:
if checkpoints_path is None:
self.signals.log.emit("Impossible de trouver le modèle"
" à évaluer.")
self.signals.log.emit("")
self.signals.error.emit("Impossible de trouver le "
"modèle à évaluer")
try:
checkpoint_nb = checkpoints_path.split('.')[-1]
index = -(int)(len(checkpoint_nb) + 1)
existing = checkpoints_path[0:index]
model = model_from_checkpoint_path_nb(
existing, checkpoint_nb)
self.signals.log.emit(
"Modèle chargé : {}".format(checkpoints_path))
except Exception as exc:
self.signals.finished.emit("Impossible de charger le "
"modèle existant !" +
traceback.format_exc())
return
if inp_images is None:
paths = get_pairs_from_paths(inp_images_dir,
annotations_dir)
paths = list(zip(*paths))
inp_images = list(paths[0])
annotations = list(paths[1])
tpm = np.zeros(model.n_classes)
fpm = np.zeros(model.n_classes)
fnm = np.zeros(model.n_classes)
n_pixels = np.zeros(model.n_classes)
file_processed = 0
for inp, ann in tqdm(zip(inp_images, annotations)):
pred = predict(model, inp)
ground = get_segmentation_array(ann,
model.n_classes,
model.output_width,
model.output_height,
no_reshape=True)
ground = ground.argmax(-1)
pred = pred.flatten()
ground = ground.flatten()
matrix = confusion_matrix(ground, pred)
self.signals.log.emit("Image {}".format(str(inp)))
self.signals.log.emit(
"Matrice de confusion :\n{}\n".format(str(matrix)))
for cl_i in range(model.n_classes):
tpm[cl_i] += np.sum((pred == cl_i) * (ground == cl_i))
fpm[cl_i] += np.sum((pred == cl_i) * (ground != cl_i))
fnm[cl_i] += np.sum((pred != cl_i) * (ground == cl_i))
n_pixels[cl_i] += np.sum(ground == cl_i)
file_processed += 1
progression = 100 * file_processed / len(inp_images)
self.signals.progressed.emit(progression)
cl_wise_score = tpm / (tpm + fpm + fnm + 0.000000000001)
n_pixels_norm = n_pixels / np.sum(n_pixels)
frequency_weighted_iu = np.sum(cl_wise_score * n_pixels_norm)
mean_iu = np.mean(cl_wise_score)
self.signals.log.emit("frequency_weighted_IU {}".format(
str(frequency_weighted_iu)))
self.signals.log.emit("mean_IU {}".format(str(mean_iu)))
self.signals.log.emit("class_wise_IU {}".format(
str(cl_wise_score)))
self.signals.log.emit("")
self.signals.finished.emit("Evaluation terminée !")
from keras_segmentation.predict import predict, predict_multiple, model_from_checkpoint_path, evaluate
model = model_from_checkpoint_path(
"..\\..\\Checkpoints\\AllTools\\mobilenet_alltools")
# BACKGROUND, TOOL, CAT
print(
model.evaluate_segmentation(
inp_images_dir=
"C:\\Users\\Leonardo\\Desktop\\Catetere\\UpdatedDataset\\Test\\Original\\JPEGImages\\",
annotations_dir=
"C:\\Users\\Leonardo\\Desktop\\Catetere\\UpdatedDataset\\Test\\Original\\Labels\\"
))
# out = model.predict_segmentation(inp="C:\\Users\\Leonardo\\Desktop\\Catetere\\UpdatedDataset\\Test\\Prova\\JPEGImages\\frame1140.jpg", out_fname="..\\a.png")
'''
predict(checkpoints_path="checkpoints\\vgg_unet_1",
inp="C:\\Users\\d053175\\Desktop\\Prostate\\Dataset\\Test\\39151.png",
out_fname="C:\\Users\\d053175\\Desktop\\output.png"
)
predict_multiple(checkpoints_path="checkpoints\\vgg_unet_1",
inp_dir="C:\\Users\\d053175\\Desktop\\Prostate\\Test\\",
out_dir="C:\\Users\\d053175\\Desktop\\outputs\\"
)
'''
plotDir = "log/plot"
segTrainOutDir = 'COCO/segTrain2017'
segValOutDir = 'COCO/segVal2017'
model = vgg_segnet(n_classes=91, input_height=416, input_width=608, encoder_level=3)
model.load_weights(ckPtDir + "/vgg_segnet.199")
model.summary()
# segTrain2017 Img Gen
for (path, _, files) in os.walk(trainImgs):
for filename in files:
predict(model,
overlay_img=True,
inp = path+filename,
out_fname = segTrainOutDir + '/' + filename[:-3]+'png'
)
# segVal2017 Img Gen
for (path, _, files) in os.walk(valImgs):
for filename in files:
predict(model,
overlay_img=True,
inp = path+filename,
out_fname = segValOutDir + '/' + filename[:-3]+'png'
)
# send the msg to discord channel
from discord_webhook import DiscordWebhook
url = 'https://discordapp.com/api/webhooks/710208007618822145/4yUFIEoTa7kZFOhyJpSkalNn2NysrM6p5PFVG5iBDkt1ikJxBPwV3_J4FDYi40THgxvl'
'/home/arudrin/Documents/nivfrm-ml/logs/mobilenet_unet_50e-0.015LR/checkpoints/weights-050-0.5345.hdf5'
)
source = '/home/arudrin/Documents/nivfrm-ml/results/source' # Source Folder / INPUT
dstpath = '/home/arudrin/Documents/nivfrm-ml/results/destination' # Destination Folder / OUTPUT
try:
makedirs(dstpath)
except:
print("Directory already exist, images will be written in same folder")
files = list(filter(lambda f: isfile(join(source, f)), listdir(source)))
for image in files:
inp = os.path.join(source, image)
out = os.path.join(dstpath, image)
predict(model, inp, out)
exit()
# try:
# img = cv2.imread(os.path.join(path,image))
# gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# dstPath = join(dstpath,image)
# cv2.imwrite(dstPath,gray)
# except:
# print ("{} is not converted".format(image))
#for fil in glob.glob("*.jpg"):
# try:
# image = cv2.imread(fil)
# gray_image = cv2.cvtColor(os.path.join(path,image), cv2.COLOR_BGR2GRAY) # convert to greyscale
# cv2.imwrite(os.path.join(dstpath,fil),gray_image)
def main():
# Setup the training parameters, input paths etc.,
checkpoints_path = "./checkpoints_mobilenet_unet_2class/"
test_images_path = "./dataset2/images_prepped_test/"
test_masks_path = "./dataset2/masks_prepped_test_2class/"
predicted_masks_path = "./dataset2/masks_predicted/"
predicted_overlay_path = "./dataset2/overlay_predicted/"
# Enable printing of IoU scores for tests.
print_test_results = 0
# Model checkpoint path should exist, else it is an error.
if not os.path.exists(checkpoints_path):
print("[ERROR] invalid checkpoints path {}".format(checkpoints_path))
sys.exit(1)
# Get Intersection over Union (IoU) results for the test data set.
# The model is picked up from the latest model in the checkpoints_path.
# The input images and masks (masks) are picked up from their paths.
if print_test_results:
test_results = evaluate(inp_images_dir=test_images_path,
masks_dir=test_masks_path,
checkpoints_path=checkpoints_path)
print(test_results)
print("Test results complete")
# Create output directory to store predicted masks and overlays.
# Remove any existing png files.
if not os.path.exists(predicted_masks_path):
os.makedirs(predicted_masks_path)
if not os.path.exists(predicted_overlay_path):
os.makedirs(predicted_overlay_path)
for f in glob.glob(predicted_masks_path + '/*.png'):
os.remove(f)
for f in glob.glob(predicted_overlay_path + '/*.png'):
os.remove(f)
# Predict results for the input images and store in output directory.
# Store both the predicted masks and the overlaid images with masks.
# Step 1. Load model from checkpoint path.
model = model_from_checkpoint_path(checkpoints_path)
# Step 2. Read images one by one and feed it in into predict function.
# Output predicted mask is written to the predicted masks directory.
# Assume that input images are in png format.
for infile in glob.glob(test_images_path + '/*.png'):
filename = os.path.split(infile)[1]
outfile = os.path.join(predicted_masks_path, filename)
overlayfile = os.path.join(predicted_overlay_path, filename)
print("Predicting mask for file {}, output in {}".format(
infile, outfile))
# Create predicted mask from input file, and store it in outfile.
predict(inp=infile, out_fname=outfile, model=model)
# Overlay the predicted mask file over input file for display.
overlay_image_with_mask(image_file=infile,
mask_file=outfile,
overlay_file=overlayfile)
print("Prediction complete")
_ = subprocess.check_output(['bash', '-c', set_cuda_cache])
_ = subprocess.check_output(['bash', '-c', allow_gpu_growth])
config = compat.ConfigProto()
config.gpu_options.allow_growth = True
session = compat.InteractiveSession(config=config)
batch_size = 1
#FOR LOADING SAVED MODELS , GIVES VALUE ERROR, asks for custom_objects
#model = load_model('/home/arudrin/Documents/nivfrm-ml/scripts/mobilenet_50E-0.015LR_saved_model')
model = mobilenet_unet(n_classes=2,
input_height=240,
input_width=240,
batch_size=batch_size)
logs_path = "../logs/mobilenet_unet"
adam = optmzrs.Adam(amsgrad=True)
model.compile(loss=pixel_wise_loss, optimizer=adam, metrics=[iou, dice])
model.load_weights(
'/home/arudrin/Documents/nivfrm-ml/logs/mobilenet_unet_50e-0.015LR/checkpoints/weights-050-0.5345.hdf5'
)
#val = inference result, inp = input
val = '/home/arudrin/Documents/nivfrm-ml/val/where.jpg'
inp = '/home/arudrin/Documents/nivfrm-ml/scripts/data_in_scriptfolder/raw-240x240/proper/1.jpg'
predict(model, inp,
val) #modified model.predict from /keras_segmentation/predict.py
