def call(self, y_true, y_pred):
real_loss = categorical_crossentropy(y_true, tf.math.real(y_pred))
if y_pred.dtype.is_complex:
imag_loss = categorical_crossentropy(y_true, tf.math.imag(y_pred))
else:
imag_loss = real_loss
return (real_loss + imag_loss) / 2.
def custom_loss(y_true, y_pred):
y_true_label_1 = y_true[:, :num_classes]
y_true_label_2 = y_true[:, num_classes:num_classes * 2]
y_pred_label_1 = y_pred[:, :num_classes]
y_pred_label_2 = y_pred[:, num_classes:num_classes * 2]
y_pred_embedding_1 = y_pred[:,
num_classes * 2:num_classes * 2 + emb_size]
y_pred_embedding_2 = y_pred[:, num_classes * 2 + emb_size:]
class_loss_1 = categorical_crossentropy(y_true_label_1, y_pred_label_1)
class_loss_2 = categorical_crossentropy(y_true_label_2, y_pred_label_2)
embedding_loss = cosine_similarity(y_pred_embedding_1,
y_pred_embedding_2)
are_labels_equal = K.all(K.equal(y_true_label_1, y_true_label_2),
axis=1)
a = tf.where(are_labels_equal,
tf.fill([tf.shape(are_labels_equal)[0]], 1.0),
tf.fill([tf.shape(are_labels_equal)[0]], -1.0))
result = class_loss_1 + class_loss_2 + tf.math.multiply(
a, embedding_loss)
return tf.math.reduce_mean(result)
def dice_cce(y_true, y_pred, axis=(1, 2, 3), ignore_background=False):
"y_true and y_pred should be one_hot encoded"
dice = 1 - generalized_dice(y_true, y_pred, axis=(1, 2, 3))
if ignore_background:
mask = 1 - y_true[:, :, :, :, 0]
loss = categorical_crossentropy(y_true, y_pred)
cce = tf.math.multiply(loss, mask)
else:
cce = categorical_crossentropy(y_true, y_pred)
return dice + cce
def build_tabor_regularization(self, input_raw_tensor, model,
y_target_tensor, y_true_tensor):
reg_losses = []
# R1 - Overly large triggers
mask_l1_norm = K.sum(K.abs(self.mask_upsample_tensor))
mask_l2_norm = K.sum(K.square(self.mask_upsample_tensor))
mask_r1 = (mask_l1_norm + mask_l2_norm)
pattern_tensor = (K.ones_like(self.mask_upsample_tensor) \
- self.mask_upsample_tensor) * self.pattern_raw_tensor
pattern_l1_norm = K.sum(K.abs(pattern_tensor))
pattern_l2_norm = K.sum(K.square(pattern_tensor))
pattern_r1 = (pattern_l1_norm + pattern_l2_norm)
# R2 - Scattered triggers
pixel_dif_mask_col = K.sum(K.square(
self.mask_upsample_tensor[:-1, :, :] \
- self.mask_upsample_tensor[1:, :, :]))
pixel_dif_mask_row = K.sum(K.square(
self.mask_upsample_tensor[:, :-1, :] \
- self.mask_upsample_tensor[:, 1:, :]))
mask_r2 = pixel_dif_mask_col + pixel_dif_mask_row
pixel_dif_pat_col = K.sum(K.square(pattern_tensor[:-1, :, :] \
- pattern_tensor[1:, :, :]))
pixel_dif_pat_row = K.sum(K.square(pattern_tensor[:, :-1, :] \
- pattern_tensor[:, 1:, :]))
pattern_r2 = pixel_dif_pat_col + pixel_dif_pat_row
# R3 - Blocking triggers
cropped_input_tensor = (K.ones_like(self.mask_upsample_tensor) \
- self.mask_upsample_tensor) * input_raw_tensor
r3 = K.mean(
categorical_crossentropy(
model(cropped_input_tensor),
K.reshape(y_true_tensor[0], shape=(1, -1))))
# R4 - Overlaying triggers
mask_crop_tensor = self.mask_upsample_tensor * self.pattern_raw_tensor
r4 = K.mean(
categorical_crossentropy(
model(mask_crop_tensor),
K.reshape(y_target_tensor[0], shape=(1, -1))))
reg_losses.append(mask_r1)
reg_losses.append(pattern_r1)
reg_losses.append(mask_r2)
reg_losses.append(pattern_r2)
reg_losses.append(r3)
reg_losses.append(r4)
return K.stack(reg_losses)
def masked_loss(y_true, y_pred):
max_args = argmax(y_true)
mask = cast(not_equal(max_args, zeros_like(max_args)), dtype='float32')
loss = switch(mask,
categorical_crossentropy(y_true, y_pred, from_logits=True),
zeros_like(mask, dtype=floatx()))
return sum(loss) / (cast(sum(mask), dtype='float32') + epsilon())
def model_vgg16_cifar(n_clasif, xshape):
input_shape = xshape[1:]
model = Sequential()
# 2 x Conv
model.add(
Conv2D(64, (3, 3),
input_shape=input_shape,
padding='same',
activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# 2 x Conv
model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
#model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# 3 x Conv
model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
#model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# 3 x Conv
model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))
#model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))
#model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# 3 x Conv
model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))
#model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))
#model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(
Dense(1000,
activation='relu',
activity_regularizer=regularizers.l2(0.001)))
model.add(
Dense(1000,
activation='relu',
activity_regularizer=regularizers.l2(0.001)))
#model.add(Dense(4096 , activation='relu'))
model.add(
Dense(n_clasif,
activation='linear',
activity_regularizer=regularizers.l2(0.001)))
model.summary()
# Compile the model
model.compile(
loss=losses.categorical_crossentropy(from_logits=True),
optimizer=optimizers.Adam(
learning_rate=0.001), #optimizers.SGD(lr=0.03),
metrics=[metrics.CategoricalAccuracy('acc')])
return model
def actor_loss(self, states, actions, values, rewards, next_values, dones):
policy = self.actor_model(
tf.convert_to_tensor(np.vstack(states), dtype=tf.float32))
advantages = []
for i in range(len(states)):
reward = np.array(rewards[i])
value = np.array(values[i])
next_value = np.array(next_values[i])
if dones[i]:
advantages.append(reward - value)
else:
advantages.append(reward + self.df * next_value - value)
advantages = tf.reshape(advantages, [len(states)])
tf.convert_to_tensor(advantages, dtype=tf.float32)
# SparseCategoricalCrossentropy
entropy = losses.categorical_crossentropy(policy,
policy,
from_logits=True)
ce_loss = losses.SparseCategoricalCrossentropy(from_logits=True)
#policy_loss = ce_loss(actions, policy, sample_weight=np.array(advantages)) # same way
log_pi = ce_loss(actions, policy)
policy_loss = log_pi * np.array(advantages)
policy_loss = tf.reduce_mean(policy_loss)
log_pi = tf.reduce_mean(log_pi)
return policy_loss - self.en * entropy, log_pi
def predict(gids, model_path, mode="train"):
model = load_model(model_path, custom_objects=TF_CUSTOM_METRICS)
images = []
labels = []
for gid in gids:
image = cv2.imread(
os.path.join("E:", "data", "unet", mode, "images", f"{gid}.png"),
cv2.IMREAD_COLOR)
images.append(image / 255)
label = cv2.imread(
os.path.join("E:", "data", "unet", mode, "labels", f"{gid}.png"),
cv2.IMREAD_GRAYSCALE)
labels.append(one_hot_encoding(label))
pred = model.predict(np.array(images))
losses = categorical_crossentropy(labels, pred)
losses = np.mean(losses, axis=(1, 2))
argmax_mean_iou = ArgmaxMeanIoU(num_classes=6)
for idx, p in enumerate(pred):
argmax_mean_iou.update_state(labels[idx], p)
iou = argmax_mean_iou.result().numpy()
print(f"{gids[idx]}: loss={losses[idx]:02f} iou={iou:02f}")
cv2.imwrite(f"images/{mode}/{gids[idx]}-prediction.png",
one_hot_to_rgb(p))
cv2.imwrite(f"images/{mode}/{gids[idx]}-label.png",
one_hot_to_rgb(labels[idx]))
cv2.imwrite(f"images/{mode}/{gids[idx]}-image.png", images[idx] * 255)
def _actor_loss(self, acts_and_advs, actor_logits):
"""The custom loss function for the actor
For explanation of how tf/keras calls it, see critic loss above and reference.
y_true = targets are actions and advantages. The y_pred = policy = output (logits) of
the actor network (not normalized)
"""
actions, advantages = tf.split(acts_and_advs, 2, axis=-1)
# sparse categorical CE loss obj that supports sample_weight arg on call()
# from_logits argument ensures transformation into normalized probabilities
weighted_sparse_ce = kls.SparseCategoricalCrossentropy(
from_logits=True)
# policy loss is defined by policy gradients, weighted by advantages
# note: we only calculate the loss on the actions we've actually taken
# that and because A2C is on policy method is the reason why policy gardients
# ususally require many episodeds to converge
actions = tf.cast(actions, tf.int32)
policy_loss = weighted_sparse_ce(actions,
actor_logits,
sample_weight=advantages)
# entropy loss can be calculated via CE over itself
entropy_loss = kls.categorical_crossentropy(actor_logits,
actor_logits,
from_logits=True)
#signs are flipped because optimizer minimizes
return policy_loss - self.ENTROPY_FACTOR * entropy_loss
def validate(model, x, y, bs):
prediction = model.predict(x, batch_size=bs)
validation_loss = K.eval(
K.mean(categorical_crossentropy(K.constant(y),
K.constant(prediction))))
log_validation_performance(val_loss=validation_loss)
return validation_loss
def _logits_loss(self, acts_and_advs, logits):
# a trick to input actions and advantages through same API
actions, advantages = tf.split(acts_and_advs, 2, axis=-1)
# sparse categorical CE loss obj that supports sample_weight arg on call()
# from_logits argument ensures transformation into normalized probabilities
weighted_sparse_ce = kls.SparseCategoricalCrossentropy(
from_logits=True)
# policy loss is defined by policy gradients, weighted by advantages
# note: we only calculate the loss on the actions we've actually taken
actions = tf.cast(actions, tf.int32)
policy_loss = weighted_sparse_ce(actions,
logits,
sample_weight=advantages)
# entropy loss can be calculated via CE over itself
entropy_loss = kls.categorical_crossentropy(logits,
logits,
from_logits=True)
# here signs are flipped because optimizer minimizes
return policy_loss - self.params['entropy'] * entropy_loss
def _self_guided_earth_mover_distance(
y_true: K.placeholder,
y_pred: K.placeholder,
) -> K.placeholder:
cross_entropy_loss = categorical_crossentropy(
y_true=y_true,
y_pred=y_pred
)
if model.emd_weight_head_start.emd_weight == 0:
if model.emd_weight_head_start.epoch == 3:
self_guided_emd_loss = _calculate_self_guided_loss(
y_true=y_true,
y_pred=y_pred,
ground_distance_sensitivity=ground_distance_sensitivity,
ground_distance_bias=ground_distance_bias,
ground_distance_manager=model.ground_distance_manager
)
model.emd_weight_head_start.cross_entropy_loss_history.append(cross_entropy_loss)
model.emd_weight_head_start.self_guided_emd_loss_history.append(self_guided_emd_loss)
return cross_entropy_loss
else:
self_guided_emd_loss = _calculate_self_guided_loss(
y_true=y_true,
y_pred=y_pred,
ground_distance_sensitivity=ground_distance_sensitivity,
ground_distance_bias=ground_distance_bias,
ground_distance_manager=model.ground_distance_manager
)
return cross_entropy_loss + model.emd_weight_head_start.emd_weight * self_guided_emd_loss
def action_loss(self, actions, advantages, policy_prediction):
actions = tf.cast(actions, tf.int32)
policy_loss = kls.SparseCategoricalCrossentropy(from_logits=True)(
actions, policy_prediction, sample_weight=advantages)
policy_2 = tf.nn.softmax(policy_prediction)
entropy_loss = kls.categorical_crossentropy(policy_2, policy_2)
return policy_loss - self.params['entropy'] * entropy_loss
def pi_loss(y_true, m_out):
y_pred, advs, vf = m_out[0], m_out[1], m_out[2]
y_true_action = y_true[0]
vf_true = tf.cast(y_true[1], tf.float32)
# First, one-hot encoding of true value y_true
y_true_action = tf.expand_dims(tf.cast(y_true_action, tf.int32),
axis=1)
y_true_action = tf.one_hot(y_true_action, depth=action_size)
# Execute categorical crossentropy
neglogp = cat_crosentropy(
y_true_action, # True actions chosen
y_pred, # Logits from model
# sample_weight=advs
)
policy_loss = tf.reduce_mean(advs * neglogp)
entropy_loss = kls.categorical_crossentropy(y_pred,
y_pred,
from_logits=True)
loss_vf = kls.mean_squared_error(vf, vf_true)
return policy_loss - coeff_entropy * entropy_loss + coeff_vf * loss_vf
def loss_function(self, state, y_model, d_model, prob, act, value):
# Reward
R = d_model - self.alpha * tf.reduce_mean(tf.square(state - y_model))
# ========= A2C RL training =========
# ======= Value Loss =======
advantage = R - value
value_loss = advantage**2
# ======= Policy Loss =======
# One hot encode actions for all L steps
action_one_hot = tf.one_hot(act, self.L, dtype=tf.float32)
# Entropy of filter's prob dist for each img, sum over filters and steps
entropy = tf.reduce_sum(prob * tf.math.log(prob + 1e-20), axis=[1, 2])
entropy = tf.reshape(entropy, (-1, 1))
# Cross-entropy for multi-class exclusive problem sum down all filters
policy_loss = tf.reduce_sum(categorical_crossentropy(
action_one_hot, prob),
axis=1,
keepdims=True)
# Stop gradient flow from value network with advantage calculation
policy_loss *= tf.stop_gradient(advantage)
policy_loss -= self.beta * entropy
total_loss = tf.reduce_mean((0.5 * value_loss + policy_loss))
return total_loss
def loss(y_true, y_pred):
mask = np.zeros((1, 362))
mask[0][-1] = 1
value_loss = mean_squared_error(mask*y_true, mask*y_pred)
mask = 1-mask
policy_loss = K.sum(categorical_crossentropy(mask*y_true, mask*y_pred))
return policy_loss+value_loss
def _logits_loss(self, actions_and_advantages, logits):
# A trick to input actions and advantages through the same API.
actions, advantages = tf.split(actions_and_advantages, 2, axis=-1)
# Sparse categorical CE loss obj that supports sample_weight arg on `call()`.
# `from_logits` argument ensures transformation into normalized probabilities.
weighted_sparse_ce = kls.SparseCategoricalCrossentropy(
from_logits=True)
# Policy loss is defined by policy gradients, weighted by advantages.
# Note: we only calculate the loss on the actions we've actually taken.
actions = tf.cast(actions, tf.int32)
### NOT SURE, but to ignore the case where advantages equal negative, which causing neg loss
# adv2 = tf.where( advantages > 0 , advantages, 0)
policy_loss = weighted_sparse_ce(actions,
logits,
sample_weight=advantages)
# policy_loss = weighted_sparse_ce(actions, logits, sample_weight=adv2)
# Entropy loss can be calculated as cross-entropy over itself.
probs = tf.nn.softmax(logits)
entropy_loss = kls.categorical_crossentropy(probs, probs)
# We want to minimize policy and maximize entropy losses.
# Here signs are flipped because the optimizer minimizes.
policy_loss2 = tf.where(policy_loss > 0, policy_loss,
tf.math.maximum(policy_loss, -10))
# return policy_loss - self.entropy_c * entropy_loss
return policy_loss2 - self.entropy_c * entropy_loss
def loop_loss(index, sum_loss):
#pred box (box, (xmin, ymin, xmax, ymax))
pred_box = y_pred[index, :, 0:4]
#找出標記ground truth 的anchor
obj_mask = tf.reshape(y_true[index, :, 4:5], (-1, ))
boxes = tf.boolean_mask(y_true[index, :, 0:4], obj_mask)
#使用nms還原ground truth box
box_ind = tf.image.non_max_suppression(
boxes, tf.ones(tf.shape(boxes)[0], tf.float32), 40)
boxes = tf.gather(boxes, box_ind)
#計算所有預測bbox 與 ground truth bbox 的 CIoU
CIoU = box_ciou(y_pred[index, :, 0:4], boxes)
CIoU_loss = tf.reduce_sum(tf.boolean_mask((1 - CIoU), obj_mask))
#classes loss (只計算正樣本)
cls_loss = categorical_crossentropy(y_true[index, :, 5:],
y_pred[index, :, 5:])
cls_loss = tf.reduce_sum(tf.boolean_mask(cls_loss, obj_mask))
#計算其他預測bbox與ground truth bbox IoU，如果大於ignore_thresh則不計算conf loss
ignore_mask = CIoU < 0.7
#利用ignore_mask與obj_mask算出參與計算的conf loss
mask = tf.math.logical_or(ignore_mask, tf.cast(obj_mask, tf.bool))
#confidience loss
conf_loss = binary_crossentropy(y_true[index, :, 4:5], y_pred[index, :,
4:5])
conf_loss = tf.reduce_sum(tf.boolean_mask(conf_loss, mask))
return index + 1, sum_loss + CIoU_loss + cls_loss + conf_loss
def custom_loss(y_true, y_pred):
"""
The final loss function consists of the summation of two losses "GDL" and "CE"
with a regularization term.
"""
return generalized_dice_loss(
y_true, y_pred) + 1.25 * categorical_crossentropy(y_true, y_pred)
def class_loss_cls(y_true, y_pred):
"""
计算具体的分类loss
:param y_true: 真实值 [batch_size, num_rois, 4+1]
:param y_pred: 预测值 [batch_size, num_rois, 4+1]
:return: classifier class_loss
"""
return backend.mean(losses.categorical_crossentropy(y_true, y_pred))
def loss(target, pred):
target_label = target[..., :1]
pred_label = pred[..., :1]
ceLoss = categorical_crossentropy(target_label, pred_label)
smoothL1 = smooth_l1_loss(target, pred)
return tf.reduce_mean(ceLoss) + smoothL1
def loss(y_true, y_pred):
policy_loss = 0.
for i in range(config.mu.unroll_steps):
policy_loss += losses.categorical_crossentropy(
y_true[:, i], y_pred[:, i]) / config.mu.unroll_steps
return policy_loss
def optimize_actor_func(policy, action):
# print(action_reward_value.shape)
# action, rewards, value = action_reward_value[:,:3], action_reward_value[:,3], action_reward_value[:,4]
# policy, value = policy_value[0], policy_value[1]
# policy = policy
# action = action_rewards
return categorical_crossentropy(policy, action)
def entropy2(self, logits):
'''
Entropy calc with keras over logits ??
'''
entropy = kls.categorical_crossentropy(logits,
logits,
from_logits=True)
return entropy
def custom_loss(y_true, y_pred, lambda_r=10):
"""
custom loss function that is a combination of mean squared error and categorical cross entropy loss
"""
reg_loss = lambda_r * mean_squared_error(y_true[:, :1], y_pred[:, :1])
clf_loss = categorical_crossentropy(y_true[:, 1:], y_pred[:, 1:])
return reg_loss + clf_loss
def custom_loss(y_true, y_pred): # target is a 8 - tuple # (row, col, depth, width, class1, class2, class3, object_appeared) bce = binary_crossentropy(y_true[:, :4], y_pred[:, :4]) # location cce = categorical_crossentropy(y_true[:, 4:7], y_pred[:, 4:7]) #object class bce2 = binary_crossentropy(y_true[:, -1], y_pred[:, -1]) #object appeared return bce * y_true[:, -1] + cce * y_true[:, -1] + 0.5 * bce2
def _logits_loss(self, target, logits):
TDerrors, actions = tf.split(target, 2, axis=-1)
logprob = self.logit2logprob(
actions, logits, sample_weight=TDerrors
) #really the log probability is negative of this.
probs = tf.nn.softmax(logits)
entropy_loss = kls.categorical_crossentropy(probs, probs)
return logprob - self.entropy_const * entropy_loss
def weighted_cat_cross_entropy(y_true, y_pred, class_weights):
class_weights = tf.reduce_sum(y_true, axis=-1, keepdims=True) / tf.reduce_sum(y_true)
weights = tf.reduce_sum(class_weights * tf.cast(y_true, tf.float32), axis=-1)
unweighted_losses = categorical_crossentropy(tf.cast(y_true, tf.float32), tf.cast(y_pred, tf.float32))
weighted_losses = tf.cast(unweighted_losses, tf.float32) * tf.cast(weights, tf.float32)
loss = tf.reduce_mean(weighted_losses)
return loss
def _logits_loss(self, act_adv, logits):
ce = kls.CategoricalCrossentropy(from_logits=True)
actions, advantages = tf.split(act_adv, 2, axis=-1)
actions = tf.cast(actions, tf.int32)
policy_loss = ce(actions, logits, sample_weight=advantages)
entropy_loss = kls.categorical_crossentropy(logits,
logits,
from_logits=True)
return policy_loss - entropy_loss * self.params['entropy']
def call(self, y_true, y_pred):
# print(y_true.shape, y_pred.shape) # (None, 256) (None, 256)
y_true = tf.split(y_true, 64, axis=-1) # a list of 64 * vectors
y_pred = tf.split(y_pred, 64, axis=-1)
myloss = 0
for (true, pred) in zip(y_true, y_pred):
myloss += losses.categorical_crossentropy(true, pred)
return myloss