def __call__(self, current_model, data_pool=None, excluded_indexes=None, loss_function=None, n_classes=None, n_samples=10, batch_size=32): # check if data pool is empty or not. if data_pool is None and self.data_pool is None: raise AssertionError("data pool is empty!") data_pool_ = data_pool if data_pool is not None else self.data_pool if excluded_indexes is not None: excluded_indexes_ = excluded_indexes elif self.excluded_indexes is not None: excluded_indexes_ = self.excluded_indexes else: excluded_indexes_ = [] n_data_pool = len(list(data_pool)) candidates = [ i for i in range(0, n_data_pool) if i not in excluded_indexes_ ] x = tf.convert_to_tensor(data_pool_[candidates]) preds = current_model(x) sorted_preds = tf.sort(preds, axis=1, direction="DESCENDING") # compute margin margin = sorted_preds[:, 0] - sorted_preds[:, 1] indexes = heapq.nsmallest(n_samples, range(len(candidates)), margin.__getitem__) samples = data_pool_[indexes] return indexes, samples
def forward(Y, U, PI, mode='train', remove_diag=True): if mode == 'train': U = tf.gather(U, indices=np.where(labeledIndexes)[0], axis=0) Y = tf.gather(Y, indices=np.where(labeledIndexes)[0], axis=0) #F = tf.gather(F,indices=np.where(labeledIndexes)[0],axis=0) PI = tf.gather(PI, indices=np.where(labeledIndexes)[0], axis=0) pi_Y = spd_matmul(to_sp_diag(tf.abs(PI)), Y) alpha = get_alpha(MU) """ Maybe apply custom convolution to LAMBDA, otherwise just fit LGC's alpha using the corresponding filter 1/(1-alpha + alpha*lambda) """ if not self.custom_conv: lambda_tilde = tf.math.reciprocal(1 - alpha + alpha * LAMBDA) else: #lambda_tilde = tf.math.reciprocal(1-alpha + alpha*LAMBDA) _lambda = (LAMBDA - tf.reduce_mean(LAMBDA)) / tf.math.reduce_std(LAMBDA) lambda_tilde = tf.clip_by_value( 2 * tf.nn.sigmoid( tf.reshape(model(_lambda[None, :, None]), (-1, ))), 0, 1) lambda_tilde = tf.sort(lambda_tilde, direction='DESCENDING') lambda_tilde = tf.reshape(divide_by_row(lambda_tilde[None, :]), (-1, )) _self_infl = mult_each_row_by( tf.square(U), by=lambda_tilde ) #Square each element of U, then dot product of each row with lambda_tilde _self_infl = tf.reduce_sum(_self_infl, axis=1) _P_op = U @ (mult_each_col_by( (tf.transpose(U) @ pi_Y), by=lambda_tilde)) if not remove_diag: _diag_P_op = tf.zeros_like( mult_each_col_by(pi_Y, by=_self_infl)) else: _diag_P_op = mult_each_col_by(pi_Y, by=_self_infl) return divide_by_row(_P_op - _diag_P_op), lambda_tilde, pi_Y
def build_decoder(self): """ Builds the decoder network. The decoder network is the generative model mapping: [z,cond] to xhat """ # Input layer z_samp = tfkl.Input((self.nlatent, ), name='z') cond = tfkl.Input((self.ncond, ), name='cond') z_cond = tfkl.Concatenate(name='z_cond')([z_samp, cond]) # Hidden layers layer_names = [] h = z_cond for i in range(len(self.nunits_enc)): h = tfkl.Dense(self.nunits_enc[i], activation='sigmoid',\ bias_initializer=None, name='FC%d' % i)(h) layer_names.append('FC%d' % i) # Add the output mean with optional sorting x_mu = tfkl.Dense(self.ndat, name='x_mu',\ bias_initializer=None)(h) if self.sort_out: x_mu = tf.sort(x_mu, direction='DESCENDING', axis=-1) # Add the output variance. x_log_var = tfkl.Dense(self.ndat, name='x_log_var')(h) x_log_var = tf.maximum(x_log_var, np.log(self.out_var_min)) # Build the decoder self.decoder = tfkm.Model([z_samp, cond], [x_mu, x_log_var]) # Set the initialization set_initialization(self.decoder, layer_names,\ self.init_kernel_stddev, self.init_bias_stddev) # Build the decoder with sampling x_samp = self.reparm(x_mu, x_log_var) self.sampler = tfkm.Model([z_samp, cond], x_samp)
def calc_precision(qry_num, ref_num, reference_labels_idx, DistMatrix, labels, topK): precision = tf.constant(0, dtype=tf.float32) for qry_i in range(qry_num): qry_label = labels[qry_i] precision_one = tf.constant(0, dtype=tf.float32) buf = DistMatrix[qry_i] buf = tf.sort(buf, direction='DESCENDING') assert topK < ref_num, "ERROR:topk >= ref_num" threshold = buf[topK - 1] for k in range(len(reference_labels_idx[qry_label])): ref_idx = reference_labels_idx[qry_label][k] if DistMatrix[qry_i][ref_idx] > threshold: precision_one += 1 if precision_one > topK: precision_one = topK precision += precision_one / topK precision = precision / qry_num return precision
def call(self, y_true, norm_logits): pick_cond = tf.cast(y_true, dtype=tf.bool) y_pred_vals = norm_logits[pick_cond] theta = tf.acos(y_pred_vals) med_pos = tf.shape(norm_logits)[0] // 2 - 1 theta_med = tf.sort(theta)[med_pos] B_avg = tf.where(pick_cond, tf.zeros_like(norm_logits), tf.exp(self.scale * norm_logits)) B_avg = tf.reduce_mean(tf.reduce_sum(B_avg, axis=1)) self.scale.assign( tf.math.log(B_avg) / tf.cos(tf.minimum(self.theta_med_max, theta_med))) tf.print(", scale =", self.scale, ", theta_med =", theta_med, end="") arcface_logits = norm_logits * self.scale return tf.keras.losses.categorical_crossentropy( y_true, arcface_logits, from_logits=self.from_logits, label_smoothing=self.label_smoothing)
def nucleus_sampling(logits, p=0.9): sorted_logits = tf.sort(logits, direction='DESCENDING') sorted_indices = tf.argsort(logits, direction='DESCENDING') cumulative_probs = tf.cumsum(tf.nn.softmax(sorted_logits)) t_sorted_indices_to_remove = cumulative_probs > p ''' Shift the indices to the right to keep also the first token above the threshold ''' indices = tf.range(1, tf.shape(logits)[0], 1) sorted_indices_to_remove = tf.scatter_nd(tf.expand_dims(indices, 1), t_sorted_indices_to_remove[:-1], logits.shape) # indices_to_remove = tf.boolean_mask(sorted_indices, sorted_indices_to_remove) # t = tf.ones(tf.shape(indices_to_remove)[0], dtype=tf.bool) # to_remove = tf.scatter_nd(indices_to_remove, t, logits.shape) logits = tf.where(sorted_indices_to_remove, tf.ones_like(logits, dtype=logits.dtype) * -1e10, logits) logits = tf.reshape(logits, (h_parms.batch_size, -1)) sample = tf.random.categorical(logits, num_samples=1, dtype=tf.int32, seed=1) return sample
def make_reg_label(label, patch_pos, patch_size): ''' Return absolute distance from the middle of the patch to the closest threshhold between labels ''' label = tf.sort(label, direction='DESCENDING') reg_label_=[] threshold_=[] for idx in range(config['body_identification_n_classes'] - 1): threshold_.append( (label[idx] + label[idx + 1]) / 2) threshold= tf.stack(threshold_,axis=0) for idx in range(patch_pos.shape[0]): temp = tf.abs(threshold - patch_pos[idx][2] - patch_size[2] / 2) reg_label_.append([tf.reduce_min(temp)]) reg_label = tf.stack(reg_label_, axis=0) return reg_label
def mutual_information_gap_batch_estimate(labels, samples, encoding_dist, *encoding_parameters): """Estimates mutual information gap (MIG) 1/K sum_{k=1}^K 1/H(v_k) (I(z_j[k]; v_k) - max_{j !=j[k]} I(z_j;v_k)) Args: labels: Factor values for samples ∊ ℝ (N, D) samples: z ∼ q(z|x) ∊ ℝ (N, D) encoding_dist: q(z|x) *encoding_parameters: list of parameters ∊ ℝ [N] Returns: (tf.Tensor) ∊ ℝ [] """ # I_n(z_j; v_k) = (H(z_j) - H(z_j | v_k)) / H(v_k) ∊ ℝ [D, K] nmi = normalized_mutual_information(labels, samples, encoding_dist, *encoding_parameters) nmi = tf.sort(nmi, axis=0, direction="DESCENDING") # ∊ ℝ [K] mig = nmi[0, :] - nmi[1, :] return tf.reduce_mean(mig)
def flat_perc(logits, p): sps = tf.sort(tf.nn.softmax(logits, axis=1), direction='DESCENDING', axis=1) indices = tf.argsort(logits, direction='DESCENDING', axis=1) tail_ids = tf.cast( sps.shape[1].value - tf.argmax(tf.cast(tf.greater(tf.reverse(sps, axis=[1]), p), tf.int8), axis=1), tf.int32) logit_inds = tf.stack([tf.range(0, logits.shape[0].value), tail_ids], axis=1) tail_min_vals = tf.expand_dims(tf.gather_nd(logits, logit_inds), 1) return tf.where( logits < tail_min_vals, # if it is worse than this lower bound. I can do this for my ones too! does it for each batch simultaneously. tf.ones_like(logits, dtype=logits.dtype) * -1e10, logits, ) '''while_condition = lambda i, logits_to_return: tf.less(i, logits.shape[0].value)
def top_p_logits(logits, p): """Nucleus sampling""" batch, _ = logits.shape.as_list() sorted_logits = tf.sort(logits, direction='DESCENDING', axis=-1) cumulative_probs = tf.cumsum(tf.nn.softmax(sorted_logits, axis=-1), axis=-1) indices = tf.stack( [ tf.range(0, batch), # number of indices to include tf.maximum( tf.reduce_sum(tf.cast(cumulative_probs <= p, tf.int32), axis=-1) - 1, 0), ], axis=-1) min_values = tf.gather_nd(sorted_logits, indices) return tf.where( logits < min_values, tf.ones_like(logits) * -1e10, logits, )
def compare_with_tensorflow(device_type, in_shape, axis, direction, data_type): assert device_type in ["gpu", "cpu"] assert data_type in ["float32", "double", "int8", "int32", "int64"] flow.clear_default_session() func_config = flow.FunctionConfig() func_config.default_logical_view(flow.scope.mirrored_view()) func_config.default_data_type(flow.float) @flow.global_function(function_config=func_config) def SortJob(input: oft.ListNumpy.Placeholder( tuple([dim + 10 for dim in in_shape]), dtype=type_name_to_flow_type[data_type], )): with flow.scope.placement(device_type, "0:0"): return flow.sort(input, axis, direction) input = (np.random.random(in_shape) * 100).astype( type_name_to_np_type[data_type]) of_out = SortJob([input]).get().numpy_list()[0] tf_out = tf.sort(input, axis, direction) assert np.array_equal(of_out, tf_out.numpy())
def predict(mode): PREDS = [] CONFS = [] NUM_SELECT = 10 batch_size = 320 for batch_id, X in enumerate(batch_generator(mode,batch_size=batch_size,loop=False)): x = X[0] print("Predicting {} - Batch {}".format(mode,batch_id)) pred = model.predict_on_batch(x) if batch_id == 0: print(pred) PREDS.append(tf.argsort(pred,axis=-1)[:,-NUM_SELECT:]) CONFS.append(tf.sort(pred,axis=-1)[:,-NUM_SELECT:]) PREDS = np.concatenate(PREDS,axis=0) CONFS = np.concatenate(CONFS,axis=0) PREDS = np.concatenate([PREDS,CONFS],axis=1) cols = ['pred_{}'.format(k) for k in range(NUM_SELECT)] + \ ['conf_{}'.format(k) for k in range(NUM_SELECT)] fname = os.path.join(DATA_DIR,'dom_pred_{}.csv'.format(mode)) pd.DataFrame(PREDS,index=range(PREDS.shape[0]),columns=cols).to_csv(fname)
def fit(self, X, y): X = tf.convert_to_tensor(X, tf.float32) y = tf.convert_to_tensor(y, tf.int32) classes = tf.sort(tf.unique(y).y) if self.n_components is None: self.n_components = classes.shape[0] - 1 means = [] for i in classes: Xg = X[y == i] means.append(tf.reduce_mean(Xg, axis=0)) self.means = tf.stack(means, axis=0) # [cls, d] eigvals, eigvecs = linear_discriminative_eigvals(y, X, self.lambda_val, ret_vecs=True) eigvecs = tf.reverse(eigvecs, axis=[1]) # [d, cls] eigvecs = eigvecs / tf.linalg.norm(eigvecs, axis=0, keepdims=True) # [d, cls] self.scaling = eigvecs.numpy() self.coef = tf.matmul(tf.matmul(self.means, eigvecs), tf.transpose(eigvecs, (1, 0))) # [cls, d] self.intercept = -0.5 * tf.linalg.diag_part( tf.matmul(self.means, tf.transpose(self.coef, (1, 0)))) # [cls] self.coef = self.coef.numpy() self.intercept = self.intercept.numpy() eigvals = eigvals.numpy() if self.verbose: top_k_evals = eigvals[-self.n_components + 1:] self.logger( "\nLDA-Eigenvalues:", np.array_str(top_k_evals, precision=2, suppress_small=True)) self.logger( "Eigenvalues Ratio min/max: %.3f, Mean: %.3f" % (top_k_evals.min() / top_k_evals.max(), top_k_evals.mean())) return eigvals
def labelstr2onehot(labelstr, class_list): """One-hot label encoding labelstr: label, encoded as 'id1#...#idN', where idn is an int class_list: list of classes used as the reference for the one hot encoding """ # parse string labels = tf.cond(tf.equal(tf.strings.length(labelstr), 0), true_fn=lambda: tf.constant([], dtype=tf.int32), false_fn=lambda: tf.strings.to_number( tf.strings.split(labelstr, '#'), out_type=tf.int32)) # sort class_list and get indices of labels in class_list class_list = tf.sort(class_list) labels = tf.where(tf.equal(tf.expand_dims(labels, axis=1), class_list))[:, 1] return tf.cond(tf.equal(tf.size(labels), 0), true_fn=lambda: tf.zeros(tf.size(class_list)), false_fn=lambda: tf.reduce_max( tf.one_hot(labels, tf.size(class_list)), 0))
def topp_topk(logits, p, k): sorted_logits = tf.sort(logits, direction='DESCENDING') sorted_indices = tf.argsort(logits, direction='DESCENDING') cumulative_probs = tf.cumsum(tf.nn.softmax(sorted_logits)) t_sorted_indices_to_remove = cumulative_probs > p ''' Shift the indices to the right to keep also the first token above the threshold ''' indices = tf.range(1, tf.shape(logits)[0], 1) sorted_indices_to_remove = tf.scatter_nd(tf.expand_dims(indices, 1), t_sorted_indices_to_remove[:-1], logits.shape) logits = tf.where(sorted_indices_to_remove, tf.ones_like(logits, dtype=logits.dtype) * -1e10, logits) values, _ = tf.nn.top_k(logits, k=k) min_value = tf.reduce_min(values) logits = tf.where(logits < min_value, tf.ones_like(logits, dtype=logits.dtype) * -1e10, logits) logits = tf.reshape(logits, (h_parms.validation_batch_size, -1)) sample = tf.random.categorical(logits, num_samples=1, dtype=tf.int32, seed=1) return sample
def _tag_filter(features_dict, tags, which_tags=None): ''' Removes unwanted tids from the dataset based on given tags (use with tf.data.Dataset.filter). Parameters ---------- features_dict: dict Dict of features (as provided by .filter). tags: list or list-like List containing tag idxs (as int) to be "allowed" in the output dataset. which_tags: int If not None, specifies the database to filter on (when multiple databases are provided). ''' tags = tf.dtypes.cast(tags, dtype=tf.int64) if which_tags is None: dict_key = 'tags' else: assert isinstance(which_tags, int), 'which_tags must be an integer' dict_key = 'tags_' + str(which_tags) num_tags = tf.cast(tf.shape(features_dict[dict_key]), tf.int64) feature_tags = tf.math.equal( tf.unstack(features_dict[dict_key]), tf.constant(1, dtype=tf.int64) ) # bool tensor where True/False correspond to has/doesn't have tag idxs = tf.subtract(tf.reshape(tf.sort(tags), [-1, 1]), tf.constant(1, dtype=tf.int64)) vals = tf.constant(1, dtype=tf.int64, shape=tags.get_shape()) tags_mask = tf.SparseTensor(indices=idxs, values=vals, dense_shape=num_tags) tags_mask = tf.sparse.to_dense(tags_mask) tags_mask = tf.dtypes.cast(tags_mask, tf.bool) return tf.math.reduce_any( feature_tags & tags_mask ) # returns True if and only if at least one feature tag is in the desired 'tags' list
def split_latents(x, minibatch_size, hy_ncut=1): # x: [b, dim] b = minibatch_size dim = x.get_shape().as_list()[1] split_idx = tf.random.uniform(shape=[b, hy_ncut], maxval=dim + 1, dtype=tf.int32) split_idx = tf.sort(split_idx, axis=-1) idx_range = tf.tile(tf.range(dim)[tf.newaxis, :], [b, 1]) masks = [] mask_last = tf.zeros([b, dim], dtype=tf.float32) for i in range(hy_ncut): mask_tmp = tf.cast(idx_range < split_idx[:, i:i + 1], tf.float32) masks.append(mask_tmp - mask_last) masks_last = mask_tmp mask_tmp = tf.cast(idx_range < split_idx[:, -1:], tf.float32) masks.append(1. - mask_tmp) x_split_ls = [x * mask for mask in masks] # mask_1 = tf.cast(idx_range < split_idx[:, tf.newaxis], tf.float32) # mask_2 = 1. - mask_1 # return x * mask_1, x * mask_2 return x_split_ls
def ohem_single(score, gt_text, training_mask): pos_num = int(tf.math.reduce_sum(tf.cast( gt_text > 0.5, dtype=tf.float32))) - int( tf.math.reduce_sum( tf.cast( (gt_text > 0.5) & (training_mask <= 0.5), dtype=tf.float32))) if pos_num == 0: # selected_mask = gt_text.copy() * 0 # may be not good selected_mask = training_mask selected_mask = tf.cast( tf.reshape(selected_mask, [selected_mask.shape[0], selected_mask.shape[1], 1]), dtype=tf.float32) return selected_mask neg_num = int(tf.math.reduce_sum(tf.cast(gt_text <= 0.5, dtype=tf.float32))) neg_num = int(min(pos_num * 3, neg_num)) if neg_num == 0: selected_mask = training_mask selected_mask = tf.cast( tf.reshape(selected_mask, [selected_mask.shape[0], selected_mask.shape[1], 1]), dtype=tf.float32) return selected_mask neg_score = score[gt_text <= 0.5] neg_score_sorted = tf.sort(-neg_score) threshold = -neg_score_sorted[neg_num - 1] selected_mask = ((score >= threshold) | (gt_text > 0.5)) & (training_mask > 0.5) selected_mask = tf.cast(tf.reshape( selected_mask, [selected_mask.shape[0], selected_mask.shape[1], 1]), dtype=tf.float32) return selected_mask
def gaussian_mixture_wasserstein_loss(x, pi, mu, var, order): # Sort input data for computing alignment with Gaussian mixture. x = tf.sort(x) nx = x.shape[0] # Calculate variances of the distributions. prec = 1. / var # Split Gaussian mixture distribution into N parts to compute transportation cost. # It also computes the split point between right-facing transporation and left-facing transportation # to compute 1-Wasserstein integral properly. ratio = tf.cast(tf.linspace(1. / nx, 1 - 1. / nx, nx - 1), tf.float64) partition = gaussian_mixture_cdfinv(ratio, pi, mu, var) partition_left = tf.concat([[-1e+10], partition], axis=0) partition_right = tf.concat([partition, [1e+10]], axis=0) partition_mid = tf.minimum(tf.maximum(partition_left, x), partition_right) # Change of variables, for later integrals integral_left = (partition_left[:, None] - mu[None, :]) * tf.sqrt(.5 * prec)[None, :] integral_mid = (partition_mid[:, None] - mu[None, :]) * tf.sqrt(.5 * prec)[None, :] integral_right = (partition_right[:, None] - mu[None, :]) * tf.sqrt(.5 * prec)[None, :] if (order == 1): loss_left = (x[:, None] - mu[None, :]) * integrate_emx2(integral_left, integral_mid) loss_left -= 1. / tf.sqrt(.5 * prec[None, :]) * integrate_xemx2(integral_left, integral_mid) loss_left *= tf.cast(1. / tf.sqrt(np.pi), tf.float64) loss_right = 1. / tf.sqrt(.5 * prec[None, :]) * integrate_xemx2(integral_mid, integral_right) loss_right -= (x[:, None] - mu[None, :]) * integrate_emx2(integral_mid, integral_right) loss_right *= tf.cast(1. / tf.sqrt(np.pi), tf.float64) return pi[None, :] * (loss_left + loss_right) elif (order == 2): diff = x[:, None] - mu[None, :] loss = (diff * diff) * integrate_emx2(integral_left, integral_right) loss -= 2 * diff / tf.sqrt(.5 * prec[None, :]) * integrate_xemx2(integral_left, integral_right) loss += 1. / (.5 * prec[None, :]) * integrate_x2emx2(integral_left, integral_right) loss *= tf.cast(1. / tf.sqrt(np.pi), tf.float64) return pi[None, :] * loss else: assert False
def compute_conf(): batch = self.mini_buffer.get_random_batch(num_exps) [states, meta_actions, next_states] = batch [predicted_alphas, predicted_thetas] = self.completion(states, meta_actions) [actual_alphas, actual_thetas] = self.inv_completion(states, meta_actions, next_states) for i in range(num_exps): batch[i].append([predicted_alphas, predicted_thetas]) batch[i].append([actual_alphas, actual_thetas]) batch[i].append(tf.norm(states[i] - state, ord=2)) sorted_batch = tf.sort(batch) # sorts according to last axis weight_base = (num_exps + num_exps**2) / 2 for i in range(num_exps): [predicted_alpha, predicted_theta] = sorted_batch[i][-3] [actual_alpha, actual_theta] = sorted_batch[i][-2] conf += (tf.square(predicted_alpha - actual_alpha) + tf.square(predicted_theta - actual_theta)) / weight_base * i return conf
def balanced_sample_weight(labels, maxlen): # Sort labels = tf.sort(labels, axis=-1, direction='DESCENDING') # Reduce each label combination to unique sequence def reduce_concat(input, maxlen): maxlen = input.shape[-1] if maxlen is None else maxlen dec = 10**tf.range(maxlen - 1, -1, -1) return tf.reduce_sum(input * dec, axis=-1) labels = reduce_concat(labels, maxlen) # Identify unique label combinations, idx, and counts y, idx, count = tf.unique_with_counts(labels) # Calculate class weights total_count = tf.size(labels) label_count = tf.size(y) calc_weight = lambda x: tf.divide(tf.divide(total_count, x), tf.cast(label_count, tf.float64)) class_weights = tf.map_fn(fn=calc_weight, elems=count, dtype=tf.float64) # Gather sample weights sample_weights = tf.gather(class_weights, idx) return tf.cast(sample_weights, tf.float32)
def __get_dlr_target(self, logits, y_input, y_target): """ Private function Get targeted version of DLR loss Args: logit: (tf_tensor) Logits y_input: (tf_tensor) Input label y_target: (tf_tensor) Input targeted label Returns: loss: (tf_tensor) Targeted DLR loss """ x = logits x_sort = tf.sort(x, axis=1) y_onehot = tf.one_hot(y_input, self.num_classes) y_target_onehot = tf.one_hot(y_target, self.num_classes) loss = -(tf.reduce_sum(x * y_onehot, axis=1) - tf.reduce_sum( x * y_target_onehot, axis=1)) / (x_sort[:, -1] - .5 * x_sort[:, -3] - .5 * x_sort[:, -4] + 1e-12) return loss
def get_move(self, state): """Runs all playouts sequentially and returns the most visited action. state: the current game state Return: the selected action """ x = tf.placeholder(tf.int32, [None]) y = tf.sort(x, direction='DESCENDING', axis=0) with tf.Session() as sess: for n in range(self._n_playout): # to prevent killed by ITP if state._ef_for_eight > 0: a = sess.run(y, feed_dict={ x: np.random.randint(100, size=(100000)) }).shape state_copy = copy.deepcopy(state) self._playout(state_copy) return max(self._root._children.items(), key=lambda act_node: act_node[1]._n_visits)[0]
def call(self, x, mask=None): avg_atten = self.calc_avg_atten(self.atten, 12) attended_by = self.atten_col(avg_atten) attended_by = attended_by[:, 1:] indices = tf.cast(tf.math.top_k(attended_by, k=self.index - 1, sorted=True).indices, dtype=tf.int32) indices = tf.expand_dims(tf.add(indices, tf.constant([1], dtype=tf.int32)), axis=-1) CLS_SEP = tf.broadcast_to( tf.constant([0], dtype=tf.int32), shape=[tf.shape(x, out_type=tf.dtypes.int32)[0], 1]) indices_CLS_SEP = tf.concat( [indices, tf.expand_dims(CLS_SEP, axis=-1)], axis=1) indices_CLS_SEP = tf.sort(indices_CLS_SEP, axis=1, direction='ASCENDING') extract_layer = tf.gather_nd(x, indices_CLS_SEP, batch_dims=1) return extract_layer
def hard_negative_mining(loss, anchors_tag, negatives_per_positive, min_negatives_per_image): """ 困难负样本挖掘 :param loss: [num_anchors] :param anchors_tag: [num_anchors] 1:正样本,-1:负样本,0: ignore :param negatives_per_positive: :param min_negatives_per_image: :return: """ positive_loss = tf.gather_nd(loss, tf.where(tf.equal(anchors_tag, 1.))) negative_loss = tf.gather_nd(loss, tf.where(tf.equal(anchors_tag, -1.))) num_positives = tf.size(positive_loss) num_negatives = tf.maximum(num_positives * negatives_per_positive, min_negatives_per_image) negative_loss = tf.sort(negative_loss, axis=0, direction='DESCENDING') negative_loss = negative_loss[:num_negatives] total_loss = tf.concat([positive_loss, negative_loss], axis=0) return [tf.reduce_sum(total_loss), tf.cast(num_positives, tf.float32)]
def call(self,x,training=True): predictions = [] args_predictions = [] for feature_map in x: b,h,w,c = feature_map.shape feature_map = tf.reshape(feature_map,(b,-1,c)) # normalize the feature maps to make the distance #feature_map,_ = tf.linalg.normalize(feature_map,axis=-1) # http://www.robots.ox.ac.uk/~albanie/notes/Euclidean_distance_trick.pdf G = tf.einsum('bik, bjk->bij', feature_map, feature_map) D = tf.reshape(tf.linalg.diag_part(G),(b,-1,1))+ tf.transpose(tf.reshape(tf.linalg.diag_part(G),(b,-1,1)),perm=(0,2,1)) - 2*G D = tf.keras.activations.relu(D) # It is possible to get negative values in the matrix due to a lack of floating point precision D = D+self.epsilon #any zero values in the distance matrix will produce infinite gradients norms = tf.sqrt(D) prediction = tf.sort(norms,axis=-1) arg_prediction = tf.argsort(norms,axis=-1)[:,:,1] prediction = tf.where((prediction[:,:,1] / prediction[:,:,2] < self.Tl), 2/(1+tf.exp(prediction[:,:,1])),2/(1+self.l*tf.exp(prediction[:,:,1]))) prediction = tf.reshape(prediction,(b,h,w,1)) predictions.append(prediction) arg_prediction = tf.reshape(arg_prediction,(b,h,w,1)) args_predictions.append(arg_prediction) return predictions,args_predictions
def sample(self, time, outputs, state, name=None): """sample for SampleEmbeddingHelper.""" del time, state # unused by sample_fn # Outputs are logits, we sample instead of argmax (greedy). if not isinstance(outputs, ops.Tensor): raise TypeError("Expected outputs to be a single Tensor, got: %s" % type(outputs)) logits_sort = tf.sort(outputs, direction='DESCENDING') probs_sort = tf.nn.softmax(logits_sort) probs_sort_sum = tf.cumsum(probs_sort, axis=1, exclusive=True) logits_sort_masked = tf.where( probs_sort_sum < self._top_p, logits_sort, tf.ones_like(outputs, dtype=outputs.dtype) * 1e10) min_logits = tf.reduce_min(logits_sort_masked, axis=1, keep_dims=True) sample_logits = tf.where( outputs < min_logits, tf.ones_like(outputs, dtype=outputs.dtype) * -1e10, outputs) sample_ids = tf.multinomial(sample_logits, num_samples=1, output_dtype=tf.int32) sample_ids = tf.squeeze(sample_ids, axis=1) return sample_ids
def Compute_LeftPoint(self, c1, UU, LL, n): #print('<<<<<<<<<<<<') c1_sort = tf.sort(c1, direction='ASCENDING') c1_index = tf.argsort(c1, direction='ASCENDING') #print('c1_index,UU,LL',c1_index,UU,LL) UU_sort = tf.gather(UU, c1_index) #print('*****************',UU,c1_index) LL_sort = tf.gather(LL, c1_index) l_out = 0 s = 0 s1 = 0 b2 = c1_sort #print('<<<<<<<<<<<<') s = tf.reduce_sum(tf.multiply(b2, LL_sort)) s1 = tf.reduce_sum(LL_sort) + 0.0000001 l_out = s / s1 for i in range(n): s += b2[i] * (UU_sort[i] - LL_sort[i]) s1 += UU_sort[i] - LL_sort[i] l_out = tf.minimum(l_out, s / s1) return l_out
def greedy_update_margins(self, y_true, y_pred): # instabilities during learning if self.perc is None: return margin_other, y_true = self.preprocess_margins(y_true, y_pred) new_margins = [] for cl in range(self.depth): selected = tf.boolean_mask(margin_other, y_true == cl) batch_size = tf.cast(tf.shape(selected), dtype=tf.float32) idx = tf.cast(self.perc * batch_size, dtype=tf.int64) emp_perc = tf.gather(tf.sort(selected), idx) emp_std = tf.math.reduce_std(selected) emp_mean = tf.reduce_mean(selected) th_perc = emp_std * (2**0.5) * tf.math.erfinv(2 * self.perc / 100 - 1) + emp_mean perc = emp_perc * ( 1 - self.gaussian_prior) + th_perc * self.gaussian_prior new_margins.append(perc) grad = tf.stack(new_margins, axis=1) update = (1 - self.lr) * self.margins + self.lr * grad update = tf.maximum(update, self.min_margin) self.margins.assign(update)
def calc_ignore_mask(self, true_obj, true_box, pred_box): # YOLOv3: # "If the bounding box prior is not the best but does overlap a ground # truth object by more than some threshold we ignore the prediction, # following [17]. We use the threshold of .5." # calculate the iou for each pair of pred bbox and true bbox, then find the best among them # (None, 13, 13, 3, 4) true_box_shape = tf.shape(true_box) # (None, 13, 13, 3, 4) pred_box_shape = tf.shape(pred_box) # (None, 507, 4) true_box = tf.reshape(true_box, [true_box_shape[0], -1, 4]) # sort true_box to have non-zero boxes rank first true_box = tf.sort(true_box, axis=1, direction="DESCENDING") # (None, 100, 4) # only use maximum 100 boxes per groundtruth to calcualte IOU, otherwise # GPU emory comsumption would explode for a matrix like (16, 52*52*3, 52*52*3, 4) true_box = true_box[:, 0:100, :] # (None, 507, 4) pred_box = tf.reshape(pred_box, [pred_box_shape[0], -1, 4]) # https://github.com/dmlc/gluon-cv/blob/06bb7ec2044cdf3f433721be9362ab84b02c5a90/gluoncv/model_zoo/yolo/yolo_target.py#L198 # (None, 507, 507) iou = broadcast_iou(pred_box, true_box) # (None, 507) best_iou = tf.reduce_max(iou, axis=-1) # (None, 13, 13, 3) best_iou = tf.reshape(best_iou, [ pred_box_shape[0], pred_box_shape[1], pred_box_shape[2], pred_box_shape[3] ]) # ignore_mask = 1 => don't ignore # ignore_mask = 0 => should ignore ignore_mask = tf.cast(best_iou < self.ignore_thresh, tf.float32) # (None, 13, 13, 3, 1) ignore_mask = tf.expand_dims(ignore_mask, axis=-1) return ignore_mask