def _dense_alphabeta_dtd(layer, R, beta, parameter2): print('_dense_alphabeta_dtd') if layer.activation.__name__ == 'softmax': raise NotImplementedError( 'Please use softmax only on Activation layer ' 'and not directly on Dense layer') alpha = 1 + beta Z = layer.kernel * K.expand_dims(layer.input, axis=-1) if not alpha == 0: Zp = K.maximum(Z, 0) Zsp = K.sum(Zp, axis=1, keepdims=True) Zsp += 1e-12 * K.switch(K.greater_equal(Zsp, 0), K.ones_like(Zsp, dtype=K.floatx()), K.ones_like(Zsp, dtype=K.floatx()) * -1.) Ralpha = alpha * K.sum((Zp / Zsp) * K.expand_dims(R, axis=1), axis=2) else: Ralpha = 0 if not beta == 0: Zn = K.minimum(Z, 0) Zsn = K.sum(Zn, axis=1, keepdims=True) Zsn += 1e-12 * K.switch(K.greater_equal(Zsn, 0), K.ones_like(Zsn, dtype=K.floatx()), K.ones_like(Zsn, dtype=K.floatx()) * -1.) Rbeta = beta * K.sum((Zn / Zsn) * K.expand_dims(R, axis=1), axis=2) else: Rbeta = 0 return Ralpha - Rbeta
def recall_binary(y_true, y_pred): """ Keras metric for computing recall for a binary classification task during training Recall = true positives / (true positives + false negatives) Parameters ---------- y_true : K.variable Ground truth N-dimensional Keras variable of float type with only 0's and 1's. y_pred : K.variable Predicted Keras variable of float type with predicted values between 0 and 1. Returns ------- K.variable A single value indicating the recall. """ logical_and = K.cast( K.all(K.stack([K.cast(y_true, 'bool'), K.greater_equal(y_pred, 0.5)], axis=0), axis=0), 'float32') logical_or = K.cast( K.any(K.stack([K.cast(y_true, 'bool'), K.greater_equal(y_pred, 0.5)], axis=0), axis=0), 'float32') tp = K.sum(logical_and) fn = K.sum(logical_or - K.cast(K.greater_equal(y_pred, 0.5), 'float32')) return K.switch(K.equal(tp, K.variable(0)), K.variable(0), tp / (tp + fn))
def is_in_geo_range(patch_x_and_y): patch_x_tensor = patch_x_and_y[0] patch_y_tensor = patch_x_and_y[1] base_leaner_x_max = K.constant(geo_range[0], dtype='float32') base_leaner_x_min = K.constant(geo_range[1], dtype='float32') base_leaner_y_max = K.constant(geo_range[2], dtype='float32') base_leaner_y_min = K.constant(geo_range[3], dtype='float32') layer_output = patch_x_and_y[2] #coef_geo_range = K.ones((K.int_shape(img_input)[0],1),dtype='float32') coef_geo_range = layer_output coef_geo_range = K.switch( K.less_equal(patch_x_tensor, base_leaner_x_max), coef_geo_range * 1.0, coef_geo_range * 0.0) coef_geo_range = K.switch( K.greater_equal(patch_x_tensor, base_leaner_x_min), coef_geo_range * 1.0, coef_geo_range * 0.0) coef_geo_range = K.switch( K.less_equal(patch_y_tensor, base_leaner_y_max), coef_geo_range * 1.0, coef_geo_range * 0.0) coef_geo_range = K.switch( K.greater_equal(patch_y_tensor, base_leaner_y_min), coef_geo_range * 1.0, coef_geo_range * 0.0) return coef_geo_range
def get_jaccard_index1_from_sigmoid(y_true, y_pred, smooth=default_smooth): """Calculate jaccard index but from signed-dist vectors""" thresh = K.constant(0.5) ji = get_jaccard_index1(K.cast(K.greater_equal(y_true, thresh), 'float32'), K.cast(K.greater_equal(y_pred, thresh), 'float32'), smooth=K.constant(smooth)) return ji
def berHu_loss_elementwise_w_border(y_true, y_pred): ''' Proposed Lpano as described in our paper. ''' ret_loss = 0 y_diff = y_true - y_pred y_diff_abs = K.abs(y_diff) c = (1.0/5.0)*K.max(y_diff_abs) L2_berHu = (K.pow(y_diff_abs, 2) + c**2) / (2*c) berHu_tensor = tf.where(K.less_equal(y_diff_abs, c), y_diff_abs, L2_berHu) ## regular reverse huber n_pixels = tf.to_float(tf.size(y_true)) berHu_overall = K.sum(berHu_tensor) / n_pixels ## add extra weight to the borders ## build boolean mask by combining boundary conditions for the rows and cols shape = tf.shape(berHu_tensor) bs, R, C, chans = tf.meshgrid(tf.range(shape[0]), tf.range(shape[1]), tf.range(shape[2]), tf.range(shape[3])) ## batch_size, width, height, channels row_lines = tf.logical_or(K.less_equal(R, 16), K.greater_equal(R, 112)) # these numbers will need to change when moving to larger image sizes or different border width col_lines = tf.logical_or(K.less_equal(C, 16), K.greater_equal(C, 240)) border_mask = tf.logical_or(row_lines, col_lines) border_berHu_vals = tf.boolean_mask(berHu_tensor, border_mask) n_border_pixels = tf.to_float(tf.size(border_berHu_vals)) berHu_border = K.sum(border_berHu_vals) / n_border_pixels lambda_frac = 0.5 # default amount for the weight matrix ret_loss = berHu_overall + lambda_frac*berHu_border return ret_loss
def dice_coef_for_sigmoid(y_true, y_pred, threshold=0.5): y_true_bi = K.cast(K.greater_equal(y_true, threshold), 'float32') y_pred_bi = K.cast(K.greater_equal(y_pred, threshold), 'float32') inter = K.sum(y_true_bi*y_pred_bi, axis=[1, 2]) union = K.sum(y_true_bi, axis=[1, 2]) + K.sum(y_pred_bi, axis=[1, 2]) dice_coef = (2.0*inter + K.epsilon()) / (union + K.epsilon()) return K.mean(dice_coef, axis=-1)
def greater_equal(f, other): """Element-wise comparison applied to the `Functional` objects. # Arguments f: Functional object. other: A python number or a tensor or a functional object. # Returns A Functional. """ validate_functional(f) inputs = f.inputs.copy() if is_functional(other): inputs += to_list(other.inputs) lmbd = [Lambda(lambda x: K.cast_to_floatx(K.greater_equal(x[0], x[1])), name=graph_unique_name("greater_equal")) for X in f.outputs] else: _warn_for_ndarray(other) lmbd = [Lambda(lambda x: K.cast_to_floatx(K.greater_equal(x, other)), name=graph_unique_name("greater_equal")) for X in f.outputs] Functional = f.get_class() res = Functional( inputs=unique_tensors(inputs), outputs=_apply_operation(lmbd, f, other), layers=lmbd ) return res
def call(self, x): y = x[1] BinPop = {} id_bin_1 = K.cast(K.less(x, self.ValueRange[0]), K.floatx()) id_bin_last = K.cast(K.greater_equal(x, self.ValueRange[1]), K.floatx()) BinPop[1] = K.sum(id_bin_1, axis=1, keepdims=True) BinPop[self.nbins] = K.sum(id_bin_last, axis=1, keepdims=True) start = self.ValueRange[0] stop = start + self.binwidth for i in range(2, self.nbins): id_bin = K.tf.multiply( K.cast(K.greater_equal(x, start), K.floatx()), K.cast(K.less(x, stop), K.floatx())) BinPop[i] = K.sum(id_bin, axis=1, keepdims=True) for i2 in range(2, self.nbins): id_bin_i2 = K.tf.multiply( K.cast(K.greater_equal(y, start), K.floatx()), K.cast(K.less(y, stop), K.floatx())) start = stop stop = start + self.binwidth hist = K.concatenate(list(BinPop.values())) return hist
def call(self, x): min_cat = K.less(x, self.thresholds[0]) max_cat = K.greater_equal(x, self.thresholds[-1]) other_cat = map( lambda (th1, th2): K.all(K.stack([K.greater_equal(x, th1), K.less(x, th2)], axis=0), axis=0), zip(self.thresholds[:-1], self.thresholds[1:]) ) return K.cast(K.concatenate([min_cat] + other_cat + [max_cat]), K.floatx())
def EuiLoss(y_true, y_pred): y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) d = K.sum(K.sqrt(K.square(y_true_f - y_pred_f) + 1e-12)) a = K.cast(K.greater_equal(d, 0.5), dtype='float32') b = K.cast(K.greater_equal(0.12, d), dtype='float32') c = K.cast(K.greater_equal(0.3, d), dtype='float32') loss = (2 + 4 * a - 0.5 * b - 1 * c) * d + 0.2 * y_pred_f *d return loss
def Checking_if_object(x1_window, y1_window, x2_window, y2_window, x_max_true, x_min_true, y_max_true, y_min_true): x_middle_true = (x_max_true + x_min_true) / 2.0 y_middle_true = (y_max_true + y_min_true) / 2.0 matching_x = tf.logical_and(K.greater_equal(x=x_middle_true, y=x1_window), K.greater_equal(x=x2_window, y=x_middle_true)) matching_y = tf.logical_and(K.greater_equal(x=y_middle_true, y=y1_window), K.greater_equal(x=y2_window, y=y_middle_true)) matching = tf.logical_and(matching_x, matching_y) return matching
def get_jaccard_index1_from_sdt(y_true, y_pred, smooth=default_smooth): """Calculate jaccard index but from signed-dist vectors""" thresh = K.constant(0) y_true = K.cast(K.greater_equal(y_true, thresh), 'float32') y_pred = K.cast(K.greater_equal(y_pred, thresh), 'float32') ji = get_jaccard_index1(K.cast(K.argmax(y_true, axis=-1), 'int64'), K.cast(K.argmax(y_pred, axis=-1), 'int64'), smooth=K.constant(smooth)) return ji
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 intersection_over_union(y_true, y_pred): smooth = 1. y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) y_t = K.greater_equal(y_true_f, 0.5) y_p = K.greater_equal(y_pred_f, 0.5) union1 = [i for i, j in zip(y_true_f, y_pred_f) if i or j] union2 = [j for i, j in zip(y_true_f, y_pred_f) if i or j] intersection = [i for i, j in zip(y_true_f, y_pred_f) if i and j] unionAll = union1 + union2 + intersection return (np.sum(intersection) + smooth) / float(np.sum(unionAll) + smooth)
def loss(y, y_pred): data['steps'] += 1 data['epoch'] = int(data['steps'] / steps_per_epoch) + 1 # which epoch is running decay = pow(rate, max(1, data['epoch'] - epochs_without_decay)) assert decay > 1 if data['epoch'] > epochs_without_decay: data['ones'] = tf.ones_like(y_pred) if data['ones'] is None else data['ones'] y_pred = K.switch(K.greater_equal(y_pred, 1 - smoothing_threshold), data['ones'], y_pred) y_pred = K.switch(K.greater_equal(y_pred, 0.5), K.pow(y_pred, 1 / decay), y_pred) y_pred = K.switch(K.less(y_pred, 0.5), K.pow(y_pred, decay), y_pred) return K.categorical_crossentropy(y, y_pred)
def Padlayer1(x): print("before cropping: ", K.shape(x)) image_rows = K.shape(x)[1] image_cols = K.shape(x)[2] image_batch = K.shape(x)[3] difsizeZ = lz - image_batch difsizeY = ly - image_cols difsizeX = lx - image_rows Vy = tf.cond(K.greater_equal(difsizeZ, 0), lambda: K.cast(difsizeZ, 'int32'), lambda: 0) Xy = tf.cond(K.greater_equal(difsizeX, 0), lambda: K.cast(difsizeX, 'int32'), lambda: 0) Yy = tf.cond(K.greater_equal(difsizeY, 0), lambda: K.cast(difsizeY, 'int32'), lambda: 0) return K.reshape(K.stack([Xy, Yy, Vy]), (1, 3))
def EuiLoss_new(y_true, y_pred): y_true_t = y_true[:, 0:1] y_pred_t = y_pred[:, 0:1] y_true_f = K.flatten(y_true_t) y_pred_f = K.flatten(y_pred_t) d = K.mean(K.sqrt(K.square(y_true_f - y_pred_f) + 1e-12)) a = K.cast(K.greater_equal(d, 0.5), dtype='float32') b = K.cast(K.greater_equal(0.12, d), dtype='float32') c = K.cast(K.greater_equal(0.3, d), dtype='float32') #e = K.cast(y_pred_f, dtype='float32') loss = (2 + 4 * a - 0.5 * b - 1 * c) * d + 0.2 * y_pred_f * d return loss
def m_accuracy(true_y,pred_y): treshold = 0 mask = Lambda(lambda x:K.greater_equal(x, treshold))(true_y) mask = Lambda(lambda x:K.cast(x, 'float32'))(mask) pred_label = Lambda(lambda x: x * mask)(pred_y) true_label = Lambda(lambda x: x * mask)(true_y) return K.mean(K.equal(K.argmax(true_label, axis=-1), K.argmax(pred_label, axis=-1)))
def yolo_filter_boxes(box_confidence, boxes, box_class_probs, threshold = .6): ''' Filters the classified YOLO boxes by thresholding on the objects classified and on the basis of box_confidence Returns values of the filter: scores -- tensor of shape (None,), containing the class probability score for selected boxes boxes -- tensor of shape (None, 4), containing (b_x, b_y, b_h, b_w) coordinates of selected boxes classes -- tensor of shape (None,), containing the index of the class detected by the selected boxes Note: "None" is here because we don't know the exact number of selected boxes, as it depends on the threshold. For example, the actual output size of scores would be (10,) if there are 10 boxes. ''' # Computing the box scores box_scores = np.multiply(box_confidence,box_class_probs) # Finding the box_classes thanks to the max box_scores, keep track of the corresponding score box_classes = K.argmax(box_scores, axis=-1) # gives the index of the maximum number in the obtained box_score matrix/array (1D) box_class_scores = K.max(box_scores, axis=-1) # gives the maximum value from the box_score # Create a filtering mask based on "box_class_scores" by using "threshold". The mask should have the # same dimension as box_class_scores, and the boxes with probability >= threshold are classified as True or 1 and remaining False or 0 filtering_mask = K.greater_equal(box_class_scores, threshold) # Applying the mask to scores, boxes and classes scores = tf.boolean_mask(box_class_scores,filtering_mask) # the scores grater than corresponding threshold are selected boxes = tf.boolean_mask(boxes,filtering_mask) # the boxes grater than corresponding threshold are selected classes = tf.boolean_mask(box_classes,filtering_mask) # the classes grater than corresponding threshold are selected return scores, boxes, classes
def _simple_lrp(layer, R, parameter): ''' LRP according to Eq(56) in DOI: 10.1371/journal.pone.0130140 ''' print('_maxpooling3d_simple_lrp') volume_patches = patches.extract_volume_patches(layer.input, layer.pool_size, layer.strides, layer.padding) Z = K.equal( K.reshape(layer.output, (-1, layer.output_shape[1], layer.output_shape[2], layer.output_shape[3], 1, 1, 1, layer.output_shape[4])), volume_patches) Z = K.switch(Z, K.ones_like(Z, dtype=K.floatx()), K.zeros_like(Z, dtype=K.floatx())) Zs = K.sum(Z, axis=[4, 5, 6], keepdims=True) Zs += 1e-12 * K.switch(K.greater_equal(Zs, 0), K.ones_like(Zs, dtype=K.floatx()), K.ones_like(Zs, dtype=K.floatx()) * -1.) result = (Z / Zs) * K.reshape( R, (-1, layer.output_shape[1], layer.output_shape[2], layer.output_shape[3], 1, 1, 1, layer.output_shape[4])) return patches.restitch_volume_patches(result, layer.input_shape, layer.pool_size, layer.strides, layer.padding)
def dice_coef(y_true, y_pred): y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) mask = K.cast(K.greater_equal(y_true_f, -0.5), dtype='float32') intersection = K.sum(y_true_f * y_pred_f * mask) return (2. * intersection + ss) / (K.sum(y_true_f * mask) + K.sum(y_pred_f * mask) + ss)
def binary_crossentropy_with_ranking(y_true, y_pred): """ Trying to combine ranking loss with numeric precision""" # first get the log loss like normal logloss = K.mean(K.binary_crossentropy(y_pred, y_true), axis=-1) # next, build a rank loss # clip the probabilities to keep stability y_pred_clipped = K.clip(y_pred, K.epsilon(), 1 - K.epsilon()) # translate into the raw scores before the logit y_pred_score = K.log(y_pred_clipped / (1 - y_pred_clipped)) # determine what the maximum score for a zero outcome is y_pos = K.cast(K.greater_equal(y_true, 0.5), 'float32') y_neg = K.cast(K.less(y_true, 0.5), 'float32') y_pred_score_zerooutcome_max = K.max(y_pred_score * y_neg) # determine how much each score is above or below it rankloss = y_pred_score - y_pred_score_zerooutcome_max # only keep losses for positive outcomes rankloss = rankloss * y_pos # only keep losses where the score is below the max rankloss = K.square(K.clip(rankloss, -10, 0)) # average the loss for just the positive outcomes rankloss = K.sum(rankloss, axis=-1) / (K.sum(y_pos) + 1) # return (rankloss + 1) * logloss - an alternative to try return rankloss + logloss
def BooleanMask(x): output = K.greater_equal(x[0], x[1]) output = K.cast(output, dtype='float32') output = K.tf.multiply(output, x[1]) return output
def yolo_filter_boxes(box_confidence, boxes, box_class_probs, threshold=.6): """Filters YOLO boxes by thresholding on object and class confidence. Arguments: box_confidence -- tensor of shape (19, 19, 5, 1) boxes -- tensor of shape (19, 19, 5, 4) box_class_probs -- tensor of shape (19, 19, 5, 80) threshold -- real value, if [ highest class probability score < threshold], then get rid of the corresponding box Returns: scores -- tensor of shape (None,), containing the class probability score for selected boxes boxes -- tensor of shape (None, 4), containing (b_x, b_y, b_h, b_w) coordinates of selected boxes classes -- tensor of shape (None,), containing the index of the class detected by the selected boxes Note: "None" is here because you don't know the exact number of selected boxes, as it depends on the threshold. For example, the actual output size of scores would be (10,) if there are 10 boxes. """ # Step 1: Compute box scores box_scores = box_confidence * box_class_probs # Step 2: Find the box_classes using the max box_scores, keep track of the corresponding score box_classes = K.argmax(box_scores, axis=-1) box_class_scores = K.max(box_scores, axis=-1) # Step 3: Create a filtering mask based on "box_class_scores" by using "threshold". The mask should have the # same dimension as box_class_scores, and be True for the boxes you want to keep (with probability >= threshold) filtering_mask = K.greater_equal(box_class_scores, threshold) # Step 4: Apply the mask to box_class_scores, boxes and box_classes scores = tf.boolean_mask(box_class_scores, filtering_mask) boxes = tf.boolean_mask(boxes, filtering_mask) classes = tf.boolean_mask(box_classes, filtering_mask) return scores, boxes, classes
def zeroing_function(orig_prediction_tensor): """Zeroes out predicted heating rate at top of profile. :param orig_prediction_tensor: Keras tensor with model predictions. :return: new_prediction_tensor: Same as input but with top heating rate zeroed out. """ num_outputs = orig_prediction_tensor.get_shape().as_list()[-1] zero_tensor = K.greater_equal( orig_prediction_tensor[..., top_heating_rate_index], 1e12) zero_tensor = K.cast(zero_tensor, dtype=K.floatx()) new_prediction_tensor = K.concatenate( (orig_prediction_tensor[..., :top_heating_rate_index], K.expand_dims(zero_tensor, axis=-1)), axis=-1) if top_heating_rate_index == num_outputs - 1: return new_prediction_tensor return K.concatenate( (new_prediction_tensor, orig_prediction_tensor[..., (top_heating_rate_index + 1):]), axis=-1)
def loss(y_true, y_pred): L = _categorical_crossentropy(target=y_true, output=y_pred, axis=axis, from_logits=from_logits) _epsilon = K.epsilon() y_true_p = K.argmax(y_true, axis=axis) y_pred_bin = K.cast(K.greater_equal(y_pred, threshold), K.dtype(y_true)) if from_logits else K.argmax( y_pred, axis=axis) y_pred_probs = y_preds if from_logits else K.max(y_pred, axis=axis) for c in range(classes): c_true = K.cast(K.equal(y_true_p, c), K.dtype(y_pred)) w = 1. / (K.sum(c_true) + _epsilon) C = K.sum(L * c_true * w) if c == 0 else C + K.sum(L * c_true * w) # Calc. FP Rate Correction c_false_p = K.cast(K.not_equal( y_true_p, c), K.dtype(y_pred)) * K.cast( K.equal(y_pred_bin, c), K.dtype(y_pred)) # Calculate false predictions gamma = 0.5 + (K.sum(K.abs((c_false_p * y_pred_probs) - 0.5)) / (K.sum(c_false_p) + _epsilon)) # Calculate Gamme wc = w * gamma # gamma / |Y+| C = C + K.sum(L * c_false_p * wc) # Add FP Correction return C
def accuracy_m(y_true, y_pred): y_true = K.round(y_true) y_pred = K.round(y_pred) correct_predictions = K.sum(K.cast(K.equal(y_true, y_pred), K.floatx())) all_instances = K.sum(K.cast(K.greater_equal(y_true, 0.), K.floatx())) accuracy = correct_predictions / all_instances return accuracy
def __call__(self, w): other_weights = K.cast(K.greater_equal(w, 0)[:-1], K.floatx()) last_weight = K.cast( K.equal(K.reshape(w[-1, :], (1, K.shape(w)[1])), 0.), K.floatx()) appended = K.concatenate([other_weights, last_weight], axis=0) w *= appended return w
def get_binary_sat_loss(state, state_pred): sat_threshold = 0.105 sat = K.expand_dims(state[:, :, :, 0], -1) sat_pred = K.expand_dims(state_pred[:, :, :, 0], -1) sat_bool = K.greater_equal(sat, sat_threshold) #will return boolean values sat_bin = K.cast(sat_bool, dtype=K.floatx()) #will convert bool to 0 and 1 sat_pred_bool = K.greater_equal(sat_pred, sat_threshold) #will return boolean values sat_pred_bin = K.cast(sat_pred_bool, dtype=K.floatx()) #will convert bool to 0 and 1 binary_loss = losses.binary_crossentropy(sat_bin, sat_pred_bin) return K.mean(binary_loss)
def dice_coef_for_softmax(y_true, y_pred, threshold=0.5): y_true_bi = K.cast(K.greater_equal(y_true, threshold), 'float32')[:, :, :, :4] y_pred_bi = K.cast(tf.one_hot(K.argmax(y_pred), tf.shape(y_pred)[-1]), 'float32')[:, :, :, :4] inter = K.sum(y_true_bi*y_pred_bi, axis=[1, 2]) union = K.sum(y_true_bi, axis=[1, 2]) + K.sum(y_pred_bi, axis=[1, 2]) dice_coef = (2.0*inter + K.epsilon()) / (union + K.epsilon()) return K.mean(dice_coef, axis=-1)
def simple_test(image_path): image = cv2.imread(image_path, cv2.IMREAD_COLOR) height = image.shape[1] width = image.shape[0] image = cv2.resize(image, (image_w,image_h)) image = image.reshape((1,image_w,image_h,3)) prediction = model.predict(image, batch_size=1) print(prediction.shape) # 1, 13, 13, 125 # Reshape it to 1,13,13,5,25 # 5 anchor boxes at every grid in 13 x 13 # 25 elements of reach anchorbox # probabiliity if an object is present, bx, by, w, h, 20 dim vector for each class p_resh = prediction.reshape(1, 13, 13, 5, 25) print(p_resh.shape) for box_i in range(5): box = p_resh[0][0][0][box_i] pc = box[0] c_scores = box[5:] res = pc * c_scores idx = np.argmax(res) p = class_dict[idx] print("Box No {} score {} box {},{},{},{} class {} ".format(box_i, res[idx], box[1],box[2],box[3],box[4], p)) box_confidence = p_resh[:,:,:,:,0] box_confidence = box_confidence.reshape(1,13,13,5,1) boxes = p_resh[:,:,:,:,1:5] boxes = boxes.reshape(1,13,13,5,4) box_class_prob = p_resh[:,:,:,:,5:] box_class_prob = box_class_prob.reshape(1,13,13,5,20) # Filter the boxes threshold = 0.6 box_scores = np.multiply(box_confidence, box_class_prob) print(box_scores.shape) box_class = K.argmax(box_scores, axis =-1) box_class_scores = K.max(box_scores, axis=-1) # Filtering mask filtering_mask = K.greater_equal(box_class_scores, threshold) with K.get_session() as test: scores = tf.boolean_mask(box_class_scores, filtering_mask).eval() boxes = tf.boolean_mask(boxes, filtering_mask).eval() classes = tf.boolean_mask(box_class, filtering_mask).eval() print(boxes.shape) print(classes.shape) print(scores.shape) max_boxes = 5 iou_threshold = 0.6 max_boxes_tensor = K.variable(max_boxes, dtype='int32') # tensor to be used in tf.image.non_max_suppression() test.run(tf.variables_initializer([max_boxes_tensor]))# initialize variable max_boxes_tensor # Use tf.image.non_max_suppression() to get the list of indices corresponding to boxes you keep nms_indices = tf.image.non_max_suppression(boxes, scores, max_boxes_tensor, iou_threshold=iou_threshold) scores = K.gather(scores, nms_indices).eval() boxes = K.gather(boxes, nms_indices).eval() classes = K.gather(classes, nms_indices).eval() print(boxes.shape) print(classes.shape) print(scores.shape) # scale the boxes image_dims = K.stack([height, width, height, width]) image_dims = K.reshape(image_dims, [1, 4]) boxes = boxes * image_dims print(boxes.eval())
def __call__(self, w): w *= K.cast(K.greater_equal(w, 0.), K.floatx()) # Ensure non-negativity return w / (K.epsilon() + K.sum(w, axis=0, keepdims=True)) # Ensure columns sum to 1