def body(tf_content_encodings, level, copy_score, output, i):
# find value for write
# which is "copy" tensor
##################################
current_content = tf_content_encodings[i] # single content sample in batch
current_level = level[i] # single level sample in batch
current_copy_score_vector = copy_score[i]
# find the copy indices to generate the s_t^copy vector
c, _ = tf.setdiff1d(current_content, current_level) # test should be content and target should be level
output_level_index, true_content_index = tf.setdiff1d(current_content, c)
# true_content_index is the index to extract copy score...
# output_level_index is the index to place the copy score
# Use the gather and the scatter_add mechanism to obtain the final s_t^copy vector
out_value_list = tf.gather(current_copy_score_vector, true_content_index)
final_output = tf.scatter_add(
# This reference must not be added to the optimizer's backpropagation ops
# so turn the trainable property off.
# Also, since the initial_value is a lambda, the dtype has to be explicitly mentioned
tf.Variable(lambda: tf.zeros(shape=(content_label_vocab_size)), trainable=False, dtype=tf.float32),
output_level_index, out_value_list)
#################################
w_v = final_output
output = output.write(i,w_v)
return tf_content_encodings, level,copy_score, output, i + 1
def sparse_dropout_row_col(values, mask_inds, shape, rate=0.0, training=True):
"""Apply dropout to rows and columns independently with probability rate."""
N, M, K = shape
vals = tf.reshape(values, [-1, K])
num_vals = tf.shape(vals)[0]
row_mask = np.random.choice([0, 1], size=N,
p=(rate, 1 -
rate)) # Dropout rows where this mask is 0
row_keep = np.arange(N)[row_mask == 1]
_, row_inds = tf.setdiff1d(mask_inds[:, 0], row_keep)
col_mask = np.random.choice([0, 1], size=M,
p=(rate, 1 -
rate)) # Dropout cols where this mask is 0
col_keep = np.arange(M)[col_mask == 1]
_, col_inds = tf.setdiff1d(mask_inds[:, 1], col_keep)
inds, _ = tf.unique(tf.concat([row_inds, col_inds], axis=0))
drop_mask = tf.scatter_nd(tf.expand_dims(inds, axis=1),
tf.ones_like(inds),
shape=[num_vals])
drop_mask = tf.cast(drop_mask, tf.bool)
new_vals = tf.where(drop_mask, tf.zeros_like(vals), vals)
new_vals = tf.reshape(new_vals, [-1]) / (1 - rate * rate)
return new_vals
def dataset_fft_to_mel_multi_with_files(fn, tfrecord, num_timesteps, num_freqs, linear_to_mel_weight_matrix, all_labels):
""" Takes consequtive samples with step size out of each tfr"""
context_out, feat_list_out = tf.parse_single_sequence_example(
tfrecord,
context_features={
"label": tf.FixedLenFeature((1,), dtype=tf.string)
},
sequence_features={
"spectrogram": tf.FixedLenSequenceFeature((num_freqs,), tf.float32),
}
)
spectrogram_all = feat_list_out['spectrogram']
mel_spect = tf.tensordot(spectrogram_all, linear_to_mel_weight_matrix, 1)
mel_spect = tf.math.log(mel_spect + 0.00001)
mel_spect = tf.expand_dims(mel_spect, -1)
spectrogram_frames = tf.transpose(shape_ops.frame(mel_spect, num_timesteps, num_timesteps//4, axis=0),[0,2,1,3])
lbl = context_out['label']
_, idx = tf.setdiff1d(tf.constant(all_labels), lbl)
idx, _ = tf.setdiff1d(tf.range(len(all_labels)), idx)
lblIndex = tf.fill([tf.shape(spectrogram_frames)[0]], tf.to_int32(idx[0]))
files = tf.fill([tf.shape(spectrogram_frames)[0]], fn)
return spectrogram_frames, lblIndex, files
def closest_class_prediction(pairwise_distances, labels):
"""
Helper function to gather predictions for top-1 accuracy calculation
:param pairwise_distances: nxn matrix with cosine distances within a batch
:param labels: nx1 ids of identities
:return:
"""
max_values = tf.reduce_max(pairwise_distances)
diag_replacer = tf.tile(
tf.reduce_max(pairwise_distances)[None, ...],
[tf.shape(pairwise_distances)[0]])
# The distance of embedding to itself will be 0, so we're replacing it with the max value
replaced_diag = tf.linalg.set_diag(pairwise_distances, diag_replacer)
indecies_min = tf.arg_min(replaced_diag, 1)
predictions_raw = tf.gather(labels, indecies_min)
# Filter classes with one instance only
classes, _, counts = tf.unique_with_counts(labels)
classes_not_for_acuracy = classes[tf.equal(counts, 1)]
_, indecies_to_keep = tf.setdiff1d(labels, classes_not_for_acuracy)
labels_selected = tf.gather(labels, indecies_to_keep)
predictions = tf.gather(predictions_raw, indecies_to_keep)
return predictions, labels_selected
def run(self):
x = self.convert(
np.array([[2, 2, 1, 3], [4, 5, 6, 1], [0, 1, 1, -2], [6, 2, 3,
0]]))
y = self.convert(np.array([1, 2, 3, 5, 7]))
z = self.convert((np.array([1, 0, 4, 6, 2])))
arg_min = tf.argmin(x, 1)
arg_max = tf.argmax(x, 1)
unique = tf.unique(y)
diff = tf.setdiff1d(y, z)
with tf.Session() as session:
print("Sequence utilities examples:")
print("argmin and argmax input matrix: ")
print(session.run(x))
print("Argmin axis 1: ", session.run(arg_min))
print("Argmax axis 1: ", session.run(arg_max))
print("")
print("Unique input array: ", session.run(y))
print("Unique: ", session.run(unique))
print("")
print("Diff input arays: ")
print(session.run(y))
print(session.run(z))
print("Diff: ", session.run(diff))
def _tensordot_reshape(a, axes, flipped=False):
"""Helper method to perform transpose and reshape for contraction op.
This method is helpful in reducing `math_tf.tensordot` to `math_tf.matmul`
using `tf.transpose` and `tf.reshape`. The method takes a
tensor and performs the correct transpose and reshape operation for a given
set of indices. It returns the reshaped tensor as well as a list of indices
necessary to reshape the tensor again after matrix multiplication.
Args:
a: `Tensor`.
axes: List or `int32` `Tensor` of unique indices specifying valid axes of
`a`.
flipped: An optional `bool`. Defaults to `False`. If `True`, the method
assumes that `a` is the second argument in the contraction operation.
Returns:
A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is
the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is
either a list of integers or an `int32` `Tensor`, depending on whether
the shape of a is fully specified, and free_dims_static is either a list
of integers and None values, or None, representing the inferred
static shape of the free dimensions
"""
if a.get_shape().is_fully_defined() and isinstance(axes, (list, tuple)):
shape_a = a.get_shape().as_list()
axes = [i if i >= 0 else i + len(shape_a) for i in axes]
free = [i for i in range(len(shape_a)) if i not in axes]
free_dims = [shape_a[i] for i in free]
prod_free = int(np.prod([shape_a[i] for i in free]))
prod_axes = int(np.prod([shape_a[i] for i in axes]))
perm = list(axes) + free if flipped else free + list(axes)
new_shape = [prod_axes, prod_free] if flipped else [prod_free, prod_axes]
reshaped_a = tf.reshape(tf.transpose(a, perm), new_shape)
return reshaped_a, free_dims, free_dims
else:
if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):
shape_a = a.get_shape().as_list()
axes = [i if i >= 0 else i + len(shape_a) for i in axes]
free = [i for i in range(len(shape_a)) if i not in axes]
free_dims_static = [shape_a[i] for i in free]
else:
free_dims_static = None
shape_a = tf.shape(a)
rank_a = tf.rank(a)
axes = tf.convert_to_tensor(axes, dtype=tf.int32, name="axes")
axes = tf.cast(axes >= 0, tf.int32) * axes + tf.cast(
axes < 0, tf.int32) * (
axes + rank_a)
free, _ = tf.setdiff1d(tf.range(rank_a), axes)
free_dims = tf.gather(shape_a, free)
axes_dims = tf.gather(shape_a, axes)
prod_free_dims = tf.reduce_prod(free_dims)
prod_axes_dims = tf.reduce_prod(axes_dims)
perm = tf.concat([axes_dims, free_dims], 0)
if flipped:
perm = tf.concat([axes, free], 0)
new_shape = tf.stack([prod_axes_dims, prod_free_dims])
else:
perm = tf.concat([free, axes], 0)
new_shape = tf.stack([prod_free_dims, prod_axes_dims])
reshaped_a = tf.reshape(tf.transpose(a, perm), new_shape)
return reshaped_a, free_dims, free_dims_static
def forward_tensor(self, x):
y = tf.reshape(x, [-1])
total_size = tf.shape(y)[0] + self.fixed_inds.shape[0]
nonfixed_inds = tf.setdiff1d(tf.range(total_size), self.fixed_inds)[0]
y = tf.reshape(
tf.dynamic_stitch([self.fixed_inds, nonfixed_inds],
[self.fixed_vals, y]), [tf.shape(x)[0], -1])
return y
def variable_set_accuracy_1d(y_pred, y_true):
mask = tf.not_equal(tf.zeros_like(y_true), y_true)
diff = tf.setdiff1d(tf.boolean_mask(y_pred, mask),
tf.boolean_mask(y_true, mask))
#diff = tf.listdiff(tf.boolean_mask(y_pred,mask),tf.boolean_mask(y_true,mask))
accuracy = 1 - tf.reduce_sum(tf.to_float(tf.ones_like(
diff.idx))) / tf.reduce_sum(tf.to_float(mask))
return accuracy
def func_body_augmented(iteration, chosen_ids):
# find a new facility location to add
# based on the clustering score and the NMI score
candidate_ids = tf.setdiff1d(all_ids, chosen_ids)[0]
new_chosen_idx = _find_loss_augmented_facility_idx(
pairwise_distances, labels, chosen_ids, candidate_ids,
margin_multiplier, margin_type)
chosen_ids = tf.concat([chosen_ids, [new_chosen_idx]], 0)
return iteration + 1, chosen_ids
def _squeeze(x, axis):
"""A version of squeeze that works with dynamic axis."""
x = tf.convert_to_tensor(x, name='x')
if axis is None:
return tf.squeeze(x, axis=None)
axis = tf.convert_to_tensor(axis, name='axis', dtype=tf.int32)
axis += tf.zeros([1], dtype=axis.dtype) # Make axis at least 1d.
keep_axis, _ = tf.setdiff1d(tf.range(0, tf.rank(x)), axis)
return tf.reshape(x, tf.gather(tf.shape(x), keep_axis))
def _squeeze(x, axis):
"""A version of squeeze that works with dynamic axis."""
x = tf.convert_to_tensor(x, name='x')
if axis is None:
return tf.squeeze(x, axis=None)
axis = tf.convert_to_tensor(axis, name='axis')
axis += tf.zeros([1], dtype=axis.dtype) # Make axis at least 1d.
keep_axis, _ = tf.setdiff1d(tf.range(0, tf.rank(x)), axis)
return tf.reshape(x, tf.gather(tf.shape(x), keep_axis))
def _match_when_rows_are_non_empty():
"""Performs matching when the rows of similarity matrix are non empty.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
# Matches for each column
matches = tf.argmax(similarity_matrix, 0)
# Deal with matched and unmatched threshold
if self._matched_threshold is not None:
# Get logical indices of ignored and unmatched columns as tf.int64
matched_vals = tf.reduce_max(similarity_matrix, 0)
below_unmatched_threshold = tf.greater(self._unmatched_threshold,
matched_vals)
between_thresholds = tf.logical_and(
tf.greater_equal(matched_vals, self._unmatched_threshold),
tf.greater(self._matched_threshold, matched_vals))
if self._negatives_lower_than_unmatched:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-1)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-2)
else:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-2)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-1)
if self._ignore_sim_less_than_zero:
# If a minimum value is less than zero and a maximum value is zero, the columns are ignored
ignore_vals = tf.reduce_min(similarity_matrix, 0)
ignore_indicator = tf.logical_and(tf.less(ignore_vals, 0), tf.equal(matched_vals, 0))
matches = self._set_values_using_indicator(matches, ignore_indicator, -2)
if self._force_match_for_each_row:
forced_matches_ids = tf.cast(tf.argmax(similarity_matrix, 1), tf.int32)
# Set matches[forced_matches_ids] = [0, ..., R], R is number of rows.
row_range = tf.range(tf.shape(similarity_matrix)[0])
col_range = tf.range(tf.shape(similarity_matrix)[1])
forced_matches_values = tf.cast(row_range, matches.dtype)
keep_matches_ids, _ = tf.setdiff1d(col_range, forced_matches_ids)
keep_matches_values = tf.gather(matches, keep_matches_ids)
matches = tf.dynamic_stitch([forced_matches_ids, keep_matches_ids],
[forced_matches_values, keep_matches_values])
return tf.cast(matches, tf.int32)
def dataset_fft_to_mel_single(tfrecord, num_timesteps, num_freqs, linear_to_mel_weight_matrix, all_labels, augment):
""" Takes a single random sample out of each tfr"""
context_out, feat_list_out = tf.parse_single_sequence_example(
tfrecord,
context_features={
"label": tf.FixedLenFeature((1,), dtype=tf.string)
},
sequence_features={
"spectrogram": tf.FixedLenSequenceFeature((num_freqs,), tf.float32),
}
)
spectrogram_all = feat_list_out['spectrogram']
shp = tf.shape(spectrogram_all)
if augment:
# augment by scaling and shifting
shift=tf.random_uniform([1,1],1-0.3,1+0.3)
scale=tf.random_uniform([1,1],1-0.3,1+0.3)
shift_scale=tf.concat([shift, tf.zeros([1,3]),scale, tf.zeros([1, 3])],axis=1,name='shiftscale')
spectrogram_aug = tf.cond(tf.random_uniform([],0,1) < 0.5, lambda: tf.contrib.image.transform(spectrogram_all,shift_scale,interpolation='BILINEAR',name='augment'), lambda: spectrogram_all )
else:
spectrogram_aug=spectrogram_all
# random offset into the file
frame_offset=tf.cond( shp[0]>num_timesteps, lambda: tf.random_uniform([1],minval=0,maxval=tf.subtract(shp[0],num_timesteps),dtype=tf.int32,seed=42),lambda: tf.zeros([1], dtype=tf.int32))
slice_start = tf.concat([frame_offset,[0]],0)
slice = tf.slice(spectrogram_aug, slice_start, [num_timesteps, num_freqs])
mel_slice = tf.tensordot(slice, linear_to_mel_weight_matrix, 1)
mel_slice = tf.math.log(mel_slice + 0.00001)
mel_slice = tf.expand_dims(tf.transpose(mel_slice), -1)
lbl = context_out['label']
_, idx = tf.setdiff1d(tf.constant(all_labels), lbl)
idx, _ = tf.setdiff1d(tf.range(len(all_labels)), idx)
return mel_slice , idx[0]
def body(tf_content_encodings, level, copy_score, output,
i):
# find value for write
# which is "copy" tensor
##################################
current_content = tf_content_encodings[
i] # single content sample in batch
current_level = level[
i] # single level sample in batch
current_copy_score_vector = copy_score[i]
# find the copy indices to generate the s_t^copy vector
c, _ = tf.setdiff1d(
current_content, current_level
) # test should be content and target should be level
output_level_index, true_content_index = tf.setdiff1d(
current_content, c)
# true_content_index is the index to extract copy score...
# output_level_index is the index to place the copy score
# Use the gather and the scatter_add mechanism to obtain the final s_t^copy vector
out_value_list = tf.gather(current_copy_score_vector,
true_content_index)
final_output = tf.scatter_add(
# This reference must not be added to the optimizer's backpropagation ops
# so turn the trainable property off.
# Also, since the initial_value is a lambda, the dtype has to be explicitly mentioned
tf.Variable(lambda: tf.zeros(shape=(
content_label_vocab_size)),
trainable=False,
dtype=tf.float32),
output_level_index,
out_value_list)
#################################
w_v = final_output
output = output.write(i, w_v)
return tf_content_encodings, level, copy_score, output, i + 1
def predict(itemSet, true_target):
precision = []
itemSets = tf.reshape(tf.tile(itemSet, [numItems]),
[numItems, tf.size(itemSet)])
#itemSets = [itemSet for i in range(numItems)]
targets = list(range(numItems))
scores = unnormalized_predict(itemSets, targets)
_, indices = tf.nn.top_k(scores, k=numItems, sorted=True)
percentile_rank = tf.where(tf.equal(indices, true_target))
for K in Ks:
_, indices = tf.nn.top_k(scores, k=K, sorted=True)
out, idx = tf.setdiff1d(indices, true_target)
precision.append(K - tf.shape(out))
return precision, percentile_rank
def find_dup(a):
""" Find the duplicated elements in 1-D a tensor.
Args:
a: 1-D tensor.
Return:
more_than_one_vals: duplicated value in a.
indexes_in_a: duplicated value's index in a.
dups_in_a: duplicated value with duplicate in a.
"""
unique_a_vals, unique_idx = tf.unique(a)
count_a_unique = tf.unsorted_segment_sum(tf.ones_like(a), unique_idx,
tf.shape(a)[0])
more_than_one = tf.greater(count_a_unique, 1)
more_than_one_idx = tf.squeeze(tf.where(more_than_one))
more_than_one_vals = tf.squeeze(tf.gather(unique_a_vals,
more_than_one_idx))
not_duplicated, _ = tf.setdiff1d(a, more_than_one_vals)
dups_in_a, indexes_in_a = tf.setdiff1d(a, not_duplicated)
return more_than_one_vals, indexes_in_a, dups_in_a
def find_dup(a):
""" Find the duplicated elements in 1-D a tensor.
Args:
a: 1-D tensor.
Return:
more_than_one_vals: duplicated value in a.
indexes_in_a: duplicated value's index in a.
dups_in_a: duplicated value with duplicate in a.
"""
unique_a_vals, unique_idx = tf.unique(a)
count_a_unique = tf.unsorted_segment_sum(tf.ones_like(a),
unique_idx,
tf.shape(a)[0])
more_than_one = tf.greater(count_a_unique, 1)
more_than_one_idx = tf.squeeze(tf.where(more_than_one))
more_than_one_vals = tf.squeeze(tf.gather(unique_a_vals, more_than_one_idx))
not_duplicated, _ = tf.setdiff1d(a, more_than_one_vals)
dups_in_a, indexes_in_a = tf.setdiff1d(a, not_duplicated)
return more_than_one_vals, indexes_in_a, dups_in_a
def _sparse_tensordot_reshape(a, axes, flipped=False):
if a.get_shape().is_fully_defined() and isinstance(
axes, (list, tuple)):
shape_a = a.get_shape().as_list()
axes = [i if i >= 0 else i + len(shape_a) for i in axes]
free = [i for i in tf.range(len(shape_a)) if i not in axes]
free_dims = [shape_a[i] for i in free]
# prod_free = int(np.prod(np.array([shape_a[i] for i in free])))
# prod_axes = int(np.prod(np.array([shape_a[i] for i in axes])))
prod_free = tf.math.reduce_prod(
tf.constant([shape_a[i] for i in free]))
prod_axes = tf.math.reduce_prod(
tf.constant([shape_a[i] for i in axes]))
perm = list(axes) + free if flipped else free + list(axes)
new_shape = [prod_axes, prod_free
] if flipped else [prod_free, prod_axes]
reshaped_a = tf.sparse.reshape(tf.sparse.transpose(a, perm),
new_shape)
return reshaped_a, free_dims, free_dims
else:
if a.get_shape().ndims is not None and isinstance(
axes, (list, tuple)):
shape_a = a.get_shape().as_list()
axes = [i if i >= 0 else i + len(shape_a) for i in axes]
free = [i for i in tf.range(len(shape_a)) if i not in axes]
free_dims_static = [shape_a[i] for i in free]
else:
free_dims_static = None
shape_a = tf.shape(a)
rank_a = tf.rank(a)
axes = tf.convert_to_tensor(axes, dtype=tf.int32, name="axes")
axes = tf.cast(axes >= 0, tf.int32) * axes + tf.cast(
axes < 0, tf.int32) * (axes + rank_a)
# print(sess.run(rank_a), sess.run(axes))
free, _ = tf.setdiff1d(tf.range(rank_a), axes)
free_dims = tf.gather(shape_a, free)
axes_dims = tf.gather(shape_a, axes)
prod_free_dims = tf.reduce_prod(free_dims)
prod_axes_dims = tf.reduce_prod(axes_dims)
# perm = tf.concat([axes_dims, free_dims], 0)
if flipped:
perm = tf.concat([axes, free], 0)
new_shape = tf.stack([prod_axes_dims, prod_free_dims])
else:
perm = tf.concat([free, axes], 0)
new_shape = tf.stack([prod_free_dims, prod_axes_dims])
reshaped_a = tf.sparse_reshape(tf.sparse_transpose(a, perm),
new_shape)
return reshaped_a, free_dims, free_dims_static
def _match_when_rows_are_non_empty():
"""Performs matching when the rows of similarity matrix are non empty.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
# Matches for each column
matches = tf.argmax(similarity_matrix, 0)
# Deal with matched and unmatched threshold
if self._matched_threshold is not None:
# Get logical indices of ignored and unmatched columns as tf.int64
matched_vals = tf.reduce_max(similarity_matrix, 0)
below_unmatched_threshold = tf.greater(self._unmatched_threshold,
matched_vals)
between_thresholds = tf.logical_and(
tf.greater_equal(matched_vals, self._unmatched_threshold),
tf.greater(self._matched_threshold, matched_vals))
if self._negatives_lower_than_unmatched:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-1)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-2)
else:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-2)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-1)
if self._force_match_for_each_row:
forced_matches_ids = tf.cast(tf.argmax(similarity_matrix, 1), tf.int32)
# Set matches[forced_matches_ids] = [0, ..., R], R is number of rows.
row_range = tf.range(tf.shape(similarity_matrix)[0])
col_range = tf.range(tf.shape(similarity_matrix)[1])
forced_matches_values = tf.cast(row_range, matches.dtype)
keep_matches_ids, _ = tf.setdiff1d(col_range, forced_matches_ids)
keep_matches_values = tf.gather(matches, keep_matches_ids)
matches = tf.dynamic_stitch(
[forced_matches_ids,
keep_matches_ids], [forced_matches_values, keep_matches_values])
return tf.cast(matches, tf.int32)
def wrapperSummary(url,nSent=4,nRelevance=10):
urlTarget = url
sess = tf.Session()
nl = NaturalLanguageUnderstandingV1(
username='******',
password='******',
version='2017-02-27')
#print(nRelevance)
response = nl.analyze(
url=urlTarget,
#text="Different categories of gender very in the context they are in.",
features=Features(
#entities=EntitiesOptions(emotion=True,sentiment=True,limit=2),
keywords=KeywordsOptions(limit=nRelevance+1)),
return_analyzed_text=True)
stopword = set(corpus.stopwords.words("english"));
article = tk.sent_tokenize(response["analyzed_text"])
keywords = response['keywords']
print(keywords)
sentRelevance = []
s = stem.PorterStemmer();
for sent in article:
score = [k['relevance'] for k in keywords if stemmedPunctuationTokenized(sent,stopword).lower().find(stemmedPunctuationTokenized(k['text'],stopword).lower())!=-1]
#print(score)
floatscore = [float(number) for number in score ]
sentRelevance.append(np.sum(floatscore))
totalSent = np.size(sentRelevance)
#nSentActual = math.floor(totalSent*(1-compressionRate))
nSentActual = min(nSent,totalSent)
relevantV,indicies =tf.nn.top_k(tf.constant(sentRelevance),k=nSentActual)
indexZeros = tf.reshape(tf.where(tf.equal(relevantV,0)),[-1])
indexAll = tf.expand_dims(tf.range(0,tf.shape(indicies)[0]),0)
flatIndexAll = tf.reduce_sum(indexAll,0)
validSet= tf.setdiff1d(flatIndexAll,tf.cast(indexZeros,dtype=tf.int32))
indexNonZero = sess.run(tf.gather(indicies,validSet[0]))
relevantSentences = np.take(article,np.sort(indexNonZero))
joinedRelevance = " ".join(relevantSentences)
return joinedRelevance
def func():
rank = tf.constant(3, dtype=tf.int32, name='rank')
start = tf.constant(0, dtype=tf.int32, name='start')
delta = tf.constant(1, dtype=tf.int32, name='delta')
tensor_dot_range = tf.range(start, rank, delta)
axes = tf.constant([2], dtype=tf.int32, name='axes')
ge_y = tf.constant(0, dtype=tf.int32, name='ge_y')
ge = tf.greater_equal(axes, ge_y)
cast = tf.cast(ge, tf.int32)
mul_1 = tf.multiply(cast, axes)
less_y = tf.constant(0, dtype=tf.int32)
less = tf.less(axes, less_y)
cast_2 = tf.cast(less, tf.int32)
add_1 = tf.add(axes, rank)
mul_2 = tf.multiply(cast_2, add_1)
add_2 = tf.add(mul_1, mul_2)
out, _ = tf.setdiff1d(tensor_dot_range, add_2)
return tf.identity(out, name="output_0")
def test_bahdanau_attention_memory_layer_tensordot(self):
rank = tf.constant(3, dtype=tf.int32, name='rank')
start = tf.constant(0, dtype=tf.int32, name='start')
delta = tf.constant(1, dtype=tf.int32, name='delta')
tensor_dot_range = tf.range(start, rank, delta)
axes = tf.constant([2], dtype=tf.int32, name='axes')
ge_y = tf.constant(0, dtype=tf.int32, name='ge_y')
ge = tf.greater_equal(axes, ge_y)
cast = tf.cast(ge, tf.int32)
mul_1 = tf.multiply(cast, axes)
less_y = tf.constant(0, dtype=tf.int32)
less = tf.less(axes, less_y)
cast_2 = tf.cast(less, tf.int32)
add_1 = tf.add(axes, rank)
mul_2 = tf.multiply(cast_2, add_1)
add_2 = tf.add(mul_1, mul_2)
out, _ = tf.setdiff1d(tensor_dot_range, add_2)
_ = tf.identity(out, name="output_0")
self._run_test_case(["output_0:0"], {})
>array([13, 2, 7, 4], dtype=int32) """ tf.segment_mean(data, segment_ids, name=None) tf.segment_max(data, segment_ids, name=None) tf.segment_min(data, segment_ids, name=None) tf.segment_prod(data, segment_ids, name=None) # 其它 tf.unsorted_segment_sum tf.sparse_segment_sum tf.sparse_segment_mean tf.sparse_segment_sqrt_n # 比较两个 list 或者 string 的不同，并返回不同的值和索引 tf.setdiff1d(x, y, index_dtype=tf.int32, name=None) # 返回 x 中的唯一值所组成的tensor 和原 tensor 中元素在现 tensor 中的索引 tf.unique(x, out_idx=None, name=None) # x if condition else y, condition 为 bool 类型的，可用tf.equal()等来表示 # x 和 y 的形状和数据类型必须一致 tf.where(condition, x=None, y=None, name=None) # 返回沿着坐标轴方向的最大/最小值的索引 tf.argmax(input, axis=None, name=None, output_type=tf.int64) tf.argmin(input, axis=None, name=None, output_type=tf.int64) # x 的值当作 y 的索引，range(len(x)) 索引当作 y 的值 # y[x[i]] = i for i in [0, 1, ..., len(x) - 1] tf.invert_permutation(x, name=None)
def one_step(self, current_state, previous_kernel_results):
"""Takes one step of the TransitionKernel.
Args:
current_state: `Tensor` or Python `list` of `Tensor`s representing the
current state(s) of the Markov chain(s).
previous_kernel_results: A (possibly nested) `tuple`, `namedtuple` or
`list` of `Tensor`s representing internal calculations made within the
previous call to this function (or as returned by `bootstrap_results`).
Returns:
next_state: `Tensor` or Python `list` of `Tensor`s representing the
next state(s) of the Markov chain(s).
kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of
`Tensor`s representing internal calculations made within this function.
This inculdes replica states.
"""
# Key difficulty: The type of exchanges differs from one call to the
# next...even the number of exchanges can differ.
# As a result, exchanges must happen dynamically, in while loops.
with tf.name_scope(name=mcmc_util.make_name(self.name, 'remc',
'one_step'),
values=[current_state, previous_kernel_results]):
# Each replica does `one_step` to get pre-exchange states/KernelResults.
sampled_replica_states, sampled_replica_results = zip(*[
rk.one_step(previous_kernel_results.replica_states[i],
previous_kernel_results.replica_results[i])
for i, rk in enumerate(self.replica_kernels)
])
sampled_replica_states = list(sampled_replica_states)
sampled_replica_results = list(sampled_replica_results)
states_are_lists = mcmc_util.is_list_like(
sampled_replica_states[0])
if not states_are_lists:
sampled_replica_states = [[s] for s in sampled_replica_states]
num_state_parts = len(sampled_replica_states[0])
dtype = sampled_replica_states[0][0].dtype
# Must put states into TensorArrays. Why? We will read/write states
# dynamically with Tensor index `i`, and you cannot do this with lists.
# old_states[k][i] is Tensor of (old) state part k, for replica i.
# The `k` will be known statically, and `i` is a Tensor.
old_states = [
tf.TensorArray(
dtype,
size=self.num_replica,
dynamic_size=False,
clear_after_read=False,
tensor_array_name='old_states',
# State part k has same shape, regardless of replica. So use 0.
element_shape=sampled_replica_states[0][k].shape)
for k in range(num_state_parts)
]
for k in range(num_state_parts):
for i in range(self.num_replica):
old_states[k] = old_states[k].write(
i, sampled_replica_states[i][k])
exchange_proposed = self.exchange_proposed_fn(
self.num_replica, seed=self._seed_stream())
exchange_proposed_n = tf.shape(exchange_proposed)[0]
exchanged_states = self._get_exchanged_states(
old_states, exchange_proposed, exchange_proposed_n,
sampled_replica_states, sampled_replica_results)
no_exchange_proposed, _ = tf.setdiff1d(
tf.range(self.num_replica), tf.reshape(exchange_proposed,
[-1]))
exchanged_states = self._insert_old_states_where_no_exchange_was_proposed(
no_exchange_proposed, old_states, exchanged_states)
next_replica_states = []
for i in range(self.num_replica):
next_replica_states_i = []
for k in range(num_state_parts):
next_replica_states_i.append(exchanged_states[k].read(i))
next_replica_states.append(next_replica_states_i)
if not states_are_lists:
next_replica_states = [s[0] for s in next_replica_states]
sampled_replica_states = [s[0] for s in sampled_replica_states]
# Now that states are/aren't exchanged, bootstrap next kernel_results.
# The viewpoint is that after each exchange, we are starting anew.
next_replica_results = [
rk.bootstrap_results(state)
for rk, state in zip(self.replica_kernels, next_replica_states)
]
next_state = next_replica_states[
0] # Replica 0 is the returned state(s).
kernel_results = ReplicaExchangeMCKernelResults(
replica_states=next_replica_states,
replica_results=next_replica_results,
sampled_replica_states=sampled_replica_states,
sampled_replica_results=sampled_replica_results,
)
return next_state, kernel_results
def covariance(x,
y=None,
sample_axis=0,
event_axis=-1,
keepdims=False,
name=None):
"""Estimate covariance between members of `event_axis`.
Sample covariance for scalars is defined as:
```none
Cov[X, Y] := N^{-1} sum_{n=1}^N (X_n - Xbar) Conj{(Y_n - Ybar)}
Xbar := N^{-1} sum_{n=1}^N X_n
Ybar := N^{-1} sum_{n=1}^N Y_n
```
For vectors `X = (X1, ..., XN)`, `Y = (Y1, ..., YN)`, one is often interested
in the covariance matrix, `C_{ij} := Cov[Xi, Yj]`.
```python
x = tf.random_normal(shape=(100, 2, 3))
y = tf.random_normal(shape=(100, 2, 3))
# cov[i, j] is the sample covariance between x[:, i, j] and y[:, i, j].
cov = covariance(x, y, sample_axis=0, event_axis=None)
# cov_matrix[i, m, n] is the sample covariance of x[:, i, m] and y[:, i, n]
cov_matrix = covariance(x, y, sample_axis=0, event_axis=-1)
```
Notice we divide by `N` (the numpy default), which does not create `NaN`
when `N = 1`, but is slightly biased.
Args:
x: A numeric `Tensor` holding samples.
y: Optional `Tensor` with same `dtype` and `shape` as `x`.
Default value: `None` (`y` is effectively set to `x`).
sample_axis: Scalar or vector `Tensor` designating axis holding samples, or
`None` (meaning all axis hold samples).
Default value: `0` (leftmost dimension).
event_axis: Scalar or vector `Tensor`, or `None`. Axis holding random
events, whose covariance we are interested in. If a vector, entries must
form a contiguous block of dims. `sample_axis` and `event_axis` should not
intersect.
Default value: `-1` (rightmost axis holds events).
keepdims: Boolean. Whether to keep the sample axis as singletons.
name: Python `str` name prefixed to Ops created by this function.
Default value: `None` (i.e., `'covariance'`).
Returns:
cov: A `Tensor` of same `dtype` as the `x`, and rank equal to
`rank(x) - len(sample_axis) + 2 * len(event_axis)`.
Raises:
AssertionError: If `x` and `y` are found to have different shape.
ValueError: If `sample_axis` and `event_axis` are found to overlap.
ValueError: If `event_axis` is found to not be contiguous.
"""
with tf.name_scope(name,
'covariance',
values=[x, y, event_axis, sample_axis]):
x = tf.convert_to_tensor(x, name='x')
# Covariance *only* uses the centered versions of x (and y).
x -= tf.reduce_mean(x, axis=sample_axis, keepdims=True)
if y is None:
y = x
else:
y = tf.convert_to_tensor(y, name='y', dtype=x.dtype)
# If x and y have different shape, sample_axis and event_axis will likely
# be wrong for one of them!
x.shape.assert_is_compatible_with(y.shape)
y -= tf.reduce_mean(y, axis=sample_axis, keepdims=True)
if event_axis is None:
return tf.reduce_mean(x * tf.conj(y),
axis=sample_axis,
keepdims=keepdims)
if sample_axis is None:
raise ValueError(
'sample_axis was None, which means all axis hold events, and this '
'overlaps with event_axis ({})'.format(event_axis))
event_axis = _make_positive_axis(event_axis, tf.rank(x))
sample_axis = _make_positive_axis(sample_axis, tf.rank(x))
# If we get lucky and axis is statically defined, we can do some checks.
if _is_list_like(event_axis) and _is_list_like(sample_axis):
if set(event_axis).intersection(sample_axis):
raise ValueError(
'sample_axis ({}) and event_axis ({}) overlapped'.format(
sample_axis, event_axis))
if (np.diff(sorted(event_axis)) > 1).any():
raise ValueError(
'event_axis must be contiguous. Found: {}'.format(
event_axis))
batch_axis = list(
sorted(
set(range(x.shape.ndims)).difference(sample_axis +
event_axis)))
else:
batch_axis, _ = tf.setdiff1d(
tf.range(0, tf.rank(x)), tf.concat((sample_axis, event_axis),
0))
event_axis = tf.convert_to_tensor(event_axis, name='event_axis')
sample_axis = tf.convert_to_tensor(sample_axis, name='sample_axis')
batch_axis = tf.convert_to_tensor(batch_axis, name='batch_axis')
# Permute x/y until shape = B + E + S
perm_for_xy = tf.concat((batch_axis, event_axis, sample_axis), 0)
x_permed = tf.transpose(x, perm=perm_for_xy)
y_permed = tf.transpose(y, perm=perm_for_xy)
batch_ndims = tf.size(batch_axis)
batch_shape = tf.shape(x_permed)[:batch_ndims]
event_ndims = tf.size(event_axis)
event_shape = tf.shape(x_permed)[batch_ndims:batch_ndims + event_ndims]
sample_shape = tf.shape(x_permed)[batch_ndims + event_ndims:]
sample_ndims = tf.size(sample_shape)
n_samples = tf.reduce_prod(sample_shape)
n_events = tf.reduce_prod(event_shape)
# Flatten sample_axis into one long dim.
x_permed_flat = tf.reshape(
x_permed, tf.concat((batch_shape, event_shape, [n_samples]), 0))
y_permed_flat = tf.reshape(
y_permed, tf.concat((batch_shape, event_shape, [n_samples]), 0))
# Do the same for event_axis.
x_permed_flat = tf.reshape(
x_permed, tf.concat((batch_shape, [n_events], [n_samples]), 0))
y_permed_flat = tf.reshape(
y_permed, tf.concat((batch_shape, [n_events], [n_samples]), 0))
# After matmul, cov.shape = batch_shape + [n_events, n_events]
cov = tf.matmul(x_permed_flat, y_permed_flat,
adjoint_b=True) / tf.cast(n_samples, x.dtype)
# Insert some singletons to make
# cov.shape = batch_shape + event_shape**2 + [1,...,1]
# This is just like x_permed.shape, except the sample_axis is all 1's, and
# the [n_events] became event_shape**2.
cov = tf.reshape(
cov,
tf.concat(
(
batch_shape,
# event_shape**2 used here because it is the same length as
# event_shape, and has the same number of elements as one
# batch of covariance.
event_shape**2,
tf.ones([sample_ndims], tf.int32)),
0))
# Permuting by the argsort inverts the permutation, making
# cov.shape have ones in the position where there were samples, and
# [n_events * n_events] in the event position.
cov = tf.transpose(cov, perm=tf.invert_permutation(perm_for_xy))
# Now expand event_shape**2 into event_shape + event_shape.
# We here use (for the first time) the fact that we require event_axis to be
# contiguous.
e_start = event_axis[0]
e_len = 1 + event_axis[-1] - event_axis[0]
cov = tf.reshape(
cov,
tf.concat((tf.shape(cov)[:e_start], event_shape, event_shape,
tf.shape(cov)[e_start + e_len:]), 0))
# tf.squeeze requires python ints for axis, not Tensor. This is enough to
# require our axis args to be constants.
if not keepdims:
squeeze_axis = tf.where(sample_axis < e_start, sample_axis,
sample_axis + e_len)
cov = _squeeze(cov, axis=squeeze_axis)
return cov
def get_predictions_and_loss(self, tokens, context_word_emb, head_word_emb, lm_emb, char_index, text_len, speaker_ids, genre, is_training, gold_starts, gold_ends, cluster_ids, scene_emb, genders, fpronouns):
self.dropout = self.get_dropout(self.config["dropout_rate"], is_training)
self.lexical_dropout = self.get_dropout(self.config["lexical_dropout_rate"], is_training)
self.lstm_dropout = self.get_dropout(self.config["lstm_dropout_rate"], is_training)
num_sentences = tf.shape(context_word_emb)[0]
max_sentence_length = tf.shape(context_word_emb)[1]
context_emb_list = [context_word_emb]
head_emb_list = [head_word_emb]
if self.config["char_embedding_size"] > 0:
char_emb = tf.gather(tf.get_variable("char_embeddings", [len(self.char_dict), self.config["char_embedding_size"]]), char_index) # [num_sentences, max_sentence_length, max_word_length, emb]
flattened_char_emb = tf.reshape(char_emb, [num_sentences * max_sentence_length, util.shape(char_emb, 2), util.shape(char_emb, 3)]) # [num_sentences * max_sentence_length, max_word_length, emb]
flattened_aggregated_char_emb = util.cnn(flattened_char_emb, self.config["filter_widths"], self.config["filter_size"]) # [num_sentences * max_sentence_length, emb]
aggregated_char_emb = tf.reshape(flattened_aggregated_char_emb, [num_sentences, max_sentence_length, util.shape(flattened_aggregated_char_emb, 1)]) # [num_sentences, max_sentence_length, emb]
context_emb_list.append(aggregated_char_emb)
head_emb_list.append(aggregated_char_emb)
if not self.lm_file:
elmo_module = hub.Module("https://tfhub.dev/google/elmo/2")
lm_embeddings = elmo_module(
inputs={"tokens": tokens, "sequence_len": text_len},
signature="tokens", as_dict=True)
word_emb = lm_embeddings["word_emb"] # [num_sentences, max_sentence_length, 512]
lm_emb = tf.stack([tf.concat([word_emb, word_emb], -1),
lm_embeddings["lstm_outputs1"],
lm_embeddings["lstm_outputs2"]], -1) # [num_sentences, max_sentence_length, 1024, 3]
lm_emb_size = util.shape(lm_emb, 2)
lm_num_layers = util.shape(lm_emb, 3)
with tf.variable_scope("lm_aggregation"):
self.lm_weights = tf.nn.softmax(tf.get_variable("lm_scores", [lm_num_layers], initializer=tf.constant_initializer(0.0)))
self.lm_scaling = tf.get_variable("lm_scaling", [], initializer=tf.constant_initializer(1.0))
flattened_lm_emb = tf.reshape(lm_emb, [num_sentences * max_sentence_length * lm_emb_size, lm_num_layers])
flattened_aggregated_lm_emb = tf.matmul(flattened_lm_emb, tf.expand_dims(self.lm_weights, 1)) # [num_sentences * max_sentence_length * emb, 1]
aggregated_lm_emb = tf.reshape(flattened_aggregated_lm_emb, [num_sentences, max_sentence_length, lm_emb_size])
aggregated_lm_emb *= self.lm_scaling
context_emb_list.append(aggregated_lm_emb)
context_emb = tf.concat(context_emb_list, 2) # [num_sentences, max_sentence_length, emb]
head_emb = tf.concat(head_emb_list, 2) # [num_sentences, max_sentence_length, emb]
context_emb = tf.nn.dropout(context_emb, self.lexical_dropout) # [num_sentences, max_sentence_length, emb]
head_emb = tf.nn.dropout(head_emb, self.lexical_dropout) # [num_sentences, max_sentence_length, emb]
text_len_mask = tf.sequence_mask(text_len, maxlen=max_sentence_length) # [num_sentence, max_sentence_length]
context_outputs = self.lstm_contextualize(context_emb, text_len, text_len_mask) # [num_words, emb]
num_words = util.shape(context_outputs, 0)
genre_emb = tf.gather(tf.get_variable("genre_embeddings", [len(self.genres), self.config["feature_size"]]), genre) # [emb]
sentence_indices = tf.tile(tf.expand_dims(tf.range(num_sentences), 1), [1, max_sentence_length]) # [num_sentences, max_sentence_length]
flattened_sentence_indices = self.flatten_emb_by_sentence(sentence_indices, text_len_mask) # [num_words]
flattened_head_emb = self.flatten_emb_by_sentence(head_emb, text_len_mask) # [num_words]
candidate_starts = tf.tile(tf.expand_dims(tf.range(num_words), 1), [1, self.max_span_width]) # [num_words, max_span_width]
candidate_ends = candidate_starts + tf.expand_dims(tf.range(self.max_span_width), 0) # [num_words, max_span_width]
#debug
prev_can_st = candidate_starts
prev_can_ends = candidate_ends
#debug
candidate_start_sentence_indices = tf.gather(flattened_sentence_indices, candidate_starts) # [num_words, max_span_width]
candidate_end_sentence_indices = tf.gather(flattened_sentence_indices, tf.minimum(candidate_ends, num_words - 1)) # [num_words, max_span_width]
candidate_mask = tf.logical_and(candidate_ends < num_words, tf.equal(candidate_start_sentence_indices, candidate_end_sentence_indices)) # [num_words, max_span_width]
flattened_candidate_mask = tf.reshape(candidate_mask, [-1]) # [num_words * max_span_width]
candidate_starts = tf.boolean_mask(tf.reshape(candidate_starts, [-1]), flattened_candidate_mask) # [num_candidates]
candidate_ends = tf.boolean_mask(tf.reshape(candidate_ends, [-1]), flattened_candidate_mask) # [num_candidates]
combined_candidate_st = candidate_starts*10000 + candidate_ends
combined_gold_st = gold_starts*10000 + gold_ends
_, non_top_span_list = tf.setdiff1d(combined_candidate_st, combined_gold_st) #[num_candidate - num_gold_mentions]
whole_candidate_indices_list = tf.range(util.shape(candidate_starts,0)) # [num_candidates]
gold_span_indices, _ = tf.setdiff1d(whole_candidate_indices_list, non_top_span_list) #[num_gold_mentions]
candidate_sentence_indices = tf.boolean_mask(tf.reshape(candidate_start_sentence_indices, [-1]), flattened_candidate_mask) # [num_candidates]
candidate_cluster_ids = self.get_candidate_labels(candidate_starts, candidate_ends, gold_starts, gold_ends, cluster_ids) # [num_candidates]
candidate_span_emb = self.get_span_emb(flattened_head_emb, context_outputs, candidate_starts, candidate_ends) # [num_candidates, emb]
#Video Scene Emb
ffnn_scene_emb = util.ffnn(scene_emb, num_hidden_layers=self.config["ffnn_depth"], hidden_size=400, output_size=128, dropout=self.dropout) # [num_words, 100]
candidate_scene_emb = self.get_scene_emb(ffnn_scene_emb, candidate_starts) #[num_candidates, 100]
'''
#Comment : This part is for calculating mention scores and prnunign metnion
#It is not used for this task, because mention boundary are given.
candidate_mention_scores = self.get_mention_scores(candidate_span_emb) # [k, 1]
candidate_mention_scores = tf.squeeze(candidate_mention_scores, 1) # [k]
k = tf.to_int32(tf.floor(tf.to_float(tf.shape(context_outputs)[0]) * self.config["top_span_ratio"]))
top_span_indices = coref_ops.extract_spans(tf.expand_dims(candidate_mention_scores, 0),
tf.expand_dims(candidate_starts, 0),
tf.expand_dims(candidate_ends, 0),
tf.expand_dims(k, 0),
util.shape(context_outputs, 0),
True) # [1, k]
top_span_indices.set_shape([1, None])
top_span_indices = tf.squeeze(top_span_indices, 0) # [k]
'''
######## Only Using Gold Span Indices #####
k = tf.to_int32(util.shape(gold_span_indices,0))
top_span_indices = gold_span_indices
############
top_span_starts = tf.gather(candidate_starts, top_span_indices) # [k]
top_span_ends = tf.gather(candidate_ends, top_span_indices) # [k]
top_span_emb = tf.gather(candidate_span_emb, top_span_indices) # [k, emb]
top_scene_emb = tf.gather(candidate_scene_emb, top_span_indices) # [k, emb-scene]
top_span_cluster_ids = tf.gather(candidate_cluster_ids, top_span_indices) # [k]
#top_span_mention_scores = tf.gather(candidate_mention_scores, top_span_indices) # [k]
top_span_sentence_indices = tf.gather(candidate_sentence_indices, top_span_indices) # [k]
top_span_speaker_ids = tf.gather(speaker_ids, top_span_starts) # [k]
top_span_genders = tf.gather(genders, top_span_ends)
top_span_fpronouns = tf.gather(fpronouns, top_span_ends)
# k : total number of candidates span (M in paper)
# c : how many antecedents we check (K in paper)
c = tf.minimum(self.config["max_top_antecedents"], k)
if self.config["coarse_to_fine"]:
top_antecedents, top_antecedents_mask, top_fast_antecedent_scores, top_antecedent_offsets = self.coarse_to_fine_pruning(top_span_emb, top_span_mention_scores, c)
else:
#top_antecedents, top_antecedents_mask, top_fast_antecedent_scores, top_antecedent_offsets = self.distance_pruning(top_span_emb, top_span_mention_scores, c)
top_antecedents, top_antecedents_mask, top_fast_antecedent_scores, top_antecedent_offsets = self.distance_prnuing_wo_mention_score(top_span_emb, c)
dummy_scores = tf.zeros([k, 1]) # [k, 1]
for i in range(self.config["coref_depth"]):
with tf.variable_scope("coref_layer", reuse=(i > 0)):
top_antecedent_emb = tf.gather(top_span_emb, top_antecedents) # [k, c, emb]
top_antecedent_scene_emb = tf.gather(top_scene_emb, top_antecedents) # [k, c, emb-scene]
top_antecedent_scores = top_fast_antecedent_scores + self.get_slow_antecedent_scores(top_span_emb, top_antecedents, top_antecedent_emb, top_antecedent_offsets, top_span_speaker_ids, genre_emb, top_scene_emb, top_antecedent_scene_emb, top_span_genders, top_span_fpronouns) # [k, c]
top_antecedent_weights = tf.nn.softmax(tf.concat([dummy_scores, top_antecedent_scores], 1)) # [k, c + 1]
top_antecedent_emb = tf.concat([tf.expand_dims(top_span_emb, 1), top_antecedent_emb], 1) # [k, c + 1, emb]
attended_span_emb = tf.reduce_sum(tf.expand_dims(top_antecedent_weights, 2) * top_antecedent_emb, 1) # [k, emb]
with tf.variable_scope("f"):
f = tf.sigmoid(util.projection(tf.concat([top_span_emb, attended_span_emb], 1), util.shape(top_span_emb, -1))) # [k, emb]
top_span_emb = f * attended_span_emb + (1 - f) * top_span_emb # [k, emb]
top_antecedent_scores = tf.concat([dummy_scores, top_antecedent_scores], 1) # [k, c + 1]
top_antecedent_cluster_ids = tf.gather(top_span_cluster_ids, top_antecedents) # [k, c]
top_antecedent_cluster_ids += tf.to_int32(tf.log(tf.to_float(top_antecedents_mask))) # [k, c]
same_cluster_indicator = tf.equal(top_antecedent_cluster_ids, tf.expand_dims(top_span_cluster_ids, 1)) # [k, c]
non_dummy_indicator = tf.expand_dims(top_span_cluster_ids > 0, 1) # [k, 1]
pairwise_labels = tf.logical_and(same_cluster_indicator, non_dummy_indicator) # [k, c]집단사기범
dummy_labels = tf.logical_not(tf.reduce_any(pairwise_labels, 1, keepdims=True)) # [k, 1]
top_antecedent_labels = tf.concat([dummy_labels, pairwise_labels], 1) # [k, c + 1]
top_antecedent_prob = tf.nn.softmax(top_antecedent_scores, 1) # [k, c + 1]
if (self.config["use_gender_logic_rule"]):
top_antecedent_prob_with_logic = self.project_logic_rule(top_antecedent_prob, top_span_genders, top_span_fpronouns, top_span_speaker_ids, top_antecedents, k)
'''
marginal_prob = tf.reduce_sum(top_antecedent_prob*tf.to_float(top_antecedent_labels),axis=1)
gold_loss = -1 * tf.reduce_sum(tf.log(marginal_prob))
top_antecedent_scores = top_antecedent_prob
'''
origin_loss = self.softmax_loss(top_antecedent_scores, top_antecedent_labels) # [k]
origin_loss = tf.reduce_sum(origin_loss)
# cross_entropy : -1 * ground_truth * log(prediction)
#teacher_loss = tf.reduce_min(tf.nn. (labels=top_antecedent_prob_with_logic, logits=top_antecedent_scores))
teacher_loss = tf.reduce_sum(-tf.reduce_sum(top_antecedent_prob_with_logic * tf.log(top_antecedent_prob + 1e-10), reduction_indices=[1]))
pi = tf.minimum(self.config["logic_rule_pi_zero"], 1.0 - tf.pow(self.config["logic_rule_imitation_alpha"], tf.to_float(self.global_step)+1.0))
# For Validation Loss
marginal_prob = tf.reduce_sum(top_antecedent_prob_with_logic*tf.to_float(top_antecedent_labels),axis=1)
validation_loss = -1 * tf.reduce_sum(tf.log(marginal_prob))
#loss = teacher_loss + origin_loss
loss = tf.where(is_training, pi*teacher_loss + (1.0-pi)*origin_loss, validation_loss)
top_antecedent_scores = top_antecedent_prob_with_logic
else:
loss = self.softmax_loss(top_antecedent_scores, top_antecedent_labels) # [k]
loss = tf.reduce_sum(loss) # []
teacher_loss = loss
origin_loss = loss
return [candidate_starts, candidate_ends, top_span_starts, top_span_ends, top_antecedents, top_antecedent_scores, teacher_loss, origin_loss], loss
import tensorflow as tf
import numpy as np
input_a = np.array([1, 0, 2, 5])
input_b = np.array([2, 3, 4, 5])
input_c = np.array([[True, False], [True, True]])
input_d = np.array([1, 1, 2, 2, 3, 5, 6])
input_e = np.array([0, 2, 3, 1, 4])
a_argmin = tf.argmin(input_a)
a_argmax = tf.argmax(input_a)
a_listdiff = tf.setdiff1d(input_a, input_b)
c_where = tf.where(input_c)
d_unique = tf.unique(input_d)
e_invert_permutation = tf.invert_permutation(input_e)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(a_argmin), '\n', sess.run(a_argmax), '\n', sess.run(a_listdiff), '\n', sess.run(c_where))
print(sess.run(d_unique), '\n', sess.run(e_invert_permutation))
def _tensordot_reshape(
a: tf.Tensor,
axes: Union[Sequence[int], tf.Tensor],
is_right_term=False
) -> Tuple[tf.Tensor, Union[List[int], tf.Tensor], Optional[List[int]],
bool]:
"""Helper method to perform transpose and reshape for contraction op.
This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul`
using `array_ops.transpose` and `array_ops.reshape`. The method takes a
tensor and performs the correct transpose and reshape operation for a given
set of indices. It returns the reshaped tensor as well as a list of indices
necessary to reshape the tensor again after matrix multiplication.
Args:
a: `Tensor`.
axes: List or `int32` `Tensor` of unique indices specifying valid axes of
`a`.
is_right_term: Whether `a` is the right (second) argument to `matmul`.
Returns:
A tuple `(reshaped_a, free_dims, free_dims_static, transpose_needed)`
where `reshaped_a` is the tensor `a` reshaped to allow contraction via
`matmul`, `free_dims` is either a list of integers or an `int32`
`Tensor`, depending on whether the shape of a is fully specified, and
free_dims_static is either a list of integers and None values, or None,
representing the inferred static shape of the free dimensions.
`transpose_needed` indicates whether `reshaped_a` must be transposed,
or not, when calling `matmul`.
"""
if a.get_shape().is_fully_defined() and isinstance(
axes, (list, tuple)):
shape_a = a.get_shape().as_list()
# NOTE: This will fail if axes contains any tensors
axes = [i if i >= 0 else i + len(shape_a) for i in axes]
free = [i for i in range(len(shape_a)) if i not in axes]
flipped = _tensordot_should_flip(axes, free)
free_dims = [shape_a[i] for i in free]
prod_free = int(np.prod([shape_a[i] for i in free]))
prod_axes = int(np.prod([shape_a[i] for i in axes]))
perm = axes + free if flipped else free + axes
new_shape = [prod_axes, prod_free
] if flipped else [prod_free, prod_axes]
transposed_a = _tranpose_if_necessary(a, perm)
reshaped_a = _reshape_if_necessary(transposed_a, new_shape)
transpose_needed = (not flipped) if is_right_term else flipped
return reshaped_a, free_dims, free_dims, transpose_needed
if a.get_shape().ndims is not None and isinstance(axes, (list, tuple)):
shape_a = a.get_shape().as_list()
axes = [i if i >= 0 else i + len(shape_a) for i in axes]
free = [i for i in range(len(shape_a)) if i not in axes]
flipped = _tensordot_should_flip(axes, free)
perm = axes + free if flipped else free + axes
axes_dims = [shape_a[i] for i in axes]
free_dims = [shape_a[i] for i in free]
free_dims_static = free_dims
axes = tf.convert_to_tensor(axes,
dtype=tf.dtypes.int32,
name="axes")
free = tf.convert_to_tensor(free,
dtype=tf.dtypes.int32,
name="free")
shape_a = tf.shape(a)
transposed_a = _tranpose_if_necessary(a, perm)
else:
free_dims_static = None
shape_a = tf.shape(a)
rank_a = tf.rank(a)
axes = tf.convert_to_tensor(axes,
dtype=tf.dtypes.int32,
name="axes")
axes = tf.where(axes >= 0, axes, axes + rank_a)
free, _ = tf.setdiff1d(tf.range(rank_a), axes)
# Matmul does not accept tensors for its transpose arguments, so fall
# back to the previous, fixed behavior.
# NOTE(amilsted): With a suitable wrapper for `matmul` using e.g. `case`
# to match transpose arguments to tensor values, we could also avoid
# unneeded tranposes in this case at the expense of a somewhat more
# complicated graph. Unclear whether this would be beneficial overall.
flipped = is_right_term
perm = (tf.concat([axes, free], 0)
if flipped else tf.concat([free, axes], 0))
transposed_a = tf.transpose(a, perm)
free_dims = tf.gather(shape_a, free)
axes_dims = tf.gather(shape_a, axes)
prod_free_dims = tf.reduce_prod(free_dims)
prod_axes_dims = tf.reduce_prod(axes_dims)
if flipped:
new_shape = tf.stack([prod_axes_dims, prod_free_dims])
else:
new_shape = tf.stack([prod_free_dims, prod_axes_dims])
reshaped_a = tf.reshape(transposed_a, new_shape)
transpose_needed = (not flipped) if is_right_term else flipped
return reshaped_a, free_dims, free_dims_static, transpose_needed
def covariance(x,
y=None,
sample_axis=0,
event_axis=-1,
keepdims=False,
name=None):
"""Sample covariance between observations indexed by `event_axis`.
Given `N` samples of scalar random variables `X` and `Y`, covariance may be
estimated as
```none
Cov[X, Y] := N^{-1} sum_{n=1}^N (X_n - Xbar) Conj{(Y_n - Ybar)}
Xbar := N^{-1} sum_{n=1}^N X_n
Ybar := N^{-1} sum_{n=1}^N Y_n
```
For vector-variate random variables `X = (X1, ..., Xd)`, `Y = (Y1, ..., Yd)`,
one is often interested in the covariance matrix, `C_{ij} := Cov[Xi, Yj]`.
```python
x = tf.random_normal(shape=(100, 2, 3))
y = tf.random_normal(shape=(100, 2, 3))
# cov[i, j] is the sample covariance between x[:, i, j] and y[:, i, j].
cov = tfp.stats.covariance(x, y, sample_axis=0, event_axis=None)
# cov_matrix[i, m, n] is the sample covariance of x[:, i, m] and y[:, i, n]
cov_matrix = tfp.stats.covariance(x, y, sample_axis=0, event_axis=-1)
```
Notice we divide by `N` (the numpy default), which does not create `NaN`
when `N = 1`, but is slightly biased.
Args:
x: A numeric `Tensor` holding samples.
y: Optional `Tensor` with same `dtype` and `shape` as `x`.
Default value: `None` (`y` is effectively set to `x`).
sample_axis: Scalar or vector `Tensor` designating axis holding samples, or
`None` (meaning all axis hold samples).
Default value: `0` (leftmost dimension).
event_axis: Scalar or vector `Tensor`, or `None` (scalar events).
Axis indexing random events, whose covariance we are interested in.
If a vector, entries must form a contiguous block of dims. `sample_axis`
and `event_axis` should not intersect.
Default value: `-1` (rightmost axis holds events).
keepdims: Boolean. Whether to keep the sample axis as singletons.
name: Python `str` name prefixed to Ops created by this function.
Default value: `None` (i.e., `'covariance'`).
Returns:
cov: A `Tensor` of same `dtype` as the `x`, and rank equal to
`rank(x) - len(sample_axis) + 2 * len(event_axis)`.
Raises:
AssertionError: If `x` and `y` are found to have different shape.
ValueError: If `sample_axis` and `event_axis` are found to overlap.
ValueError: If `event_axis` is found to not be contiguous.
"""
with tf.name_scope(
name, 'covariance', values=[x, y, event_axis, sample_axis]):
x = tf.convert_to_tensor(x, name='x')
# Covariance *only* uses the centered versions of x (and y).
x -= tf.reduce_mean(x, axis=sample_axis, keepdims=True)
if y is None:
y = x
else:
y = tf.convert_to_tensor(y, name='y', dtype=x.dtype)
# If x and y have different shape, sample_axis and event_axis will likely
# be wrong for one of them!
x.shape.assert_is_compatible_with(y.shape)
y -= tf.reduce_mean(y, axis=sample_axis, keepdims=True)
if event_axis is None:
return tf.reduce_mean(x * tf.conj(y), axis=sample_axis, keepdims=keepdims)
if sample_axis is None:
raise ValueError(
'sample_axis was None, which means all axis hold events, and this '
'overlaps with event_axis ({})'.format(event_axis))
event_axis = _make_positive_axis(event_axis, tf.rank(x))
sample_axis = _make_positive_axis(sample_axis, tf.rank(x))
# If we get lucky and axis is statically defined, we can do some checks.
if _is_list_like(event_axis) and _is_list_like(sample_axis):
if set(event_axis).intersection(sample_axis):
raise ValueError(
'sample_axis ({}) and event_axis ({}) overlapped'.format(
sample_axis, event_axis))
if (np.diff(sorted(event_axis)) > 1).any():
raise ValueError(
'event_axis must be contiguous. Found: {}'.format(event_axis))
batch_axis = list(
sorted(
set(range(x.shape.ndims)).difference(sample_axis + event_axis)))
else:
batch_axis, _ = tf.setdiff1d(
tf.range(0, tf.rank(x)), tf.concat((sample_axis, event_axis), 0))
event_axis = tf.convert_to_tensor(
event_axis, name='event_axis', dtype=tf.int32)
sample_axis = tf.convert_to_tensor(
sample_axis, name='sample_axis', dtype=tf.int32)
batch_axis = tf.convert_to_tensor(
batch_axis, name='batch_axis', dtype=tf.int32)
# Permute x/y until shape = B + E + S
perm_for_xy = tf.concat((batch_axis, event_axis, sample_axis), 0)
x_permed = tf.transpose(x, perm=perm_for_xy)
y_permed = tf.transpose(y, perm=perm_for_xy)
batch_ndims = tf.size(batch_axis)
batch_shape = tf.shape(x_permed)[:batch_ndims]
event_ndims = tf.size(event_axis)
event_shape = tf.shape(x_permed)[batch_ndims:batch_ndims + event_ndims]
sample_shape = tf.shape(x_permed)[batch_ndims + event_ndims:]
sample_ndims = tf.size(sample_shape)
n_samples = tf.reduce_prod(sample_shape)
n_events = tf.reduce_prod(event_shape)
# Flatten sample_axis into one long dim.
x_permed_flat = tf.reshape(
x_permed, tf.concat((batch_shape, event_shape, [n_samples]), 0))
y_permed_flat = tf.reshape(
y_permed, tf.concat((batch_shape, event_shape, [n_samples]), 0))
# Do the same for event_axis.
x_permed_flat = tf.reshape(
x_permed, tf.concat((batch_shape, [n_events], [n_samples]), 0))
y_permed_flat = tf.reshape(
y_permed, tf.concat((batch_shape, [n_events], [n_samples]), 0))
# After matmul, cov.shape = batch_shape + [n_events, n_events]
cov = tf.matmul(
x_permed_flat, y_permed_flat, adjoint_b=True) / tf.cast(
n_samples, x.dtype)
# Insert some singletons to make
# cov.shape = batch_shape + event_shape**2 + [1,...,1]
# This is just like x_permed.shape, except the sample_axis is all 1's, and
# the [n_events] became event_shape**2.
cov = tf.reshape(
cov,
tf.concat(
(
batch_shape,
# event_shape**2 used here because it is the same length as
# event_shape, and has the same number of elements as one
# batch of covariance.
event_shape**2,
tf.ones([sample_ndims], tf.int32)),
0))
# Permuting by the argsort inverts the permutation, making
# cov.shape have ones in the position where there were samples, and
# [n_events * n_events] in the event position.
cov = tf.transpose(cov, perm=tf.invert_permutation(perm_for_xy))
# Now expand event_shape**2 into event_shape + event_shape.
# We here use (for the first time) the fact that we require event_axis to be
# contiguous.
e_start = event_axis[0]
e_len = 1 + event_axis[-1] - event_axis[0]
cov = tf.reshape(
cov,
tf.concat((tf.shape(cov)[:e_start], event_shape, event_shape,
tf.shape(cov)[e_start + e_len:]), 0))
# tf.squeeze requires python ints for axis, not Tensor. This is enough to
# require our axis args to be constants.
if not keepdims:
squeeze_axis = tf.where(sample_axis < e_start, sample_axis,
sample_axis + e_len)
cov = _squeeze(cov, axis=squeeze_axis)
return cov
def range_not_j(j, m):
return tf.setdiff1d(tf.range(m), [j])
import tensorflow as tf
sess = tf.InteractiveSession()
x = tf.constant([[2, 5, 3, -5],
[0, 3,-2, 5],
[4, 3, 5, 3],
[6, 1, 4, 0]])
listx = tf.constant([1,2,3,4,5,6,7,8])
listy = tf.constant([4,5,8,9])
boolx = tf.constant([[True,False], [False,True]])
tf.argmin(x, 1).eval() # Position of the maximum value of columns
tf.argmax(x, 1).eval() # Position of the minimum value of rows
tf.setdiff1d(listx, listy)[0].eval() # List differences
tf.where(boolx).eval() # Show true values
tf.unique(listx)[0].eval() # Unique values in list
def compute_target_actions_values(self):
next_targets = self.forward_rewards[
0] + self.gamma * self.compute_slow_target_action_values(
0, self.choose_best_actions(0))
violations_penalties = tf.identity(next_targets)
forward_targets = np.zeros(self.transition_length)
backward_targets = np.zeros(self.transition_length)
for i in np.arange(1, self.transition_length):
forward_targets[i] = self.forward_rewards[i] + (
self.gamma**i) * self.compute_slow_target_action_values(
i, self.choose_best_actions(i))
for i in np.arange(0, self.transition_length):
backward_targets[i] = self.backward_rewards[i] + (
self.gamma**i) * self.compute_slow_target_action_values(
i, self.choose_best_actions(i))
max_q_value_indices = tf.argmax(backward_targets, axis=1)
min_q_value_indices = tf.argmax(forward_targets, axis=1)
flattened_forward_targets = tf.reshape(forward_targets, [-1])
flattened_backward_targets = tf.reshape(backward_targets, [-1])
flattened_backward_ind_max = max_q_value_indices + tf.cast(
tf.range(tf.shape(backward_targets)[0]) *
tf.shape(backward_targets)[1], tf.int64)
flattened_forward_ind_max = min_q_value_indices + tf.cast(
tf.range(tf.shape(forward_targets)[0]) *
tf.shape(forward_targets)[1], tf.int64)
min_q_values = tf.gather(flattened_forward_targets,
flattened_forward_ind_max)
max_q_values = tf.gather(flattened_backward_targets,
flattened_backward_ind_max)
upper_violation = tf.where(tf.greater(max_q_values - 20, next_targets))
lower_violation = tf.where(tf.greater(next_targets, min_q_values + 20))
upper_violation_range = tf.range(tf.shape(upper_violation)[0])
lower_violation_range = tf.range(tf.shape(lower_violation)[0])
flattened_upper_violation = tf.gather_nd(
upper_violation,
tf.stack((upper_violation_range,
tf.fill([tf.shape(upper_violation)[0]], 0)),
axis=1))
flattened_lower_violation = tf.gather_nd(
lower_violation,
tf.stack((lower_violation_range,
tf.fill([tf.shape(lower_violation)[0]], 0)),
axis=1))
diff = tf.setdiff1d(flattened_upper_violation,
flattened_lower_violation)
diff_2 = tf.setdiff1d(flattened_lower_violation,
flattened_upper_violation)
diff_3 = tf.setdiff1d(flattened_upper_violation, diff[0])
only_upper_bound_violation_indices = tf.stack(
(diff[0], tf.fill(tf.shape(diff[0]), tf.constant(0,
dtype=tf.int64))),
axis=1)
only_lower_bound_violation_indices = tf.stack(
(diff_2[0],
tf.fill(tf.shape(diff_2[0]), tf.constant(0, dtype=tf.int64))),
axis=1)
both_bounds_violations_indices = tf.stack(
(diff_3[0],
tf.fill(tf.shape(diff_3[0]), tf.constant(0, dtype=tf.int64))),
axis=1)
violations_penalties += tf.scatter_nd(
only_upper_bound_violation_indices,
tf.gather(max_q_values, only_upper_bound_violation_indices),
[self.minibatch_size, 1])
violations_penalties += tf.scatter_nd(
only_lower_bound_violation_indices,
tf.gather(min_q_values, only_lower_bound_violation_indices),
[self.minibatch_size, 1])
violations_penalties += tf.scatter_nd(
both_bounds_violations_indices,
0.5 * tf.gather(min_q_values, both_bounds_violations_indices) +
tf.gather(max_q_values, both_bounds_violations_indices),
[self.minibatch_size, 1])
final_targets = 0.8 * next_targets + 0.2 * violations_penalties
return final_targets
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
sess = tf.InteractiveSession()
x = tf.constant([[2, 5, 3, -5], [0, 3, -2, 5], [4, 3, 5, 3], [6, 1, 4, 0]])
listx = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
listy = tf.constant([4, 5, 8, 9])
print("\nx=\n", x.eval())
print("\nlistx=", listx.eval())
print("\nlisty=", listy.eval())
boolx = tf.constant([[True, False], [False, True]])
print("\ntf.argmin(x, 1).eval() ") # Position of the min value of columns
print(tf.argmin(x, 1).eval()) # Position of the min value of columns
print("\ntf.argmax(x, 1).eval() ") # Position of the max value of rows
print(tf.argmax(x, 1).eval()) # Position of the max value of rows
print("\ntf.setdiff1d(listx, listy)[0].eval() ") # List differences
print(tf.setdiff1d(listx, listy)[0].eval()) # List differences
print(tf.where(boolx).eval()) # Show true values
print(tf.unique(listx)[0].eval()) # Unique values in list
def detect_targets_graph(gt_boxes, gt_class_ids, proposals,
train_rois_per_image, roi_positive_ratio):
"""
每个图像生成检测网络的分类和回归目标
IoU>=0.5的为正样本；IoU<0.5的为负样本
:param gt_boxes: GT 边框坐标 [MAX_GT_BOXs, (y1,x1,y2,x2,tag)] ,tag=0 为padding
:param gt_class_ids: GT 类别 [MAX_GT_BOXs, 1+1] ;最后一位为tag, tag=0 为padding
:param proposals: [N,(y1,x1,y2,x2,tag)] ,tag=0 为padding
:param train_rois_per_image: 每张图像训练的proposal数量
:param roi_positive_ratio: proposal正负样本比
:return:
"""
# 去除padding
gt_boxes = tf_utils.remove_pad(gt_boxes)
gt_class_ids = tf_utils.remove_pad(gt_class_ids)[:, 0] # 从[N,1]变为[N]
proposals = tf_utils.remove_pad(proposals)
# 计算iou
iou = compute_iou(gt_boxes, proposals)
# 每个GT边框IoU最大的proposal为正
# gt_iou_argmax = tf.argmax(iou, axis=1)
gt_iou_argmax = tf.cond( # 需要考虑proposal个数为0的情况
tf.greater(tf.shape(proposals)[0], 0),
true_fn=lambda: tf.argmax(iou, axis=1),
false_fn=lambda: tf.cast(tf.constant([]), tf.int64))
# GT和对应的proposal
# gt_boxes_pos_1 = tf.identity(gt_boxes)
# gt_class_ids_pos_1 = tf.identity(gt_class_ids)
# proposal_pos_1 = tf.gather(proposals, gt_iou_argmax)
# 在接下来的操作之前提出已经被选中的proposal
indices = tf.unique(gt_iou_argmax)[0] # 被选中的索引
all_indices = tf.range(tf.shape(proposals)[0]) # 所有的索引
remainder_indices = tf.setdiff1d(all_indices,
tf.cast(indices, tf.int32))[0] # 剩余的索引
# 剩余的proposals和iou
proposals = tf.gather(proposals, remainder_indices)
iou = tf.gather(iou, remainder_indices, axis=1)
# 正样本每个proposal 最大的iou,且iou>=0.5
proposal_iou_max = tf.reduce_max(iou, axis=0)
proposal_pos_idx = tf.where(
proposal_iou_max >= 0.5) # 正样本proposal对应的索引号,二维
# proposal_iou_argmax = tf.argmax(iou, axis=0)
proposal_iou_argmax = tf.cond( # 需要考虑GT个数为0的情况
tf.greater(tf.shape(gt_boxes)[0], 0),
true_fn=lambda: tf.argmax(iou, axis=0),
false_fn=lambda: tf.cast(tf.constant([]), tf.int64))
gt_pos_idx = tf.gather_nd(proposal_iou_argmax,
proposal_pos_idx) # 对应的GT 索引号，一维的
gt_boxes_pos_2 = tf.gather(gt_boxes, gt_pos_idx)
gt_class_ids_pos_2 = tf.gather(gt_class_ids, gt_pos_idx)
proposal_pos_2 = tf.gather_nd(proposals, proposal_pos_idx)
# 合并两部分正样本
# gt_boxes_pos = tf.concat([gt_boxes_pos_1, gt_boxes_pos_2], axis=0)
# class_ids = tf.concat([gt_class_ids_pos_1, gt_class_ids_pos_2], axis=0)
# proposal_pos = tf.concat([proposal_pos_1, proposal_pos_2], axis=0)
gt_boxes_pos = gt_boxes_pos_2
class_ids = gt_class_ids_pos_2
proposal_pos = proposal_pos_2
# 根据正负样本比确定最终的正样本
positive_num = tf.minimum(
tf.shape(proposal_pos)[0],
int(train_rois_per_image * roi_positive_ratio))
gt_boxes_pos, class_ids, proposal_pos = shuffle_sample(
[gt_boxes_pos, class_ids, proposal_pos],
tf.shape(proposal_pos)[0], positive_num)
# 计算回归目标
deltas = regress_target(proposal_pos, gt_boxes_pos)
# 负样本：与所有GT的iou<0.5
proposal_neg_idx = tf.where(proposal_iou_max < 0.5)
# 确定负样本数量
negative_num = tf.minimum(train_rois_per_image - positive_num,
tf.shape(proposal_neg_idx)[0])
proposal_neg_idx = tf.random_shuffle(proposal_neg_idx)[:negative_num]
# 收集负样本
proposal_neg = tf.gather_nd(proposals, proposal_neg_idx)
class_ids_neg = tf.zeros(shape=[negative_num]) # 背景类，类别id为0
deltas_neg = tf.zeros(shape=[negative_num, 4])
# 合并正负样本
train_rois = tf.concat([proposal_pos, proposal_neg], axis=0)
deltas = tf.concat([deltas, deltas_neg], axis=0)
class_ids = tf.concat([class_ids, class_ids_neg], axis=0)
# 计算padding
class_ids, train_rois = tf_utils.pad_list_to_fixed_size(
[tf.expand_dims(class_ids, axis=1), train_rois],
train_rois_per_image) # class_ids分类扩一维
# 为后续处理方便负样本tag设置为-1
deltas = tf_utils.pad_to_fixed_size_with_negative(
deltas, train_rois_per_image, negative_num=negative_num)
# 其它统计指标
gt_num = tf.shape(gt_class_ids)[0] # GT数
miss_match_gt_num = gt_num - tf.shape(
tf.unique(gt_pos_idx)[0])[0] # 未分配anchor的GT
return [
deltas, class_ids, train_rois,
tf_utils.scalar_to_1d_tensor(miss_match_gt_num)
]
import tensorflow as tf
sess = tf.InteractiveSession()
x = tf.constant([[2, 5, 3, -5],
[0, 3,-2, 5],
[4, 3, 5, 3],
[6, 1, 4, 0]])
listx = tf.constant([1,2,3,4,5,6,7,8])
listy = tf.constant([4,5,8,9])
print("\nx=\n", x.eval())
print("\nlistx=", listx.eval())
print("\nlisty=", listy.eval())
boolx = tf.constant([[True,False], [False,True]])
print("\ntf.argmin(x, 1).eval() ")# Position of the min value of columns
print(tf.argmin(x, 1).eval() )# Position of the min value of columns
print("\ntf.argmax(x, 1).eval() ")# Position of the max value of rows
print(tf.argmax(x, 1).eval() )# Position of the max value of rows
print("\ntf.setdiff1d(listx, listy)[0].eval() ")# List differences
print(tf.setdiff1d(listx, listy)[0].eval() )# List differences
print(tf.where(boolx).eval() )# Show true values
print(tf.unique(listx)[0].eval() )# Unique values in list
def __init__(self,
base,
inputs,
k_transfer,
positive_feature_weights=False,
readout_sparsity=0.017,
init_masks='sta',
scope='readout',
reuse=False,
**kwargs):
with base.tf_session.graph.as_default():
with tf.variable_scope(scope, reuse=reuse):
data = base.data
_, num_px_y, num_px_x, num_features = inputs.shape.as_list()
num_neurons = data.num_neurons
# masks
if init_masks == 'sta':
images_train, responses_train = data.train()
k = (images_train.shape[1] - num_px_y) // 2
mask_init = sta_init(images_train,
responses_train,
max_val=0.01,
sd=0.001)[:, k:-k, k:-k]
mask_init = tf.constant_initializer(mask_init)
else:
mask_init = tf.truncated_normal_initializer(mean=0.0,
stddev=0.01)
self.masks = tf.get_variable(
'masks',
shape=[num_neurons, num_px_y, num_px_x],
initializer=mask_init)
self.masks = tf.abs(self.masks, name='positive_masks')
# split masks into neurons used for training the core and neurons
# used for transfer learning (i.e. only readout weights are trained,
# but they do not affect the core). We then insert a stop_gradient
# for the units used only for transfer learning, apply the masks
# and put things back together. This way, there is no gradient flow
# from the units used for transfer learning back into the core.
idx_train = tf.range(num_neurons, delta=k_transfer)
idx_transfer, _ = tf.setdiff1d(tf.range(num_neurons),
idx_train)
idx_all = tf.invert_permutation(
tf.concat([idx_train, idx_transfer], axis=0))
masks_train = tf.gather(self.masks, idx_train)
masks_transfer = tf.gather(self.masks, idx_transfer)
masked_train = tf.tensordot(masks_train,
inputs, [[1, 2], [1, 2]],
name='masked_train')
masked_transfer = tf.tensordot(masks_transfer,
tf.stop_gradient(inputs),
[[1, 2], [1, 2]],
name='masked_transfer')
self.masked = tf.transpose(
tf.gather(tf.concat([masked_train, masked_transfer],
axis=0),
idx_all,
name='masked'), [1, 2, 0])
# feature weights
self.feature_weights = tf.get_variable(
'feature_weights',
shape=[num_neurons, num_features],
initializer=tf.truncated_normal_initializer(mean=0.0,
stddev=0.01))
if positive_feature_weights:
self.feature_weights = tf.abs(
self.feature_weights, name='positive_feature_weights')
self.h = tf.reduce_sum(
self.masked * tf.transpose(self.feature_weights), 1)
# L1 regularization for readout layer
self.readout_reg = readout_sparsity * tf.reduce_sum(
tf.reduce_sum(tf.abs(self.masks), [1, 2]) * \
tf.reduce_sum(tf.abs(self.feature_weights), 1))
tf.losses.add_loss(self.readout_reg,
tf.GraphKeys.REGULARIZATION_LOSSES)
# bias and output nonlinearity
_, responses = data.train()
bias_init = 0.5 * inv_soft_threshold(responses.mean(axis=0))
self.biases = tf.get_variable(
'biases',
shape=[num_neurons],
initializer=tf.constant_initializer(bias_init))
self.output = tf.identity(soft_threshold(self.h + self.biases),
name='output')
import tensorflow as tf sess = tf.InteractiveSession() x = tf.constant([[2, 5, 3, -5], [0, 3, -2, 5], [4, 3, 5, 3], [6, 1, 4, 0]]) listx = tf.constant([1, 2, 3, 4, 5, 6, 7, 8]) listy = tf.constant([4, 5, 8, 9]) boolx = tf.constant([[True, False], [False, True]]) tf.argmin(x, 1).eval() # Position of the maximum value of columns tf.argmax(x, 1).eval() # Position of the minimum value of rows tf.setdiff1d(listx, listy)[0].eval() # List differences tf.where(boolx).eval() # Show true values tf.unique(listx)[0].eval() # Unique values in list
def _match_when_rows_are_non_empty():
"""Performs matching when the rows of similarity matrix are non empty.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
# Matches for each column
matches = tf.argmax(similarity_matrix, 0)
# Deal with matched and unmatched threshold
if self._matched_threshold is not None:
# Get logical indices of ignored and unmatched columns as tf.int64
matched_vals = tf.reduce_max(similarity_matrix, 0)
below_unmatched_threshold = tf.greater(
self._unmatched_threshold, matched_vals)
between_thresholds = tf.logical_and(
tf.greater_equal(matched_vals, self._unmatched_threshold),
tf.greater(self._matched_threshold, matched_vals))
tfprint.matches_raw = tf.Print(
matches,
["raw matches", tf.shape(matches), matches])
if self._negatives_lower_than_unmatched:
matches = self._set_values_using_indicator(
matches, below_unmatched_threshold, -1)
matches = self._set_values_using_indicator(
matches, between_thresholds, -2)
else:
matches = self._set_values_using_indicator(
matches, below_unmatched_threshold, -2)
matches = self._set_values_using_indicator(
matches, between_thresholds, -1)
tfprint.matches_thresh = tf.Print(
matches,
["after thresh matches",
tf.shape(matches), matches])
if self._force_match_for_each_row:
forced_matches_ids = tf.cast(tf.argmax(similarity_matrix, 1),
tf.int32)
# Set matches[forced_matches_ids] = [0, ..., R], R is number of rows.
row_range = tf.range(tf.shape(similarity_matrix)[0])
col_range = tf.range(tf.shape(similarity_matrix)[1])
forced_matches_values = tf.cast(row_range, matches.dtype)
keep_matches_ids, _ = tf.setdiff1d(col_range,
forced_matches_ids)
keep_matches_values = tf.gather(matches, keep_matches_ids)
matches = tf.dynamic_stitch(
[forced_matches_ids, keep_matches_ids],
[forced_matches_values, keep_matches_values])
tfprint.argmax_row_range = tf.Print(
row_range,
["row_range", tf.shape(row_range), row_range])
tfprint.argmax_col_range = tf.Print(
col_range,
["col_range", tf.shape(col_range), col_range])
tfprint.forced_matches_values = tf.Print(
forced_matches_values, [
"forced_matches_values",
tf.shape(forced_matches_values), forced_matches_values
])
tfprint.keep_matches_ids = tf.Print(keep_matches_ids, [
"keep_matches_ids",
tf.shape(keep_matches_ids), keep_matches_ids
])
tfprint.keep_matches_values = tf.Print(keep_matches_values, [
"keep_matches_values",
tf.shape(keep_matches_values), keep_matches_values
])
return tf.cast(matches, tf.int32)
