def yolo_correct_boxes(box_xy, box_wh, input_shape,
image_shape): #调整框的相对大小以适应原始图像的长宽比
'''Get corrected boxes'''
box_yx = box_xy[..., ::-1]
box_hw = box_wh[..., ::-1]
input_shape = K.cast(input_shape, K.dtype(box_yx))
image_shape = K.cast(image_shape, K.dtype(box_yx))
new_shape = K.round(image_shape * K.min(input_shape / image_shape))
offset = (input_shape - new_shape) / 2. / input_shape
scale = input_shape / new_shape
box_yx = (box_yx - offset) * scale
box_hw *= scale
box_mins = box_yx - (box_hw / 2.)
box_maxes = box_yx + (box_hw / 2.)
boxes = K.concatenate([
box_mins[..., 0:1], # y_min
box_mins[..., 1:2], # x_min
box_maxes[..., 0:1], # y_max
box_maxes[..., 1:2] # x_max
])
# Scale boxes back to original image shape.
boxes *= K.concatenate([image_shape, image_shape])
return boxes
def YOLOCorrectBoxes(box_xy, box_wh, input_shape, image_shape):
'''Get Corrected Boxes.'''
box_yx = box_xy[..., ::-1]
box_hw = box_wh[..., ::-1]
input_shape = K.cast(input_shape, K.dtype(box_yx))
image_shape = K.cast(image_shape, K.dtype(box_yx))
new_shape = K.round(image_shape * K.min(input_shape / image_shape))
offset = (input_shape - new_shape) / 2. / input_shape
scale = input_shape / new_shape
box_yx = (box_yx - offset) * scale
box_hw *= scale
box_mins = box_yx - (box_hw / 2.)
box_max = box_yx + (box_hw / 2.)
boxes = K.concatenate([
box_mins[..., 0:1], #y min
box_mins[..., 1:2], #x min
box_max[..., 0:1], #y max
box_max[..., 1:2] #x max
])
#Scale boxes back to original image shape
boxes *= K.concatenate([image_shape, image_shape])
return boxes
def softmax_with_mask(tensor_and_mask):
input_tensor, mask_tensor = tensor_and_mask
min_tensor = K.min(input_tensor, axis=1, keepdims=True)
positive_tensor = (min_tensor - input_tensor) * mask_tensor
max_tensor = K.max(positive_tensor, axis=1, keepdims=True)
exp_tensor = K.exp(positive_tensor - max_tensor)
masked_tensor = exp_tensor * mask_tensor
summed_tensor = K.sum(masked_tensor, axis=1, keepdims=True)
return masked_tensor / (summed_tensor + 1e-10)
def call(self, x, mask=None):
""" The actual processing in the layer: Normalize, padd, then convolution.
"""
input_1, input_2 = x
input_shape = input_1.shape
# assert input_shape == input_2._keras_shape
self.H = input_shape[1]
self.W = input_shape[2]
self.C = input_shape[3]
# normalization
if self.use_norm is 'euclidean':
input_1 = K.l2_normalize(input_1, axis=2)
input_2 = K.l2_normalize(input_2, axis=2)
if self.use_norm is 'scaling':
input_1_min = K.min(input_1, axis=2, keepdims=True)
input_1_max = K.max(input_1, axis=2, keepdims=True)
input_1 = (input_1 - input_1_min) / (input_1_max - input_1_min + 0.000001)
input_2_min = K.min(input_2, axis=2, keepdims=True)
input_2_max = K.max(input_2, axis=2, keepdims=True)
input_2 = (input_2 - input_2_min) / (input_2_max - input_2_min + 0.000001)
if self.use_norm is 'standardization':
input_1 = (input_1 - K.mean(input_1, axis=2, keepdims=True)) + 0.00001
input_1 = K.l2_normalize(input_1, axis=2)
input_2 = (input_2 - K.mean(input_2, axis=2, keepdims=True)) + 0.00001
input_2 = K.l2_normalize(input_2, axis=2)
# Pad the first input1 circular, so that a correlation can be computed for
# every horizontal position
padding1 = RangePadding2D(padding=self.W // 2)(input_1)
# tf.scan的原理解析：https://zhuanlan.zhihu.com/p/96503559
out = tf.scan(self.single_sample_corr,
elems=[padding1, input_2],
initializer=(K.zeros((int(self.H), int(self.W), int(self.output_dim))))
)
return out
def call(self, y):
# Sanity Check
if isinstance(y, list):
raise ValueError('TSG layer has only 1 input')
# y = tf_print(y, [y], message='{}: The unconstrained action is:'.format(y.name.split('/')[0]), summarize=-1)
y = check_numerics(y, 'Problem with input y')
# Calculate A.c
Ac = tensordot(self.A_graph, self.c_graph, 1)
# Calculate b - Ac
bMinusAc = self.b_graph - Ac
# Calculate y - c
yMinusc = y - self.c_graph
# Calculate A.(y - c)
ADotyMinusc = K.sum((self.A_graph * expand_dims(yMinusc, -2)), axis=2)
# Do elem-wise division
intersection_points = bMinusAc / (ADotyMinusc + K.epsilon()
) # Do we need the K.epsilon()?
# Enforce 0 <= intersection_points <= 1 because the point must lie between c and y
greater_1 = K.greater(intersection_points,
K.ones_like(intersection_points))
candidate_alpha = K.switch(greater_1,
K.ones_like(intersection_points) + 1,
intersection_points)
less_0 = K.less(candidate_alpha, K.zeros_like(intersection_points))
candidate_alpha = K.switch(less_0,
K.ones_like(intersection_points) + 1,
candidate_alpha)
# Find farthest intersection point from y to get projection point
alpha = K.min(candidate_alpha, axis=-1, keepdims=True)
# If it is an interior point, y itself is the projection point
interior_point = K.greater(alpha, K.ones_like(alpha))
alpha = K.switch(interior_point, K.ones_like(alpha), alpha)
# alpha = tf_print(alpha, [alpha], message="{}: The value of alpha is: ".format(alpha.name.split('/')[0]))
# Return \alpha.y + (1 - \alpha).c
z = alpha * y + ((1 - alpha) * self.c_graph)
# z = tf_print(z, [z], message='{}: The constrained action is:'.format(z.name.split('/')[0]), summarize=-1)
return z
def f(x):
max_x = K.max(x, axis=1)
min_x = K.min(x, axis=1)
return max_x, min_x
def call(self, inputs):
if self.data_format == 'channels_last':
return backend.min(inputs, axis=[1, 2])
else:
return backend.min(inputs, axis=[2, 3])
def calc_adj_mat_error(batch_imgs, batch_size):
adj_mat = k.zeros(shape=(108, 108))
for o in range(batch_size):
img = batch_imgs[o]
classes = np.unique(img)
classes = classes[1:]
if 255 in classes:
classes = classes[:-1]
mat_contour = []
for i in range(len(classes)):
value = classes[i]
mask = cv2.inRange(img, int(value), int(value))
per, _ = cv2.findContours(image=mask, mode=cv2.RETR_TREE, method=cv2.CHAIN_APPROX_SIMPLE)
mat_total = k.zeros(shape=(1, 2))
for q in range(len(per)):
tmp = per[q]
mat = k.zeros(shape=(len(tmp), 2))
for j in range(len(tmp)):
point = tmp[j]
x = point[0][0]
y = point[0][1]
mat[j][0] = x
mat[j][1] = y
mat_total = k.concatenate((mat_total, mat), axis=0)
mat_contour.append(mat_total[1:])
for i in range(len(classes)):
tmp = mat_contour[i]
for j in range(i + 1, len(classes)):
# for j in range(0, len(classes)):
min_v = sys.maxsize
second_mat = mat_contour[j]
for p in range(len(tmp)):
first_mat = tmp[p]
dif = first_mat - second_mat
# dif = np.multiply(dif, dif)
dif = dif * dif
sum_mat = k.sum(dif, 1)
sqrt = k.sqrt(sum_mat)
min_tmp = k.min(sqrt)
if min_tmp < min_v:
min_v = min_tmp
if min_v <= 1:
adj_mat[classes[i]][classes[j]] = 1 + adj_mat[classes[i]][classes[j]]
# adj_mat = normalize(adj_mat, axis=1, norm='l1')
return adj_mat
