def create_binary_sim_set(n_kp, thresh, n_elem):
input_images, target_masks = simulation.generate_random_data(192,
192,
count=n_elem)
input_images_rgb = [x.astype(np.uint8) for x in input_images]
data_list = []
for i in range(n_elem):
image = np.ascontiguousarray(input_images_rgb[i], dtype=np.uint8)
msk = target_masks[i, :, :, :]
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
keypoint_pos, keypoint_val, y = random_keypoints(
gray, image, thresh, n_kp)
edges = keypoint_function.maxDistances3(keypoint_pos)
data = Data(x=keypoint_val, edge_index=edges, pos=keypoint_pos, y=y)
data_list.append(data)
return data_list
def create_knn_sim_set(n_kp, n_elem):
input_images, target_masks = simulation.generate_random_data(192,
192,
count=n_elem)
input_images_rgb = [x.astype(np.uint8) for x in input_images]
target_masks_rgb = [helper.masks_to_colorimg(x) for x in target_masks]
data_list = []
for img, mask in zip(input_images_rgb, target_masks_rgb):
scan_segments = 1 + segmentation.slic(
img, compactness=1, n_segments=n_kp)
g = graph.rag_mean_color(img, scan_segments)
gray_mask = rgb2gray(mask)
edges = []
for start in g.adj._atlas:
if start > 399:
break
for stop in list(g.adj._atlas[start].keys()):
if stop > 399:
continue
edges.append([start, stop])
kp_value = []
kp_pos = []
y = []
regions = regionprops(scan_segments, intensity_image=rgb2gray(img))
for props in regions:
cy, cx = props.weighted_centroid
if (isnan(cy)) or (isnan(cx)):
cy, cx = props.centroid
kp_pos.append([cy, cx])
kp_value.append(rgb2gray(img)[int(round(cy)), int(round(cx))])
mask_value = rgb2gray(img)[int(round(cy)), int(round(cx))]
if mask_value > 0:
y.append(1)
else:
y.append(0)
if len(y) == 400:
break
if len(y) < 400:
continue
keypoint_pos = torch.tensor(kp_pos)
keypoint_val = torch.tensor(kp_value, dtype=torch.float32).view(400, 1)
kp_edges = torch.tensor(edges).view(2, len(edges))
y = torch.tensor(y, dtype=torch.long)
data = Data(x=keypoint_val, edge_index=kp_edges, pos=keypoint_pos, y=y)
data_list.append(data)
return data_list
def create_sift_sim_set(n_kp, n_elem):
input_images, target_masks = simulation.generate_random_data(192,
192,
count=n_elem)
input_images_rgb = [x.astype(np.uint8) for x in input_images]
target_masks_rgb = [helper.masks_to_colorimg(x) for x in target_masks]
sift = cv2.xfeatures2d.SIFT_create(n_kp)
data_list = []
for img, i in zip(input_images_rgb, range(target_masks.shape[0])):
msk = target_masks[i, :, :, :]
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
kp_values = []
kp_y = []
kp, des = sift.detectAndCompute(img, None)
if len(kp) < 25:
continue
kp_sampled = random.choices(kp, k=25)
points2f = cv2.KeyPoint_convert(kp_sampled)
edges = keypoint_function.maxDistances3(points2f)
channel_list = []
for keypoint in points2f:
kp_values.append(gray[int(keypoint[0]), int(keypoint[1])])
if gray[int(keypoint[0]), int(keypoint[1])] > 0:
kp_y.append(1)
else:
kp_y.append(0)
key_values = torch.tensor(kp_values, dtype=torch.float32).view(25, 1)
kp_pos = torch.tensor(points2f)
y = torch.tensor(kp_y, dtype=torch.long)
data = Data(
x=key_values,
edge_index=edges,
pos=kp_pos,
y=y,
)
data_list.append(data)
return data_list
if use_gpu:
batch_train_x = batch_train_x.cuda()
batch_train_y = batch_train_y.cuda()
batch_loss = train_step(batch_train_x, batch_train_y, optimizer,
criterion, unet, width_out, height_out)
total_loss += batch_loss
if (_ + 1) % epoch_lapse == 0:
val_loss = get_val_loss(x_val, y_val, width_out, height_out, unet)
print("Total loss in epoch %f : %f and validation loss : %f" %
(_ + 1, total_loss, val_loss))
gc.collect()
if __name__ == '__main__':
input_images, target_masks = simulation.generate_random_data(192,
192,
count=3)
width_in = 192
height_in = 192
width_out = 192
height_out = 192
batch_size = 3
epochs = 1
epoch_lapse = 50
threshold = 0.5
learning_rate = 0.01
unet = UNet(in_channel=1, out_channel=2)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(unet.parameters(), lr=0.01, momentum=0.99)
train(unet, batch_size, epochs, epoch_lapse, threshold, learning_rate,
criterion, optimizer, x_train, y_train, x_val, y_val, width_out,
def __init__(self, count, transform=None):
self.input_images, self.target_masks = simulation.generate_random_data(
192, 192, count=count)
self.transform = transform