def AddMax(inputs): xmax = K.max(inputs, axis=1, keepdims=True) xmin = K.min(inputs, axis=1, keepdims=True) xlocmax = K.expand_dims(K.cast_to_floatx(K.argmax(inputs, axis=1))) xlocmin = K.expand_dims(K.cast_to_floatx(K.argmin(inputs, axis=1))) output = K.concatenate([inputs, xmax, xmin, xlocmax, xlocmin], axis=1) return output
def _process_channel(args): __kps, __hm_hp = args thresh = 0.1 __hm_scores, __hm_inds = tf.math.top_k(__hm_hp, k=k, sorted=True) __hm_xs = K.cast(__hm_inds % width, 'float32') __hm_ys = K.cast(K.cast(__hm_inds / width, 'int32'), 'float32') __hp_offset = K.gather(_hp_offset, __hm_inds) __hm_xs = __hm_xs + __hp_offset[..., 0] __hm_ys = __hm_ys + __hp_offset[..., 1] mask = K.cast(__hm_scores > thresh, 'float32') __hm_scores = (1. - mask) * -1. + mask * __hm_scores __hm_xs = (1. - mask) * -10000. + mask * __hm_xs __hm_ys = (1. - mask) * -10000. + mask * __hm_ys __hm_kps = K.stack([__hm_xs, __hm_ys], -1) # k x 2 __broadcast_hm_kps = K.expand_dims(__hm_kps, 1) # k x 1 x 2 __broadcast_kps = K.expand_dims(__kps, 0) # 1 x k x 2 dist = K.sqrt( K.sum(K.pow(__broadcast_kps - __broadcast_hm_kps, 2), 2)) # k, k min_dist = K.min(dist, 0) min_ind = K.argmin(dist, 0) __hm_scores = K.gather(__hm_scores, min_ind) __hm_kps = K.gather(__hm_kps, min_ind) mask = (K.cast(__hm_kps[..., 0] < _x1, 'float32') + K.cast(__hm_kps[..., 0] > _x2, 'float32') + K.cast(__hm_kps[..., 1] < _y1, 'float32') + K.cast(__hm_kps[..., 1] > _y2, 'float32') + K.cast(__hm_scores < thresh, 'float32') + K.cast( min_dist > 0.3 * (K.maximum(_wh[..., 0], _wh[..., 1])), 'float32')) mask = K.expand_dims(mask, -1) mask = K.cast(mask > 0, 'float32') __kps = (1. - mask) * __hm_kps + mask * __kps return __kps
def step(self, input_energy_t, states, return_logZ=True): # not in the following `prev_target_val` has shape = (B, F) # where B = batch_size, F = output feature dim # Note: `i` is of float32, due to the behavior of `K.rnn` prev_target_val, i, chain_energy = states[:3] t = K.cast(i[0, 0], dtype='int32') if len(states) > 3: if K.backend() == 'theano': m = states[3][:, t:(t + 2)] else: m = K.slice(states[3], [0, t], [-1, 2]) input_energy_t = input_energy_t * K.expand_dims(m[:, 0]) # (1, F, F)*(B, 1, 1) -> (B, F, F) chain_energy = chain_energy * K.expand_dims( K.expand_dims(m[:, 0] * m[:, 1])) if return_logZ: # shapes: (1, B, F) + (B, F, 1) -> (B, F, F) energy = chain_energy + K.expand_dims( input_energy_t - prev_target_val, 2) new_target_val = K.logsumexp(-energy, 1) # shapes: (B, F) return new_target_val, [new_target_val, i + 1] else: energy = chain_energy + K.expand_dims( input_energy_t + prev_target_val, 2) min_energy = K.min(energy, 1) # cast for tf-version `K.rnn argmin_table = K.cast(K.argmin(energy, 1), K.floatx()) return argmin_table, [min_energy, i + 1]
def update_state(self, y_true, y_pred, sample_weight=None): row = tf.range(0, tf.shape(y_true)[0], dtype=tf.int64) col = k.argmin(y_pred, axis=1) pred_val = tf.gather_nd(y_true, tf.stack([row, col], axis=1)) values = pred_val - k.min(y_true, axis=1) # tf.print(tf.gather(y_true,0), tf.gather(y_pred,0), tf.gather(pred_val,0),k.min(y_true, axis=1), values, sep='\n') return super(DBM, self).update_state(values, sample_weight=sample_weight)
def payoff_Eq_MSE(game, pureStrategies_perPlayer, nashEq_true, nashEq_pred, computePayoff_function, num_players): """ Function to compute the the mean square error of equilibria and the mean square error of payoffs resulted from the associated equilibria. This is not a loss function. It is used by other loss functions to compute their final loss values. """ # Compute error error = nashEq_true - nashEq_pred # Compute the weight for the final result to recompense the replacement of nans with zeros and its effect # on the averaging nan_count = tf.reduce_sum( tf.cast(tf.math.is_nan(nashEq_true[0][0]), tf.int32)) eq_n_elements = tf.size(nashEq_true[0][0]) compensation_factor = tf.cast(eq_n_elements / (eq_n_elements - nan_count), tf.float32) # Replace nan values with 0 error = tf.where(tf.math.is_nan(error), tf.zeros_like(error), error) # Computing the minimum of mean of squared error (MSE) of nash equilibria MSE_eq = K.mean(K.square(error), axis=[2, 3]) min_index = K.argmin(MSE_eq, axis=1) loss_Eq_MSE = tf.gather_nd( MSE_eq, tf.stack( (tf.range(0, tf.shape(min_index)[0]), tf.cast(min_index, dtype='int32')), axis=1)) loss_Eq_MSE *= compensation_factor # Computing the payoffs given the selected output for each sample in the batch selected_trueNash = tf.gather_nd( nashEq_true, tf.stack( (tf.range(0, tf.shape(min_index)[0]), tf.cast(min_index, dtype='int32')), axis=1)) payoff_true = computePayoff_function['computePayoff']( game, selected_trueNash, pureStrategies_perPlayer, num_players) payoff_pred = computePayoff_function['computePayoff']( game, tf.gather(nashEq_pred, 0, axis=1), pureStrategies_perPlayer, num_players) # Computing the mean squared error (MSE) of payoffs loss_payoff_MSE = K.mean(K.square(payoff_true - payoff_pred), axis=1) return loss_Eq_MSE, loss_payoff_MSE
def chamfer_loss(ref, targ, return_argmin=False): nr = ref.shape[0] nt = targ.shape[0] r = tf.tile(ref, [nt, 1]) r = tf.reshape(r, [nt, nr, 3]) t = tf.tile(targ, [1, nr]) t = tf.reshape(t, [nt, nr, 3]) dist = K.sum(K.square(r - t), axis=2) if (return_argmin == True): closest = K.argmin(dist, axis=0) loss = (K.mean(K.min(dist, axis=1)) + K.mean(K.min(dist, axis=0))) / 2 return loss, closest else: return (K.mean(K.min(dist, axis=1)) + K.mean(K.min(dist, axis=0))) / 2
def call(self, inputs): inputs = K.expand_dims(inputs, -1) distance = (inputs - K.expand_dims(self.evaluate_table, 0))**2 idx = K.argmin(distance, axis=-2) takecare = tf.nn.embedding_lookup(self.takecare_table, idx) idx_clip = tf.clip_by_value(idx, self.idx_min, self.idx_max) idx_table = idx_clip + K.expand_dims(self.idx_table, 0) evaluate = tf.nn.embedding_lookup(self.evaluate_table, idx_table) vector = tf.nn.embedding_lookup(self.vector_table, idx_table) score = (inputs - evaluate)**2 score = score * -1.0 * takecare score = tf.nn.softmax(score, axis=-2) outputs = vector * score outputs = tf.math.reduce_sum(outputs, axis=-2) return outputs
def triplet_hard_loss(y_true, y_pred, margin = 0.3): label_shape = K.int_shape(y_true) print('label shape: ', label_shape) batch_size = label_shape[0] print('batch size: ', batch_size) print('y_true dim number', K.ndim(y_true)) assert K.ndim(y_true) == 2, 'triplet hard loss label should be one-dim tensor' #anchor = K.l2_normalize(y_pred, axis=1) anchor = y_pred similarity_matrix = K.dot(anchor, K.transpose(anchor)) similarity_matrix = K.clip(similarity_matrix, 0.0, 1.0) row2mat = K.repeat_elements(y_true, rep=batch_size, axis=1) col2mat = K.repeat_elements(K.transpose(y_true), rep=batch_size, axis=0) gt_matrix = K.cast(K.equal(row2mat, col2mat), 'float') positive_ind = K.argmin(similarity_matrix + 99. * (1 - gt_matrix), axis=1) negative_ind = K.argmax(similarity_matrix - 99 * gt_matrix, axis=1) positive = K.gather(anchor, positive_ind) negative = K.gather(anchor, negative_ind) pos_anchor_dist = K.sum(K.square(positive-anchor), axis=1) neg_anchor_dist = K.sum(K.square(negative-anchor), axis=1) basic_loss = pos_anchor_dist - neg_anchor_dist + margin loss = K.maximum(basic_loss, 0.0) return loss
def delta_equilibrium(game, pureStrategies_perPlayer, nashEq_true, nashEq_pred, computePayoff_function, num_players): """ Function to compute the delta (regret of not playing equilibrium strategy while others play that). """ # Compute error error = nashEq_true - nashEq_pred # Replace nan values with 0 error = tf.where(tf.math.is_nan(error), tf.zeros_like(error), error) # Computing indices of the minimum of mean of squared error (MSE) of nash equilibria MSE_eq = K.mean(K.square(error), axis=[2, 3]) min_index = K.argmin(MSE_eq, axis=1) # Find the matching true output for each sample in the batch selected_trueNash = tf.gather_nd( nashEq_true, tf.stack( (tf.range(0, tf.shape(min_index)[0]), tf.cast(min_index, dtype='int32')), axis=1)) # Compute payoff of true equilibria (shape: [batch, players]) payoff_true = computePayoff_function['computePayoff']( game, selected_trueNash, pureStrategies_perPlayer, num_players) # Compute the difference in payoff a player when their strategy in true equilibrium is replaced by the predicted # strategy (shape: A list with size of players with each element [batch]) delta_per_player = [] outperform_eq_per_player = [] for player in range(num_players): # Replace the prediction for a player on the true equilibrium unstacked_list = tf.unstack(selected_trueNash, axis=1, num=num_players) unstacked_list[player] = nashEq_pred[:, 0, player] approx_on_true = tf.stack(unstacked_list, axis=1) # Compute payoff for the modified equilibrium approx_payoff_current_player = computePayoff_function['computePayoff']( game, approx_on_true, pureStrategies_perPlayer, num_players) # Compute delta and possible payoff improvement delta_per_player.append( tf.maximum( payoff_true[:, player] - approx_payoff_current_player[:, player], 0)) outperform_eq_per_player.append( tf.math.greater(approx_payoff_current_player[:, player], payoff_true[:, player])) # Find the maximum delta for all players delta_stacked = tf.stack(delta_per_player, axis=1) delta = tf.reduce_max(delta_stacked, axis=1) # delta = tf.reduce_max(delta_stacked) # Also find if any equilibrium better than the classical methods (true equilibrium) found (A scalar) outperform_stacked = tf.stack(outperform_eq_per_player, axis=1) outperform_no = tf.math.count_nonzero( tf.reduce_all(outperform_stacked, axis=1)) return delta, outperform_no
def hydra_delta_equilibrium(nashEq_predicted, nashEq_true, game, pureStrategies_perPlayer, computePayoff_function, num_players): """ Function to compute the delta (regret of not playing equilibrium strategy while others play that) in a hydra network. """ # Create a row-wise meshgrid of predicted equilibria for each sample in the batch by adding a new dimension and # replicate the array along that predicted_grid = tf.tile(tf.expand_dims(nashEq_predicted, axis=2), [1, 1, tf.shape(nashEq_predicted)[1], 1, 1]) # Create a column-wise meshgrid of true equilibria for each sample in the batch by adding a new dimension and # replicate the array along that true_grid = tf.tile(tf.expand_dims(nashEq_true, axis=1), [1, tf.shape(nashEq_true)[1], 1, 1, 1]) # Compute error grid error_grid = predicted_grid - true_grid # Replace nan values with 0 error_grid = tf.where(tf.math.is_nan(error_grid), tf.zeros_like(error_grid), error_grid) # Computing indices of the minimum of mean of squared error (MSE) of nash equilibria MSE_eq = K.mean(K.square(error_grid), axis=[3, 4]) min_index = K.argmin(MSE_eq, axis=2) # Convert the indices tensor to make it usable for later tf.gather_nd operations indexGrid = tf.reshape( min_index, (tf.shape(min_index)[0] * tf.shape(min_index)[1], 1, 1, 1)) # Find the matching true output for each sample in the batch selected_trueNash = tf.squeeze(tf.gather_nd(true_grid, indexGrid, batch_dims=2), axis=2) # Compute payoff of true equilibria (shape: [batch, max_eq, players]) payoff_true = computePayoff_function['computePayoff_2dBatch']( game, selected_trueNash, pureStrategies_perPlayer, num_players) # Compute the difference in payoff a player when their strategy in true equilibrium is replaced by the predicted # strategy (shape: A list with size of players with each element [batch]) delta_per_player = [] outperform_eq_per_player = [] for player in range(num_players): # Replace the prediction for a player on the true equilibrium unstacked_list = tf.unstack(selected_trueNash, axis=2, num=num_players) unstacked_list[player] = nashEq_predicted[:, :, player] approx_on_true = tf.stack(unstacked_list, axis=2) # Compute payoff for the modified equilibria approx_payoff_current_player = computePayoff_function[ 'computePayoff_2dBatch'](game, approx_on_true, pureStrategies_perPlayer, num_players) # Compute delta and possible payoff improvement delta_per_player.append( tf.maximum( payoff_true[:, :, player] - approx_payoff_current_player[:, :, player], 0)) # delta_per_player.append(tf.reduce_max(tf.maximum(payoff_true[:, :, player] - approx_payoff_current_player[:, :, player], 0), axis=1)) outperform_eq_per_player.append( tf.reduce_all(tf.math.greater( approx_payoff_current_player[:, :, player], payoff_true[:, :, player]), axis=1)) # Find the maximum delta for all players delta_stacked = tf.stack(delta_per_player, axis=2) # delta_stacked = tf.stack(delta_per_player, axis=1) delta = tf.reduce_max(delta_stacked, axis=2) # delta = tf.reduce_max(delta_stacked) # Also find if any equilibrium better than the classical methods (true equilibrium) found (A scalar) outperform_stacked = tf.stack(outperform_eq_per_player, axis=1) outperform_no = tf.math.count_nonzero( tf.reduce_all(outperform_stacked, axis=1)) return delta, outperform_no
def call(self, inputs, **kwargs): return K.cast(K.argmin(inputs, axis=1), dtype=K.floatx())
def hydra_oneSided_payoff_Eq_MSE(nashEq_proposer, nashEq_proposed, game, pureStrategies_perPlayer, computePayoff_function, num_players): """ Function to compute MSE of equilibria and payoffs from the matched equilibria with a proposer and proposed defined (in Deferred Acceptance Algorithm terms). """ # Create a row-wise meshgrid of proposed equilibria for each sample in the batch by adding a new dimension and # replicate the array along that proposed_grid = tf.tile(tf.expand_dims(nashEq_proposed, axis=2), [1, 1, tf.shape(nashEq_proposed)[1], 1, 1]) # Create a column-wise meshgrid of proposer equilibria for each sample in the batch by adding a new dimension and # replicate the array along that proposer_grid = tf.tile(tf.expand_dims(nashEq_proposer, axis=1), [1, tf.shape(nashEq_proposer)[1], 1, 1, 1]) # Compute the weight for the final result to recompense the replacement of nans with zeros and its effect # on the averaging nan_count = tf.reduce_sum( tf.cast(tf.math.is_nan(nashEq_proposer[0][0] + nashEq_proposed[0][0]), tf.int32)) eq_n_elements = tf.size(nashEq_proposer[0][0]) compensation_factor = tf.cast(eq_n_elements / (eq_n_elements - nan_count), tf.float32) # Compute error grid error_grid = proposed_grid - proposer_grid # Replace nan values with 0 error_grid = tf.where(tf.math.is_nan(error_grid), tf.zeros_like(error_grid), error_grid) # Computing indices of the minimum of mean of squared error (MSE) of nash equilibria MSE_eq = K.mean(K.square(error_grid), axis=[3, 4]) min_index = K.argmin(MSE_eq, axis=2) # Convert the indices tensor to make it usable for later tf.gather_nd operations indexGrid = tf.reshape( min_index, (tf.shape(min_index)[0] * tf.shape(min_index)[1], 1, 1, 1)) # Find the minimum of mean of squared error (MSE) of nash equilibria loss_Eq_MSE = K.max(tf.squeeze(tf.gather_nd(MSE_eq, indexGrid, batch_dims=2), axis=[2]), axis=1) loss_Eq_MSE *= compensation_factor # Computing the payoffs given the selected output for each sample in the batch selected_proposerNash = tf.squeeze(tf.gather_nd(proposer_grid, indexGrid, batch_dims=2), axis=2) payoff_proposer = computePayoff_function['computePayoff_2dBatch']( game, selected_proposerNash, pureStrategies_perPlayer, num_players) payoff_proposed = computePayoff_function['computePayoff_2dBatch']( game, nashEq_proposed, pureStrategies_perPlayer, num_players) # Computing the mean squared error (MSE) of payoffs loss_payoff_MSE = K.max(K.mean(K.square(payoff_proposed - payoff_proposer), axis=2), axis=1) return loss_Eq_MSE, loss_payoff_MSE