def _normalize_attention(attmat): att = attmat[0] mat = attmat[1] ques_len = attmat[2] if transpose: att = K.permute_dimensions(att, (0, 2, 1)) # 3d softmax e = K.exp(att - K.max(att, axis=-1, keepdims=True)) g = e * ques_len s = K.sum(g, axis=-1, keepdims=True) sm_att = g / s if Flag: if model_param.k_value_ans == -1: threshold = 1.0 / K.sum( ques_len, axis=-1, keepdims=True) else: threshold = model_param.k_value_ans else: if model_param.k_value_ques == -1: threshold = 1.0 / K.sum( ques_len, axis=-1, keepdims=True) else: threshold = model_param.k_value_ques k_threshold_e = K.switch( K.lesser_equal(sm_att, threshold), 0.0, sm_att) new_s = K.clip( K.sum(k_threshold_e, axis=-1, keepdims=True), 0.00001, 1024) new_sm_att = k_threshold_e / new_s return K.batch_dot(new_sm_att, mat)
def class_loss_regr_fixed_num(y_true, y_pred): x = y_true[:, :, 4 * num_classes:] - y_pred x_abs = K.abs(x) x_bool = K.cast(K.lesser_equal(x_abs, 1.0), 'float32') return lambda_cls_regr * K.sum( y_true[:, :, :4 * num_classes] * (x_bool * (0.5 * x * x) + (1 - x_bool) * (x_abs - 0.5))) / K.sum(epsilon + y_true[:, :, :4 * num_classes])
def rpn_loss_regr_fixed_num(y_true, y_pred): if K.image_dim_ordering() == 'th': x = y_true[:, 4 * num_anchors:, :, :] - y_pred x_abs = K.abs(x) x_bool = K.lesser_equal(x_abs, 1.0) return lambda_rpn_regr * K.sum( y_true[:, :4 * num_anchors, :, :] * (x_bool * (0.5 * x * x) + (1 - x_bool) * (x_abs - 0.5))) / K.sum(epsilon + y_true[:, :4 * num_anchors, :, :]) else: x = y_true[:, :, :, 4 * num_anchors:] - y_pred x_abs = K.abs(x) x_bool = K.cast(K.lesser_equal(x_abs, 1.0), 'float32') return lambda_rpn_regr * K.sum( y_true[:, :, :, :4 * num_anchors] * (x_bool * (0.5 * x * x) + (1 - x_bool) * (x_abs - 0.5))) / K.sum(epsilon + y_true[:, :, :, :4 * num_anchors])
def rpn_loss_regr_fixed_num(y_true, y_pred): x = y_true[:, 4 * num_anchors:, :, :] - y_pred x_abs = K.abs(x) x_bool = K.lesser_equal(x_abs, 1.0) return lambda_rpn_regr * K.sum( y_true[:, :4 * num_anchors, :, :] * (x_bool * (0.5 * x * x) + (1 - x_bool) * (x_abs - 0.5))) / 256.
def softplus_stoch(x): y = softplus(x) shape_x = K.shape(y) active_bool = K.lesser_equal(K.random_uniform(shape_x),y) res = tf.where(active_bool, K.ones_like(y), K.zeros_like(y)) return res
def stoch_activation_function(x): shape_x = K.shape(x) active_bool = K.lesser_equal(K.random_uniform(shape_x),x) res = tf.where(active_bool, K.ones_like(x), K.zeros_like(x)) return res
def maxStat(stat): return kb.cast(kb.lesser_equal(stat, 1.0), "float32") * stat
def class_loss_regr_fixed_num(y_true, y_pred): x = y_true[:, :, 4:] - y_pred x_abs = K.abs(x) x_bool = K.lesser_equal(x_abs, 1.0) return lambda_cls_regr * K.sum(y_true[:, :, :4] * (x_bool * (0.5 * x * x) + (1 - x_bool) * (x_abs - 0.5))) / num_rois
def neighbor(y_true, y_pred, n=2): ##### NOT WORKING ##### ''' Trying to do what neighbor_accuracy does later ''' return K.cast( K.lesser_equal( K.abs(K.argmax(y_pred, axis=-1) - K.argmax(y_true, axis=-1)), n), K.floatx())
def get_updates(self, params, constraints, loss): # Note: get_updates is called *once* by keras. Its job is to return a set of 'update # operations' to any K.variable (e.g. model weights or self.num_games). Updates are applied # whenever Keras' train_function is evaluated, i.e. in every batch. Model.fit_on_batch() # will trigger exactly one update. All updates use the 'old' value of parameters - there is # no dependency on the order of the list of updates. self.updates = [] # Get expressions for gradients of model parameters. grads = self.get_gradients(loss, params) # Create a set of accumulated gradients, one for each game. shapes = [K.get_variable_shape(p) for p in params] self.cumulative_gradients = [[K.zeros(shape) for shape in shapes] for _ in range(self.num_games)] def conditional_update(cond, variable, new_value): '''Helper function to create updates that only happen when cond is True. Writes to self.updates and returns the new variable. Note: K.update(x, x) is cheap, but K.update_add(x, K.zeros_like(x)) can be expensive. ''' maybe_new_value = K.switch(cond, new_value, variable) self.updates.append(K.update(variable, maybe_new_value)) return maybe_new_value # Update cumulative gradient at index game_idx. This is done by returning an update for all # gradients that is a no-op everywhere except for the game_idx'th one. When game_idx is # changed by a call to set_current_game(), it will change the gradient that is getting # accumulated. # new_cumulative_gradients keeps references to the updated variables for use below in # updating parameters with the freshly-accumulated gradients. new_cumulative_gradients = [[None] * len(cgs) for cgs in self.cumulative_gradients] for i, cgs in enumerate(self.cumulative_gradients): for j, (g, cg) in enumerate(zip(grads, cgs)): new_gradient = conditional_update(K.equal(self.game_idx, i), cg, cg + g) new_cumulative_gradients[i][j] = new_gradient # Compute the net update to parameters, taking into account the sign of each cumulative # gradient. net_grads = [K.zeros_like(g) for g in grads] for i, cgs in enumerate(new_cumulative_gradients): for j, cg in enumerate(cgs): net_grads[j] += self.gradient_sign[i] * cg # Trigger a full update when all games have finished. self.trigger_update = K.lesser_equal(self.running_games, 0) # Update model parameters conditional on trigger_update. for p, g in zip(params, net_grads): new_p = p + g * self.lr if p in constraints: c = constraints[p] new_p = c(new_p) conditional_update(self.trigger_update, p, new_p) # 'reset' game counter and gradient signs when parameters are updated. for sign in self.gradient_sign: conditional_update(self.trigger_update, sign, K.variable(0)) conditional_update(self.trigger_update, self.running_games, K.variable(self.num_games)) return self.updates