def reweight(y_true,
y_pred,
tp_weight=.3,
tn_weight=.3,
fp_weight=4,
fn_weight=0.7):
# Get predictions
y_pred_classes = K.greater_equal(y_pred, 0.5)
y_pred_classes_float = K.cast(y_pred_classes, K.floatx())
# Get misclassified examples
wrongly_classified = K.not_equal(y_true, y_pred_classes_float)
wrongly_classified_float = K.cast(wrongly_classified, K.floatx())
# Get correctly classified examples
correctly_classified = K.equal(y_true, y_pred_classes_float)
correctly_classified_float = K.cast(correctly_classified, K.floatx())
# Get tp, fp, tn, fn
tp = correctly_classified_float * y_true
tn = correctly_classified_float * (1 - y_true)
fp = wrongly_classified_float * y_true
fn = wrongly_classified_float * (1 - y_true)
# Get weights
weight_tensor = tp_weight * tp + fp_weight * fp + tn_weight * tn + fn_weight * fn
loss = K.binary_crossentropy(y_true, y_pred)
weighted_loss = loss * weight_tensor
return weighted_loss
def contrastive_loss_old(labels, dists):
label_first = labels[0:1, :]
other_labels = labels[1:, :]
labels_shifted = K.concatenate(
[labels, other_labels, label_first],
axis=0) # [ l1 ........ ln | l2 ... ln-1 ln ]
labels_orig = K.concatenate(
[labels, labels], axis=0) # [ l1 ........ ln | l1 ... ln-2 ln ]
zeros = K.zeros_like(labels_orig) # [ 0 ........ 0 | 0 ... 0 0 ]
h = K.cast(K.equal(labels_orig - labels_shifted, zeros),
dtype='float32') # [ 1 1 ...... 1 | 0 ... 1 0 ]
# h: ALL ONES | MOST ZEROS
# h[i] = 1 where labels_orig[i] == labels_shifted[i] (i-th image correlated with i+1-th image, i.e. same artwork)
# h[i] = 0 where labels_orig[i] != labels_shifted[i]
first_dist = dists[0:1]
other_dists = dists[1:]
shifted_dists = K.concatenate(
[dists, other_dists, first_dist],
axis=0) # [ d1 ........ dn | d1 ... dn-2 dn ]
# equation: Lcon = (1/2N) SUM[ h(i) d(i)^2 + (1-h(i)) max(1-d(i), 0)^2
Z = K.zeros_like(shifted_dists)
max_z_sd = K.max(K.stack([1 - shifted_dists, Z]), axis=0, keepdims=False)
#max_z_sd = K.sqrt(K.cast(K.shape(shifted_dists)[0], dtype='float32')) - shifted_dists
first_operand = h * K.square(shifted_dists)
second_operand = (1 - h) * K.square(max_z_sd)
tensor_sum = first_operand + second_operand
sum = K.sum(tensor_sum, axis=0) / K.cast(K.shape(shifted_dists)[0],
dtype='float32')
return K.mean(sum)
def call(self, x, mask=None):
uit = dot_product(x, self.W)
if self.bias:
uit += self.b
uit = K.tanh(uit)
ait = dot_product(uit, self.u)
# ait = K.dot(uit, self.u)
a = K.exp(ait)
# apply mask after the exp. will be re-normalized next
if mask is not None:
# Cast the mask to floatX to avoid float64 upcasting in theano
a *= K.cast(mask, K.floatx())
# in some cases especially in the early stages of training the sum may be almost zero
# and this results in NaN's. A workaround is to add a very small positive number ε to the sum.
# a /= K.cast(K.sum(a, axis=1, keepdims=True), K.floatx())
a /= K.cast(K.sum(a, axis=1, keepdims=True) + K.epsilon(), K.floatx())
a = K.expand_dims(a)
weighted_input = x * a
return K.sum(weighted_input, axis=1)
def __call__(self, y_true, y_pred):
# initial shape is (batch_size, squence_length, n_classes)
conds_list = self.cond(y_true, y_pred) #+ (y_true_wo_index_mask, )
conds_xd = K.cast(K.stack(conds_list, axis=-1), 'bool')
res = K.sum(K.cast(K.all(conds_xd, axis=-1), 'int32'))
updates = [keras.backend.update_add(self.count, res)]
self.add_update(updates)
return self.count
def call(self, x, mask=None):
# size of x :[batch_size, sel_len, attention_dim]
# size of u :[batch_size, attention_dim]
# uit = tanh(xW+b)
uit = K.tile(K.expand_dims(self.W, axis=0), (K.shape(x)[0], 1, 1))
uit = tf.matmul(x, uit)
uit = K.tanh(K.bias_add(uit, self.b))
ait = K.dot(uit, self.u)
ait = K.squeeze(ait, -1)
ait = K.exp(ait)
if mask is not None:
# Cast the mask to floatX to avoid float64 upcasting in theano
ait *= K.cast(mask, K.floatx())
ait /= K.cast(K.sum(ait, axis=1, keepdims=True) + K.epsilon(), K.floatx())
ait = K.expand_dims(ait)
weighted_input = x * ait
output = K.sum(weighted_input, axis=1)
return output
def call(self, x, mask=None):
features_dim = self.features_dim
step_dim = self.step_dim
eij = K.reshape(K.dot(K.reshape(x, (-1, features_dim)),
K.reshape(self.W, (features_dim, 1))), (-1, step_dim))
if self.bias:
eij += self.b
eij = K.tanh(eij)
a = K.exp(eij)
if mask is not None:
a *= K.cast(mask, K.floatx())
a /= K.cast(K.sum(a, axis=1, keepdims=True) + K.epsilon(), K.floatx())
a = K.expand_dims(a)
weighted_input = x * a
return K.sum(weighted_input, axis=1)
def call(self, inputs):
if K.dtype(inputs) != 'int32':
inputs = K.cast(inputs, 'int32')
out = K.gather(self.embeddings, inputs)
mask = K.expand_dims(K.clip(K.cast(inputs, 'float32'), 0, 1), axis=-1)
return out * mask
def seq_accuracy(y_true, y_pred):
return K.cast(K.all(K.equal(y_true, K.round(y_pred)), axis=-2), 'float32')
def accuracy(y_true, y_pred): # Tensor上的操作
'''Compute classification accuracy with a fixed threshold on distances.
'''
return K.mean(K.equal(y_true, K.cast(y_pred < 0.5, y_true.dtype)))
def sequence_length(sequence):
return K.cast(K.sum(sequence_mask(sequence), 1), tf.int32)
