def haraka_post_corrections(self, in_out):
"""
Change any obviously wrong haraka marks according to the character and its context.
:param in_out: input layer and prediction layers outputs.
:return: corrected predictions.
"""
inputs, pred_haraka, pred_shadda = in_out
if not self.rules_enabled:
return pred_haraka
char_index = K.argmax(inputs[:, -1], axis=-1)
# Force the correct haraka on some letters
forced_diac_chars = {CHAR2INDEX['إ']: 3}
for f_diac_char, f_diac in forced_diac_chars.items():
mask = K.reshape(K.cast(K.not_equal(char_index, f_diac_char), 'float32'), (-1, 1))
pred_haraka = mask * pred_haraka + (1 - mask) * K.one_hot(f_diac, K.int_shape(pred_haraka)[-1])
# Force the correct haraka before some letters
f_prev_diac_chars = {CHAR2INDEX['ى']: 1, CHAR2INDEX['ة']: 1}
prev_char_index = K.argmax(inputs[:, -2], axis=-1)
for fd_char, f_diac in f_prev_diac_chars.items():
mask = K.cast(K.not_equal(char_index[1:], fd_char), 'float32')
mask = K.reshape(K.concatenate([mask, K.ones((1,))], axis=0), (-1, 1))
pred_haraka = pred_haraka * mask + (1 - mask) * K.one_hot(f_diac, K.int_shape(pred_haraka)[-1])
# Allow only Fatha, Fathatan, or nothing before ا if it is in the end of the word
mask = K.reshape(K.concatenate([K.clip(
K.cast(K.not_equal(char_index[1:-1], CHAR2INDEX['ا']), 'float32') +
K.cast(K.not_equal(char_index[2:], CHAR2INDEX[' ']), 'float32'), 0, 1), K.ones((2,))], axis=0), (-1, 1))
pred_haraka = mask * pred_haraka + (1 - mask) * K.constant([1, 1, 0, 0, 0, 1, 0, 0], shape=(1, 8)) * pred_haraka
# Force Fatha before ا if it is not in the end of the word
mask = K.reshape(K.concatenate([K.clip(
K.cast(K.not_equal(char_index[1:-1], CHAR2INDEX['ا']), 'float32') +
K.cast(K.equal(char_index[2:], CHAR2INDEX[' ']), 'float32'), 0, 1), K.ones((2,))], axis=0), (-1, 1))
pred_haraka = mask * pred_haraka + (1 - mask) * K.one_hot(1, K.int_shape(pred_haraka)[-1])
# Force no sukun and tanween at the beginning of the word
mask = K.reshape(
K.concatenate([K.zeros((1,)), K.cast(K.not_equal(prev_char_index[1:], CHAR2INDEX[' ']), 'float32')],
axis=0), (-1, 1))
pred_haraka = mask * pred_haraka + (1 - mask) * K.constant([1, 1, 1, 1, 0, 0, 0, 0], shape=(1, 8)) * pred_haraka
# Allow tanween only at the end of the word
mask = K.reshape(K.concatenate([K.cast(K.not_equal(char_index[1:], CHAR2INDEX[' ']), 'float32'), K.zeros((1,))],
axis=0), (-1, 1))
pred_haraka = mask * K.constant([1, 1, 1, 1, 1, 0, 0, 0], shape=(1, 8)) * pred_haraka + (1 - mask) * pred_haraka
# Prohibit Fathatan on most letters
mask = K.reshape(K.concatenate([K.clip(
K.cast(K.not_equal(char_index[1:], CHAR2INDEX[' ']), 'float32') +
K.cast(K.not_equal(char_index[:-1], CHAR2INDEX['ء']), 'float32'), 0, 1), K.ones((1,))], axis=0), (-1, 1))
mask *= K.reshape(K.cast(K.not_equal(char_index, CHAR2INDEX['ة']), 'float32'), (-1, 1))
mask *= K.reshape(K.concatenate([K.clip(
K.cast(K.not_equal(char_index[1:-1], CHAR2INDEX['ا']), 'float32') +
K.cast(K.not_equal(char_index[2:], CHAR2INDEX[' ']), 'float32'), 0, 1), K.ones((2,))], axis=0), (-1, 1))
pred_haraka = mask * K.constant([1, 1, 1, 1, 1, 0, 1, 1], shape=(1, 8)) * pred_haraka + (1 - mask) * pred_haraka
# Drop haraka from the forbidden characters
forbidden_chars = [CHAR2INDEX[' '], CHAR2INDEX['0'], CHAR2INDEX['آ'], CHAR2INDEX['ى'], CHAR2INDEX['ا']]
mask = K.cast(K.not_equal(char_index, forbidden_chars[0]), 'float32')
for forbidden_char in forbidden_chars[1:]:
mask *= K.cast(K.not_equal(char_index, forbidden_char), 'float32')
mask = K.reshape(mask, (-1, 1))
pred_haraka = mask * pred_haraka + (1 - mask) * K.one_hot(0, K.int_shape(pred_haraka)[-1])
return pred_haraka
def dice_myo(y_true, y_pred, smooth=1e-7, num_classes=4):
'''
Multiclass Dice score. Ignores background pixel label 0
Pass to model as metric during compile statement
'''
y_true_f = K.flatten(
K.one_hot(K.cast(y_true, 'int32'), num_classes=4)[..., 2:3])
y_pred_f = K.flatten(
K.one_hot(argmax(y_pred, axis=3), num_classes=4)[..., 2:3])
intersect = K.sum(y_true_f * y_pred_f, axis=-1)
denom = K.sum(y_true_f + y_pred_f, axis=-1)
return K.mean((2. * intersect / (denom + smooth)))
def __build_train_fn(self):
"""Create a train function
It replaces `model.fit(X, y)` because we use the output of model and use it for training.
"""
action_prob_placeholder = self.model.model.outputs
advantage_placeholder = K.placeholder(shape=(None, ), name="advantage")
action_placeholder = []
old_mu_placeholder = []
action_prob_old = []
loss = []
for i in range(len(self.output_dim)):
o_mu_pl = K.placeholder(shape=(None, ),
name="old_mu_placeholder" + str(i))
old_mu_placeholder.append(o_mu_pl)
act_pl = K.placeholder(shape=(None, ),
name="action_placeholder" + str(i),
dtype='int32')
action_placeholder.append(act_pl)
act_prob = K.sum(K.one_hot(act_pl, self.output_dim[i]) *
action_prob_placeholder[i],
axis=1)
act_prob_old = K.sum(K.one_hot(act_pl, self.output_dim[i]) *
o_mu_pl,
axis=1)
action_prob_old.append(K.mean(-K.log(act_prob_old)))
logp = K.log(act_prob)
old_logp = K.log(act_prob_old)
kl = losses.kullback_leibler_divergence(old_mu_placeholder[i],
action_prob_placeholder[i])
l = (act_prob - act_prob_old) * advantage_placeholder - kl
loss.append(-K.mean(l))
entropy = K.sum(action_prob_old)
loss = K.stack(loss)
loss_p = K.sum(loss)
adam = optimizers.Adam(lr=self.pi_lr)
updates = adam.get_updates(loss=loss,
params=self.model.trainable_weights)
self.train_fn = K.function(inputs=[
*self.model.model.inputs, *old_mu_placeholder, *action_placeholder,
advantage_placeholder
],
outputs=[loss_p, entropy],
updates=updates)
def build_model(hidden_dim, max_seq_len, vocabulary_size):
## encoder Input and layers
encoder_in = Input((max_seq_len, ), dtype='int32', name='encoder_in')
ith_str = Input((1, ), dtype='int32', name='ith_str')
word = Input((1, ), dtype='int32', name='word')
OneHot = Lambda(lambda x: K.one_hot(x, vocabulary_size), name='OneHot')
## building encoder
encoder_in_and_word = Concatenate()([ith_str, word, encoder_in])
encoder_out, state = GRU(hidden_dim,
return_state=True)(OneHot(encoder_in_and_word))
encoder_out_dup = RepeatVector(max_seq_len)(encoder_out)
## decoder Input and layers
decoder_in = Input((max_seq_len, ), dtype='int32', name='decoder_in')
ith = Input((1, ), dtype='int32', name='ith')
decoder_GRU = GRU(hidden_dim, return_sequences=True, return_state=True)
decoder_Dense = Dense(vocabulary_size,
activation='softmax',
name='decoder_out')
## building decoder
ith_dup = RepeatVector(max_seq_len)(K.cast(ith, 'float'))
word_dup = K.reshape(RepeatVector(max_seq_len)(word), (-1, max_seq_len))
x = Concatenate()(
[ith_dup,
OneHot(word_dup),
OneHot(decoder_in), encoder_out_dup])
x, _ = decoder_GRU(x, initial_state=state)
decoder_out = decoder_Dense(x)
## get the specific word
gather = K.concatenate(
[K.reshape(tf.range(K.shape(decoder_out)[0]), (-1, 1)), ith])
specific_word = tf.gather_nd(decoder_out, gather)
specific_word = Lambda(tf.identity, name='word_out')(
specific_word
) # Add this layer because the name of tf.gather_nd is too ugly
model = Model([encoder_in, decoder_in, ith, ith_str, word],
[decoder_out, specific_word])
encoder_model = Model([encoder_in, ith_str, word], [encoder_out, state])
## building decoder model given encoder_out and states
decoder_in_one_word = Input((1, ),
dtype='int32',
name='decoder_in_one_word')
decoder_state_in = Input((hidden_dim, ), name='decoder_state_in')
encoder_out = Input((hidden_dim, ), name='decoder_encoder_out')
x = Concatenate()([
K.cast(ith, 'float')[:, tf.newaxis],
OneHot(word),
OneHot(decoder_in_one_word), encoder_out[:, tf.newaxis]
])
x, decoder_state = decoder_GRU(x, initial_state=decoder_state_in)
decoder_out = decoder_Dense(x)
decoder_model = Model(
[decoder_in_one_word, encoder_out, decoder_state_in, ith, word],
[decoder_out, decoder_state])
return model, encoder_model, decoder_model
def crf_nll(y_true, y_pred):
"""The negative log-likelihood for linear chain Conditional Random Field (CRF).
This loss function is only used when the `layers.CRF` layer
is trained in the "join" mode.
# Arguments
y_true: tensor with true targets.
y_pred: tensor with predicted targets.
# Returns
A scalar representing corresponding to the negative log-likelihood.
# Raises
TypeError: If CRF is not the last layer.
# About GitHub
If you open an issue or a pull request about CRF, please
add `cc @lzfelix` to notify Luiz Felix.
"""
crf, idx = y_pred._keras_history[:2]
if crf._outbound_nodes:
raise TypeError('When learn_model="join", CRF must be the last layer.')
if crf.sparse_target:
y_true = K.one_hot(K.cast(y_true[:, :, 0], 'int32'), crf.units)
X = crf._inbound_nodes[idx].input_tensors
mask = crf._inbound_nodes[idx].inbound_layers.input_mask
nloglik = crf.get_negative_log_likelihood(y_true, X, mask)
return nloglik
def dice_coeff(y_true, y_pred):
smooth = 1.
y_true_f = K.flatten(K.one_hot(K.cast(y_true, 'int32'), num_classes=11)[...,1:])
y_pred_f = K.flatten(y_pred[...,1:])
intersect = K.sum(y_true_f * y_pred_f, axis=-1)
denom = K.sum(y_true_f + y_pred_f, axis=-1)
return K.mean((2. * intersect / (denom + smooth)))
def jaccard2_macro_avg(y_true, y_pred, smooth=SMOOTH):
y_true_ndim = K.ndim(y_true)
y_pred_ndim = K.ndim(y_pred)
# 3d or 2d cases
assert (y_true_ndim == 4 and y_pred_ndim == 5) or (
y_true_ndim == 3 and y_pred_ndim
== 4), f"{y_true_ndim=} {y_pred_ndim=}" # batch_idx, x, y, z (, class)
# one hot encoding
n_classes = y_pred.shape[-1]
y_true = K.cast(K.one_hot(K.cast(y_true, "int32"), n_classes),
y_pred.dtype)
axis = (0, 1, 2, 3) if y_pred_ndim == 5 else (
0,
1,
2,
) # batch_idx, x, y(, z)
intersection = K.sum(y_true * y_pred, axis=axis)
# y_true is ohe, so y_true ** 2 is the same thing
union = K.sum(y_true, axis=axis) + K.sum(y_pred**2,
axis=axis) - intersection
jaccards = (intersection + smooth) / (union + smooth)
return 1. - K.mean(jaccards)
def grad_cam(input_model, image, category_index, layer_name):
model = Sequential()
model.add(input_model)
nb_classes = 8
loss = K.one_hot([category_index], nb_classes) * model.layers[0].output)
conv_output = [l for l in model.layers[0].layers if l.name == layer_name][0].output
grads = normalize(K.gradients(loss, conv_output)[0])
gradient_function = K.function([model.layers[0].input], [conv_output, grads])
output, grads_val = gradient_function([image])
output, grads_val = output[0, :], grads_val[0, :, :, :]
weights = np.mean(grads_val, axis = (0, 1))
cam = np.ones(output.shape[0 : 2], dtype = np.float32)
for i, w in enumerate(weights):
cam += w * output[:, :, i]
cam = cv2.resize(cam, (112, 112))
cam = np.maximum(cam, 0)
heatmap = cam / np.max(cam)
#Return to BGR [0..255] from the preprocessed image
image = image[0, :]
image -= np.min(image)
image = np.minimum(image, 255)
cam = cv2.applyColorMap(np.uint8(255*heatmap), cv2.COLORMAP_JET)
cam = np.float32(cam) + np.float32(image)
cam = 255 * cam / np.max(cam)
return np.uint8(cam), heatmap
def to_one_hot(x):
x, x_mask = x
x = K.cast(x, 'int32') # cast相当于转换数据类型
x = K.one_hot(x, len(chars) + 4) # 在原有的基础上扩展一维
x = K.sum(x_mask * x, 1, keepdims=True)
x = K.cast(K.greater(x, 0.5), 'float32')
return x
def call(self, x, **kwargs):
assert isinstance(x, list)
inp_a, inp_b = x
outp_a = K.l2_normalize(inp_a, -1)
outp_b = K.l2_normalize(inp_b, -1)
alpha = K.batch_dot(outp_b, outp_a, axes=[2, 2])
alpha = K.l2_normalize(alpha, 1)
alpha = K.one_hot(K.argmax(alpha, 1), K.int_shape(inp_a)[1])
hmax = K.batch_dot(alpha, outp_b, axes=[1, 1])
kcon = K.eye(K.int_shape(inp_a)[1], dtype='float32')
m = []
for i in range(self.output_dim):
outp_a = inp_a * self.W[i]
outp_hmax = hmax * self.W[i]
outp_a = K.l2_normalize(outp_a, -1)
outp_hmax = K.l2_normalize(outp_hmax, -1)
outp = K.batch_dot(outp_hmax, outp_a, axes=[2, 2])
outp = K.sum(outp * kcon, -1, keepdims=True)
m.append(outp)
if self.output_dim > 1:
persp = K.concatenate(m, 2)
else:
persp = m[0]
return [persp, persp]
def symmetric_cross_entropy(y_actual, y_pred, A=-6, alpha=0.1, beta=1):
'''Define the symmetric cross entropy that will be used for training '''
q = K.one_hot(K.cast(y_actual, 'uint8'), 10) # 200 or 10
custom_loss = -alpha * K.mean(
K.batch_dot(q, K.maximum(K.log(y_pred + 1e-15), A))) - beta * K.mean(
K.batch_dot(K.maximum(K.log(q + 1e-15), A), y_pred))
return custom_loss
def Mask(self, inputs, seq_len, mode="add"):
"""Mask operation used in multi-head self attention
Args:
seq_len (obj): sequence length of inputs.
mode (str): mode of mask.
Returns:
obj: tensors after masking.
"""
if seq_len == None:
return inputs
else:
mask = K.one_hot(indices=seq_len[:, 0],
num_classes=K.shape(inputs)[1])
mask = 1 - K.cumsum(mask, axis=1)
for _ in range(len(inputs.shape) - 2):
mask = K.expand_dims(mask, 2)
if mode == "mul":
return inputs * mask
elif mode == "add":
return inputs - (1 - mask) * 1e12
def get_image(image_path,
img_height=240,
img_width=240,
mask=False,
flip=0,
flip2=0):
img = tf.io.read_file(image_path)
if not mask:
img = tf.cast(tf.image.decode_png(img, channels=4), dtype=tf.float32)
img = tf.image.resize(images=img, size=[img_height, img_width]) / 255
img_shape = tf.shape(img)
print(img_shape)
img = tf.case(
[(tf.greater(flip, 0), lambda: tf.image.flip_left_right(img))],
default=lambda: img)
img = tf.case(
[(tf.greater(flip2, 0), lambda: tf.image.flip_up_down(img))],
default=lambda: img)
else:
img = tf.image.decode_png(img, channels=1)
img = tf.cast(tf.image.resize(images=img, size=[img_height,
img_width]),
dtype=tf.uint8)
img = tf.case(
[(tf.greater(flip, 0), lambda: tf.image.flip_left_right(img))],
default=lambda: img)
img = tf.case(
[(tf.greater(flip2, 0), lambda: tf.image.flip_up_down(img))],
default=lambda: img)
img = K.squeeze(img, axis=-1)
img = K.one_hot(tf.cast(img, tf.int32), num_classes)
return img
def WNet(feature_maps=None, nb_classes=6, dropout=0.65, model_name_suffix=""):
if feature_maps is None:
feature_maps = [64, 128, 256, 512, 1024]
encoder_input, encoder_output = UNet(input_size=(256, 256, 3),
feature_maps=feature_maps,
nb_classes=nb_classes,
dropout=dropout,
conv_padding="same",
build_model=False)
encoder_output = K.one_hot(K.argmax(encoder_output), nb_classes)
_, decoder_output = UNet(input_layer=encoder_output,
nb_classes=3,
output_layer_activation="sigmoid",
dropout=dropout,
feature_maps=feature_maps,
conv_padding="same",
build_model=False)
nb_conv_layers = 6 + 10 * (len(feature_maps) - 1)
dropout_suffix = "D" if dropout > 0.0 else ""
model_name = f"WNet-{nb_conv_layers}{dropout_suffix}-{nb_classes}{model_name_suffix}"
full_model = Model(name=model_name,
inputs=encoder_input,
outputs=decoder_output)
encoder_model = Model(name=f"{model_name}-Encoder",
inputs=encoder_input,
outputs=encoder_output)
return full_model, encoder_model
def path_energy0(y, x, U, mask=None):
'''Path energy without boundary potential handling.'''
n_classes = K.shape(x)[2]
y_one_hot = K.one_hot(y, n_classes)
# Tag path energy
energy = K.sum(x * y_one_hot, 2)
energy = K.sum(energy, 1)
# Transition energy
y_t = y[:, :-1]
y_tp1 = y[:, 1:]
U_flat = K.reshape(U, [-1])
# Convert 2-dim indices (y_t, y_tp1) of U to 1-dim indices of U_flat:
flat_indices = y_t * n_classes + y_tp1
U_y_t_tp1 = K.gather(U_flat, flat_indices)
if mask is not None:
mask = K.cast(mask, K.floatx())
y_t_mask = mask[:, :-1]
y_tp1_mask = mask[:, 1:]
U_y_t_tp1 *= y_t_mask * y_tp1_mask
energy += K.sum(U_y_t_tp1, axis=1)
return energy
def _label_to_one_hot(tens, nb_labels):
"""
Transform a label nD Tensor to a one-hot 3D Tensor. The input tensor is first
batch-flattened, and then each batch and each voxel gets a one-hot representation
"""
y = K.batch_flatten(tens)
return K.one_hot(y, nb_labels)
def update_state(self, y_true, y_pred, sample_weight=None):
# if log_metrics:
# wandb_log_report(report)
# skip to count samples with label __unknown__
mask = K.cast(K.not_equal(y_true, 1), K.floatx())
if self.threshold is None:
threshold = tf.reduce_max(y_pred, axis=-1, keepdims=True)
# make sure [0, 0, 0] doesn't become [1, 1, 1]
# Use abs(x) > eps, instead of x != 0 to check for zero
y_pred = tf.logical_and(y_pred >= threshold,
tf.abs(y_pred) > 1e-12)
else:
y_pred = y_pred > self.threshold
y_true = K.one_hot(K.cast(K.flatten(y_true), tf.int32),
y_pred.shape[1])
y_true = tf.cast(y_true, self.dtype)
y_pred = tf.cast(y_pred, self.dtype)
# # skip counting samples where the PAD token is predicted
def _weighted_sum(val, sample_weight):
if sample_weight is not None:
val = tf.math.multiply(val, tf.expand_dims(sample_weight, 1))
return tf.reduce_sum(val * mask, axis=self.axis)[2:]
self.true_positives.assign_add(
_weighted_sum(y_pred * y_true, sample_weight))
self.false_positives.assign_add(
_weighted_sum(y_pred * (1 - y_true), sample_weight))
self.false_negatives.assign_add(
_weighted_sum((1 - y_pred) * y_true, sample_weight))
self.weights_intermediate.assign_add(
_weighted_sum(y_true, sample_weight))
def loss(y_true, y_pred):
pred_labels = K.one_hot(K.argmax(y_pred, 1),
num_classes=K.shape(y_true)[1])
y_new = alpha * y_true + (1. - alpha) * pred_labels
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
return -K.sum(y_new * K.log(y_pred), axis=-1)
def _train(self, screens_input, action_input, select_input, reward, action,
screen_action, screen_used):
_entropy = _policy_loss = _value_loss = 0.
with tf.GradientTape() as tape:
spatial_policy, ns_policy, value = self.model(
[screens_input, action_input, select_input])
value = K.squeeze(value, axis=1)
ns_action_one_hot = K.one_hot(action, len(ACTION_OPTIONS))
screen_action_one_hot = K.one_hot(screen_action,
SCREEN_SIZE * SCREEN_SIZE)
value_loss = .5 * K.square(reward - value)
entropy = -K.sum(ns_policy * K.log(ns_policy + 1e-10), axis=1) - \
K.sum(spatial_policy * K.log(spatial_policy + 1e-10), axis=1)
ns_log_prob = K.log(
K.sum(ns_policy * ns_action_one_hot, axis=1) + 1e-10)
spatial_log_prob = K.log(
K.sum(spatial_policy * screen_action_one_hot, axis=1) + 1e-10)
advantage = reward - K.stop_gradient(value)
# Mask out spatial_log_prob when the action taken did not use the screen
policy_loss = -(ns_log_prob + spatial_log_prob *
screen_used) * advantage - entropy * ENTROPY_RATE
total_loss = policy_loss + value_loss
_entropy = K.mean(entropy)
_policy_loss = K.mean(K.abs(policy_loss))
_value_loss = K.mean(value_loss)
gradients = tape.gradient(total_loss, self.model.trainable_variables)
global_norm = tf.linalg.global_norm(gradients)
print(tf.linalg.global_norm(gradients))
gradients, _ = tf.clip_by_global_norm(
gradients,
GRADIENT_CLIP_MAX) # Prevents exploding gradients...I think
self.opt.apply_gradients(zip(gradients,
self.model.trainable_variables))
return [
float(_value_loss),
float(_policy_loss),
float(_entropy), global_norm
]
def call(self, inputs, **kwargs):
if type(inputs) is list:
inputs, mask = inputs
else:
x = K.sqrt(K.sum(K.square(inputs), -1))
mask = K.one_hot(indices=K.argmax(x, 1), num_classes=x.get_shape().as_list()[1])
masked = K.batch_flatten(inputs * K.expand_dims(mask, -1))
return masked
def expand_binary(x):
# remove last dim
x = backend.squeeze(x, axis=-1)
# scale to 0 or 1
x = backend.round(x)
x = backend.cast(x, 'int32')
x = backend.one_hot(x, 2)
return x
def bi_tempered_loss(y_true, y_pred):
y_true = K.cast(K.reshape(y_true, (-1, )), "int64")
labels = K.one_hot(y_true, N_CLASSES)
return bi_tempered_logistic_loss(y_pred,
labels,
T1,
T2,
label_smoothing=0.2)
def generalized_dice_loss(y_true, y_pred, smooth=1e-7, num_classes=4):
y_true_f = K.flatten(
K.one_hot(K.cast(y_true, 'int32'), num_classes=4)[..., 1:])
y_pred_f = K.flatten(y_pred[..., 1:])
intersect = K.sum(y_true_f * y_pred_f, axis=-1)
denom = K.sum(y_true_f + y_pred_f, axis=-1)
return 1.0 - K.mean((2. * intersect / (denom + smooth)))
def ground_truth_generator(dataset, ANCHORS, IMAGE_W, IMAGE_H, GRID_W, GRID_H,
CLASS):
'''
Ground truth batch generator from a yolo dataset, ready to compare with YOLO prediction in loss function.
Parameters
----------
- YOLO dataset. Generate batch:
batch : tupple(images, annotations)
batch[0] : images : tensor (shape : batch_size, IMAGE_W, IMAGE_H, 3)
batch[1] : annotations : tensor (shape : batch_size, max annot, 5)
Returns
-------
- imgs : images to predict. tensor (shape : batch_size, IMAGE_H, IMAGE_W, 3)
- detector_mask : tensor, shape (batch size, GRID_W, GRID_H, anchors_count, 1)
1 if bounding box detected by grid cell, else 0
- matching_true_boxes : tensor, shape (batch_size, GRID_W, GRID_H, anchors_count, 5)
Contains adjusted coords of bounding box in YOLO format
- class_one_hot : tensor, shape (batch_size, GRID_W, GRID_H, anchors_count, class_count)
One hot representation of bounding box label
- true_boxes_grid : annotations : tensor (shape : batch_size, max annot, 5)
true_boxes format : x, y, w, h, c, coords unit : grid cell
'''
for batch in dataset:
# imgs
imgs = batch[0]
# true boxes
true_boxes = batch[1]
# matching_true_boxes and detector_mask
batch_matching_true_boxes = []
batch_detector_mask = []
batch_true_boxes_grid = []
for i in range(true_boxes.shape[0]): # for each image in batch
one_matching_true_boxes, one_detector_mask, true_boxes_grid = process_true_boxes(
true_boxes[i], ANCHORS, IMAGE_W, IMAGE_H, GRID_W, GRID_H)
batch_matching_true_boxes.append(one_matching_true_boxes)
batch_detector_mask.append(one_detector_mask)
batch_true_boxes_grid.append(true_boxes_grid)
detector_mask = tf.convert_to_tensor(np.array(batch_detector_mask),
dtype='float32')
matching_true_boxes = tf.convert_to_tensor(
np.array(batch_matching_true_boxes), dtype='float32')
true_boxes_grid = tf.convert_to_tensor(np.array(batch_true_boxes_grid),
dtype='float32')
# class one_hot
matching_classes = K.cast(matching_true_boxes[..., 4], 'int32')
class_one_hot = K.one_hot(matching_classes, CLASS + 1)[:, :, :, :, 1:]
class_one_hot = tf.cast(class_one_hot, dtype='float32')
batch = (imgs, detector_mask, matching_true_boxes, class_one_hot,
true_boxes_grid)
yield batch
def sparse_loss(self, y_true, y_pred): """y_true需要是整数形式（非one hot） """ # y_true需要重新明确一下shape和dtype y_true = K.reshape(y_true, K.shape(y_pred)[:-1]) y_true = K.cast(y_true, 'int32') # 转为one hot y_true = K.one_hot(y_true, K.shape(self.trans)[0]) return self.dense_loss(y_true, y_pred)
def dice_loss_3d(y_true, y_pred):
smooth = 1.
y_pred = K.reshape(y_pred, (-1, K.int_shape(y_pred)[-1]))
softmax = tf.nn.softmax(y_pred)
y_true = K.one_hot(tf.to_int32(K.flatten(y_true)), K.int_shape(y_pred)[-1])
intersection = K.sum(y_true * softmax, axis=0)
return 1 - K.mean(
(2. * intersection + smooth) /
(K.sum(y_true, axis=0) + K.sum(softmax, axis=0) + smooth))
def call(self, inputs):
encoder_output = K.one_hot(inputs['primary'], self._n_symbols)
try:
encoder_output = K.concatenate(
(encoder_output, inputs['evolutionary']))
except KeyError:
raise TypeError("Evolutionary inputs not available for this task.")
inputs['encoder_output'] = encoder_output
return inputs
def _build_gradient_func(self, action):
"""
Make a function which returns gradients of the `action`th component of the output
of the actor model, with respect to the input and weights of the actor model
"""
predicted_action_mass = K.dot(K.one_hot([action],self.action_size), # select output component
K.transpose(K.log(self.actor.output)))
grads = K.gradients([predicted_action_mass], self._get_actor_weights())
return K.function(self.actor.inputs, grads)
def call(self, inputs, mask=None, **kwargs):
logits, sequence_lengths = inputs
sequence_lengths = K.flatten(sequence_lengths)
tags_seq, tags_score = tf.contrib.crf.crf_decode(
logits, self.transitions, sequence_lengths)
tags_seq = tf.identity(tags_seq, name='logits')
outputs = K.one_hot(tags_seq, self.num_tags)
return K.in_train_phase(logits, outputs)
def kronecker_product(args):
S, A = args
if K.ndim(S) == 1 and K.dtype(S).startswith('int'):
S = K.one_hot(S, self.env.observation_space.n)
elif K.ndim(S) > 2:
S = keras.layers.Flatten()(S)
check_tensor(S, ndim=2, dtype=('float32', 'float64'))
check_tensor(A, ndim=2, dtype=('float32', 'float64'))
return tf.einsum('ij,ik->ijk', S, A)
