def dice_coef(y_true, y_pred, epsilon=1e-5):
dice_numerator = 2.0 * K.sum(y_true * y_pred, axis=[1, 2, 3, 4])
dice_denominator = K.sum(K.square(y_true), axis=[1, 2, 3, 4]) + K.sum(
K.square(y_pred), axis=[1, 2, 3, 4])
dice_score = dice_numerator / (dice_denominator + epsilon)
return K.mean(dice_score, axis=0)
def dice_coef(y_true, y_pred, smooth=1):
"""
https://radiopaedia.org/articles/dice-similarity-coefficient
"""
intersection = K.sum(y_true * y_pred, axis=[1, 2, 3])
sum_of_cardinals = K.sum(y_true, axis=[1, 2, 3]) + K.sum(y_pred,
axis=[1, 2, 3])
return K.mean((2.0 * intersection + smooth) / (sum_of_cardinals + smooth),
axis=0)
def dice_coef(y_true, y_pred, smooth=1):
intersection = K.sum(y_true * y_pred, axis=[1, 2, 3])
union = K.sum(y_true, axis=[1, 2, 3]) + K.sum(y_pred, axis=[1, 2, 3])
return K.mean((2.0 * intersection + smooth) / (union + smooth), axis=0)
def __init__(self,
n_word_vocab=50001,
n_role_vocab=7,
n_factors_emb=256,
n_factors_cls=512,
n_hidden=256,
word_vocabulary={},
role_vocabulary={},
unk_word_id=50000,
unk_role_id=7,
missing_word_id=50001,
using_dropout=False,
dropout_rate=0.3,
optimizer='adagrad',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']):
super(NNRF_ResROFA,
self).__init__(n_word_vocab, n_role_vocab, n_factors_emb,
n_hidden, word_vocabulary, role_vocabulary,
unk_word_id, unk_role_id, missing_word_id,
using_dropout, dropout_rate, optimizer, loss,
metrics)
# minus 1 here because one of the role is target role
self.input_length = n_role_vocab - 1
# each input is a fixed window of frame set, each word correspond to one role
input_words = Input(
shape=(self.input_length, ), dtype=tf.uint32,
name='input_words') # Switched dtype to tf specific (team1-change)
input_roles = Input(
shape=(self.input_length, ), dtype=tf.uint32,
name='input_roles') # Switched dtype to tf specific (team1-change)
target_role = Input(
shape=(1, ), dtype=tf.uint32,
name='target_role') # Switched dtype to tf specific (team1-change)
# role based embedding layer
embedding_layer = role_based_word_embedding(
input_words, input_roles, n_word_vocab, n_role_vocab,
glorot_uniform(), missing_word_id, self.input_length,
n_factors_emb, True, using_dropout, dropout_rate)
# fully connected layer, output shape is (batch_size, input_length, n_hidden)
lin_proj = Dense(n_factors_emb,
activation='linear',
use_bias=False,
input_shape=(n_factors_emb, ),
name='lin_proj')(embedding_layer)
non_lin = PReLU(alpha_initializer='ones', name='non_lin')(lin_proj)
# fully connected layer, output shape is (batch_size, input_length, n_hidden)
lin_proj2 = Dense(n_factors_emb,
activation='linear',
use_bias=False,
input_shape=(n_factors_emb, ),
name='lin_proj2')(non_lin)
residual_0 = Add(name='residual_0')([embedding_layer, lin_proj2])
# mean on input_length direction;
# obtaining context embedding layer, shape is (batch_size, n_hidden)
context_embedding = Lambda(lambda x: K.mean(x, axis=1),
name='context_embedding',
output_shape=(n_factors_emb, ))(residual_0)
# hidden layer
hidden_layer2 = target_word_hidden(context_embedding,
target_role,
n_word_vocab,
n_role_vocab,
glorot_uniform(),
n_factors_cls,
n_hidden,
using_dropout=using_dropout,
dropout_rate=dropout_rate)
# softmax output layer
output_layer = Dense(n_word_vocab,
activation='softmax',
input_shape=(n_factors_cls, ),
name='softmax_word_output')(hidden_layer2)
self.model = Model(inputs=[input_words, input_roles, target_role],
outputs=[output_layer])
self.model.compile(optimizer, loss, metrics)
def mean_absolute_error(y_true, y_pred):
return K.mean(K.abs(y_pred - y_true), axis=-1)
def mean_squared_error(y_true, y_pred):
return K.mean(K.square(y_pred - y_true), axis=-1)
def gradcam(model,
layer,
img,
class_idx,
preprocess_func=None,
preprocess_img=min_max_scale,
show=False):
x = np.expand_dims(image.img_to_array(img), axis=0)
img = np.copy(img)
class_idx = np.argmax(class_idx, axis=0) if type(
class_idx) == list or type(class_idx) == np.ndarray else class_idx
if preprocess_func is not None:
x = preprocess_func(x)
if preprocess_img is not None:
img = preprocess_img(img)
preds = model.predict(x)
preds = np.argmax(preds, axis=1)[0]
class_output = model.output[:, class_idx]
last_conv_layer = model.get_layer(layer)
layer_out_channels = last_conv_layer.output_shape[-1]
grads = K.gradients(class_output, last_conv_layer.output)[0]
pooled_grads = K.mean(grads, axis=(0, 1, 2))
iterate = K.function([model.input],
[pooled_grads, last_conv_layer.output[0]])
pooled_grads_value, conv_layer_output_value = iterate([x])
for i in range(layer_out_channels):
conv_layer_output_value[:, :, i] *= pooled_grads_value[i]
heatmap = np.mean(conv_layer_output_value, axis=-1)
heatmap = np.maximum(heatmap, 0)
heatmap /= np.max(heatmap)
heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
heatmap = np.uint8(255 * heatmap)
heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
heatmap = heatmap / 255
for i in range(len(heatmap)):
for j in range(len(heatmap[0])):
if heatmap[i][j][1] <= 0.01 and heatmap[i][j][2] <= 0.01:
heatmap[i][j] = 0
superimposed_img = 0.6 * img + 0.4 * heatmap
for i in range(len(heatmap)):
for j in range(len(heatmap[0])):
if np.sum(heatmap[i][j]) == 0:
superimposed_img[i][j] = img[i][j]
superimposed_img = np.clip(
superimposed_img,
0,
1,
)
if show:
plt.imshow(img)
plt.axis("off")
plt.show()
plt.imshow(heatmap)
plt.axis("off")
plt.show()
plt.imshow(superimposed_img)
plt.axis("off")
plt.show()
return img, heatmap, superimposed_img, preds
def __init__(self,
n_word_vocab=50001,
n_role_vocab=7,
n_factors_emb=300,
n_hidden=300,
word_vocabulary=None,
role_vocabulary=None,
unk_word_id=50000,
unk_role_id=7,
missing_word_id=50001,
using_dropout=False,
dropout_rate=0.3,
optimizer='adagrad',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'],
loss_weights=[1., 1.]):
super(MTRFv4, self).__init__(n_word_vocab, n_role_vocab, n_factors_emb,
n_hidden, word_vocabulary,
role_vocabulary, unk_word_id, unk_role_id,
missing_word_id, using_dropout,
dropout_rate, optimizer, loss, metrics)
# minus 1 here because one of the role is target role
input_length = n_role_vocab - 1
n_factors_cls = n_hidden
# each input is a fixed window of frame set, each word correspond to one role
input_words = Input(
shape=(input_length, ), dtype=tf.uint32,
name='input_words') # Switched dtype to tf specific (team1-change)
input_roles = Input(
shape=(input_length, ), dtype=tf.uint32,
name='input_roles') # Switched dtype to tf specific (team1-change)
target_word = Input(
shape=(1, ), dtype=tf.uint32,
name='target_word') # Switched dtype to tf specific (team1-change)
target_role = Input(
shape=(1, ), dtype=tf.uint32,
name='target_role') # Switched dtype to tf specific (team1-change)
# role based embedding layer
embedding_layer = factored_embedding(input_words, input_roles,
n_word_vocab, n_role_vocab,
glorot_uniform(), missing_word_id,
input_length, n_factors_emb,
n_hidden, True, using_dropout,
dropout_rate)
# non-linear layer, using 1 to initialize
non_linearity = PReLU(alpha_initializer='ones')(embedding_layer)
# mean on input_length direction;
# obtaining context embedding layer, shape is (batch_size, n_hidden)
context_embedding = Lambda(lambda x: K.mean(x, axis=1),
name='context_embedding',
output_shape=(n_hidden, ))(non_linearity)
# target word hidden layer
tw_hidden = target_word_hidden(context_embedding,
target_role,
n_word_vocab,
n_role_vocab,
glorot_uniform(),
n_hidden,
n_hidden,
using_dropout=using_dropout,
dropout_rate=dropout_rate)
# target role hidden layer
tr_hidden = target_role_hidden(context_embedding,
target_word,
n_word_vocab,
n_role_vocab,
glorot_uniform(),
n_hidden,
n_hidden,
using_dropout=using_dropout,
dropout_rate=dropout_rate)
# softmax output layer
target_word_output = Dense(n_word_vocab,
activation='softmax',
input_shape=(n_hidden, ),
name='softmax_word_output')(tw_hidden)
# softmax output layer
target_role_output = Dense(n_role_vocab,
activation='softmax',
input_shape=(n_hidden, ),
name='softmax_role_output')(tr_hidden)
self.model = Model(
inputs=[input_words, input_roles, target_word, target_role],
outputs=[target_word_output, target_role_output])
self.model.compile(optimizer, loss, metrics, loss_weights)