def call(self, x, mask=None):
assert (len(x) == 2)
img = x[0]
rois = x[1]
outputs = []
for roi_idx in range(self.num_rois):
x = rois[0, roi_idx, 0]
y = rois[0, roi_idx, 1]
w = rois[0, roi_idx, 2]
h = rois[0, roi_idx, 3]
x = tf.cast(x, 'int32')
y = tf.cast(y, 'int32')
w = tf.cast(w, 'int32')
h = tf.cast(h, 'int32')
rs = tf.image.resize(img[:, y:y + h, x:x + w, :],
(self.pool_size, self.pool_size))
outputs.append(rs)
final_output = tf.concat(outputs, axis=0)
final_output = tf.reshape(final_output,
(1, self.num_rois, self.pool_size,
self.pool_size, self.nb_channels))
return final_output
def angle(z):
if z.dtype == tf.complex128:
dtype = tf.float64
elif z.dtype == tf.complex64:
dtype = tf.float32
else:
raise ValueError('input z must be of type complex64 or complex128')
x = tf.math.real(z)
y = tf.math.imag(z)
x_neg = tf.cast(x < 0.0, dtype)
y_neg = tf.cast(y < 0.0, dtype)
y_pos = tf.cast(y >= 0.0, dtype)
offset = x_neg * (y_pos - y_neg) * np.pi
return tf.math.atan(y / x) + offset
def call(self, image):
image = cast(image, float32)
image = rgb_to_grayscale(image)
hidden_representation = self.representation_network(image)
value = self.value_network(hidden_representation)
policy_logits = self.policy_network(hidden_representation)
return hidden_representation, value, policy_logits
def discriminative_loss_single(prediction, correct_label, feature_dim, delta_v,
delta_d, param_var, param_dist, param_reg):
''' Discriminative loss for a single prediction/label pair.
:param prediction: inference of network
:param correct_label: instance label
:feature_dim: feature dimension of prediction
:param label_shape: shape of label
:param delta_v: cutoff variance distance
:param delta_d: curoff cluster distance
:param param_var: weight for intra cluster variance
:param param_dist: weight for inter cluster distances
:param param_reg: weight regularization
'''
### Reshape so pixels are aligned along a vector
#correct_label = tf.reshape(correct_label, [label_shape[1] * label_shape[0]])
reshaped_pred = tf.reshape(prediction, [-1, feature_dim])
### Count instances
unique_labels, unique_id, counts = tf.unique_with_counts(correct_label)
counts = tf.cast(counts, tf.float32)
num_instances = tf.size(unique_labels)
segmented_sum = tf.unsorted_segment_sum(reshaped_pred, unique_id,
num_instances)
mu = tf.div(segmented_sum, tf.reshape(counts, (-1, 1)))
mu_expand = tf.gather(mu, unique_id)
### Calculate l_var
#distance = tf.norm(tf.subtract(mu_expand, reshaped_pred), axis=1)
#tmp_distance = tf.subtract(reshaped_pred, mu_expand)
tmp_distance = reshaped_pred - mu_expand
distance = tf.norm(tmp_distance, ord=1, axis=1)
distance = tf.subtract(distance, delta_v)
distance = tf.clip_by_value(distance, 0., distance)
distance = tf.square(distance)
l_var = tf.unsorted_segment_sum(distance, unique_id, num_instances)
l_var = tf.div(l_var, counts)
l_var = tf.reduce_sum(l_var)
l_var = tf.divide(l_var, tf.cast(num_instances, tf.float32))
### Calculate l_dist
# Get distance for each pair of clusters like this:
# mu_1 - mu_1
# mu_2 - mu_1
# mu_3 - mu_1
# mu_1 - mu_2
# mu_2 - mu_2
# mu_3 - mu_2
# mu_1 - mu_3
# mu_2 - mu_3
# mu_3 - mu_3
mu_interleaved_rep = tf.tile(mu, [num_instances, 1])
mu_band_rep = tf.tile(mu, [1, num_instances])
mu_band_rep = tf.reshape(mu_band_rep,
(num_instances * num_instances, feature_dim))
mu_diff = tf.subtract(mu_band_rep, mu_interleaved_rep)
# Filter out zeros from same cluster subtraction
eye = tf.eye(num_instances)
zero = tf.zeros(1, dtype=tf.float32)
diff_cluster_mask = tf.equal(eye, zero)
diff_cluster_mask = tf.reshape(diff_cluster_mask, [-1])
mu_diff_bool = tf.boolean_mask(mu_diff, diff_cluster_mask)
#intermediate_tensor = tf.reduce_sum(tf.abs(mu_diff),axis=1)
#zero_vector = tf.zeros(1, dtype=tf.float32)
#bool_mask = tf.not_equal(intermediate_tensor, zero_vector)
#mu_diff_bool = tf.boolean_mask(mu_diff, bool_mask)
mu_norm = tf.norm(mu_diff_bool, ord=1, axis=1)
mu_norm = tf.subtract(2. * delta_d, mu_norm)
mu_norm = tf.clip_by_value(mu_norm, 0., mu_norm)
mu_norm = tf.square(mu_norm)
l_dist = tf.reduce_mean(mu_norm)
def rt_0():
return 0.
def rt_l_dist():
return l_dist
l_dist = tf.cond(tf.equal(1, num_instances), rt_0, rt_l_dist)
### Calculate l_reg
l_reg = tf.reduce_mean(tf.norm(mu, ord=1, axis=1))
param_scale = 1.
l_var = param_var * l_var
l_dist = param_dist * l_dist
l_reg = param_reg * l_reg
loss = param_scale * (l_var + l_dist + l_reg)
return loss, l_var, l_dist, l_reg
import tensorflow_core as tf
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
#启动计算图
sess = tf.InteractiveSession()
#占位符
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])
#权重
W = tf.Variable(tf.zeros([784, 10]))
#偏置
b = tf.Variable(tf.zeros([10]))
#初始化
sess.run(tf.initialize_all_variables())
#预测
y = tf.nn.softmax(tf.matmul(x, W) + b)
# 交叉熵作为损失函数
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
# 训练---最小化损失函数
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
#循环次数
for i in range(1000):
batch = mnist.train.next_batch(50)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
#判断是否预测正确
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
#计算准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# 打印准确率
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))