def compute_position_ids(self, inputs): """T5的相对位置分桶(直接翻译自官方T5源码) """ q, v = inputs # 计算位置差 q_idxs = K.arange(0, K.shape(q)[1], dtype='int32') q_idxs = K.expand_dims(q_idxs, 1) v_idxs = K.arange(0, K.shape(v)[1], dtype='int32') v_idxs = K.expand_dims(v_idxs, 0) pos_ids = v_idxs - q_idxs # 后处理操作 num_buckets, max_distance = self.input_dim, self.max_distance ret = 0 n = -pos_ids if self.bidirectional: num_buckets //= 2 ret += K.cast(K.less(n, 0), 'int32') * num_buckets n = K.abs(n) else: n = K.maximum(n, 0) # now n is in the range [0, inf) max_exact = num_buckets // 2 is_small = K.less(n, max_exact) val_if_large = max_exact + K.cast( K.log(K.cast(n, K.floatx()) / max_exact) / np.log(max_distance / max_exact) * (num_buckets - max_exact), 'int32', ) val_if_large = K.minimum(val_if_large, num_buckets - 1) ret += K.switch(is_small, n, val_if_large) return ret
def get_updates(self, params, loss): grads = self.get_gradients(loss, params) shapes = [K.get_variable_shape(p) for p in params] alphas = [ K.variable(K.ones(shape) * self.init_alpha) for shape in shapes ] old_grads = [K.zeros(shape) for shape in shapes] self.weights = alphas + old_grads self.updates = [] for p, grad, old_grad, alpha in zip(params, grads, old_grads, alphas): grad = K.sign(grad) new_alpha = K.switch( K.greater(grad * old_grad, 0), K.minimum(alpha * self.scale_up, self.max_alpha), K.switch(K.less(grad * old_grad, 0), K.maximum(alpha * self.scale_down, self.min_alpha), alpha)) grad = K.switch(K.less(grad * old_grad, 0), K.zeros_like(grad), grad) new_p = p - grad * new_alpha # Apply constraints. if getattr(p, 'constraint', None) is not None: new_p = p.constraint(new_p) self.updates.append(K.update(p, new_p)) self.updates.append(K.update(alpha, new_alpha)) self.updates.append(K.update(old_grad, grad)) return self.updates
def update_state(self, y_true, y_pred, sample_weight=None): y_true = K.less(y_true, self.threshold) y_pred = K.less(y_pred, self.threshold) pos = tf.math.logical_and(y_true, y_pred) # print(pos) # print(K.equal(y_true, y_pred)) true_pos = K.sum(K.cast(pos, dtype=tf.float32)) self.cat_true_neg.assign_add(true_pos)
def _get_update_list(self, kernel): update_list = super(E2EFSSoft, self)._get_update_list(kernel) update_list += [ (self.moving_factor, K.switch(K.less(self.moving_T, self.warmup_T), self.start_alpha, K.minimum(self.alpha_M, self.start_alpha + (1. - self.start_alpha) * (self.moving_T - self.warmup_T) / self.T))), (self.moving_T, self.moving_T + 1), (self.moving_decay, K.switch(K.less(self.moving_factor, self.alpha_M), self.moving_decay, K.maximum(.75, self.moving_decay + self.epsilon))) ] return update_list
def get_spikes(self, new_mem): """Linear activation.""" thr = self._v_thresh pos_spikes = k.cast( tf.logical_and(k.less(self.mem, thr), k.greater_equal(new_mem, thr)), k.floatx()) neg_spikes = k.cast( tf.logical_and(k.less(new_mem, thr), k.greater_equal(self.mem, thr)), k.floatx()) return pos_spikes - neg_spikes
def _get_update_list(self, kernel): super(E2EFSSoft, self)._get_update_list(kernel) self.moving_factor.assign( K.switch( K.less(self.moving_T, self.warmup_T), self.start_alpha, K.minimum( self.alpha_M, self.start_alpha + (1. - self.start_alpha) * (self.moving_T - self.warmup_T) / self.T))) self.moving_T.assign_add(1.) self.moving_decay.assign( K.switch(K.less(self.moving_factor, self.alpha_M), self.moving_decay, K.maximum(.75, self.moving_decay + self.epsilon)))
def get_updates(self, params, loss): grads = self.get_gradients(loss, params) shapes = [K.shape(p) for p in params] alphas = [ K.variable(K.ones(shape) * self.init_alpha) for shape in shapes ] old_grads = [K.zeros(shape) for shape in shapes] prev_weight_deltas = [K.zeros(shape) for shape in shapes] self.weights = alphas + old_grads self.updates = [] for param, grad, old_grad, prev_weight_delta, alpha in zip( params, grads, old_grads, prev_weight_deltas, alphas): # equation 4 new_alpha = K.switch( K.greater(grad * old_grad, 0), K.minimum(alpha * self.scale_up, self.max_alpha), K.switch(K.less(grad * old_grad, 0), K.maximum(alpha * self.scale_down, self.min_alpha), alpha)) # equation 5 new_delta = K.switch( K.greater(grad, 0), -new_alpha, K.switch(K.less(grad, 0), new_alpha, K.zeros_like(new_alpha))) # equation 7 weight_delta = K.switch(K.less(grad * old_grad, 0), -prev_weight_delta, new_delta) # equation 6 new_param = param + weight_delta # reset gradient_{t-1} to 0 if gradient sign changed (so that we do # not "double punish", see paragraph after equation 7) grad = K.switch(K.less(grad * old_grad, 0), K.zeros_like(grad), grad) # Apply constraints #if param in constraints: # c = constraints[param] # new_param = c(new_param) self.updates.append(K.update(param, new_param)) self.updates.append(K.update(alpha, new_alpha)) self.updates.append(K.update(old_grad, grad)) self.updates.append(K.update(prev_weight_delta, weight_delta)) return self.updates
def smooth_l1(y_true, y_pred): """ 计算rpn 建议框坐标的loss 使用smooth l1 loss f(x) = 0.5 * (sigma * x)^2 if |x| < 1 / sigma / sigma |x| - 0.5 / sigma^2 otherwise :param sigma: 是平滑参数,控制平滑区域 :param y_true: 真实值 [batch_size, num_anchor, 4+1] :param y_pred: 预测值 [batch_size, num_anchor, 4] :return: rpn regr_loss """ regression_pred = y_pred regression_true = y_true[:, :, :-1] # 取rpn上的坐标 label_true = y_true[:, :, -1] # 取框内是否有物体的预测值 # 找到只有物体的框,不要背景 indices = tf.where(backend.equal(label_true, 1)) # 如果x,y都为None,就返回condition的坐标 regression_pred = tf.gather_nd(regression_pred, indices) # 根据有物体的索引,取出预测框的相关坐标 regression_true = tf.gather_nd(regression_true, indices) # 取出真实框的坐标 # 计算 smooth L1 loss regression_diff = backend.abs(regression_pred - regression_true) regression_loss = tf.where( # tf.where用做判断条件 backend.less(regression_diff, 1.0 / sigma_squared), # 绝对值是否小于1 0.5 * sigma_squared * backend.pow(regression_diff, 2), # 如果是 regression_diff - 0.5 / sigma_squared # 如果不是 ) # 除于N_cls normalizer = backend.maximum(1, backend.shape(indices)[0]) normalizer = backend.cast(normalizer, dtype='float32') loss = backend.sum(regression_loss) / normalizer return loss
def smooth_l1(y_true, y_pred, sigma=3.0, axis=None): """Compute the smooth L1 loss of y_pred w.r.t. y_true. Args: y_true: Tensor from the generator of shape (B, N, 5). The last value for each box is the state of the anchor (ignore, negative, positive). y_pred: Tensor from the network of shape (B, N, 4). sigma: The point where the loss changes from L2 to L1. Returns: The smooth L1 loss of y_pred w.r.t. y_true. """ if axis is None: axis = 1 if K.image_data_format() == 'channels_first' else K.ndim(y_pred) - 1 sigma_squared = sigma ** 2 # compute smooth L1 loss # f(x) = 0.5 * (sigma * x)^2 if |x| < 1 / sigma / sigma # |x| - 0.5 / sigma / sigma otherwise regression_diff = K.abs(y_true - y_pred) # |y - f(x)| regression_loss = tf.where( K.less(regression_diff, 1.0 / sigma_squared), 0.5 * sigma_squared * K.pow(regression_diff, 2), regression_diff - 0.5 / sigma_squared) return K.sum(regression_loss, axis=axis)
def call(self, x, training=None): mask = K.random_uniform(K.shape(x)[:-1], 0.0, 1.0) mask = K.expand_dims(mask, -1) mask = K.repeat_elements(mask, K.int_shape(x)[-1], -1) rand_x = K.switch(K.less(mask, self.rate), K.random_normal(K.shape(x), 0.0, 1.0), x) return K.in_train_phase(rand_x, x, training=training)
def _smooth_l1(y_true, y_pred): # y_true [batch_size, num_anchor, 4+1] # y_pred [batch_size, num_anchor, 4] regression = y_pred regression_target = y_true[:, :, :-1] anchor_state = y_true[:, :, -1] # 找到正样本 indices = tf.where(K.equal(anchor_state, 1)) regression = tf.gather_nd(regression, indices) regression_target = tf.gather_nd(regression_target, indices) # 计算smooth L1损失 regression_diff = regression - regression_target regression_diff = K.abs(regression_diff) regression_loss = tf.where( K.less(regression_diff, 1.0 / sigma_squared), 0.5 * sigma_squared * K.pow(regression_diff, 2), regression_diff - 0.5 / sigma_squared) # 将所获得的loss除上正样本的数量 normalizer = K.maximum(1, K.shape(indices)[0]) normalizer = K.cast(normalizer, dtype=K.floatx()) regression_loss = K.sum(regression_loss) / normalizer return regression_loss
def _smooth_l1(y_true, y_pred): """ Compute the smooth L1 loss of y_pred w.r.t. y_true. Args y_true: Tensor from the generator of shape (B, N, 5). The last value for each box is the state of the anchor (ignore, negative, positive). y_pred: Tensor from the network of shape (B, N, 4). Returns The smooth L1 loss of y_pred w.r.t. y_true. """ # separate target and state regression = y_pred regression_target = y_true[:, :, :-1] anchor_state = y_true[:, :, -1] # filter out "ignore" anchors indices = tf.where(K.equal(anchor_state, 1)) regression = tf.gather_nd(regression, indices) regression_target = tf.gather_nd(regression_target, indices) # compute smooth L1 loss # f(x) = 0.5 * (sigma * x)^2 if |x| < 1 / sigma / sigma # |x| - 0.5 / sigma / sigma otherwise regression_diff = regression - regression_target regression_diff = K.abs(regression_diff) regression_loss = tf.where( K.less(regression_diff, 1.0 / sigma_squared), 0.5 * sigma_squared * K.pow(regression_diff, 2), regression_diff - 0.5 / sigma_squared) # compute the normalizer: the number of positive anchors normalizer = K.maximum(1, K.shape(indices)[0]) normalizer = K.cast(normalizer, dtype=K.floatx()) return K.sum(regression_loss) / normalizer
def apply(self, Xs, Ys, Rs, reverse_state): #this method is correct, but wasteful grad = ilayers.GradientWRT(len(Xs)) times_alpha0 = tensorflow.keras.layers.Lambda( lambda x: x * self._alpha[0]) times_alpha1 = tensorflow.keras.layers.Lambda( lambda x: x * self._alpha[1]) times_beta0 = tensorflow.keras.layers.Lambda( lambda x: x * self._beta[0]) times_beta1 = tensorflow.keras.layers.Lambda( lambda x: x * self._beta[1]) keep_positives = tensorflow.keras.layers.Lambda( lambda x: x * K.cast(K.greater(x, 0), K.floatx())) keep_negatives = tensorflow.keras.layers.Lambda( lambda x: x * K.cast(K.less(x, 0), K.floatx())) def f(layer, X): Zs = kutils.apply(layer, X) # Divide incoming relevance by the activations. tmp = [ilayers.SafeDivide()([a, b]) for a, b in zip(Rs, Zs)] # Propagate the relevance to the input neurons # using the gradient tmp = iutils.to_list(grad(X + Zs + tmp)) # Re-weight relevance with the input values. tmp = [ tensorflow.keras.layers.Multiply()([a, b]) for a, b in zip(X, tmp) ] return tmp # Distinguish postive and negative inputs. Xs_pos = kutils.apply(keep_positives, Xs) Xs_neg = kutils.apply(keep_negatives, Xs) # xpos*wpos r_pp = f(self._layer_wo_act_positive, Xs_pos) # xneg*wneg r_nn = f(self._layer_wo_act_negative, Xs_neg) # a0 * r_pp + a1 * r_nn r_pos = [ tensorflow.keras.layers.Add()([times_alpha0(pp), times_beta1(nn)]) for pp, nn in zip(r_pp, r_nn) ] # xpos*wneg r_pn = f(self._layer_wo_act_negative, Xs_pos) # xneg*wpos r_np = f(self._layer_wo_act_positive, Xs_neg) # b0 * r_pn + b1 * r_np r_neg = [ tensorflow.keras.layers.Add()([times_beta0(pn), times_beta1(np)]) for pn, np in zip(r_pn, r_np) ] return [ tensorflow.keras.layers.Subtract()([a, b]) for a, b in zip(r_pos, r_neg) ]
def weighted_bce_dice_loss(y_true, y_pred): y_true = K.cast(y_true, 'float32') y_pred = K.cast(y_pred, 'float32') # if we want to get same size of output, kernel size must be odd number if K.int_shape(y_pred)[1] == 128: kernel_size = 11 elif K.int_shape(y_pred)[1] == 256: kernel_size = 21 else: raise ValueError('Unexpected image size') averaged_mask = K.pool2d(y_true, pool_size=(kernel_size, kernel_size), strides=(1, 1), padding='same', pool_mode='avg') border = K.cast(K.greater(averaged_mask, 0.005), 'float32') * K.cast( K.less(averaged_mask, 0.995), 'float32') weight = K.ones_like(averaged_mask) w0 = K.sum(weight) weight += border * 2 w1 = K.sum(weight) weight *= (w0 / w1) loss = weighted_bce_loss(y_true, y_pred, weight) + ( 1 - weighted_dice_coeff(y_true, y_pred, weight)) return loss
def customAccuracy(y_true, y_pred): diff = K.abs( y_true - y_pred) #absolute difference between correct and predicted values correct = K.less( diff, 0.01) #tensor with 0 for false values and 1 for true values return K.mean(correct) #sum all 1's and divide by the total.
def _smooth_l1(self, y_true, y_pred): absolute_value_loss = K.abs(y_true - y_pred) square_loss = 0.5 * (y_true - y_pred)**2 absolute_value_condition = K.less(absolute_value_loss, 1.0) l1_smooth_loss = tf.where(absolute_value_condition, square_loss, absolute_value_loss - 0.5) return K.sum(l1_smooth_loss, axis=-1)
def yolo_confidence_loss(y_true, y_pred, t): error = K.square(y_true-y_pred) object_true = OBJECT_SCALE*(error) object_false = NO_OBJECT_SCALE*(error) object_default = K.zeros_like(y_true) loss1 = tf.where(t, object_true, object_default) loss2 = tf.where(K.less(tf.to_float(t),0.5), object_false, object_default) return K.sum(loss1) + K.sum(loss2)
def smooth_l1_loss(y_true, y_pred): """Implements Smooth-L1 loss. y_true and y_pred are typically: [N, 4], but could be any shape. """ diff = K.abs(y_true - y_pred) less_than_one = K.cast(K.less(diff, 1.0), "float32") loss = (less_than_one * 0.5 * diff**2) + (1 - less_than_one) * (diff - 0.5) return loss
def custom_loss(y_true, y_pred): #custom_loss = K.mean(K.sum(K.square(y_true - y_pred))) alpha = 100. loss = K.switch(K.less(y_true * y_pred, 0), \ alpha*y_pred**2 - K.sign(y_true)*y_pred + K.abs(y_true), \ K.abs(y_true - y_pred) ) return K.mean(loss, axis=-1)
def regularization(x): l_units = loss_units(x) t = x / K.max(K.abs(x)) p = K.switch(K.less(t, K.epsilon()), K.zeros_like(x), x) cost = K.cast_to_floatx(0.) cost += K.sum(p * (1. - p)) + 2. * l_units # cost += K.sum(K.relu(x - 1.)) return cost
def _resource_apply_sparse(self, grad, var, apply_state=None): var_device, var_dtype = var.device, var.dtype.base_dtype coefficients = ((apply_state or {}).get((var_device, var_dtype)) or self._fallback_apply_state(var_device, var_dtype)) old_grad = self.get_slot(var, "old_grad") old_weight_delta = self.get_slot(var, "old_weight_delta") alpha = self.get_slot(var, "alpha") gradneg = K.less(grad * old_grad, 0) # equation 4 scale_down = coefficients["scale_down_t"] min_alpha = coefficients["min_alpha_t"] alpha_t = state_ops.\ assign(alpha, K.switch(K.greater(grad * old_grad, 0), K.minimum(alpha * coefficients["scale_up_t"], coefficients["max_alpha_t"]), K.switch(gradneg, K.maximum(alpha * scale_down, min_alpha), alpha)), use_locking=self._use_locking) # equation 5 new_tmp_delta_t = K.switch( K.greater(grad, 0), -alpha_t, K.switch(K.less(grad, 0), alpha_t, K.zeros_like(alpha_t))) # equation 7 old_weight_delta_t = state_ops.assign( old_weight_delta, K.switch(gradneg, -old_weight_delta, new_tmp_delta_t), use_locking=self._use_locking) # equation 6 # var_new = math_ops.add(var, old_weight_delta_t) var_update = state_ops.assign_add(var, old_weight_delta_t, use_locking=self._use_locking) #print(f"var: {var}") #print(f"var update: {var_update}") old_grad_t = state_ops.assign(old_grad, grad, use_locking=self._use_locking) return control_flow_ops.group( *[var_update, old_grad_t, old_weight_delta_t, alpha_t])
def triplet_acc(y_true,y_pred): a = y_pred[0::3] p = y_pred[1::3] n = y_pred[2::3] ap = K.sum(K.square(a-p),-1) an = K.sum(K.square(a-n),-1) return K.less(ap+alpha,an)
def apply(self, Xs, Ys, Rs, reverse_state): #this method is correct, but wasteful grad = ilayers.GradientWRT(len(Xs)) times_alpha = tensorflow.keras.layers.Lambda(lambda x: x * self._alpha) times_beta = tensorflow.keras.layers.Lambda(lambda x: x * self._beta) keep_positives = tensorflow.keras.layers.Lambda( lambda x: x * K.cast(K.greater(x, 0), K.floatx())) keep_negatives = tensorflow.keras.layers.Lambda( lambda x: x * K.cast(K.less(x, 0), K.floatx())) def f(layer1, layer2, X1, X2): # Get activations of full positive or negative part. Z1 = kutils.apply(layer1, X1) Z2 = kutils.apply(layer2, X2) Zs = [ tensorflow.keras.layers.Add()([a, b]) for a, b in zip(Z1, Z2) ] # Divide incoming relevance by the activations. tmp = [ilayers.SafeDivide()([a, b]) for a, b in zip(Rs, Zs)] # Propagate the relevance to the input neurons # using the gradient tmp1 = iutils.to_list(grad(X1 + Z1 + tmp)) tmp2 = iutils.to_list(grad(X2 + Z2 + tmp)) # Re-weight relevance with the input values. tmp1 = [ tensorflow.keras.layers.Multiply()([a, b]) for a, b in zip(X1, tmp1) ] tmp2 = [ tensorflow.keras.layers.Multiply()([a, b]) for a, b in zip(X2, tmp2) ] #combine and return return [ tensorflow.keras.layers.Add()([a, b]) for a, b in zip(tmp1, tmp2) ] # Distinguish postive and negative inputs. Xs_pos = kutils.apply(keep_positives, Xs) Xs_neg = kutils.apply(keep_negatives, Xs) # xpos*wpos + xneg*wneg activator_relevances = f(self._layer_wo_act_positive, self._layer_wo_act_negative, Xs_pos, Xs_neg) if self._beta: #only compute beta-weighted contributions of beta is not zero # xpos*wneg + xneg*wpos inhibitor_relevances = f(self._layer_wo_act_negative, self._layer_wo_act_positive, Xs_pos, Xs_neg) return [ tensorflow.keras.layers.Subtract()( [times_alpha(a), times_beta(b)]) for a, b in zip(activator_relevances, inhibitor_relevances) ] else: return activator_relevances
def loss_units(x): t = x / K.max(K.abs(x)) x = K.switch(K.less(t, K.epsilon()), K.zeros_like(x), x) # m = K.sum(K.cast(K.greater(x, 0.), K.floatx())) sum_x = K.sum(x) # moving_units = K.switch(K.less_equal(m, self.units), m, self.moving_units) # epsilon_minus = 0. # epsilon_plus = K.switch(K.less_equal(m, self.units), self.moving_units, 0.) return K.abs(self.moving_units - sum_x)
def dice_coef_border(y_true, y_pred): SMOOTH = 1 print("inside dice_coef_border .. y_true shape=", y_true.shape, "y_pred shape=", y_pred.shape) # negative = 1. - tf.cast(y_true, tf.float32) # positive = tf.cast(y_true, tf.float32) y_true = K.cast(y_true, 'float32') y_pred = K.cast(y_pred, 'float32') # if we want to get same size of output, kernel size must be odd number averaged_mask1 = tf.nn.avg_pool2d(y_true, pool_size=(11, 11), strides=(1, 1), padding='same') #, pool_mode='avg') border1 = K.cast(K.greater(averaged_mask1, 0.005), 'float32') * K.cast( K.less(averaged_mask1, 0.995), 'float32') # positive = K.pool2d(positive, pool_size=(11,11), padding="same", data_format='channels_last') # negative = K.pool2d(negative, pool_size=(11,11), padding="same", data_format='channels_last') # border = positive * negative # border = get_border_mask((11, 11), y_true) averaged_mask2 = tf.nn.avg_pool2d(y_pred, pool_size=(11, 11), strides=(1, 1), padding='same') #, pool_mode='avg') border2 = K.cast(K.greater(averaged_mask2, 0.005), 'float32') * K.cast( K.less(averaged_mask2, 0.995), 'float32') border1 = K.flatten(border1) border2 = K.flatten(border2) y_true_f = border1 #K.flatten(y_true) y_pred_f = border2 #K.flatten(y_pred) # y_true_f = K.gather(y_true_f, tf.where(border1 > 0.5)) # y_pred_f = K.gather(y_pred_f, tf.where(border2 > 0.5)) print("y_pred_f shape", y_pred_f.shape, "y_true_f.shape=", y_true_f.shape) intersection = K.sum(y_true_f * y_pred_f) return (2. * intersection + SMOOTH) / (K.sum(y_true_f) + K.sum(y_pred_f) + SMOOTH)
def triplet_acc(y_true,y_pred): #Accuracy Computation for Triplet loss a = y_pred[0::3] #Getting Anchor for comperision p = y_pred[1::3] #Getting Positive n = y_pred[2::3] #Getting Negative ap = K.sum(K.square(a-p),-1) #SUm of Squre between Anchor and Positve an = K.sum(K.square(a-n),-1) #SUm of Squre between Anchor and Negative return K.less(ap+alpha,an) #Min (Element wise) betweeen AchorPostive and Negative is taken
def loss_units(x): t = x / K.max(K.abs(x)) x = K.switch(K.less(t, K.epsilon()), K.zeros_like(x), x) m = K.sum(K.cast(K.greater(x, 0.), K.floatx())) sum_x = K.sum(x) moving_units = K.switch(K.less_equal(m, self.units), m, (1. - self.moving_decay) * self.moving_units) epsilon_minus = 0. epsilon_plus = K.switch(K.less_equal(m, self.units), self.moving_units, 0.) return K.relu(moving_units - sum_x - epsilon_minus) + K.relu(sum_x - moving_units - epsilon_plus)
def custom_loss(y_true, y_pred, loss_weights=loss_weights): # Verified zero_index = K.zeros_like(y_true[:, 0]) ones_index = K.ones_like(y_true[:, 0]) # Classifier labels = y_true[:, 0] class_preds = y_pred[:, 0] bi_crossentropy_loss = -labels * K.log(class_preds) - ( 1 - labels) * K.log(1 - class_preds) classify_valid_index = tf.where(K.less(y_true[:, 0], 0), zero_index, ones_index) classify_keep_num = K.cast(tf.reduce_sum(classify_valid_index) * SAMPLE_KEEP_RATIO, dtype=tf.int32) # For classification problem, only pick 70% of the valid samples. classify_loss_sum = bi_crossentropy_loss * classify_valid_index classify_loss_sum_filtered, _ = tf.nn.top_k(classify_loss_sum, k=classify_keep_num) classify_loss = K.mean(classify_loss_sum_filtered) # Bounding box regressor rois = y_true[:, 1:5] roi_preds = y_pred[:, 1:5] # roi_raw_mean_square_error = K.sum(K.square(rois - roi_preds), axis = 1) # mse roi_raw_smooth_l1_loss = K.mean( tf.where( K.abs(rois - roi_preds) < 1, 0.5 * K.square(rois - roi_preds), K.abs(rois - roi_preds) - 0.5)) # L1 Smooth Loss roi_valid_index = tf.where(K.equal(K.abs(y_true[:, 0]), 1), ones_index, zero_index) roi_keep_num = K.cast(tf.reduce_sum(roi_valid_index), dtype=tf.int32) # roi_valid_mean_square_error = roi_raw_mean_square_error * roi_valid_index # roi_filtered_mean_square_error, _ = tf.nn.top_k(roi_valid_mean_square_error, k = roi_keep_num) # roi_loss = K.mean(roi_filtered_mean_square_error) roi_valid_smooth_l1_loss = roi_raw_smooth_l1_loss * roi_valid_index roi_filtered_smooth_l1_loss, _ = tf.nn.top_k( roi_valid_smooth_l1_loss, k=roi_keep_num) roi_loss = K.mean(roi_filtered_smooth_l1_loss) loss = classify_loss * loss_weights[0] + roi_loss * loss_weights[1] return loss
def nmse(y_true, y_pred, a, c): dim = len(c) - 1 loss_classes = [[] for i in range(dim)] cond = [[] for i in range(dim)] loss = [[] for i in range(dim)] for i in range(0, dim): loss_classes[i] = a[i] * K.square((y_pred - y_true) / (y_true)) cond[i] = K.less(y_true, c[i + 1]) & K.greater(y_true, c[i]) loss[0] = K.switch(cond[0], loss_classes[0], loss_classes[1]) for i in range(1, dim): loss[i] = K.switch(cond[i], loss_classes[i], loss[i - 1]) return K.mean(loss[dim - 1], axis=-1)
def get_psp(self, output_spikes): new_spiketimes = tf.where(k.greater(output_spikes, 0), k.ones_like(output_spikes) * self.time, self.last_spiketimes) new_spiketimes = tf.where(k.less(output_spikes, 0), k.zeros_like(output_spikes) * self.time, new_spiketimes) assign_new_spiketimes = tf.assign(self.last_spiketimes, new_spiketimes) with tf.control_dependencies([assign_new_spiketimes]): last_spiketimes = self.last_spiketimes + 0 # Dummy op # psp = k.maximum(0., tf.divide(self.dt, last_spiketimes)) psp = tf.where(k.greater(last_spiketimes, 0), k.ones_like(output_spikes) * self.dt, k.zeros_like(output_spikes)) return psp