def rec_L(y_true, y_pred): s_flow = K.variable(np.array([1,0])) p = K.cast(K.equal(K.argmax(s_flow, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) n = K.cast(K.not_equal(K.argmax(s_flow, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) t = K.cast(K.equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) f = K.cast(K.not_equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) tn = t*n fp = f*p return K.sum(tn) / (K.sum(tn) + K.sum(fp))
def rec_S(y_true, y_pred): s_flow = K.variable(np.array([1,0])) p = K.cast(K.equal(K.argmax(s_flow, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) n = K.cast(K.not_equal(K.argmax(s_flow, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) t = K.cast(K.equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) f = K.cast(K.not_equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) tp = t*p fn = f*n return K.sum(tp) / (K.sum(tp) + K.sum(fn))
def _get_triplet_mask(self, y_true: Tensor, pairwise_dist: Tensor) -> Tensor:
# mask label(a) != label(p)
mask1 = K.expand_dims(K.equal(K.expand_dims(y_true, 0), K.expand_dims(y_true, 1)), 2)
mask1 = K.cast(mask1, K.dtype(pairwise_dist))
# mask a == p
mask2 = K.expand_dims(K.not_equal(pairwise_dist, 0.0), 2)
mask2 = K.cast(mask2, K.dtype(pairwise_dist))
# mask label(n) == label(a)
mask3 = K.expand_dims(K.not_equal(K.expand_dims(y_true, 0), K.expand_dims(y_true, 1)), 1)
mask3 = K.cast(mask3, K.dtype(pairwise_dist))
return mask1 * mask2 * mask3
def custom_loss(y_true, y_pred): mask = K.cast(K.not_equal(y_true, 0), dtype='float32') diff = y_pred - y_true sqdiff = diff * diff * mask sse = K.sum(K.sum(sqdiff)) n = K.sum(K.sum(mask)) return sse / n
def mask_aware_max(x):
mask = K.not_equal(K.sum(K.abs(x), axis=2, keepdims=True), 0)
mask = K.cast(mask, 'float32')
vecmin = K.min(x, axis=1, keepdims=True)
xstar = x + (vecmin * (1 - mask)) # setting masked values to the min value
return K.max(xstar, axis=1, keepdims=False)
def nonzero_rmse(y_true, y_pred):
"""RMSE that ignores zero values, assuming that there is at least
one nonzero value per row
"""
mask = K.cast(K.not_equal(y_true, 0), K.floatx())
count = K.sum(mask, 1)
se = K.sum(K.square(y_true - y_pred) * mask, 1)
rmse = K.sqrt(se / count)
return K.mean(rmse)
def nonzero_batch_mse(y_true, y_pred):
"""MSE that ignores zero values and averages over a batch, assuming
that there is at least one nonzero value per batch.
"""
mask = K.cast(K.not_equal(y_true, 0), K.floatx())
count = K.sum(mask)
se = K.sum(K.square(y_true - y_pred) * mask)
mse = se / count
return mse
def sparse_recon_loss_abs(y_true, y_pred):
#this gets the numerator correct on the final denominator of the loss function
#does this make a difference?
mask_value = 0
mask = K.cast(K.not_equal(y_true, mask_value), K.floatx())
ones = K.ones(shape=K.shape(y_true))
n = K.sum(mask * ones, axis=-1)
return 1 / n * K.sum(K.abs(y_true * mask - y_pred * mask), axis=-1)
def ignore_accuracy(y_true, y_pred):
y_true_class = K.argmax(y_true, axis=-1)
y_pred_class = K.argmax(y_pred, axis=-1)
ignore_mask = K.cast(K.not_equal(y_pred_class, to_ignore), 'int32')
matches = K.cast(K.equal(y_true_class, y_pred_class),
'int32') * ignore_mask
accuracy = K.sum(matches) / K.maximum(K.sum(ignore_mask), 1)
return accuracy
def __call__(self, Y, Yh):
'''Weighted Mean Square Error (MSE)
'''
if not K.is_tensor(Yh): Yh = K.constant(Yh)
Y = K.cast(Y, Yh.dtype)
mask = K.not_equal(Y, self.Mask) # OK! could use NaN <-> 0
# return K.mean(K.square(Yh[mask]-Y[mask])) # BUT: No boolean indexing in Keras!
mask = K.cast(mask, K.dtype(Y)) # OK!
return K.sum(K.square(K.abs(Yh - Y) * mask)) / K.sum(mask) # OK!
def compute_mask(self, inputs, mask):
channel_axis = K.ndim(inputs) - 1
mask_tensor = K.cast(mask, K.floatx())
mask_tensor = K.expand_dims(mask_tensor)
mask_output = self._compute_mask_output(mask_tensor)
mask_output = K.sum(mask_output, axis=channel_axis)
next_mask_tensor = K.not_equal(mask_output, 0.0)
return next_mask_tensor
def positive_hyperbolic_hammingoid(x, y):
mask = K.cast(K.not_equal(K.greater(x, 0), K.greater(y, 0)), "float32")
# Masked elementwise maximum
err = K.maximum(mask * x, mask * y)
# Make it smooth and asymptotically approach 1
err = err / (err + 1)
# Sum across rows, normalize by length
length = int(x.get_shape()[1])
return K.sum(err, axis=-1) / length
def loss(y_true, y_pred):
mask = K.cast_to_floatx(K.not_equal(y_true, mask_value))
y_true_one_hot = K.one_hot(y_true, num_classes)
loss = categorical_crossentropy(y_true_one_hot, y_pred, from_logits=from_logits, label_smoothing=label_smoothing)
masked_loss = loss * mask
reduced_loss = K.sum(masked_loss) / K.sum(mask)
return reduced_loss
def positions_func(inputs, pad=0):
"""
A layer filling i-th column of a 2D tensor with
1+ln(1+i) when it contains a meaningful symbol
and with 0 when it contains PAD
"""
position_inputs = kb.cumsum(kb.ones_like(inputs, dtype="float32"), axis=1)
position_inputs *= kb.cast(kb.not_equal(inputs, pad), "float32")
return kb.log(1.0 + position_inputs)
def sparse_categorical_accuracy(y_true, y_pred):
y_true = K.max(y_true, axis=-1)
y_pred = K.cast(K.argmax(y_pred, axis=-1), K.floatx())
mask = K.not_equal(y_true, mask_id)
masked_true = tf.boolean_mask(y_true, mask)
masked_pred = tf.boolean_mask(y_pred, mask)
accuracy = K.mean(K.cast(K.equal(masked_true, masked_pred),
K.floatx()))
return accuracy
def _get_anchor_positive_triplet_mask(self, y_true: Tensor,
pairwise_dist: Tensor) -> Tensor:
# mask label(a) != label(p)
mask1 = K.equal(K.expand_dims(y_true, 0), K.expand_dims(y_true, 1))
mask1 = K.cast(mask1, K.dtype(pairwise_dist))
# mask a == p
mask2 = K.not_equal(pairwise_dist, 0.0)
mask2 = K.cast(mask2, K.dtype(pairwise_dist))
return mask1 * mask2
def objective(y_true_cat, y_pred_cat):
y_true = K.argmax(y_true_cat, axis=1)
y_pred = K.argmax(y_pred_cat, axis=1)
correct = K.max(y_true_cat * y_pred_cat, axis=1)
is_unrelated = K.not_equal(y_true, unrelated)
is_related = (K.any([K.equal(y_true, r) for r in related_labels])
and K.any([K.equal(y_pred, r) for r in related_labels]))
score = correct * (0.25 + is_unrelated * 0.5) + is_related * 0.25
return 1.0 / (score + K.epsilon())
def mean_squared_error_label(y_true, y_pred, nonzero_count):
index = K.not_equal(y_true, -1)
index = K.cast(index, y_true.dtype)
y_true_ = tf.multiply(y_true, index)
y_pred_ = tf.multiply(y_pred, index)
loss = tf.reduce_sum(K.square(y_pred_ - y_true_))
nonzero_count = K.cast(nonzero_count, loss.dtype)
loss = tf.divide(loss, nonzero_count)
return loss
def masked_landmark(y_true_full, y_pred):
y_true = y_true_full[:, 6:]
mask = K.cast(K.not_equal(y_true[:, 0], -1), K.floatx())
y_true = tf.boolean_mask(y_true, mask)
y_pred = tf.boolean_mask(y_pred, mask)
loss = K.mean(K.mean(K.square(y_pred - y_true), axis=-1))
s = K.sum(mask)
return K.switch(K.equal(s, 0), .0, loss)
def spancom_r(y_true, y_pred):
y_true = K.argmax(y_true, axis=-1)
y_pred = K.argmax(y_pred, axis=-1)
mask = K.cast(K.not_equal(y_pred, 0), 'int64')
matches = K.cast(K.equal(y_true, y_pred), 'int64') * mask
accuracy = K.sum(matches) / K.maximum(K.sum(mask), 1)
return accuracy
def compute_mask(self, inputs, mask=None):
if self.mode == self.MODE_EXPAND:
if self.mask_zero:
output_mask = K.not_equal(inputs, self.mask_zero)
else:
output_mask = None
else:
output_mask = mask
return output_mask
def metrics_K(y_true, y_pred):
"""Calculates quality metrics from true and predicted Tensorflow values.
Uses just the keras.backend (K) functions to handle Tensors without eager
execution.
Definitions from paper 'A Machine Learning Framework to Identify Detailed
Routing Short Violations from a Placed Netlist' by Tabrizi et al. 2018
Args:
y_true (Tensor): Array of 'true' 0s and 1s
y_pred (Tensor): Array of predicted 0s and 1s
Returns:
TN (Tensor): Number of true negative samples
FP (Tensor): Number of false positive samples
FN (Tensor): Number of false negative samples
TP (Tensor): Number of true positive samples
TPR (Tensor): True Positive Rate ([0:1])
SPC (Tensor): Specificity ([0:1])
FPR (Tensor): False Positive Rate ([0:1])
ACC (Tensor): Accuracy ([0:1])
MCC (Tensor): Matthews Correlation Coefficient, ([-1:+1]), +1 is best
"""
# Get predicted value by rounding the probability value to the nearest int.
y_pred = K.round(y_pred)
# assert(K.int_shape(y_true) == K.int_shape(y_pred))
# Total number of elements in y_true or y_pred
num_total = K.prod(K.shape(y_true))
# Cast from int32 to floatx_wanted to ensure compatibility with other values
num_total = K.cast(num_total, floatx_wanted)
# Dot product gives sum of instances where y_true and y_pred are both 1.
TP = K.dot(y_true, K.transpose(y_pred))
FN = K.sum(y_true) - TP
falses = K.not_equal(y_true, y_pred)
# Convert from bools to 0. and 1.
falses = K.cast(falses, floatx_wanted)
FP = K.dot(y_pred, K.transpose(falses))
TN = num_total - FP
# Use K.epsilon to avoid division by zero.
eps = K.epsilon()
# Sensitivity or True Positive Rate (TPR)
TPR = TP/(TP + FN + eps)
# Specificity (SPC)
SPC = TN/(TN + FP + eps)
# False Alarm (FPR)
FPR = FP/(TN + FP + eps)
# Accuracy (ACC)
ACC = (TP + TN)/(TP + TN + FP + FN + eps)
# Matthews Correlation Coefficient (MCC); Values from -1 to +1, +1 is best.
MCC = (TP*TN - FP*FN)/K.sqrt((TP + FP + eps) * (TP + FN + eps) *
(TN + FP + eps) * (TN + FN + eps))
return TP, TN, FP, FN, TPR, SPC, FPR, ACC, MCC
def call(self, inputs, mask=None):
atoms, bonds, edges = inputs
# Import dimensions
num_samples = atoms._keras_shape[0]
max_atoms = atoms._keras_shape[1]
num_atom_features = atoms._keras_shape[-1]
num_bond_features = bonds._keras_shape[-1]
# Create a matrix that stores for each atom, the degree it is
atom_degrees = K.sum(tf.keras.backend.cast(K.not_equal(edges, -1),
dtype='float32'),
axis=-1,
keepdims=True)
# For each atom, look up the features of it's neighbour
neighbour_atom_features = neighbour_lookup(atoms,
edges,
include_self=True)
# Sum along degree axis to get summed neighbour features
summed_atom_features = K.sum(neighbour_atom_features, axis=-2)
# Sum the edge features for each atom
summed_bond_features = K.sum(bonds, axis=-2)
# Concatenate the summed atom and bond features
summed_features = K.concatenate(
[summed_atom_features, summed_bond_features], axis=-1)
# For each degree we convolve with a different weight matrix
new_features_by_degree = []
for degree in range(self.max_degree):
# Create mask for this degree
atom_masks_this_degree = K.cast(K.equal(atom_degrees, degree),
K.floatx())
# Multiply with hidden merge layer
# (use time Distributed because we are dealing with 2D input/3D for batches)
# Add keras shape to let keras now the dimensions
summed_features._keras_shape = (None, max_atoms,
num_atom_features +
num_bond_features)
new_unmasked_features = self.inner_3D_layers[degree](
summed_features)
# Do explicit masking because TimeDistributed does not support masking
new_masked_features = new_unmasked_features * atom_masks_this_degree
new_features_by_degree.append(new_masked_features)
# Finally sum the features of all atoms
new_features = keras.layers.add(new_features_by_degree)
return new_features
def sparse_recon_loss_mse(y_true, y_pred):
#this gets the numerator correct on the final denominator of the loss function
mask_value = 0
mask = K.cast(K.not_equal(y_true, mask_value), K.floatx())
n = K.int_shape(y_true)[-1]
ones = K.ones(shape=K.shape(y_true))
denom = K.sum(mask * ones, axis=-1)
return K.sum(K.square(y_true * mask - y_pred * mask), axis=-1) / denom
def update_state(self, y_true, y_pred, sample_weight=None):
y_true = K.argmax(y_true, axis=-1)
y_pred = K.argmax(y_pred, axis=-1)
y_true = K.flatten(y_true)
true_neg = K.sum(
K.cast((K.not_equal(y_true, y_pred)), dtype=tf.float32))
self.cat_true_negatives.assign_add(true_neg)
def compute_mask(self, inputs, input_mask=None):
"""
Compute the mask for the hidden state tensor. For each node, [True] indicates un-masked, and [False] indicates
masked. The returned value has only one element in the last dimension, since feature dimension is reduced to a
boolean
:param inputs:
:param input_mask:
:return: A boolean tensor of shape (num_samples, num_nodes, 1)
"""
return K.any(K.not_equal(inputs[0], 0.0), axis=-1)
def masked_multi_weighted_bce(alpha, y_pred):
y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
y_true_ = K.cast(K.greater(alpha, 0.), K.floatx())
mask = K.cast(K.not_equal(alpha, 0.), K.floatx())
num_not_missing = K.sum(mask, axis=-1)
alpha = K.abs(alpha)
bce = -alpha * y_true_ * K.log(y_pred) - (1.0 - alpha) * (
1.0 - y_true_) * K.log(1.0 - y_pred)
masked_bce = bce * mask
return K.sum(masked_bce, axis=-1) / num_not_missing
def cropOutputs(x):
# x[0] is decoded at the end
# x[1] is inputs
# both have the same shape
# padding = 1 for actual data in inputs, 0 for 0
padding = K.cast(K.not_equal(x[1], 0), dtype=K.floatx())
# if you have zeros for non-padded data, they will lose their backpropagation
return x[0] * padding
def _useful_symbols_mask_func(X, dtype):
"""
возвращает маску, содержащую нули на месте нулей, идущих до содержательных символов,
а также на месте PAD в конце
"""
# X = kb.cast(kb.not_equal(X, 0), dtype="int32")
# X_max = kb.max(X, axis=1)[:,None]
# X, X_max = kb.cast(X, "int32"), kb.cast(X_max, "int32")
# return kb.cast(kb.greater_equal(kb.cumsum(X, axis=1), X_max), dtype=dtype)
return kb.cast(kb.not_equal(X, PAD), dtype=dtype)
def call(self, text_input, mask=None):
""" text_input should be a [None, max_words, max_chars] tensor.
"""
bool_mask = K.not_equal(text_input[:, :, 0], 0.0) # [None, max_words]
float_mask = K.cast(bool_mask, K.floatx()) # [None, max_words]
repeat_mask = K.repeat(
float_mask, self.target_hidden) # [None, target_hidden, max_words]
permute_mask = K.permute_dimensions(
repeat_mask, [0, 2, 1]) # [None, max_words, target_hidden]
return permute_mask
def lcompose(self, x): """ Compose a label representation given the word vectors in the given word sequence (description). """ if self.args['maskedavg']: mask = K.not_equal(K.sum(K.abs(x), axis=3, keepdims=False), 0) n = K.sum(K.cast(mask, 'float32'), axis=2, keepdims=True) x_mean = K.sum(x, axis=2, keepdims=False) / n else: x_mean = K.mean(x, axis=2) return x_mean
def get_loss(args):
y_pred, y_true = args
y_true = K.cast(y_true, 'int32')
loss = K.sparse_categorical_crossentropy(y_true,
y_pred,
from_logits=True)
mask = K.cast(K.not_equal(y_true, 0), K.floatx())
loss = K.sum(loss * mask, -1) / K.sum(mask, -1)
loss = K.mean(loss)
return loss
def update_neurons(self):
"""Update neurons according to activation function."""
# Update membrane potentials.
new_mem = self.get_new_mem()
# Generate spikes.
output_spikes = self.linear_activation(new_mem)
# Reset membrane potential after spikes.
self.set_reset_mem(new_mem, output_spikes)
# Store refractory period after spikes.
new_refrac = k.tf.where(k.not_equal(output_spikes, 0),
k.ones_like(output_spikes) *
(self.time + self.tau_refrac),
self.refrac_until)
c = new_refrac[:self.batch_size]
cc = k.concatenate([c, c], 0)
updates = [k.tf.assign(self.refrac_until, cc)]
if self.spiketrain is not None:
c = self.time * k.cast(k.not_equal(output_spikes, 0),
k.floatx())[:self.batch_size]
cc = k.concatenate([c, c], 0)
updates += [k.tf.assign(self.spiketrain, cc)]
with k.tf.control_dependencies(updates):
masked_impulse = k.tf.where(k.greater(self.refrac_until, self.time),
k.zeros_like(self.impulse),
self.impulse)
c = k.greater(masked_impulse, 0)[:self.batch_size]
cc = k.cast(k.concatenate([c, c], 0), k.floatx())
updates = [k.tf.assign(self.prospective_spikes, cc)]
new_thresh = self._v_thresh * k.ones_like(self.v_thresh) + \
self.missing_impulse
updates += [k.tf.assign(self.v_thresh, new_thresh)]
with k.tf.control_dependencies(updates):
# Compute post-synaptic potential.
psp = self.get_psp(output_spikes)
return k.cast(psp, k.floatx())
def get_time_step_length_without_padding(x, time_step_dim=-2, padding=0):
'''Gets time steps without padding (right) of a input tensor.
# Parameters
----------
x : a tensor whose dimensions >=3
time_step_dim: the time step dimension of x
padding : a scalar tensor that represents the padding
# Returns
------
a tensor represents the length of the input tensor after removing all right padding zeros
'''
ndim = K.ndim(x)
time_step_dim = time_step_dim % ndim
x = K.cast(K.not_equal(x, padding), 'int32') # binary tensor
axis = [i for i in range(ndim) if i != time_step_dim]
s = K.sum(x, axis)
s = K.cast(K.not_equal(s, 0), 'int32')
return K.sum(s)
def weighted_mean_squared_error(self, y_true, y_pred):
mask = K.cast(K.not_equal(y_true, 0), 'float32')
n = 1/K.sum(mask, 1)
n = K.tile(n, (K.shape(n)[1], self.n_sessions))
n = K.batch_flatten(mask) * n
sq_errs = K.batch_flatten(K.square(y_pred - y_true))
w_sq_errs = sq_errs * n
sum_w_sq_errs = K.sum(w_sq_errs)
return sum_w_sq_errs / K.sum(n)
def mask_aware_mean(x):
# recreate the masks - all zero rows have been masked
mask = K.not_equal(K.sum(K.abs(x), axis=2, keepdims=True), 0)
# number of that rows are not all zeros
n = K.sum(K.cast(mask, 'float32'), axis=1, keepdims=False)
# compute mask-aware mean of x
x_mean = K.sum(x, axis=1, keepdims=False) / n
return x_mean
def lookup(self, x, W, memory_length):
# shape: (batch*memory_length, input_length)
x = K.cast(K.reshape(x, (-1, self.input_length)), 'int32')
mask = K.expand_dims(K.not_equal(x, 0.), dim=-1)
# shape: (batch*memory_length, input_length, output_dim)
X = K.gather(W, x)
if self.bow_mode == "bow":
# shape: (batch*memory_length, output_dim)
X = K.sum(X + K.expand_dims(self.Te, 0), axis=1)
# shape: (batch, memory_length, output_dim)
X = K.reshape(X, (-1, memory_length, self.output_dim))
return X, mask
def _drop_path(self, inputs):
count = len(inputs)
drops = K.switch(
self.is_global,
self._gen_global_path(count),
self._gen_local_drops(count, self.p)
)
ave = K.zeros(shape=self.average_shape)
for i in range(0, count):
ave += inputs[i] * drops[i]
sum = K.sum(drops)
# Check that the sum is not 0 (global droppath can make it
# 0) to avoid divByZero
ave = K.switch(
K.not_equal(sum, 0.),
ave/sum,
ave)
return ave
def get_output(self, train=False):
X = self.get_input(train)
retain_p = 1. - self.dropout
if train and self.dropout > 0:
B = K.random_binomial((self.input_dim,), p=retain_p)
else:
B = K.ones((self.input_dim)) * retain_p
# we zero-out rows of W at random
Xs = K.cast(K.reshape(X, (-1, self.nb_words)), 'int32')
# (samples*input_length, nb_words, dim)
out = K.gather(self.W * K.expand_dims(B), Xs)
out = K.reshape(out, (-1, self.input_length, self.nb_words,
self.output_dim))
# (samples, input_length, nb_words, dim)
out = out * K.expand_dims(K.not_equal(X, 0), dim=-1)
if self.bow_mode == "bow":
out = K.sum(out, axis=2)
return out
def lstmCh_word_pro(self):
''' input '''
arg1_ch_input = Input(shape=(self.arg_maxlen * self.word_maxlen,), dtype='int32', name='arg1_ch')
arg2_ch_input = Input(shape=(self.arg_maxlen * self.word_maxlen,), dtype='int32', name='arg2_ch')
arg1_word_input = Input(shape=(self.arg_maxlen,), dtype='int32', name='arg1_word')
arg2_word_input = Input(shape=(self.arg_maxlen,), dtype='int32', name='arg2_word')
arg1_mask = K.not_equal(arg1_word_input, 0)
arg2_mask = K.not_equal(arg2_word_input, 0)
''' embedding'''
# chareters
emb_ch = Embedding(input_dim=self.ch_dim, input_length=self.arg_maxlen * self.word_maxlen,
output_dim=self.ch_ndims)
arg1_ch = emb_ch(arg1_ch_input)
arg2_ch = emb_ch(arg2_ch_input)
arg1_ch = Reshape((self.arg_maxlen, self.word_maxlen, self.ch_ndims))(arg1_ch)
arg2_ch = Reshape((self.arg_maxlen, self.word_maxlen, self.ch_ndims))(arg2_ch)
# words
emb_word = Embedding(input_dim=self.word_dim, input_length=self.arg_maxlen, weights=[self.WE],output_dim=self.word_ndims,trainable=False)
arg1_word = emb_word(arg1_word_input)
arg2_word = emb_word(arg2_word_input)
''' convolution ch'''
ch_conv1 = Convolution1D(nb_filter=self.ch_nb_filter,
filter_length=self.ch_filter_length[0],
border_mode='same',
activation=self.activation,
subsample_length=1)
ch_conv2 = Convolution1D(nb_filter=self.ch_nb_filter,
filter_length=self.ch_filter_length[1],
border_mode='same',
activation=self.activation,
subsample_length=1)
ch_conv3 = Convolution1D(nb_filter=self.ch_nb_filter,
filter_length=self.ch_filter_length[2],
border_mode='same',
activation=self.activation,
subsample_length=1)
''' pooling ch '''
mpool = MaxPooling1D(pool_length=self.word_maxlen)
tdcnn1 = TimeDistributed(ch_conv1)
tdcnn2 = TimeDistributed(ch_conv2)
tdcnn3 = TimeDistributed(ch_conv3)
tdpol = TimeDistributed(mpool)
'''arg1 cnn+pooling'''
arg1_tconv1 = tdcnn1(arg1_ch)
arg1_tpool1 = tdpol(arg1_tconv1)
arg1_tpool_res1 = Reshape((self.arg_maxlen, self.ch_nb_filter))(arg1_tpool1)
arg1_tconv2 = tdcnn2(arg1_ch)
arg1_tpool2 = tdpol(arg1_tconv2)
arg1_tpool_res2 = Reshape((self.arg_maxlen, self.ch_nb_filter))(arg1_tpool2)
arg1_tconv3 = tdcnn3(arg1_ch)
arg1_tpool3 = tdpol(arg1_tconv3)
arg1_tpool_res3 = Reshape((self.arg_maxlen, self.ch_nb_filter))(arg1_tpool3)
'''arg2 cnn+pooling'''
arg2_tconv1 = tdcnn1(arg2_ch)
arg2_tpool1 = tdpol(arg2_tconv1)
arg2_tpool_res1 = Reshape((self.arg_maxlen, self.ch_nb_filter))(arg2_tpool1)
arg2_tconv2 = tdcnn2(arg2_ch)
arg2_tpool2 = tdpol(arg2_tconv2)
arg2_tpool_res2 = Reshape((self.arg_maxlen, self.ch_nb_filter))(arg2_tpool2)
arg2_tconv3 = tdcnn3(arg2_ch)
arg2_tpool3 = tdpol(arg2_tconv3)
arg2_tpool_res3 = Reshape((self.arg_maxlen, self.ch_nb_filter))(arg2_tpool3)
'''lstm'''
arg1_ch_cnn_merge = merge([arg1_tpool_res1,arg1_tpool_res2,arg1_tpool_res3], mode='concat', concat_axis=2)
arg2_ch_cnn_merge = merge([arg2_tpool_res1,arg2_tpool_res2,arg2_tpool_res3], mode='concat', concat_axis=2)
# arg1_lstmf = LSTM(self.lstm_size,return_sequences=True)(arg1_ch_cnn_merge, mask=arg1_mask)
# arg1_lstmb = LSTM(self.lstm_size,go_backwards=True,return_sequences=True)(arg1_ch_cnn_merge, mask=arg1_mask)
# arg2_lstmf = LSTM(self.lstm_size,return_sequences=True)(arg2_ch_cnn_merge, mask=arg2_mask)
# arg2_lstmb = LSTM(self.lstm_size,go_backwards=True,return_sequences=True)(arg2_ch_cnn_merge, mask=arg2_mask)
arg1_lstmf = LSTM(self.lstm_size,return_sequences=True)(arg1_ch_cnn_merge)
arg1_lstmb = LSTM(self.lstm_size,go_backwards=True,return_sequences=True)(arg1_ch_cnn_merge)
arg2_lstmf = LSTM(self.lstm_size,return_sequences=True)(arg2_ch_cnn_merge)
arg2_lstmb = LSTM(self.lstm_size,go_backwards=True,return_sequences=True)(arg2_ch_cnn_merge)
arg1_lstm = merge([arg1_lstmf,arg1_lstmb,arg1_word],mode='concat')
arg2_lstm = merge([arg2_lstmf,arg2_lstmb,arg2_word],mode='concat')
arg1_lstm = Dropout(self.dropout)(arg1_lstm)
arg2_lstm = Dropout(self.dropout)(arg2_lstm)
''' ch+word-level cnn + pooling'''
word_cnn1 = Convolution1D(nb_filter=self.word_nb_filter,
filter_length=self.word_filter_length[0],
border_mode='same',
activation=self.activation,
subsample_length=1)
word_cnn2 = Convolution1D(nb_filter=self.word_nb_filter,
filter_length=self.word_filter_length[1],
border_mode='same',
activation=self.activation,
subsample_length=1)
word_cnn3 = Convolution1D(nb_filter=self.word_nb_filter,
filter_length=self.word_filter_length[2],
border_mode='same',
activation=self.activation,
subsample_length=1)
word_mpol = MaxPooling1D(pool_length=self.arg_maxlen)
arg1_word_cnn1 = word_cnn1(arg1_lstm)
arg1_word_cnn2 = word_cnn2(arg1_lstm)
arg1_word_cnn3 = word_cnn3(arg1_lstm)
arg2_word_cnn1 = word_cnn1(arg2_lstm)
arg2_word_cnn2 = word_cnn2(arg2_lstm)
arg2_word_cnn3 = word_cnn3(arg2_lstm)
# merge all cnn arg:
arg1_cnn_merge = merge([arg1_word_cnn1,arg1_word_cnn2,arg1_word_cnn3])
arg2_cnn_merge = merge([arg2_word_cnn1,arg2_word_cnn2,arg2_word_cnn3])
arg1_word_mp = word_mpol(arg1_cnn_merge)
arg2_word_mp = word_mpol(arg2_cnn_merge)
flatten = Flatten()
arg1_word_mp = flatten(arg1_word_mp)
arg2_word_mp = flatten(arg2_word_mp)
merged_vector = merge([arg1_word_mp,arg2_word_mp], mode='concat', concat_axis=-1)
for i in range(0,self.dense_num):
merged_vector = Dense(self.dense_size,activation=self.activation)(merged_vector)
print("add %d times dense..."%(i))
merged_vector = Dropout(self.dropout)(merged_vector)
predictions = Dense(11, activation='softmax', name="output")(merged_vector)
model = Model(input=[arg1_ch_input, arg2_ch_input, arg1_word_input, arg2_word_input],
output=predictions)
# model.summary()
# plot(model, to_file='lstmcnn.png')
ada = Adagrad(lr=self.lr, epsilon=1e-06)
model.compile(optimizer=ada, loss='categorical_crossentropy', metrics=['accuracy'])
return model
def masked_avg_emb(src_seq_repr_seq, src_seq):
mask = K.cast(K.expand_dims(K.not_equal(src_seq, 0), -1), 'float32')
src_seq_repr_seq = src_seq_repr_seq * mask
src_seq_repr_seq = K.mean(src_seq_repr_seq, axis=1, keepdims=True)
return K.reshape(src_seq_repr_seq, [-1, d_model])
def tn(y_true, y_pred): s_flow = K.variable(np.array([1,0])) n = K.cast(K.not_equal(K.argmax(s_flow, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) t = K.cast(K.equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) tr_n = t*n return K.sum(tr_n)
def compute_mask(self, x, mask=None):
if not self.mask_zero:
return None
else:
return K.not_equal(x, 1)
def compute_mask(self, inputs, mask=None):
return K.any(K.not_equal(inputs, 0.), axis=[2, 3, 4])
def fn(y_true, y_pred): s_flow = K.variable(np.array([1,0])) n = K.cast(K.not_equal(K.argmax(s_flow, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) f = K.cast(K.not_equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)), K.floatx()) fl_n = f*n return K.sum(fl_n)
def _get_anchor_negative_triplet_mask(self, y_true: Tensor, pairwise_dist: Tensor) -> Tensor:
# mask label(n) == label(a)
mask = K.not_equal(K.expand_dims(y_true, 0), K.expand_dims(y_true, 1))
mask = K.cast(mask, K.dtype(pairwise_dist))
return mask
def get_output_mask(self, train=None):
X = self.get_input(train)
if not self.mask_zero:
return None
else:
return K.not_equal(X, 0)
