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}))